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