singleton-service/mdsal-singleton-dom-impl/src/test/java/org/opendaylight/mdsal/singleton/dom/impl/DOMClusterSingletonServiceProviderImplTest.java

   1 /*
   2  * Copyright (c) 2016 Cisco Systems, Inc. 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
   9 package org.opendaylight.mdsal.singleton.dom.impl;
  10
  11 import static org.mockito.Matchers.any;
  12 import static org.mockito.Matchers.eq;
  13 import static org.mockito.Mockito.doNothing;
  14 import static org.mockito.Mockito.doReturn;
  15 import static org.mockito.Mockito.doThrow;
  16 import static org.mockito.Mockito.never;
  17 import static org.mockito.Mockito.verify;
  18
  19 import com.google.common.util.concurrent.Futures;
  20 import com.google.common.util.concurrent.ListenableFuture;
  21 import org.junit.Assert;
  22 import org.junit.Before;
  23 import org.junit.Test;
  24 import org.mockito.Mock;
  25 import org.mockito.MockitoAnnotations;
  26 import org.opendaylight.mdsal.eos.common.api.CandidateAlreadyRegisteredException;
  27 import org.opendaylight.mdsal.eos.common.api.EntityOwnershipChangeState;
  28 import org.opendaylight.mdsal.eos.dom.api.DOMEntity;
  29 import org.opendaylight.mdsal.eos.dom.api.DOMEntityOwnershipCandidateRegistration;
  30 import org.opendaylight.mdsal.eos.dom.api.DOMEntityOwnershipChange;
  31 import org.opendaylight.mdsal.eos.dom.api.DOMEntityOwnershipListenerRegistration;
  32 import org.opendaylight.mdsal.eos.dom.api.DOMEntityOwnershipService;
  33 import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
  34 import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
  35 import org.opendaylight.mdsal.singleton.common.api.ServiceGroupIdentifier;
  36
  37 /**
  38  * Testing {@link DOMClusterSingletonServiceProviderImpl} implementation.
  39  */
  40 public class DOMClusterSingletonServiceProviderImplTest {
  41
  42     private static final String SERVICE_ENTITY_TYPE = "org.opendaylight.mdsal.ServiceEntityType";
  43     private static final String CLOSE_SERVICE_ENTITY_TYPE = "org.opendaylight.mdsal.AsyncServiceCloseEntityType";
  44     private static final String SERVICE_NAME = "testServiceName";
  45
  46     @Mock
  47     private DOMEntityOwnershipService mockEos;
  48     @Mock
  49     private DOMEntityOwnershipCandidateRegistration mockEntityCandReg;
  50     @Mock
  51     private DOMEntityOwnershipCandidateRegistration mockDoubleEntityCandReg;
  52     @Mock
  53     private DOMEntityOwnershipListenerRegistration mockEosEntityListReg;
  54     @Mock
  55     private DOMEntityOwnershipListenerRegistration mockEosDoubleEntityListReg;
  56
  57     private DOMClusterSingletonServiceProviderImpl clusterSingletonServiceProvider;
  58     private TestClusterSingletonServiceInstance clusterSingletonService;
  59     private TestClusterSingletonServiceInstance clusterSingletonService2;
  60
  61     private final DOMEntity entity = new DOMEntity(SERVICE_ENTITY_TYPE, SERVICE_NAME);
  62     private final DOMEntity doubleEntity = new DOMEntity(CLOSE_SERVICE_ENTITY_TYPE, SERVICE_NAME);
  63
  64     /**
  65      * Initialization functionality for every Tests in this suite.
  66      *
  67      * @throws Exception if the condition does not meet
  68      */
  69     @Before
  70     public void setup() throws Exception {
  71         MockitoAnnotations.initMocks(this);
  72
  73         doNothing().when(mockEosEntityListReg).close();
  74         doNothing().when(mockEosDoubleEntityListReg).close();
  75         doNothing().when(mockEntityCandReg).close();
  76         doNothing().when(mockDoubleEntityCandReg).close();
  77         doReturn(mockEosEntityListReg).when(mockEos).registerListener(eq(SERVICE_ENTITY_TYPE),
  78                 any(DOMClusterSingletonServiceProviderImpl.class));
  79         doReturn(mockEosDoubleEntityListReg).when(mockEos).registerListener(eq(CLOSE_SERVICE_ENTITY_TYPE),
  80                 any(DOMClusterSingletonServiceProviderImpl.class));
  81         doReturn(mockEntityCandReg).when(mockEos).registerCandidate(entity);
  82         doReturn(mockDoubleEntityCandReg).when(mockEos).registerCandidate(doubleEntity);
  83
  84         clusterSingletonServiceProvider = new DOMClusterSingletonServiceProviderImpl(mockEos);
  85         clusterSingletonServiceProvider.initializeProvider();
  86         verify(mockEos).registerListener(SERVICE_ENTITY_TYPE, clusterSingletonServiceProvider);
  87         verify(mockEos).registerListener(CLOSE_SERVICE_ENTITY_TYPE, clusterSingletonServiceProvider);
  88
  89         clusterSingletonService = new TestClusterSingletonServiceInstance();
  90         clusterSingletonService2 = new TestClusterSingletonServiceInstance();
  91
  92         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
  93         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
  94     }
  95
  96     /**
  97      * Test checks NullPointer for null {@link DOMEntityOwnershipService} input value.
  98      *
  99      * @throws Exception if the condition does not meet
 100      */
 101     @Test(expected = NullPointerException.class)
 102     public void initializationClusterSingletonServiceProviderNullInputTest() throws Exception {
 103         clusterSingletonServiceProvider = new DOMClusterSingletonServiceProviderImpl(null);
 104     }
 105
 106     /**
 107      * Test GoldPath for close {@link DOMClusterSingletonServiceProviderImpl}.
 108      *
 109      * @throws Exception if the condition does not meet
 110      */
 111     @Test
 112     public void closeClusterSingletonServiceProviderTest() throws Exception {
 113         verify(mockEos).registerListener(SERVICE_ENTITY_TYPE, clusterSingletonServiceProvider);
 114         verify(mockEos).registerListener(CLOSE_SERVICE_ENTITY_TYPE, clusterSingletonServiceProvider);
 115         clusterSingletonServiceProvider.close();
 116         verify(mockEosEntityListReg).close();
 117         verify(mockEosDoubleEntityListReg).close();
 118     }
 119
 120     /**
 121      * Test parser ServiceIdentifier from Entity.
 122      *
 123      * @throws Exception if the condition does not meet
 124      */
 125     @Test
 126     public void makeEntityClusterSingletonServiceProviderTest() throws Exception {
 127         final DOMEntity testEntity = clusterSingletonServiceProvider.createEntity(SERVICE_ENTITY_TYPE, SERVICE_NAME);
 128         Assert.assertEquals(entity, testEntity);
 129         final DOMEntity testDbEn = clusterSingletonServiceProvider.createEntity(CLOSE_SERVICE_ENTITY_TYPE,
 130                 SERVICE_NAME);
 131         Assert.assertEquals(doubleEntity, testDbEn);
 132     }
 133
 134     /**
 135      * Test parser ServiceIdentifier from Entity.
 136      *
 137      * @throws Exception if the condition does not meet
 138      */
 139     @Test
 140     public void getIdentifierClusterSingletonServiceProviderTest() throws Exception {
 141         final String entityIdentifier = clusterSingletonServiceProvider.getServiceIdentifierFromEntity(entity);
 142         Assert.assertEquals(SERVICE_NAME, entityIdentifier);
 143         final String doubleEntityId = clusterSingletonServiceProvider.getServiceIdentifierFromEntity(doubleEntity);
 144         Assert.assertEquals(SERVICE_NAME, doubleEntityId);
 145     }
 146
 147     /**
 148      * Test GoldPath for initialization {@link ClusterSingletonService}.
 149      *
 150      * @throws Exception if the condition does not meet
 151      */
 152     @Test
 153     public void initializationClusterSingletonServiceTest() throws Exception {
 154         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 155                 .registerClusterSingletonService(clusterSingletonService);
 156         Assert.assertNotNull(reg);
 157         verify(mockEos).registerCandidate(entity);
 158         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 159     }
 160
 161     /**
 162      * Test GoldPath for initialization with init ownership result SLAVE {@link ClusterSingletonService}.
 163      *
 164      * @throws Exception if the condition does not meet
 165      */
 166     @Test
 167     public void slaveInitClusterSingletonServiceTest() throws Exception {
 168         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 169                 .registerClusterSingletonService(clusterSingletonService);
 170         Assert.assertNotNull(reg);
 171         verify(mockEos).registerCandidate(entity);
 172         clusterSingletonServiceProvider.ownershipChanged(getInitEntityToSlave());
 173         verify(mockEos, never()).registerCandidate(doubleEntity);
 174         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 175     }
 176
 177     /**
 178      * Test GoldPath for initialization with init ownership result SLAVE, but NO-MASTER {@link ClusterSingletonService}.
 179      *
 180      * @throws Exception if the condition does not meet
 181      */
 182     @Test
 183     public void slaveInitNoMasterClusterSingletonServiceTest() throws Exception {
 184         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 185                 .registerClusterSingletonService(clusterSingletonService);
 186         Assert.assertNotNull(reg);
 187         verify(mockEos).registerCandidate(entity);
 188         clusterSingletonServiceProvider.ownershipChanged(getInitEntityToSlaveNoMaster());
 189         verify(mockEos, never()).registerCandidate(doubleEntity);
 190         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 191     }
 192
 193     /**
 194      * Test GoldPath for initialization with init ownership result MASTER {@link ClusterSingletonService}.
 195      *
 196      * @throws Exception if the condition does not meet
 197      */
 198     @Test
 199     public void masterInitClusterSingletonServiceTest() throws Exception {
 200         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 201                 .registerClusterSingletonService(clusterSingletonService);
 202         Assert.assertNotNull(reg);
 203         verify(mockEos).registerCandidate(entity);
 204         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 205         verify(mockEos).registerCandidate(doubleEntity);
 206         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 207     }
 208
 209     /**
 210      * Test GoldPath for initialization with init ownership result MASTER {@link ClusterSingletonService}.
 211      *
 212      * @throws Exception if the condition does not meet
 213      */
 214     @Test
 215     public void masterInitSlaveDoubleCandidateClusterSingletonServiceTest() throws Exception {
 216         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 217                 .registerClusterSingletonService(clusterSingletonService);
 218         Assert.assertNotNull(reg);
 219         verify(mockEos).registerCandidate(entity);
 220         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 221         verify(mockEos).registerCandidate(doubleEntity);
 222         clusterSingletonServiceProvider.ownershipChanged(getInitDoubleEntityToSlave());
 223         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 224     }
 225
 226     /**
 227      * Test GoldPath for takeLeadership with ownership result MASTER {@link ClusterSingletonService}.
 228      *
 229      * @throws Exception if the condition does not meet
 230      */
 231     @Test
 232     public void takeLeadershipClusterSingletonServiceTest() throws Exception {
 233         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 234                 .registerClusterSingletonService(clusterSingletonService);
 235         Assert.assertNotNull(reg);
 236         verify(mockEos).registerCandidate(entity);
 237         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 238         verify(mockEos).registerCandidate(doubleEntity);
 239         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 240         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 241         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 242     }
 243
 244     /**
 245      * Test GoldPath for initialization with init ownership result MASTER {@link ClusterSingletonService}.
 246      *
 247      * @throws Exception if the condition does not meet
 248      */
 249     @Test
 250     public void masterInitClusterSingletonServiceTwoServicesTest() throws Exception {
 251         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 252                 .registerClusterSingletonService(clusterSingletonService);
 253         Assert.assertNotNull(reg);
 254         verify(mockEos).registerCandidate(entity);
 255         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 256         verify(mockEos).registerCandidate(doubleEntity);
 257         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 258         final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
 259                 .registerClusterSingletonService(clusterSingletonService2);
 260         Assert.assertNotNull(reg2);
 261         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
 262     }
 263
 264     /**
 265      * Test GoldPath for takeLeadership with ownership result MASTER {@link ClusterSingletonService}.
 266      *
 267      * @throws Exception if the condition does not meet
 268      */
 269     @Test
 270     public void takeLeadershipClusterSingletonServiceTwoAddDuringWaitPhaseServicesTest() throws Exception {
 271         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 272                 .registerClusterSingletonService(clusterSingletonService);
 273         Assert.assertNotNull(reg);
 274         verify(mockEos).registerCandidate(entity);
 275         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 276         verify(mockEos).registerCandidate(doubleEntity);
 277         final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
 278                 .registerClusterSingletonService(clusterSingletonService2);
 279         Assert.assertNotNull(reg2);
 280         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 281         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
 282         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 283         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 284         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
 285     }
 286
 287     /**
 288      * Test GoldPath for takeLeadership with ownership result MASTER {@link ClusterSingletonService}.
 289      *
 290      * @throws Exception if the condition does not meet
 291      */
 292     @Test
 293     public void takeLeadershipClusterSingletonServiceTowServicesTest() throws Exception {
 294         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 295                 .registerClusterSingletonService(clusterSingletonService);
 296         Assert.assertNotNull(reg);
 297         verify(mockEos).registerCandidate(entity);
 298         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 299         verify(mockEos).registerCandidate(doubleEntity);
 300         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 301         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 302         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 303         final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
 304                 .registerClusterSingletonService(clusterSingletonService2);
 305         Assert.assertNotNull(reg2);
 306         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
 307     }
 308
 309     /**
 310      * Test checks CandidateAlreadyRegisteredException processing in initialization phase.
 311      *
 312      * @throws Exception if the condition does not meet
 313      */
 314     @Test
 315     public void initializationClusterSingletonServiceCandidateAlreadyRegistredTest() throws Exception {
 316         doThrow(CandidateAlreadyRegisteredException.class).when(mockEos).registerCandidate(entity);
 317         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 318                 .registerClusterSingletonService(clusterSingletonService);
 319         Assert.assertNull(reg);
 320     }
 321
 322     /**
 323      * Test GoldPath for lostLeadership during tryToTakeLeadership with ownership result MASTER
 324      *     {@link ClusterSingletonService}.
 325      *
 326      * @throws Exception if the condition does not meet
 327      */
 328     @Test
 329     public void lostLeadershipDuringTryToTakeLeadershipClusterSingletonServiceTest() throws Exception {
 330         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 331                 .registerClusterSingletonService(clusterSingletonService);
 332         Assert.assertNotNull(reg);
 333         verify(mockEos).registerCandidate(entity);
 334         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 335         verify(mockEos).registerCandidate(doubleEntity);
 336         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 337         clusterSingletonServiceProvider.ownershipChanged(getEntityToSlave());
 338         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 339         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 340         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 341     }
 342
 343     /**
 344      * Test GoldPath for lostLeadership with ownership result MASTER-TO-SLAVE {@link ClusterSingletonService}.
 345      *
 346      * @throws Exception if the condition does not meet
 347      */
 348     @Test
 349     public void lostLeadershipClusterSingletonServiceTest() throws Exception {
 350         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 351                 .registerClusterSingletonService(clusterSingletonService);
 352         Assert.assertNotNull(reg);
 353         verify(mockEos).registerCandidate(entity);
 354         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 355         verify(mockEos).registerCandidate(doubleEntity);
 356         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 357         clusterSingletonServiceProvider.ownershipChanged(getInitDoubleEntityToSlave());
 358         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 359         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 360         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 361         clusterSingletonServiceProvider.ownershipChanged(getEntityToSlave());
 362         Assert.assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
 363     }
 364
 365     /**
 366      * Test checks umexpected change for MASTER-TO-SLAVE double Candidate role change.
 367      *
 368      * @throws Exception if the condition does not meet
 369      */
 370     @Test
 371     public void unexpectedLostLeadershipDoubleCandidateTest() throws Exception {
 372         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 373                 .registerClusterSingletonService(clusterSingletonService);
 374         Assert.assertNotNull(reg);
 375         verify(mockEos).registerCandidate(entity);
 376         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 377         verify(mockEos).registerCandidate(doubleEntity);
 378         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 379         clusterSingletonServiceProvider.ownershipChanged(getInitDoubleEntityToSlave());
 380         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 381         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 382         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 383         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToSlave());
 384         Assert.assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
 385         verify(mockEosDoubleEntityListReg, never()).close();
 386         verify(mockEntityCandReg, never()).close();
 387         verify(mockDoubleEntityCandReg).close();
 388     }
 389
 390     /**
 391      * Test checks inJeopardy Cluster Node state for Master Instance.
 392      *
 393      * @throws Exception if the condition does not meet
 394      */
 395     @Test
 396     public void inJeopardyMasterTest() throws Exception {
 397         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 398                 .registerClusterSingletonService(clusterSingletonService);
 399         Assert.assertNotNull(reg);
 400         verify(mockEos).registerCandidate(entity);
 401         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 402         verify(mockEos).registerCandidate(doubleEntity);
 403         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 404         clusterSingletonServiceProvider.ownershipChanged(getInitDoubleEntityToSlave());
 405         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 406         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 407         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 408         clusterSingletonServiceProvider.ownershipChanged(getEntityToJeopardy());
 409         Assert.assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
 410         verify(mockEosEntityListReg, never()).close();
 411         verify(mockEosDoubleEntityListReg, never()).close();
 412         verify(mockEntityCandReg, never()).close();
 413         verify(mockDoubleEntityCandReg).close();
 414     }
 415
 416     /**
 417      * Test checks inJeopardy Cluster Node state for Slave Instance.
 418      *
 419      * @throws Exception if the condition does not meet
 420      */
 421     @Test
 422     public void inJeopardySlaveTest() throws Exception {
 423         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 424                 .registerClusterSingletonService(clusterSingletonService);
 425         Assert.assertNotNull(reg);
 426         verify(mockEos).registerCandidate(entity);
 427         clusterSingletonServiceProvider.ownershipChanged(getInitEntityToSlave());
 428         verify(mockEos, never()).registerCandidate(doubleEntity);
 429         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 430         clusterSingletonServiceProvider.ownershipChanged(getEntityToJeopardy());
 431         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 432         verify(mockEosEntityListReg, never()).close();
 433         verify(mockEosDoubleEntityListReg, never()).close();
 434         verify(mockEntityCandReg, never()).close();
 435         verify(mockDoubleEntityCandReg, never()).close();
 436     }
 437
 438     /**
 439      * Test checks close processing for {@link ClusterSingletonServiceRegistration}.
 440      *
 441      * @throws Exception if the condition does not meet
 442      */
 443     @Test
 444     public void closeClusterSingletonServiceRegistrationNoRoleTest() throws Exception {
 445         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 446                 .registerClusterSingletonService(clusterSingletonService);
 447         Assert.assertNotNull(reg);
 448         verify(mockEos).registerCandidate(entity);
 449         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 450         reg.close();
 451         verify(mockEosEntityListReg, never()).close();
 452         verify(mockEosDoubleEntityListReg, never()).close();
 453         verify(mockEntityCandReg).close();
 454         verify(mockDoubleEntityCandReg, never()).close();
 455         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 456     }
 457
 458     /**
 459      * Test checks close procesing for {@link ClusterSingletonServiceRegistration}.
 460      *
 461      * @throws Exception if the condition does not meet
 462      */
 463     @Test
 464     public void closeClusterSingletonServiceRegistrationNoRoleTwoServicesTest() throws Exception {
 465         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 466                 .registerClusterSingletonService(clusterSingletonService);
 467         Assert.assertNotNull(reg);
 468         verify(mockEos).registerCandidate(entity);
 469         final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
 470                 .registerClusterSingletonService(clusterSingletonService2);
 471         Assert.assertNotNull(reg2);
 472         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 473         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
 474         reg.close();
 475         verify(mockEosEntityListReg, never()).close();
 476         verify(mockEosDoubleEntityListReg, never()).close();
 477         verify(mockEntityCandReg, never()).close();
 478         verify(mockDoubleEntityCandReg, never()).close();
 479         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 480         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
 481     }
 482
 483     /**
 484      * Test checks close procesing for {@link ClusterSingletonServiceRegistration}.
 485      *
 486      * @throws Exception if the condition does not meet
 487      */
 488     @Test
 489     public void closeClusterSingletonServiceRegistrationSlaveTest() throws Exception {
 490         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 491                 .registerClusterSingletonService(clusterSingletonService);
 492         Assert.assertNotNull(reg);
 493         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 494         verify(mockEos).registerCandidate(entity);
 495         clusterSingletonServiceProvider.ownershipChanged(getInitEntityToSlave());
 496         reg.close();
 497         verify(mockEosEntityListReg, never()).close();
 498         verify(mockEosDoubleEntityListReg, never()).close();
 499         verify(mockEntityCandReg).close();
 500         verify(mockDoubleEntityCandReg, never()).close();
 501         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 502     }
 503
 504     /**
 505      * Test checks close procesing for {@link ClusterSingletonServiceRegistration}.
 506      *
 507      * @throws Exception if the condition does not meet
 508      */
 509     @Test
 510     public void closeClusterSingletonServiceRegistrationSlaveTwoServicesTest() throws Exception {
 511         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 512                 .registerClusterSingletonService(clusterSingletonService);
 513         Assert.assertNotNull(reg);
 514         verify(mockEos).registerCandidate(entity);
 515         final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
 516                 .registerClusterSingletonService(clusterSingletonService2);
 517         Assert.assertNotNull(reg2);
 518         clusterSingletonServiceProvider.ownershipChanged(getInitEntityToSlave());
 519         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 520         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
 521         reg.close();
 522         verify(mockEosEntityListReg, never()).close();
 523         verify(mockEosDoubleEntityListReg, never()).close();
 524         verify(mockEntityCandReg, never()).close();
 525         verify(mockDoubleEntityCandReg, never()).close();
 526         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 527         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
 528     }
 529
 530     /**
 531      * Test checks close procesing for {@link ClusterSingletonServiceRegistration}.
 532      *
 533      * @throws Exception if the condition does not meet
 534      */
 535     @Test
 536     public void closeClusterSingletonServiceRegistrationMasterTest() throws Exception {
 537         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 538                 .registerClusterSingletonService(clusterSingletonService);
 539         Assert.assertNotNull(reg);
 540         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 541         verify(mockEos).registerCandidate(entity);
 542         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 543         verify(mockEos).registerCandidate(doubleEntity);
 544         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 545         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 546         reg.close();
 547         verify(mockEosEntityListReg, never()).close();
 548         verify(mockEosDoubleEntityListReg, never()).close();
 549         verify(mockEntityCandReg).close();
 550         verify(mockDoubleEntityCandReg).close();
 551         Assert.assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
 552     }
 553
 554     /**
 555      * Test checks close procesing for {@link ClusterSingletonServiceRegistration}.
 556      *
 557      * @throws Exception if the condition does not meet
 558      */
 559     @Test
 560     public void closeClusterSingletonServiceRegistrationMasterTwoServicesTest() throws Exception {
 561         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 562                 .registerClusterSingletonService(clusterSingletonService);
 563         Assert.assertNotNull(reg);
 564         final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
 565                 .registerClusterSingletonService(clusterSingletonService2);
 566         Assert.assertNotNull(reg2);
 567         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 568         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
 569         verify(mockEos).registerCandidate(entity);
 570         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 571         verify(mockEos).registerCandidate(doubleEntity);
 572         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 573         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 574         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
 575         reg.close();
 576         verify(mockEosEntityListReg, never()).close();
 577         verify(mockEosDoubleEntityListReg, never()).close();
 578         verify(mockEntityCandReg, never()).close();
 579         verify(mockDoubleEntityCandReg, never()).close();
 580         Assert.assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
 581         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
 582     }
 583
 584     /**
 585      * Test checks validation Error processing for SLAVE-TO-MASTER entity Candidate role change.
 586      *
 587      * @throws Exception if the condition does not meet
 588      */
 589     @Test
 590     public void tryToTakeLeaderForClosedServiceRegistrationTest() throws Exception {
 591         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 592                 .registerClusterSingletonService(clusterSingletonService);
 593         Assert.assertNotNull(reg);
 594         final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
 595                 .registerClusterSingletonService(clusterSingletonService2);
 596         Assert.assertNotNull(reg2);
 597         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 598         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
 599         verify(mockEos).registerCandidate(entity);
 600         reg.close();
 601         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 602         verify(mockEos).registerCandidate(doubleEntity);
 603         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 604         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 605         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
 606         verify(mockEosEntityListReg, never()).close();
 607         verify(mockEosDoubleEntityListReg, never()).close();
 608         verify(mockEntityCandReg, never()).close();
 609         verify(mockDoubleEntityCandReg, never()).close();
 610         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 611         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
 612     }
 613
 614     private DOMEntityOwnershipChange getEntityToMaster() {
 615         return new DOMEntityOwnershipChange(entity, EntityOwnershipChangeState.from(false, true, true));
 616     }
 617
 618     private DOMEntityOwnershipChange getEntityToSlave() {
 619         return new DOMEntityOwnershipChange(entity, EntityOwnershipChangeState.from(true, false, true));
 620     }
 621
 622     private DOMEntityOwnershipChange getInitEntityToSlave() {
 623         return new DOMEntityOwnershipChange(entity, EntityOwnershipChangeState.from(false, false, true));
 624     }
 625
 626     private DOMEntityOwnershipChange getInitEntityToSlaveNoMaster() {
 627         return new DOMEntityOwnershipChange(entity, EntityOwnershipChangeState.from(false, false, false));
 628     }
 629
 630     private DOMEntityOwnershipChange getDoubleEntityToMaster() {
 631         return new DOMEntityOwnershipChange(doubleEntity, EntityOwnershipChangeState.from(false, true, true));
 632     }
 633
 634     private DOMEntityOwnershipChange getInitDoubleEntityToSlave() {
 635         return new DOMEntityOwnershipChange(doubleEntity, EntityOwnershipChangeState.from(false, false, true));
 636     }
 637
 638     private DOMEntityOwnershipChange getDoubleEntityToSlave() {
 639         return new DOMEntityOwnershipChange(doubleEntity, EntityOwnershipChangeState.from(true, false, true));
 640     }
 641
 642     private DOMEntityOwnershipChange getEntityToJeopardy() {
 643         return new DOMEntityOwnershipChange(entity, EntityOwnershipChangeState.from(false, false, false), true);
 644     }
 645
 646     /**
 647      * Base states for AbstractClusterProjectProvider.
 648      */
 649     enum TestClusterSingletonServiceState {
 650         /**
 651          * State represents a correct Instantiated process.
 652          */
 653         STARTED,
 654         /**
 655          * State represents a correct call abstract method instantiatingProject.
 656          */
 657         INITIALIZED,
 658         /**
 659          * State represents a correct call abstract method destryingProject.
 660          */
 661         DESTROYED;
 662     }
 663
 664     /**
 665      * Test implementation of {@link ClusterSingletonService}.
 666      */
 667     class TestClusterSingletonServiceInstance implements ClusterSingletonService {
 668
 669         private final ServiceGroupIdentifier serviceIndent = ServiceGroupIdentifier.create(SERVICE_NAME);
 670         private TestClusterSingletonServiceState serviceState;
 671
 672         TestClusterSingletonServiceInstance() {
 673             this.serviceState = TestClusterSingletonServiceState.INITIALIZED;
 674         }
 675
 676         @Override
 677         public void instantiateServiceInstance() {
 678             this.serviceState = TestClusterSingletonServiceState.STARTED;
 679         }
 680
 681         @Override
 682         public ListenableFuture<Void> closeServiceInstance() {
 683             this.serviceState = TestClusterSingletonServiceState.DESTROYED;
 684             return Futures.immediateFuture(null);
 685         }
 686
 687         public TestClusterSingletonServiceState getServiceState() {
 688             return serviceState;
 689         }
 690
 691         @Override
 692         public ServiceGroupIdentifier getIdentifier() {
 693             return serviceIndent;
 694         }
 695     }
 696 }