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