singleton-service/mdsal-singleton-dom-impl/src/test/java/org/opendaylight/mdsal/singleton/dom/impl/DOMClusterSingletonServiceProviderAsyncImplTest.java

   1 /*
   2  * Copyright (c) 2016 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.mdsal.singleton.dom.impl;
  10
  11 import static org.mockito.Matchers.any;
  12 import static org.mockito.Matchers.eq;
  13 import static org.mockito.Mockito.atLeastOnce;
  14 import static org.mockito.Mockito.doNothing;
  15 import static org.mockito.Mockito.doReturn;
  16 import static org.mockito.Mockito.doThrow;
  17 import static org.mockito.Mockito.never;
  18 import static org.mockito.Mockito.verify;
  19
  20 import com.google.common.util.concurrent.ListenableFuture;
  21 import com.google.common.util.concurrent.SettableFuture;
  22 import java.util.Timer;
  23 import java.util.TimerTask;
  24 import org.junit.AfterClass;
  25 import org.junit.Assert;
  26 import org.junit.Before;
  27 import org.junit.BeforeClass;
  28 import org.junit.Test;
  29 import org.mockito.Mock;
  30 import org.mockito.MockitoAnnotations;
  31 import org.opendaylight.mdsal.eos.common.api.CandidateAlreadyRegisteredException;
  32 import org.opendaylight.mdsal.eos.common.api.EntityOwnershipChangeState;
  33 import org.opendaylight.mdsal.eos.dom.api.DOMEntity;
  34 import org.opendaylight.mdsal.eos.dom.api.DOMEntityOwnershipCandidateRegistration;
  35 import org.opendaylight.mdsal.eos.dom.api.DOMEntityOwnershipChange;
  36 import org.opendaylight.mdsal.eos.dom.api.DOMEntityOwnershipListenerRegistration;
  37 import org.opendaylight.mdsal.eos.dom.api.DOMEntityOwnershipService;
  38 import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
  39 import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
  40 import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
  41
  42 /*
  43  * Testing {@link DOMClusterSingletonServiceProviderImpl} implementation
  44  */
  45 public final class DOMClusterSingletonServiceProviderAsyncImplTest {
  46
  47     private static final String SERVICE_ENTITY_TYPE = "org.opendaylight.mdsal.ServiceEntityType";
  48     private static final String CLOSE_SERVICE_ENTITY_TYPE = "org.opendaylight.mdsal.AsyncServiceCloseEntityType";
  49     private static final String SERVICE_NAME = "testServiceName";
  50
  51     @Mock
  52     private DOMEntityOwnershipService mockEos;
  53     @Mock
  54     private DOMEntityOwnershipCandidateRegistration mockEntityCandReg;
  55     @Mock
  56     private DOMEntityOwnershipCandidateRegistration mockDoubleEntityCandReg;
  57     @Mock
  58     private DOMEntityOwnershipListenerRegistration mockEosEntityListReg;
  59     @Mock
  60     private DOMEntityOwnershipListenerRegistration mockEosDoubleEntityListReg;
  61
  62     private DOMClusterSingletonServiceProviderImpl clusterSingletonServiceProvider;
  63     private TestClusterSingletonAsyncServiceInstance clusterSingletonService;
  64     private TestClusterSingletonAsyncServiceInstance clusterSingletonService2;
  65
  66     private final DOMEntity entity = new DOMEntity(SERVICE_ENTITY_TYPE, SERVICE_NAME);
  67     private final DOMEntity doubleEntity = new DOMEntity(CLOSE_SERVICE_ENTITY_TYPE, SERVICE_NAME);
  68
  69     protected static Timer timer;
  70     protected static long ASYNC_TIME_DELAY_SEC = 100L;
  71
  72     @BeforeClass
  73     public static void asyncInitTest() {
  74         timer = new Timer();
  75     }
  76
  77     @AfterClass
  78     public static void cleanTest() {
  79         timer.cancel();
  80     }
  81
  82     /**
  83      * Initialization functionality for every Tests in this suite.
  84      *
  85      * @throws Exception if the condition does not meet
  86      */
  87     @Before
  88     public void setup() throws Exception {
  89         MockitoAnnotations.initMocks(this);
  90
  91         doNothing().when(mockEosEntityListReg).close();
  92         doNothing().when(mockEosDoubleEntityListReg).close();
  93         doNothing().when(mockEntityCandReg).close();
  94         doNothing().when(mockDoubleEntityCandReg).close();
  95         doReturn(mockEosEntityListReg).when(mockEos).registerListener(eq(SERVICE_ENTITY_TYPE),
  96                 any(DOMClusterSingletonServiceProviderImpl.class));
  97         doReturn(mockEosDoubleEntityListReg).when(mockEos).registerListener(eq(CLOSE_SERVICE_ENTITY_TYPE),
  98                 any(DOMClusterSingletonServiceProviderImpl.class));
  99         doReturn(mockEntityCandReg).when(mockEos).registerCandidate(entity);
 100         doReturn(mockDoubleEntityCandReg).when(mockEos).registerCandidate(doubleEntity);
 101
 102         clusterSingletonServiceProvider = new DOMClusterSingletonServiceProviderImpl(mockEos);
 103         clusterSingletonServiceProvider.initializeProvider();
 104         verify(mockEos).registerListener(SERVICE_ENTITY_TYPE, clusterSingletonServiceProvider);
 105         verify(mockEos).registerListener(CLOSE_SERVICE_ENTITY_TYPE, clusterSingletonServiceProvider);
 106
 107         clusterSingletonService = new TestClusterSingletonAsyncServiceInstance();
 108         clusterSingletonService2 = new TestClusterSingletonAsyncServiceInstance();
 109
 110         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 111         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
 112     }
 113
 114     /**
 115      * Test checks NullPointer for null {@link DOMEntityOwnershipService} input value.
 116      *
 117      * @throws Exception if the condition does not meet
 118      */
 119     @Test(expected = NullPointerException.class)
 120     public void initializationClusterSingletonServiceProviderNullInputTest() throws Exception {
 121         clusterSingletonServiceProvider = new DOMClusterSingletonServiceProviderImpl(null);
 122     }
 123
 124     /**
 125      * Test GoldPath for close {@link DOMClusterSingletonServiceProviderImpl}.
 126      *
 127      * @throws Exception if the condition does not meet
 128      */
 129     @Test
 130     public void closeClusterSingletonServiceProviderTest() throws Exception {
 131         verify(mockEos).registerListener(SERVICE_ENTITY_TYPE, clusterSingletonServiceProvider);
 132         verify(mockEos).registerListener(CLOSE_SERVICE_ENTITY_TYPE, clusterSingletonServiceProvider);
 133         clusterSingletonServiceProvider.close();
 134         verify(mockEosEntityListReg).close();
 135         verify(mockEosDoubleEntityListReg).close();
 136     }
 137
 138     /**
 139      * Test parser ServiceIdentifier from Entity.
 140      *
 141      * @throws Exception if the condition does not meet
 142      */
 143     @Test
 144     public void makeEntityClusterSingletonServiceProviderTest() throws Exception {
 145         final DOMEntity testEntity = clusterSingletonServiceProvider.createEntity(SERVICE_ENTITY_TYPE, SERVICE_NAME);
 146         Assert.assertEquals(entity, testEntity);
 147         final DOMEntity testDbEn = clusterSingletonServiceProvider.createEntity(CLOSE_SERVICE_ENTITY_TYPE,
 148                 SERVICE_NAME);
 149         Assert.assertEquals(doubleEntity, testDbEn);
 150     }
 151
 152     /**
 153      * Test parser ServiceIdentifier from Entity.
 154      *
 155      * @throws Exception if the condition does not meet
 156      */
 157     @Test
 158     public void getIdentifierClusterSingletonServiceProviderTest() throws Exception {
 159         final String entityIdentifier = clusterSingletonServiceProvider.getServiceIdentifierFromEntity(entity);
 160         Assert.assertEquals(SERVICE_NAME, entityIdentifier);
 161         final String doubleEntityId = clusterSingletonServiceProvider.getServiceIdentifierFromEntity(doubleEntity);
 162         Assert.assertEquals(SERVICE_NAME, doubleEntityId);
 163     }
 164
 165     /**
 166      * Test GoldPath for initialization {@link ClusterSingletonService}.
 167      *
 168      * @throws Exception if the condition does not meet
 169      */
 170     @Test
 171     public void initializationClusterSingletonServiceTest() throws Exception {
 172         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 173                 .registerClusterSingletonService(clusterSingletonService);
 174         Assert.assertNotNull(reg);
 175         verify(mockEos).registerCandidate(entity);
 176         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 177     }
 178
 179     /**
 180      * Test GoldPath for initialization with init ownership result SLAVE {@link ClusterSingletonService}.
 181      *
 182      * @throws Exception if the condition does not meet
 183      */
 184     @Test
 185     public void slaveInitClusterSingletonServiceTest() throws Exception {
 186         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 187                 .registerClusterSingletonService(clusterSingletonService);
 188         Assert.assertNotNull(reg);
 189         verify(mockEos).registerCandidate(entity);
 190         clusterSingletonServiceProvider.ownershipChanged(getInitEntityToSlave());
 191         verify(mockEos, never()).registerCandidate(doubleEntity);
 192         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 193     }
 194
 195     /**
 196      * Test GoldPath for initialization with init ownership result SLAVE, but NO-MASTER {@link ClusterSingletonService}.
 197      *
 198      * @throws Exception if the condition does not meet
 199      */
 200     @Test
 201     public void slaveInitNoMasterClusterSingletonServiceTest() throws Exception {
 202         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 203                 .registerClusterSingletonService(clusterSingletonService);
 204         Assert.assertNotNull(reg);
 205         verify(mockEos).registerCandidate(entity);
 206         clusterSingletonServiceProvider.ownershipChanged(getInitEntityToSlaveNoMaster());
 207         verify(mockEos, never()).registerCandidate(doubleEntity);
 208         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 209     }
 210
 211     /**
 212      * Test GoldPath for initialization with init ownership result MASTER {@link ClusterSingletonService}.
 213      *
 214      * @throws Exception if the condition does not meet
 215      */
 216     @Test
 217     public void masterInitClusterSingletonServiceTest() throws Exception {
 218         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 219                 .registerClusterSingletonService(clusterSingletonService);
 220         Assert.assertNotNull(reg);
 221         verify(mockEos).registerCandidate(entity);
 222         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 223         verify(mockEos).registerCandidate(doubleEntity);
 224         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 225     }
 226
 227     /**
 228      * Test GoldPath for initialization with init ownership result MASTER {@link ClusterSingletonService}.
 229      *
 230      * @throws Exception if the condition does not meet
 231      */
 232     @Test
 233     public void masterInitSlaveDoubleCandidateClusterSingletonServiceTest() throws Exception {
 234         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 235                 .registerClusterSingletonService(clusterSingletonService);
 236         Assert.assertNotNull(reg);
 237         verify(mockEos).registerCandidate(entity);
 238         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 239         verify(mockEos).registerCandidate(doubleEntity);
 240         clusterSingletonServiceProvider.ownershipChanged(getInitDoubleEntityToSlave());
 241         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 242     }
 243
 244     /**
 245      * Test GoldPath for takeLeadership with ownership result MASTER {@link ClusterSingletonService}.
 246      *
 247      * @throws Exception if the condition does not meet
 248      */
 249     @Test
 250     public void takeLeadershipClusterSingletonServiceTest() throws Exception {
 251         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 252                 .registerClusterSingletonService(clusterSingletonService);
 253         Assert.assertNotNull(reg);
 254         verify(mockEos).registerCandidate(entity);
 255         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 256         verify(mockEos).registerCandidate(doubleEntity);
 257         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 258         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 259         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 260     }
 261
 262     /**
 263      * Test GoldPath for takeLeadership with ownership result MASTER {@link ClusterSingletonService}.
 264      *
 265      * @throws Exception if the condition does not meet
 266      */
 267     @Test
 268     public void takeDoubleLeadershipClusterSingletonServiceTest() throws Exception {
 269         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 270                 .registerClusterSingletonService(clusterSingletonService);
 271         Assert.assertNotNull(reg);
 272         verify(mockEos).registerCandidate(entity);
 273         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 274         verify(mockEos).registerCandidate(doubleEntity);
 275         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 276         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 277         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 278         clusterSingletonServiceProvider.ownershipChanged(getEntityToSlave());
 279         Assert.assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
 280         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 281         Assert.assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
 282         clusterSingletonServiceProvider.ownershipChanged(getInitDoubleEntityToSlave());
 283         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 284         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 285         verify(mockEosDoubleEntityListReg, never()).close();
 286         verify(mockEosEntityListReg, never()).close();
 287         verify(mockEntityCandReg, never()).close();
 288         verify(mockDoubleEntityCandReg).close();
 289     }
 290
 291     /**
 292      * Test GoldPath for initialization with init ownership result MASTER {@link ClusterSingletonService}.
 293      *
 294      * @throws Exception if the condition does not meet
 295      */
 296     @Test
 297     public void masterInitClusterSingletonServiceTwoServicesTest() throws Exception {
 298         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 299                 .registerClusterSingletonService(clusterSingletonService);
 300         Assert.assertNotNull(reg);
 301         verify(mockEos).registerCandidate(entity);
 302         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 303         verify(mockEos).registerCandidate(doubleEntity);
 304         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 305         final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
 306                 .registerClusterSingletonService(clusterSingletonService2);
 307         Assert.assertNotNull(reg2);
 308         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
 309     }
 310
 311     /**
 312      * Test GoldPath for takeLeadership with ownership result MASTER {@link ClusterSingletonService}.
 313      *
 314      * @throws Exception if the condition does not meet
 315      */
 316     @Test
 317     public void takeLeadershipClusterSingletonServiceTwoAddDuringWaitPhaseServicesTest() throws Exception {
 318         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 319                 .registerClusterSingletonService(clusterSingletonService);
 320         Assert.assertNotNull(reg);
 321         verify(mockEos).registerCandidate(entity);
 322         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 323         verify(mockEos).registerCandidate(doubleEntity);
 324         final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
 325                 .registerClusterSingletonService(clusterSingletonService2);
 326         Assert.assertNotNull(reg2);
 327         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 328         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
 329         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 330         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 331         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
 332     }
 333
 334     /**
 335      * Test GoldPath for takeLeadership with ownership result MASTER {@link ClusterSingletonService}.
 336      *
 337      * @throws Exception if the condition does not meet
 338      */
 339     @Test
 340     public void takeLeadershipClusterSingletonServiceTowServicesTest() throws Exception {
 341         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 342                 .registerClusterSingletonService(clusterSingletonService);
 343         Assert.assertNotNull(reg);
 344         verify(mockEos).registerCandidate(entity);
 345         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 346         verify(mockEos).registerCandidate(doubleEntity);
 347         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 348         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 349         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 350         final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
 351                 .registerClusterSingletonService(clusterSingletonService2);
 352         Assert.assertNotNull(reg2);
 353         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
 354     }
 355
 356     /**
 357      * Test checks CandidateAlreadyRegisteredException processing in initialization phase.
 358      *
 359      * @throws Exception if the condition does not meet
 360      */
 361     @Test(expected = RuntimeException.class)
 362     public void initializationClusterSingletonServiceCandidateAlreadyRegistredTest() throws Exception {
 363         doThrow(CandidateAlreadyRegisteredException.class).when(mockEos).registerCandidate(entity);
 364         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 365                 .registerClusterSingletonService(clusterSingletonService);
 366         Assert.assertNull(reg);
 367     }
 368
 369     /**
 370      * Test GoldPath for lostLeadership during tryToTakeLeadership with ownership result MASTER
 371      * {@link ClusterSingletonService}.
 372      *
 373      * @throws Exception if the condition does not meet
 374      */
 375     @Test
 376     public void lostLeadershipDuringTryToTakeLeadershipClusterSingletonServiceTest() throws Exception {
 377         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 378                 .registerClusterSingletonService(clusterSingletonService);
 379         Assert.assertNotNull(reg);
 380         verify(mockEos).registerCandidate(entity);
 381         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 382         verify(mockEos).registerCandidate(doubleEntity);
 383         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 384         clusterSingletonServiceProvider.ownershipChanged(getEntityToSlave());
 385         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 386         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 387         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 388     }
 389
 390     /**
 391      * Test GoldPath for lostLeadership with ownership result MASTER-TO-SLAVE {@link ClusterSingletonService}.
 392      *
 393      * @throws Exception if the condition does not meet
 394      */
 395     @Test
 396     public void lostLeadershipClusterSingletonServiceTest() throws Exception {
 397         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 398                 .registerClusterSingletonService(clusterSingletonService);
 399         Assert.assertNotNull(reg);
 400         verify(mockEos).registerCandidate(entity);
 401         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 402         verify(mockEos).registerCandidate(doubleEntity);
 403         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 404         clusterSingletonServiceProvider.ownershipChanged(getInitDoubleEntityToSlave());
 405         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 406         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 407         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 408         clusterSingletonServiceProvider.ownershipChanged(getEntityToSlave());
 409         Assert.assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
 410     }
 411
 412     /**
 413      * Test checks unexpected change for MASTER-TO-SLAVE double Candidate role change.
 414      *
 415      * @throws Exception if the condition does not meet
 416      */
 417     @Test
 418     public void unexpectedLostLeadershipDoubleCandidateTest() throws Exception {
 419         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 420                 .registerClusterSingletonService(clusterSingletonService);
 421         Assert.assertNotNull(reg);
 422         verify(mockEos).registerCandidate(entity);
 423         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 424         verify(mockEos).registerCandidate(doubleEntity);
 425         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 426         clusterSingletonServiceProvider.ownershipChanged(getInitDoubleEntityToSlave());
 427         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 428         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 429         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 430         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToSlave());
 431         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 432         Thread.sleep(ASYNC_TIME_DELAY_SEC * 2);
 433         verify(mockEosDoubleEntityListReg, never()).close();
 434         verify(mockEntityCandReg, never()).close();
 435         verify(mockDoubleEntityCandReg, never()).close();
 436         reg.close();
 437         verify(mockEosDoubleEntityListReg, never()).close();
 438         verify(mockEntityCandReg, atLeastOnce()).close();
 439         verify(mockDoubleEntityCandReg, never()).close();
 440         clusterSingletonServiceProvider.ownershipChanged(getEntityToSlave());
 441         Thread.sleep(ASYNC_TIME_DELAY_SEC * 2);
 442         verify(mockEntityCandReg, atLeastOnce()).close();
 443         verify(mockDoubleEntityCandReg, atLeastOnce()).close();
 444         verify(mockEosDoubleEntityListReg, never()).close();
 445         Assert.assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
 446     }
 447
 448     /**
 449      * Test checks inJeopardy Cluster Node state for Master Instance.
 450      *
 451      * @throws Exception if the condition does not meet
 452      */
 453     @Test
 454     public void inJeopardyMasterTest() throws Exception {
 455         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 456                 .registerClusterSingletonService(clusterSingletonService);
 457         Assert.assertNotNull(reg);
 458         verify(mockEos).registerCandidate(entity);
 459         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 460         verify(mockEos).registerCandidate(doubleEntity);
 461         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 462         clusterSingletonServiceProvider.ownershipChanged(getInitDoubleEntityToSlave());
 463         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 464         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 465         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 466         clusterSingletonServiceProvider.ownershipChanged(getEntityToJeopardy());
 467         Assert.assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
 468         Thread.sleep(ASYNC_TIME_DELAY_SEC * 2);
 469         verify(mockEosEntityListReg, never()).close();
 470         verify(mockEosDoubleEntityListReg, never()).close();
 471         verify(mockEntityCandReg, never()).close();
 472         verify(mockDoubleEntityCandReg).close();
 473     }
 474
 475     /**
 476      * Test checks inJeopardy Cluster Node state for Slave Instance.
 477      *
 478      * @throws Exception if the condition does not meet
 479      */
 480     @Test
 481     public void inJeopardySlaveTest() throws Exception {
 482         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 483                 .registerClusterSingletonService(clusterSingletonService);
 484         Assert.assertNotNull(reg);
 485         verify(mockEos).registerCandidate(entity);
 486         clusterSingletonServiceProvider.ownershipChanged(getInitEntityToSlave());
 487         verify(mockEos, never()).registerCandidate(doubleEntity);
 488         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 489         clusterSingletonServiceProvider.ownershipChanged(getEntityToJeopardy());
 490         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 491         verify(mockEosEntityListReg, never()).close();
 492         verify(mockEosDoubleEntityListReg, never()).close();
 493         verify(mockEntityCandReg, never()).close();
 494         verify(mockDoubleEntityCandReg, never()).close();
 495     }
 496
 497     /**
 498      * Test checks close processing for {@link ClusterSingletonServiceRegistration}.
 499      *
 500      * @throws Exception if the condition does not meet
 501      */
 502     @Test
 503     public void closeClusterSingletonServiceRegistrationNoRoleTest() throws Exception {
 504         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 505                 .registerClusterSingletonService(clusterSingletonService);
 506         Assert.assertNotNull(reg);
 507         verify(mockEos).registerCandidate(entity);
 508         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 509         reg.close();
 510         verify(mockEosEntityListReg, never()).close();
 511         verify(mockEosDoubleEntityListReg, never()).close();
 512         verify(mockEntityCandReg).close();
 513         verify(mockDoubleEntityCandReg, never()).close();
 514         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 515     }
 516
 517     /**
 518      * Test checks close processing for {@link ClusterSingletonServiceRegistration}.
 519      *
 520      * @throws Exception if the condition does not meet
 521      */
 522     @Test
 523     public void closeClusterSingletonServiceRegistrationNoRoleTwoServicesTest() throws Exception {
 524         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 525                 .registerClusterSingletonService(clusterSingletonService);
 526         Assert.assertNotNull(reg);
 527         verify(mockEos).registerCandidate(entity);
 528         final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
 529                 .registerClusterSingletonService(clusterSingletonService2);
 530         Assert.assertNotNull(reg2);
 531         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 532         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
 533         reg.close();
 534         verify(mockEosEntityListReg, never()).close();
 535         verify(mockEosDoubleEntityListReg, never()).close();
 536         verify(mockEntityCandReg, never()).close();
 537         verify(mockDoubleEntityCandReg, never()).close();
 538         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 539         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
 540     }
 541
 542     /**
 543      * Test checks close processing for {@link ClusterSingletonServiceRegistration}.
 544      *
 545      * @throws Exception if the condition does not meet
 546      */
 547     @Test
 548     public void closeClusterSingletonServiceRegistrationSlaveTest() throws Exception {
 549         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 550                 .registerClusterSingletonService(clusterSingletonService);
 551         Assert.assertNotNull(reg);
 552         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 553         verify(mockEos).registerCandidate(entity);
 554         clusterSingletonServiceProvider.ownershipChanged(getInitEntityToSlave());
 555         reg.close();
 556         verify(mockEosEntityListReg, never()).close();
 557         verify(mockEosDoubleEntityListReg, never()).close();
 558         verify(mockEntityCandReg).close();
 559         verify(mockDoubleEntityCandReg, never()).close();
 560         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 561     }
 562
 563     /**
 564      * Test checks close processing for {@link ClusterSingletonServiceRegistration}.
 565      *
 566      * @throws Exception if the condition does not meet
 567      */
 568     @Test
 569     public void closeClusterSingletonServiceRegistrationSlaveTwoServicesTest() throws Exception {
 570         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 571                 .registerClusterSingletonService(clusterSingletonService);
 572         Assert.assertNotNull(reg);
 573         verify(mockEos).registerCandidate(entity);
 574         final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
 575                 .registerClusterSingletonService(clusterSingletonService2);
 576         Assert.assertNotNull(reg2);
 577         clusterSingletonServiceProvider.ownershipChanged(getInitEntityToSlave());
 578         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 579         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
 580         reg.close();
 581         verify(mockEosEntityListReg, never()).close();
 582         verify(mockEosDoubleEntityListReg, never()).close();
 583         verify(mockEntityCandReg, never()).close();
 584         verify(mockDoubleEntityCandReg, never()).close();
 585         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 586         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
 587     }
 588
 589     /**
 590      * Test checks close processing for {@link ClusterSingletonServiceRegistration}.
 591      *
 592      * @throws Exception if the condition does not meet
 593      */
 594     @Test
 595     public void closeClusterSingletonServiceRegistrationMasterTest() throws Exception {
 596         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 597                 .registerClusterSingletonService(clusterSingletonService);
 598         Assert.assertNotNull(reg);
 599         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 600         verify(mockEos).registerCandidate(entity);
 601         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 602         verify(mockEos).registerCandidate(doubleEntity);
 603         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 604         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 605         reg.close();
 606         Thread.sleep(ASYNC_TIME_DELAY_SEC * 2);
 607         verify(mockEosEntityListReg, never()).close();
 608         verify(mockEosDoubleEntityListReg, never()).close();
 609         verify(mockEntityCandReg, atLeastOnce()).close();
 610         verify(mockDoubleEntityCandReg, never()).close();
 611         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 612         clusterSingletonServiceProvider.ownershipChanged(getEntityToSlave());
 613         Thread.sleep(ASYNC_TIME_DELAY_SEC * 2);
 614         verify(mockEntityCandReg, atLeastOnce()).close();
 615         verify(mockDoubleEntityCandReg, atLeastOnce()).close();
 616         verify(mockEosDoubleEntityListReg, never()).close();
 617         Assert.assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
 618     }
 619
 620     /**
 621      * Test checks close processing for {@link ClusterSingletonServiceRegistration}.
 622      *
 623      * @throws Exception if the condition does not meet
 624      */
 625     @Test
 626     public void closeClusterSingletonServiceRegistrationMasterCloseWithNotificationTimesTest() throws Exception {
 627         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 628                 .registerClusterSingletonService(clusterSingletonService);
 629         Assert.assertNotNull(reg);
 630         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 631         verify(mockEos).registerCandidate(entity);
 632         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 633         verify(mockEos).registerCandidate(doubleEntity);
 634         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 635         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 636         reg.close();
 637         Thread.sleep(ASYNC_TIME_DELAY_SEC * 2);
 638         verify(mockEosEntityListReg, never()).close();
 639         verify(mockEosDoubleEntityListReg, never()).close();
 640         verify(mockEntityCandReg, atLeastOnce()).close();
 641         verify(mockDoubleEntityCandReg, never()).close();
 642         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 643         clusterSingletonServiceProvider.ownershipChanged(getEntityToSlave());
 644         Thread.sleep(ASYNC_TIME_DELAY_SEC * 2);
 645         verify(mockEntityCandReg, atLeastOnce()).close();
 646         verify(mockDoubleEntityCandReg, atLeastOnce()).close();
 647         verify(mockEosDoubleEntityListReg, never()).close();
 648         Assert.assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
 649     }
 650
 651     /**
 652      * Test checks close processing for {@link ClusterSingletonServiceRegistration}.
 653      *
 654      * @throws Exception if the condition does not meet
 655      */
 656     @Test
 657     public void closeClusterSingletonServiceRegistrationMasterCloseCoupleTimesTest() throws Exception {
 658         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 659                 .registerClusterSingletonService(clusterSingletonService);
 660         Assert.assertNotNull(reg);
 661         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 662         verify(mockEos).registerCandidate(entity);
 663         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 664         verify(mockEos).registerCandidate(doubleEntity);
 665         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 666         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 667         reg.close();
 668         reg.close();
 669         Thread.sleep(ASYNC_TIME_DELAY_SEC * 2);
 670         verify(mockEosEntityListReg, never()).close();
 671         verify(mockEosDoubleEntityListReg, never()).close();
 672         verify(mockEntityCandReg, atLeastOnce()).close();
 673         verify(mockDoubleEntityCandReg, never()).close();
 674         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 675         clusterSingletonServiceProvider.ownershipChanged(getEntityToSlave());
 676         Thread.sleep(ASYNC_TIME_DELAY_SEC * 2);
 677         verify(mockEntityCandReg, atLeastOnce()).close();
 678         verify(mockDoubleEntityCandReg, atLeastOnce()).close();
 679         verify(mockEosDoubleEntityListReg, never()).close();
 680         Assert.assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
 681     }
 682
 683     /**
 684      * Test checks close processing for {@link ClusterSingletonServiceRegistration}.
 685      *
 686      * @throws Exception if the condition does not meet
 687      */
 688     @Test
 689     public void closeClusterSingletonServiceRegistrationMasterTwoServicesTest() throws Exception {
 690         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 691                 .registerClusterSingletonService(clusterSingletonService);
 692         Assert.assertNotNull(reg);
 693         final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
 694                 .registerClusterSingletonService(clusterSingletonService2);
 695         Assert.assertNotNull(reg2);
 696         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 697         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
 698         verify(mockEos).registerCandidate(entity);
 699         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 700         verify(mockEos).registerCandidate(doubleEntity);
 701         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 702         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 703         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
 704         reg.close();
 705         verify(mockEosEntityListReg, never()).close();
 706         verify(mockEosDoubleEntityListReg, never()).close();
 707         verify(mockEntityCandReg, never()).close();
 708         verify(mockDoubleEntityCandReg, never()).close();
 709         Assert.assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
 710         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
 711     }
 712
 713     /**
 714      * Test checks validation Error processing for SLAVE-TO-MASTER entity Candidate role change.
 715      *
 716      * @throws Exception if the condition does not meet
 717      */
 718     @Test
 719     public void tryToTakeLeaderForClosedServiceRegistrationTest() throws Exception {
 720         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 721                 .registerClusterSingletonService(clusterSingletonService);
 722         Assert.assertNotNull(reg);
 723         final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
 724                 .registerClusterSingletonService(clusterSingletonService2);
 725         Assert.assertNotNull(reg2);
 726         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 727         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
 728         verify(mockEos).registerCandidate(entity);
 729         reg.close();
 730         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 731         verify(mockEos).registerCandidate(doubleEntity);
 732         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 733         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 734         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
 735         verify(mockEosEntityListReg, never()).close();
 736         verify(mockEosDoubleEntityListReg, never()).close();
 737         verify(mockEntityCandReg, never()).close();
 738         verify(mockDoubleEntityCandReg, never()).close();
 739         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 740         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
 741     }
 742
 743     private DOMEntityOwnershipChange getEntityToMaster() {
 744         return new DOMEntityOwnershipChange(entity, EntityOwnershipChangeState.from(false, true, true));
 745     }
 746
 747     private DOMEntityOwnershipChange getEntityToSlave() {
 748         return new DOMEntityOwnershipChange(entity, EntityOwnershipChangeState.from(true, false, true));
 749     }
 750
 751     private DOMEntityOwnershipChange getInitEntityToSlave() {
 752         return new DOMEntityOwnershipChange(entity, EntityOwnershipChangeState.from(false, false, true));
 753     }
 754
 755     private DOMEntityOwnershipChange getInitEntityToSlaveNoMaster() {
 756         return new DOMEntityOwnershipChange(entity, EntityOwnershipChangeState.from(false, false, false));
 757     }
 758
 759     private DOMEntityOwnershipChange getDoubleEntityToMaster() {
 760         return new DOMEntityOwnershipChange(doubleEntity, EntityOwnershipChangeState.from(false, true, true));
 761     }
 762
 763     private DOMEntityOwnershipChange getInitDoubleEntityToSlave() {
 764         return new DOMEntityOwnershipChange(doubleEntity, EntityOwnershipChangeState.from(false, false, true));
 765     }
 766
 767     private DOMEntityOwnershipChange getDoubleEntityToSlave() {
 768         return new DOMEntityOwnershipChange(doubleEntity, EntityOwnershipChangeState.from(true, false, true));
 769     }
 770
 771     private DOMEntityOwnershipChange getEntityToJeopardy() {
 772         return new DOMEntityOwnershipChange(entity, EntityOwnershipChangeState.from(false, false, false), true);
 773     }
 774
 775     /*
 776      * Base states for AbstractClusterProjectProvider
 777      */
 778     enum TestClusterSingletonServiceState {
 779         /*
 780          * State represents a correct Instantiated process
 781          */
 782         STARTED,
 783         /*
 784          * State represents a correct call abstract method instantiatingProject
 785          */
 786         INITIALIZED,
 787         /*
 788          * State represents a correct call abstract method destryingProject
 789          */
 790         DESTROYED;
 791     }
 792
 793     /*
 794      * Test implementation of {@link ClusterSingletonService}
 795      */
 796     class TestClusterSingletonAsyncServiceInstance implements ClusterSingletonService {
 797
 798         private final ServiceGroupIdentifier serviceId = ServiceGroupIdentifier.create(SERVICE_NAME);
 799         private TestClusterSingletonServiceState serviceState;
 800         protected SettableFuture<Void> future;
 801
 802         TestClusterSingletonAsyncServiceInstance() {
 803             this.serviceState = TestClusterSingletonServiceState.INITIALIZED;
 804         }
 805
 806         @Override
 807         public void instantiateServiceInstance() {
 808             this.serviceState = TestClusterSingletonServiceState.STARTED;
 809         }
 810
 811         @Override
 812         public ListenableFuture<Void> closeServiceInstance() {
 813             this.serviceState = TestClusterSingletonServiceState.DESTROYED;
 814             future = SettableFuture.create();
 815             timer.schedule(new TimerTask() {
 816
 817                 @Override
 818                 public void run() {
 819                     future.set(null);
 820                 }
 821             }, ASYNC_TIME_DELAY_SEC);
 822             return future;
 823         }
 824
 825         public TestClusterSingletonServiceState getServiceState() {
 826             return serviceState;
 827         }
 828
 829         @Override
 830         public ServiceGroupIdentifier getIdentifier() {
 831             return serviceId;
 832         }
 833     }
 834 }