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