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

   1 /*
   2  * Copyright (c) 2017 Pantheon Technologies, s.r.o. 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 package org.opendaylight.mdsal.singleton.dom.impl;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertNotNull;
  12 import static org.junit.Assert.assertNull;
  13 import static org.mockito.ArgumentMatchers.any;
  14 import static org.mockito.ArgumentMatchers.eq;
  15 import static org.mockito.Mockito.doNothing;
  16 import static org.mockito.Mockito.doReturn;
  17 import static org.mockito.Mockito.doThrow;
  18 import static org.mockito.Mockito.never;
  19 import static org.mockito.Mockito.verify;
  20 import static org.opendaylight.mdsal.singleton.dom.impl.AbstractClusterSingletonServiceProviderImpl.CLOSE_SERVICE_ENTITY_TYPE;
  21 import static org.opendaylight.mdsal.singleton.dom.impl.AbstractClusterSingletonServiceProviderImpl.SERVICE_ENTITY_TYPE;
  22
  23 import com.google.common.util.concurrent.Futures;
  24 import com.google.common.util.concurrent.ListenableFuture;
  25 import org.junit.Before;
  26 import org.junit.Test;
  27 import org.mockito.Mock;
  28 import org.opendaylight.mdsal.eos.common.api.CandidateAlreadyRegisteredException;
  29 import org.opendaylight.mdsal.eos.common.api.EntityOwnershipChangeState;
  30 import org.opendaylight.mdsal.eos.dom.api.DOMEntity;
  31 import org.opendaylight.mdsal.eos.dom.api.DOMEntityOwnershipCandidateRegistration;
  32 import org.opendaylight.mdsal.eos.dom.api.DOMEntityOwnershipChange;
  33 import org.opendaylight.mdsal.eos.dom.api.DOMEntityOwnershipListenerRegistration;
  34 import org.opendaylight.mdsal.eos.dom.api.DOMEntityOwnershipService;
  35 import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
  36 import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
  37 import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
  38
  39 /**
  40  * Abstract {@link DOMClusterSingletonServiceProviderImpl} testing substrate.
  41  */
  42 public abstract class AbstractDOMClusterServiceProviderTest {
  43     /**
  44      * Base states for AbstractClusterProjectProvider.
  45      */
  46     enum TestClusterSingletonServiceState {
  47         /**
  48          * State represents a correct Instantiated process.
  49          */
  50         STARTED,
  51         /**
  52          * State represents a correct call abstract method instantiatingProject.
  53          */
  54         INITIALIZED,
  55         /**
  56          * State represents a correct call abstract method destryingProject.
  57          */
  58         DESTROYED,
  59     }
  60
  61     static class TestClusterSingletonService implements ClusterSingletonService {
  62         private static final ServiceGroupIdentifier SERVICE_ID = ServiceGroupIdentifier.create(SERVICE_NAME);
  63
  64         private TestClusterSingletonServiceState serviceState = TestClusterSingletonServiceState.INITIALIZED;
  65
  66         @Override
  67         public final ServiceGroupIdentifier getIdentifier() {
  68             return SERVICE_ID;
  69         }
  70
  71         @Override
  72         public final void instantiateServiceInstance() {
  73             this.serviceState = TestClusterSingletonServiceState.STARTED;
  74         }
  75
  76         final TestClusterSingletonServiceState getServiceState() {
  77             return serviceState;
  78         }
  79
  80         @Override
  81         public ListenableFuture<Void> closeServiceInstance() {
  82             this.serviceState = TestClusterSingletonServiceState.DESTROYED;
  83             return Futures.immediateFuture(null);
  84         }
  85     }
  86
  87     public static final String SERVICE_NAME = "testServiceName";
  88     public static final DOMEntity ENTITY = new DOMEntity(SERVICE_ENTITY_TYPE, SERVICE_NAME);
  89     public static final DOMEntity DOUBLE_ENTITY = new DOMEntity(CLOSE_SERVICE_ENTITY_TYPE, SERVICE_NAME);
  90
  91     @Mock
  92     public DOMEntityOwnershipService mockEos;
  93     @Mock
  94     public DOMEntityOwnershipCandidateRegistration mockEntityCandReg;
  95     @Mock
  96     public DOMEntityOwnershipCandidateRegistration mockDoubleEntityCandReg;
  97     @Mock
  98     public DOMEntityOwnershipListenerRegistration mockEosEntityListReg;
  99     @Mock
 100     public DOMEntityOwnershipListenerRegistration mockEosDoubleEntityListReg;
 101
 102     public DOMClusterSingletonServiceProviderImpl clusterSingletonServiceProvider;
 103     public TestClusterSingletonService clusterSingletonService;
 104     public TestClusterSingletonService clusterSingletonService2;
 105
 106     @Before
 107     public void setup() throws CandidateAlreadyRegisteredException {
 108         doNothing().when(mockEosEntityListReg).close();
 109         doNothing().when(mockEosDoubleEntityListReg).close();
 110         doNothing().when(mockEntityCandReg).close();
 111         doNothing().when(mockDoubleEntityCandReg).close();
 112         doReturn(mockEosEntityListReg).when(mockEos).registerListener(eq(SERVICE_ENTITY_TYPE),
 113                 any(DOMClusterSingletonServiceProviderImpl.class));
 114         doReturn(mockEosDoubleEntityListReg).when(mockEos).registerListener(eq(CLOSE_SERVICE_ENTITY_TYPE),
 115                 any(DOMClusterSingletonServiceProviderImpl.class));
 116         doReturn(mockEntityCandReg).when(mockEos).registerCandidate(ENTITY);
 117         doReturn(mockDoubleEntityCandReg).when(mockEos).registerCandidate(DOUBLE_ENTITY);
 118
 119         clusterSingletonServiceProvider = new DOMClusterSingletonServiceProviderImpl(mockEos);
 120         clusterSingletonServiceProvider.initializeProvider();
 121         verify(mockEos).registerListener(SERVICE_ENTITY_TYPE, clusterSingletonServiceProvider);
 122         verify(mockEos).registerListener(CLOSE_SERVICE_ENTITY_TYPE, clusterSingletonServiceProvider);
 123
 124         clusterSingletonService = instantiateService();
 125         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 126         clusterSingletonService2 = instantiateService();
 127         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
 128     }
 129
 130     TestClusterSingletonService instantiateService() {
 131         return new TestClusterSingletonService();
 132     }
 133
 134     static final DOMEntityOwnershipChange getEntityToMaster() {
 135         return new DOMEntityOwnershipChange(ENTITY, EntityOwnershipChangeState.LOCAL_OWNERSHIP_GRANTED);
 136     }
 137
 138     static final DOMEntityOwnershipChange getEntityToSlave() {
 139         return new DOMEntityOwnershipChange(ENTITY, EntityOwnershipChangeState.LOCAL_OWNERSHIP_LOST_NEW_OWNER);
 140     }
 141
 142     static final DOMEntityOwnershipChange getInitEntityToSlave() {
 143         return new DOMEntityOwnershipChange(ENTITY, EntityOwnershipChangeState.REMOTE_OWNERSHIP_CHANGED);
 144     }
 145
 146     static final DOMEntityOwnershipChange getInitEntityToSlaveNoMaster() {
 147         return new DOMEntityOwnershipChange(ENTITY, EntityOwnershipChangeState.REMOTE_OWNERSHIP_LOST_NO_OWNER);
 148     }
 149
 150     static final DOMEntityOwnershipChange getEntityToJeopardy() {
 151         return new DOMEntityOwnershipChange(ENTITY, EntityOwnershipChangeState.REMOTE_OWNERSHIP_LOST_NO_OWNER, true);
 152     }
 153
 154     static final DOMEntityOwnershipChange getEntityMasterJeopardy() {
 155         return new DOMEntityOwnershipChange(ENTITY, EntityOwnershipChangeState.LOCAL_OWNERSHIP_RETAINED_WITH_NO_CHANGE,
 156             true);
 157     }
 158
 159     static final DOMEntityOwnershipChange getDoubleEntityToMaster() {
 160         return new DOMEntityOwnershipChange(DOUBLE_ENTITY, EntityOwnershipChangeState.LOCAL_OWNERSHIP_GRANTED);
 161     }
 162
 163     static final DOMEntityOwnershipChange getInitDoubleEntityToSlave() {
 164         return new DOMEntityOwnershipChange(DOUBLE_ENTITY, EntityOwnershipChangeState.REMOTE_OWNERSHIP_CHANGED);
 165     }
 166
 167     static final DOMEntityOwnershipChange getDoubleEntityToSlave() {
 168         return new DOMEntityOwnershipChange(DOUBLE_ENTITY, EntityOwnershipChangeState.LOCAL_OWNERSHIP_LOST_NEW_OWNER);
 169     }
 170
 171     static final DOMEntityOwnershipChange getDoubleEntityToJeopardy() {
 172         return new DOMEntityOwnershipChange(DOUBLE_ENTITY, EntityOwnershipChangeState.REMOTE_OWNERSHIP_LOST_NO_OWNER,
 173             true);
 174     }
 175
 176     static final DOMEntityOwnershipChange getDoubleEntityMasterJeopardy() {
 177         return new DOMEntityOwnershipChange(DOUBLE_ENTITY,
 178             EntityOwnershipChangeState.LOCAL_OWNERSHIP_RETAINED_WITH_NO_CHANGE, true);
 179     }
 180
 181     /**
 182      * Test checks NullPointer for null {@link DOMEntityOwnershipService} input value.
 183      */
 184     @Test(expected = NullPointerException.class)
 185     public void initializationClusterSingletonServiceProviderNullInputTest() {
 186         new DOMClusterSingletonServiceProviderImpl(null).close();
 187     }
 188
 189     /**
 190      * Test GoldPath for close {@link DOMClusterSingletonServiceProviderImpl}.
 191      *
 192      * @throws Exception if the condition does not meet
 193      */
 194     @Test
 195     public void closeClusterSingletonServiceProviderTest() throws Exception {
 196         verify(mockEos).registerListener(SERVICE_ENTITY_TYPE, clusterSingletonServiceProvider);
 197         verify(mockEos).registerListener(CLOSE_SERVICE_ENTITY_TYPE, clusterSingletonServiceProvider);
 198         clusterSingletonServiceProvider.close();
 199         verify(mockEosEntityListReg).close();
 200         verify(mockEosDoubleEntityListReg).close();
 201     }
 202
 203     /**
 204      * Test parser ServiceIdentifier from Entity.
 205      */
 206     @Test
 207     public void makeEntityClusterSingletonServiceProviderTest() {
 208         final DOMEntity testEntity = clusterSingletonServiceProvider.createEntity(SERVICE_ENTITY_TYPE, SERVICE_NAME);
 209         assertEquals(ENTITY, testEntity);
 210         final DOMEntity testDbEn = clusterSingletonServiceProvider.createEntity(CLOSE_SERVICE_ENTITY_TYPE,
 211                 SERVICE_NAME);
 212         assertEquals(DOUBLE_ENTITY, testDbEn);
 213     }
 214
 215     /**
 216      * Test parser ServiceIdentifier from Entity.
 217      */
 218     @Test
 219     public void getIdentifierClusterSingletonServiceProviderTest() {
 220         final String entityIdentifier = clusterSingletonServiceProvider.getServiceIdentifierFromEntity(ENTITY);
 221         assertEquals(SERVICE_NAME, entityIdentifier);
 222         final String doubleEntityId = clusterSingletonServiceProvider.getServiceIdentifierFromEntity(DOUBLE_ENTITY);
 223         assertEquals(SERVICE_NAME, doubleEntityId);
 224     }
 225
 226     /**
 227      * Test GoldPath for initialization {@link ClusterSingletonService}.
 228      *
 229      * @throws CandidateAlreadyRegisteredException if the condition does not meet
 230      */
 231     @Test
 232     public void initializationClusterSingletonServiceTest() throws CandidateAlreadyRegisteredException {
 233         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 234                 .registerClusterSingletonService(clusterSingletonService);
 235         assertNotNull(reg);
 236         verify(mockEos).registerCandidate(ENTITY);
 237         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 238     }
 239
 240     /**
 241      * Test GoldPath for initialization with init ownership result SLAVE {@link ClusterSingletonService}.
 242      *
 243      * @throws CandidateAlreadyRegisteredException if the condition does not meet
 244      */
 245     @Test
 246     public void slaveInitClusterSingletonServiceTest() throws CandidateAlreadyRegisteredException {
 247         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 248                 .registerClusterSingletonService(clusterSingletonService);
 249         assertNotNull(reg);
 250         verify(mockEos).registerCandidate(ENTITY);
 251         clusterSingletonServiceProvider.ownershipChanged(getInitEntityToSlave());
 252         verify(mockEos, never()).registerCandidate(DOUBLE_ENTITY);
 253         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 254     }
 255
 256     /**
 257      * Test GoldPath for initialization with init ownership result SLAVE, but NO-MASTER {@link ClusterSingletonService}.
 258      *
 259      * @throws CandidateAlreadyRegisteredException if the condition does not meet
 260      */
 261     @Test
 262     public void slaveInitNoMasterClusterSingletonServiceTest() throws CandidateAlreadyRegisteredException {
 263         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 264                 .registerClusterSingletonService(clusterSingletonService);
 265         assertNotNull(reg);
 266         verify(mockEos).registerCandidate(ENTITY);
 267         clusterSingletonServiceProvider.ownershipChanged(getInitEntityToSlaveNoMaster());
 268         verify(mockEos, never()).registerCandidate(DOUBLE_ENTITY);
 269         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 270     }
 271
 272     /**
 273      * Test GoldPath for initialization with init ownership result MASTER {@link ClusterSingletonService}.
 274      *
 275      * @throws CandidateAlreadyRegisteredException if the condition does not meet
 276      */
 277     @Test
 278     public void masterInitClusterSingletonServiceTest() throws CandidateAlreadyRegisteredException {
 279         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 280                 .registerClusterSingletonService(clusterSingletonService);
 281         assertNotNull(reg);
 282         verify(mockEos).registerCandidate(ENTITY);
 283         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 284         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
 285         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 286     }
 287
 288     /**
 289      * Test GoldPath for initialization with init ownership result MASTER {@link ClusterSingletonService}.
 290      *
 291      * @throws CandidateAlreadyRegisteredException if the condition does not meet
 292      */
 293     @Test
 294     public void masterInitSlaveDoubleCandidateClusterSingletonServiceTest() throws CandidateAlreadyRegisteredException {
 295         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 296                 .registerClusterSingletonService(clusterSingletonService);
 297         assertNotNull(reg);
 298         verify(mockEos).registerCandidate(ENTITY);
 299         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 300         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
 301         clusterSingletonServiceProvider.ownershipChanged(getInitDoubleEntityToSlave());
 302         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 303     }
 304
 305     /**
 306      * Test GoldPath for takeLeadership with ownership result MASTER {@link ClusterSingletonService}.
 307      *
 308      * @throws CandidateAlreadyRegisteredException if the condition does not meet
 309      */
 310     @Test
 311     public void takeLeadershipClusterSingletonServiceTest() throws CandidateAlreadyRegisteredException {
 312         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 313                 .registerClusterSingletonService(clusterSingletonService);
 314         assertNotNull(reg);
 315         verify(mockEos).registerCandidate(ENTITY);
 316         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 317         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
 318         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 319         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 320         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 321     }
 322
 323     /**
 324      * Test GoldPath for initialization with init ownership result MASTER {@link ClusterSingletonService}.
 325      *
 326      * @throws CandidateAlreadyRegisteredException if the condition does not meet
 327      */
 328     @Test
 329     public void masterInitClusterSingletonServiceTwoServicesTest() throws CandidateAlreadyRegisteredException {
 330         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 331                 .registerClusterSingletonService(clusterSingletonService);
 332         assertNotNull(reg);
 333         verify(mockEos).registerCandidate(ENTITY);
 334         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 335         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
 336         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 337         final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
 338                 .registerClusterSingletonService(clusterSingletonService2);
 339         assertNotNull(reg2);
 340         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
 341     }
 342
 343     /**
 344      * Test GoldPath for takeLeadership with ownership result MASTER {@link ClusterSingletonService}.
 345      *
 346      * @throws CandidateAlreadyRegisteredException if the condition does not meet
 347      */
 348     @Test
 349     public void takeLeadershipClusterSingletonServiceTwoAddDuringWaitPhaseServicesTest()
 350             throws CandidateAlreadyRegisteredException {
 351         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 352                 .registerClusterSingletonService(clusterSingletonService);
 353         assertNotNull(reg);
 354         verify(mockEos).registerCandidate(ENTITY);
 355         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 356         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
 357         final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
 358                 .registerClusterSingletonService(clusterSingletonService2);
 359         assertNotNull(reg2);
 360         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 361         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
 362         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 363         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 364         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
 365     }
 366
 367     /**
 368      * Test checks CandidateAlreadyRegisteredException processing in initialization phase.
 369      *
 370      * @throws CandidateAlreadyRegisteredException if the condition does not meet
 371      */
 372     @Test(expected = RuntimeException.class)
 373     public void initializationClusterSingletonServiceCandidateAlreadyRegistredTest()
 374             throws CandidateAlreadyRegisteredException {
 375         doThrow(CandidateAlreadyRegisteredException.class).when(mockEos).registerCandidate(ENTITY);
 376         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 377                 .registerClusterSingletonService(clusterSingletonService);
 378         assertNull(reg);
 379     }
 380
 381     /**
 382      * Test GoldPath for lostLeadership during tryToTakeLeadership with ownership result MASTER
 383      * {@link ClusterSingletonService}.
 384      *
 385      * @throws CandidateAlreadyRegisteredException if the condition does not meet
 386      */
 387     @Test
 388     public void lostLeadershipDuringTryToTakeLeadershipClusterSingletonServiceTest()
 389             throws CandidateAlreadyRegisteredException {
 390         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 391                 .registerClusterSingletonService(clusterSingletonService);
 392         assertNotNull(reg);
 393         verify(mockEos).registerCandidate(ENTITY);
 394         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 395         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
 396         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 397         clusterSingletonServiceProvider.ownershipChanged(getEntityToSlave());
 398         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 399         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 400         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 401     }
 402
 403     /**
 404      * Test GoldPath for lostLeadership with ownership result MASTER-TO-SLAVE {@link ClusterSingletonService}.
 405      *
 406      * @throws CandidateAlreadyRegisteredException if the condition does not meet
 407      */
 408     @Test
 409     public void lostLeadershipClusterSingletonServiceTest() throws CandidateAlreadyRegisteredException {
 410         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 411                 .registerClusterSingletonService(clusterSingletonService);
 412         assertNotNull(reg);
 413         verify(mockEos).registerCandidate(ENTITY);
 414         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 415         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
 416         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 417         clusterSingletonServiceProvider.ownershipChanged(getInitDoubleEntityToSlave());
 418         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 419         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 420         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 421         clusterSingletonServiceProvider.ownershipChanged(getEntityToSlave());
 422         assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
 423     }
 424
 425     /**
 426      * Test checks inJeopardy Cluster Node state for Slave Instance.
 427      *
 428      * @throws CandidateAlreadyRegisteredException if the condition does not meet
 429      */
 430     @Test
 431     public void inJeopardySlaveTest() throws CandidateAlreadyRegisteredException {
 432         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 433                 .registerClusterSingletonService(clusterSingletonService);
 434         assertNotNull(reg);
 435         verify(mockEos).registerCandidate(ENTITY);
 436         clusterSingletonServiceProvider.ownershipChanged(getInitEntityToSlave());
 437         verify(mockEos, never()).registerCandidate(DOUBLE_ENTITY);
 438         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 439         clusterSingletonServiceProvider.ownershipChanged(getEntityToJeopardy());
 440         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 441         verify(mockEosEntityListReg, never()).close();
 442         verify(mockEosDoubleEntityListReg, never()).close();
 443         verify(mockEntityCandReg, never()).close();
 444         verify(mockDoubleEntityCandReg, never()).close();
 445     }
 446
 447     /**
 448      * Test GoldPath for takeLeadership with ownership result MASTER {@link ClusterSingletonService}.
 449      *
 450      * @throws CandidateAlreadyRegisteredException if the condition does not meet
 451      */
 452     @Test
 453     public void takeLeadershipClusterSingletonServiceTowServicesTest() throws CandidateAlreadyRegisteredException {
 454         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 455                 .registerClusterSingletonService(clusterSingletonService);
 456         assertNotNull(reg);
 457         verify(mockEos).registerCandidate(ENTITY);
 458         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 459         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
 460         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 461         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 462         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 463         final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
 464                 .registerClusterSingletonService(clusterSingletonService2);
 465         assertNotNull(reg2);
 466         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
 467     }
 468
 469     /**
 470      * Test checks close processing for {@link ClusterSingletonServiceRegistration}.
 471      *
 472      * @throws Exception if the condition does not meet
 473      */
 474     @Test
 475     public void closeClusterSingletonServiceRegistrationNoRoleTest() throws Exception {
 476         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 477                 .registerClusterSingletonService(clusterSingletonService);
 478         assertNotNull(reg);
 479         verify(mockEos).registerCandidate(ENTITY);
 480         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 481         reg.close();
 482         verify(mockEosEntityListReg, never()).close();
 483         verify(mockEosDoubleEntityListReg, never()).close();
 484         verify(mockEntityCandReg).close();
 485         verify(mockDoubleEntityCandReg, never()).close();
 486         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 487     }
 488
 489     /**
 490      * Test checks close processing for {@link ClusterSingletonServiceRegistration}.
 491      *
 492      * @throws Exception if the condition does not meet
 493      */
 494     @Test
 495     public void closeClusterSingletonServiceRegistrationNoRoleTwoServicesTest() throws Exception {
 496         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 497                 .registerClusterSingletonService(clusterSingletonService);
 498         assertNotNull(reg);
 499         verify(mockEos).registerCandidate(ENTITY);
 500         final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
 501                 .registerClusterSingletonService(clusterSingletonService2);
 502         assertNotNull(reg2);
 503         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 504         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
 505         reg.close();
 506         verify(mockEosEntityListReg, never()).close();
 507         verify(mockEosDoubleEntityListReg, never()).close();
 508         verify(mockEntityCandReg, never()).close();
 509         verify(mockDoubleEntityCandReg, never()).close();
 510         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 511         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
 512     }
 513
 514     /**
 515      * Test checks close processing for {@link ClusterSingletonServiceRegistration}.
 516      *
 517      * @throws Exception if the condition does not meet
 518      */
 519     @Test
 520     public void closeClusterSingletonServiceRegistrationSlaveTest() throws Exception {
 521         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 522                 .registerClusterSingletonService(clusterSingletonService);
 523         assertNotNull(reg);
 524         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 525         verify(mockEos).registerCandidate(ENTITY);
 526         clusterSingletonServiceProvider.ownershipChanged(getInitEntityToSlave());
 527         reg.close();
 528         verify(mockEosEntityListReg, never()).close();
 529         verify(mockEosDoubleEntityListReg, never()).close();
 530         verify(mockEntityCandReg).close();
 531         verify(mockDoubleEntityCandReg, never()).close();
 532         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 533     }
 534
 535     /**
 536      * Test checks close processing for {@link ClusterSingletonServiceRegistration}.
 537      *
 538      * @throws Exception if the condition does not meet
 539      */
 540     @Test
 541     public void closeClusterSingletonServiceRegistrationSlaveTwoServicesTest() throws Exception {
 542         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 543                 .registerClusterSingletonService(clusterSingletonService);
 544         assertNotNull(reg);
 545         verify(mockEos).registerCandidate(ENTITY);
 546         final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
 547                 .registerClusterSingletonService(clusterSingletonService2);
 548         assertNotNull(reg2);
 549         clusterSingletonServiceProvider.ownershipChanged(getInitEntityToSlave());
 550         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 551         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
 552         reg.close();
 553         verify(mockEosEntityListReg, never()).close();
 554         verify(mockEosDoubleEntityListReg, never()).close();
 555         verify(mockEntityCandReg, never()).close();
 556         verify(mockDoubleEntityCandReg, never()).close();
 557         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 558         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
 559     }
 560
 561     /**
 562      * Test checks close processing for {@link ClusterSingletonServiceRegistration}.
 563      *
 564      * @throws Exception if the condition does not meet
 565      */
 566     @Test
 567     public void closeClusterSingletonServiceRegistrationMasterTwoServicesTest() throws Exception {
 568         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 569                 .registerClusterSingletonService(clusterSingletonService);
 570         assertNotNull(reg);
 571         final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
 572                 .registerClusterSingletonService(clusterSingletonService2);
 573         assertNotNull(reg2);
 574         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 575         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
 576         verify(mockEos).registerCandidate(ENTITY);
 577         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 578         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
 579         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 580         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 581         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
 582         reg.close();
 583         verify(mockEosEntityListReg, never()).close();
 584         verify(mockEosDoubleEntityListReg, never()).close();
 585         verify(mockEntityCandReg, never()).close();
 586         verify(mockDoubleEntityCandReg, never()).close();
 587         assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
 588         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
 589     }
 590
 591     /**
 592      * Test checks validation Error processing for SLAVE-TO-MASTER entity Candidate role change.
 593      *
 594      * @throws Exception if the condition does not meet
 595      */
 596     @Test
 597     public void tryToTakeLeaderForClosedServiceRegistrationTest() throws Exception {
 598         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 599                 .registerClusterSingletonService(clusterSingletonService);
 600         assertNotNull(reg);
 601         final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
 602                 .registerClusterSingletonService(clusterSingletonService2);
 603         assertNotNull(reg2);
 604         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 605         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
 606         verify(mockEos).registerCandidate(ENTITY);
 607         reg.close();
 608         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 609         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
 610         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 611         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 612         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
 613         verify(mockEosEntityListReg, never()).close();
 614         verify(mockEosDoubleEntityListReg, never()).close();
 615         verify(mockEntityCandReg, never()).close();
 616         verify(mockDoubleEntityCandReg, never()).close();
 617         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 618         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
 619     }
 620 }