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