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