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 getDoubleEntityToMaster() {
 154         return new DOMEntityOwnershipChange(DOUBLE_ENTITY, EntityOwnershipChangeState.LOCAL_OWNERSHIP_GRANTED);
 155     }
 156
 157     static final DOMEntityOwnershipChange getInitDoubleEntityToSlave() {
 158         return new DOMEntityOwnershipChange(DOUBLE_ENTITY, EntityOwnershipChangeState.REMOTE_OWNERSHIP_CHANGED);
 159     }
 160
 161     static final DOMEntityOwnershipChange getDoubleEntityToSlave() {
 162         return new DOMEntityOwnershipChange(DOUBLE_ENTITY, EntityOwnershipChangeState.LOCAL_OWNERSHIP_LOST_NEW_OWNER);
 163     }
 164
 165     static final DOMEntityOwnershipChange getEntityToJeopardy() {
 166         return new DOMEntityOwnershipChange(ENTITY, EntityOwnershipChangeState.REMOTE_OWNERSHIP_LOST_NO_OWNER, true);
 167     }
 168
 169     /**
 170      * Test checks NullPointer for null {@link DOMEntityOwnershipService} input value.
 171      */
 172     @Test(expected = NullPointerException.class)
 173     public void initializationClusterSingletonServiceProviderNullInputTest() {
 174         new DOMClusterSingletonServiceProviderImpl(null).close();
 175     }
 176
 177     /**
 178      * Test GoldPath for close {@link DOMClusterSingletonServiceProviderImpl}.
 179      *
 180      * @throws Exception if the condition does not meet
 181      */
 182     @Test
 183     public void closeClusterSingletonServiceProviderTest() throws Exception {
 184         verify(mockEos).registerListener(SERVICE_ENTITY_TYPE, clusterSingletonServiceProvider);
 185         verify(mockEos).registerListener(CLOSE_SERVICE_ENTITY_TYPE, clusterSingletonServiceProvider);
 186         clusterSingletonServiceProvider.close();
 187         verify(mockEosEntityListReg).close();
 188         verify(mockEosDoubleEntityListReg).close();
 189     }
 190
 191     /**
 192      * Test parser ServiceIdentifier from Entity.
 193      */
 194     @Test
 195     public void makeEntityClusterSingletonServiceProviderTest() {
 196         final DOMEntity testEntity = clusterSingletonServiceProvider.createEntity(SERVICE_ENTITY_TYPE, SERVICE_NAME);
 197         assertEquals(ENTITY, testEntity);
 198         final DOMEntity testDbEn = clusterSingletonServiceProvider.createEntity(CLOSE_SERVICE_ENTITY_TYPE,
 199                 SERVICE_NAME);
 200         assertEquals(DOUBLE_ENTITY, testDbEn);
 201     }
 202
 203     /**
 204      * Test parser ServiceIdentifier from Entity.
 205      */
 206     @Test
 207     public void getIdentifierClusterSingletonServiceProviderTest() {
 208         final String entityIdentifier = clusterSingletonServiceProvider.getServiceIdentifierFromEntity(ENTITY);
 209         assertEquals(SERVICE_NAME, entityIdentifier);
 210         final String doubleEntityId = clusterSingletonServiceProvider.getServiceIdentifierFromEntity(DOUBLE_ENTITY);
 211         assertEquals(SERVICE_NAME, doubleEntityId);
 212     }
 213
 214     /**
 215      * Test GoldPath for initialization {@link ClusterSingletonService}.
 216      *
 217      * @throws CandidateAlreadyRegisteredException if the condition does not meet
 218      */
 219     @Test
 220     public void initializationClusterSingletonServiceTest() throws CandidateAlreadyRegisteredException {
 221         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 222                 .registerClusterSingletonService(clusterSingletonService);
 223         assertNotNull(reg);
 224         verify(mockEos).registerCandidate(ENTITY);
 225         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 226     }
 227
 228     /**
 229      * Test GoldPath for initialization with init ownership result SLAVE {@link ClusterSingletonService}.
 230      *
 231      * @throws CandidateAlreadyRegisteredException if the condition does not meet
 232      */
 233     @Test
 234     public void slaveInitClusterSingletonServiceTest() throws CandidateAlreadyRegisteredException {
 235         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 236                 .registerClusterSingletonService(clusterSingletonService);
 237         assertNotNull(reg);
 238         verify(mockEos).registerCandidate(ENTITY);
 239         clusterSingletonServiceProvider.ownershipChanged(getInitEntityToSlave());
 240         verify(mockEos, never()).registerCandidate(DOUBLE_ENTITY);
 241         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 242     }
 243
 244     /**
 245      * Test GoldPath for initialization with init ownership result SLAVE, but NO-MASTER {@link ClusterSingletonService}.
 246      *
 247      * @throws CandidateAlreadyRegisteredException if the condition does not meet
 248      */
 249     @Test
 250     public void slaveInitNoMasterClusterSingletonServiceTest() throws CandidateAlreadyRegisteredException {
 251         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 252                 .registerClusterSingletonService(clusterSingletonService);
 253         assertNotNull(reg);
 254         verify(mockEos).registerCandidate(ENTITY);
 255         clusterSingletonServiceProvider.ownershipChanged(getInitEntityToSlaveNoMaster());
 256         verify(mockEos, never()).registerCandidate(DOUBLE_ENTITY);
 257         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 258     }
 259
 260     /**
 261      * Test GoldPath for initialization with init ownership result MASTER {@link ClusterSingletonService}.
 262      *
 263      * @throws CandidateAlreadyRegisteredException if the condition does not meet
 264      */
 265     @Test
 266     public void masterInitClusterSingletonServiceTest() throws CandidateAlreadyRegisteredException {
 267         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 268                 .registerClusterSingletonService(clusterSingletonService);
 269         assertNotNull(reg);
 270         verify(mockEos).registerCandidate(ENTITY);
 271         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 272         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
 273         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 274     }
 275
 276     /**
 277      * Test GoldPath for initialization with init ownership result MASTER {@link ClusterSingletonService}.
 278      *
 279      * @throws CandidateAlreadyRegisteredException if the condition does not meet
 280      */
 281     @Test
 282     public void masterInitSlaveDoubleCandidateClusterSingletonServiceTest() throws CandidateAlreadyRegisteredException {
 283         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 284                 .registerClusterSingletonService(clusterSingletonService);
 285         assertNotNull(reg);
 286         verify(mockEos).registerCandidate(ENTITY);
 287         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 288         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
 289         clusterSingletonServiceProvider.ownershipChanged(getInitDoubleEntityToSlave());
 290         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 291     }
 292
 293     /**
 294      * Test GoldPath for takeLeadership with ownership result MASTER {@link ClusterSingletonService}.
 295      *
 296      * @throws CandidateAlreadyRegisteredException if the condition does not meet
 297      */
 298     @Test
 299     public void takeLeadershipClusterSingletonServiceTest() throws CandidateAlreadyRegisteredException {
 300         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 301                 .registerClusterSingletonService(clusterSingletonService);
 302         assertNotNull(reg);
 303         verify(mockEos).registerCandidate(ENTITY);
 304         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 305         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
 306         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 307         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 308         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 309     }
 310
 311     /**
 312      * Test GoldPath for initialization with init ownership result MASTER {@link ClusterSingletonService}.
 313      *
 314      * @throws CandidateAlreadyRegisteredException if the condition does not meet
 315      */
 316     @Test
 317     public void masterInitClusterSingletonServiceTwoServicesTest() throws CandidateAlreadyRegisteredException {
 318         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 319                 .registerClusterSingletonService(clusterSingletonService);
 320         assertNotNull(reg);
 321         verify(mockEos).registerCandidate(ENTITY);
 322         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 323         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
 324         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 325         final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
 326                 .registerClusterSingletonService(clusterSingletonService2);
 327         assertNotNull(reg2);
 328         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
 329     }
 330
 331     /**
 332      * Test GoldPath for takeLeadership with ownership result MASTER {@link ClusterSingletonService}.
 333      *
 334      * @throws CandidateAlreadyRegisteredException if the condition does not meet
 335      */
 336     @Test
 337     public void takeLeadershipClusterSingletonServiceTwoAddDuringWaitPhaseServicesTest()
 338             throws CandidateAlreadyRegisteredException {
 339         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 340                 .registerClusterSingletonService(clusterSingletonService);
 341         assertNotNull(reg);
 342         verify(mockEos).registerCandidate(ENTITY);
 343         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 344         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
 345         final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
 346                 .registerClusterSingletonService(clusterSingletonService2);
 347         assertNotNull(reg2);
 348         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 349         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
 350         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 351         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 352         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
 353     }
 354
 355     /**
 356      * Test checks CandidateAlreadyRegisteredException processing in initialization phase.
 357      *
 358      * @throws CandidateAlreadyRegisteredException if the condition does not meet
 359      */
 360     @Test(expected = RuntimeException.class)
 361     public void initializationClusterSingletonServiceCandidateAlreadyRegistredTest()
 362             throws CandidateAlreadyRegisteredException {
 363         doThrow(CandidateAlreadyRegisteredException.class).when(mockEos).registerCandidate(ENTITY);
 364         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 365                 .registerClusterSingletonService(clusterSingletonService);
 366         assertNull(reg);
 367     }
 368
 369     /**
 370      * Test GoldPath for lostLeadership during tryToTakeLeadership with ownership result MASTER
 371      * {@link ClusterSingletonService}.
 372      *
 373      * @throws CandidateAlreadyRegisteredException if the condition does not meet
 374      */
 375     @Test
 376     public void lostLeadershipDuringTryToTakeLeadershipClusterSingletonServiceTest()
 377             throws CandidateAlreadyRegisteredException {
 378         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 379                 .registerClusterSingletonService(clusterSingletonService);
 380         assertNotNull(reg);
 381         verify(mockEos).registerCandidate(ENTITY);
 382         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 383         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
 384         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 385         clusterSingletonServiceProvider.ownershipChanged(getEntityToSlave());
 386         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 387         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 388         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 389     }
 390
 391     /**
 392      * Test GoldPath for lostLeadership with ownership result MASTER-TO-SLAVE {@link ClusterSingletonService}.
 393      *
 394      * @throws CandidateAlreadyRegisteredException if the condition does not meet
 395      */
 396     @Test
 397     public void lostLeadershipClusterSingletonServiceTest() throws CandidateAlreadyRegisteredException {
 398         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 399                 .registerClusterSingletonService(clusterSingletonService);
 400         assertNotNull(reg);
 401         verify(mockEos).registerCandidate(ENTITY);
 402         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 403         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
 404         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 405         clusterSingletonServiceProvider.ownershipChanged(getInitDoubleEntityToSlave());
 406         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 407         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 408         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 409         clusterSingletonServiceProvider.ownershipChanged(getEntityToSlave());
 410         assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
 411     }
 412
 413     /**
 414      * Test checks inJeopardy Cluster Node state for Slave Instance.
 415      *
 416      * @throws CandidateAlreadyRegisteredException if the condition does not meet
 417      */
 418     @Test
 419     public void inJeopardySlaveTest() throws CandidateAlreadyRegisteredException {
 420         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 421                 .registerClusterSingletonService(clusterSingletonService);
 422         assertNotNull(reg);
 423         verify(mockEos).registerCandidate(ENTITY);
 424         clusterSingletonServiceProvider.ownershipChanged(getInitEntityToSlave());
 425         verify(mockEos, never()).registerCandidate(DOUBLE_ENTITY);
 426         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 427         clusterSingletonServiceProvider.ownershipChanged(getEntityToJeopardy());
 428         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 429         verify(mockEosEntityListReg, never()).close();
 430         verify(mockEosDoubleEntityListReg, never()).close();
 431         verify(mockEntityCandReg, never()).close();
 432         verify(mockDoubleEntityCandReg, never()).close();
 433     }
 434
 435     /**
 436      * Test GoldPath for takeLeadership with ownership result MASTER {@link ClusterSingletonService}.
 437      *
 438      * @throws CandidateAlreadyRegisteredException if the condition does not meet
 439      */
 440     @Test
 441     public void takeLeadershipClusterSingletonServiceTowServicesTest() throws CandidateAlreadyRegisteredException {
 442         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 443                 .registerClusterSingletonService(clusterSingletonService);
 444         assertNotNull(reg);
 445         verify(mockEos).registerCandidate(ENTITY);
 446         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 447         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
 448         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 449         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 450         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 451         final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
 452                 .registerClusterSingletonService(clusterSingletonService2);
 453         assertNotNull(reg2);
 454         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
 455     }
 456
 457     /**
 458      * Test checks close processing for {@link ClusterSingletonServiceRegistration}.
 459      *
 460      * @throws Exception if the condition does not meet
 461      */
 462     @Test
 463     public void closeClusterSingletonServiceRegistrationNoRoleTest() throws Exception {
 464         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 465                 .registerClusterSingletonService(clusterSingletonService);
 466         assertNotNull(reg);
 467         verify(mockEos).registerCandidate(ENTITY);
 468         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 469         reg.close();
 470         verify(mockEosEntityListReg, never()).close();
 471         verify(mockEosDoubleEntityListReg, never()).close();
 472         verify(mockEntityCandReg).close();
 473         verify(mockDoubleEntityCandReg, never()).close();
 474         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 475     }
 476
 477     /**
 478      * Test checks close processing for {@link ClusterSingletonServiceRegistration}.
 479      *
 480      * @throws Exception if the condition does not meet
 481      */
 482     @Test
 483     public void closeClusterSingletonServiceRegistrationNoRoleTwoServicesTest() throws Exception {
 484         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 485                 .registerClusterSingletonService(clusterSingletonService);
 486         assertNotNull(reg);
 487         verify(mockEos).registerCandidate(ENTITY);
 488         final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
 489                 .registerClusterSingletonService(clusterSingletonService2);
 490         assertNotNull(reg2);
 491         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 492         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
 493         reg.close();
 494         verify(mockEosEntityListReg, never()).close();
 495         verify(mockEosDoubleEntityListReg, never()).close();
 496         verify(mockEntityCandReg, never()).close();
 497         verify(mockDoubleEntityCandReg, never()).close();
 498         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 499         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
 500     }
 501
 502     /**
 503      * Test checks close processing for {@link ClusterSingletonServiceRegistration}.
 504      *
 505      * @throws Exception if the condition does not meet
 506      */
 507     @Test
 508     public void closeClusterSingletonServiceRegistrationSlaveTest() throws Exception {
 509         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 510                 .registerClusterSingletonService(clusterSingletonService);
 511         assertNotNull(reg);
 512         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 513         verify(mockEos).registerCandidate(ENTITY);
 514         clusterSingletonServiceProvider.ownershipChanged(getInitEntityToSlave());
 515         reg.close();
 516         verify(mockEosEntityListReg, never()).close();
 517         verify(mockEosDoubleEntityListReg, never()).close();
 518         verify(mockEntityCandReg).close();
 519         verify(mockDoubleEntityCandReg, never()).close();
 520         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 521     }
 522
 523     /**
 524      * Test checks close processing for {@link ClusterSingletonServiceRegistration}.
 525      *
 526      * @throws Exception if the condition does not meet
 527      */
 528     @Test
 529     public void closeClusterSingletonServiceRegistrationSlaveTwoServicesTest() throws Exception {
 530         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 531                 .registerClusterSingletonService(clusterSingletonService);
 532         assertNotNull(reg);
 533         verify(mockEos).registerCandidate(ENTITY);
 534         final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
 535                 .registerClusterSingletonService(clusterSingletonService2);
 536         assertNotNull(reg2);
 537         clusterSingletonServiceProvider.ownershipChanged(getInitEntityToSlave());
 538         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 539         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
 540         reg.close();
 541         verify(mockEosEntityListReg, never()).close();
 542         verify(mockEosDoubleEntityListReg, never()).close();
 543         verify(mockEntityCandReg, never()).close();
 544         verify(mockDoubleEntityCandReg, never()).close();
 545         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 546         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
 547     }
 548
 549     /**
 550      * Test checks close processing for {@link ClusterSingletonServiceRegistration}.
 551      *
 552      * @throws Exception if the condition does not meet
 553      */
 554     @Test
 555     public void closeClusterSingletonServiceRegistrationMasterTwoServicesTest() throws Exception {
 556         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 557                 .registerClusterSingletonService(clusterSingletonService);
 558         assertNotNull(reg);
 559         final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
 560                 .registerClusterSingletonService(clusterSingletonService2);
 561         assertNotNull(reg2);
 562         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 563         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
 564         verify(mockEos).registerCandidate(ENTITY);
 565         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 566         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
 567         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 568         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 569         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
 570         reg.close();
 571         verify(mockEosEntityListReg, never()).close();
 572         verify(mockEosDoubleEntityListReg, never()).close();
 573         verify(mockEntityCandReg, never()).close();
 574         verify(mockDoubleEntityCandReg, never()).close();
 575         assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
 576         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
 577     }
 578
 579     /**
 580      * Test checks validation Error processing for SLAVE-TO-MASTER entity Candidate role change.
 581      *
 582      * @throws Exception if the condition does not meet
 583      */
 584     @Test
 585     public void tryToTakeLeaderForClosedServiceRegistrationTest() throws Exception {
 586         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 587                 .registerClusterSingletonService(clusterSingletonService);
 588         assertNotNull(reg);
 589         final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
 590                 .registerClusterSingletonService(clusterSingletonService2);
 591         assertNotNull(reg2);
 592         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 593         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
 594         verify(mockEos).registerCandidate(ENTITY);
 595         reg.close();
 596         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 597         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
 598         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 599         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 600         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
 601         verify(mockEosEntityListReg, never()).close();
 602         verify(mockEosDoubleEntityListReg, never()).close();
 603         verify(mockEntityCandReg, never()).close();
 604         verify(mockDoubleEntityCandReg, never()).close();
 605         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 606         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
 607     }
 608 }