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