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