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.atLeastOnce;
  14 import static org.mockito.Mockito.doNothing;
  15 import static org.mockito.Mockito.doReturn;
  16 import static org.mockito.Mockito.doThrow;
  17 import static org.mockito.Mockito.never;
  18 import static org.mockito.Mockito.verify;
  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
  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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 268      */
 269     @Test
 270     public void takeDoubleLeadershipClusterSingletonServiceTest() 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         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 278         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 279         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 280         clusterSingletonServiceProvider.ownershipChanged(getEntityToSlave());
 281         Assert.assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
 282         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 283         Assert.assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
 284         clusterSingletonServiceProvider.ownershipChanged(getInitDoubleEntityToSlave());
 285         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 286         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 287         verify(mockEosDoubleEntityListReg, never()).close();
 288         verify(mockEosEntityListReg, never()).close();
 289         verify(mockEntityCandReg, never()).close();
 290         verify(mockDoubleEntityCandReg).close();
 291     }
 292
 293     /**
 294      * Test GoldPath for takeLeadership with ownership result MASTER {@link ClusterSingletonService}.
 295      *
 296      * @throws Exception if the condition does not meet
 297      */
 298     @Test
 299     public void takeLeadershipClusterSingletonServiceTwoAddDuringWaitPhaseServicesTest() throws Exception {
 300         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 301                 .registerClusterSingletonService(clusterSingletonService);
 302         Assert.assertNotNull(reg);
 303         verify(mockEos).registerCandidate(entity);
 304         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 305         verify(mockEos).registerCandidate(doubleEntity);
 306         final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
 307                 .registerClusterSingletonService(clusterSingletonService2);
 308         Assert.assertNotNull(reg2);
 309         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 310         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
 311         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 312         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 313         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
 314     }
 315
 316     /**
 317      * Test GoldPath for takeLeadership with ownership result MASTER {@link ClusterSingletonService}
 318      *
 319      * @throws Exception
 320      */
 321     @Test
 322     public void takeLeadershipClusterSingletonServiceTowServicesTest() throws Exception {
 323         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 324                 .registerClusterSingletonService(clusterSingletonService);
 325         Assert.assertNotNull(reg);
 326         verify(mockEos).registerCandidate(entity);
 327         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 328         verify(mockEos).registerCandidate(doubleEntity);
 329         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 330         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 331         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 332         final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
 333                 .registerClusterSingletonService(clusterSingletonService2);
 334         Assert.assertNotNull(reg2);
 335         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
 336     }
 337
 338     /**
 339      * Test checks CandidateAlreadyRegisteredException processing in initialization phase
 340      *
 341      * @throws Exception
 342      */
 343     @Test(expected = RuntimeException.class)
 344     public void initializationClusterSingletonServiceCandidateAlreadyRegistredTest() throws Exception {
 345         doThrow(CandidateAlreadyRegisteredException.class).when(mockEos).registerCandidate(entity);
 346         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 347                 .registerClusterSingletonService(clusterSingletonService);
 348         Assert.assertNull(reg);
 349     }
 350
 351     /**
 352      * Test GoldPath for lostLeadership during tryToTakeLeadership with ownership result MASTER
 353      * {@link ClusterSingletonService}
 354      *
 355      * @throws Exception
 356      */
 357     @Test
 358     public void lostLeadershipDuringTryToTakeLeadershipClusterSingletonServiceTest() throws Exception {
 359         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 360                 .registerClusterSingletonService(clusterSingletonService);
 361         Assert.assertNotNull(reg);
 362         verify(mockEos).registerCandidate(entity);
 363         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 364         verify(mockEos).registerCandidate(doubleEntity);
 365         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 366         clusterSingletonServiceProvider.ownershipChanged(getEntityToSlave());
 367         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 368         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 369         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 370     }
 371
 372     /**
 373      * Test GoldPath for lostLeadership with ownership result MASTER-TO-SLAVE {@link ClusterSingletonService}
 374      *
 375      * @throws Exception
 376      */
 377     @Test
 378     public void lostLeadershipClusterSingletonServiceTest() throws Exception {
 379         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 380                 .registerClusterSingletonService(clusterSingletonService);
 381         Assert.assertNotNull(reg);
 382         verify(mockEos).registerCandidate(entity);
 383         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 384         verify(mockEos).registerCandidate(doubleEntity);
 385         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 386         clusterSingletonServiceProvider.ownershipChanged(getInitDoubleEntityToSlave());
 387         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 388         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 389         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 390         clusterSingletonServiceProvider.ownershipChanged(getEntityToSlave());
 391         Assert.assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
 392     }
 393
 394     /**
 395      * Test checks unexpected change for MASTER-TO-SLAVE double Candidate role change.
 396      *
 397      * @throws Exception
 398      */
 399     @Test
 400     public void unexpectedLostLeadershipDoubleCandidateTest() throws Exception {
 401         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 402                 .registerClusterSingletonService(clusterSingletonService);
 403         Assert.assertNotNull(reg);
 404         verify(mockEos).registerCandidate(entity);
 405         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 406         verify(mockEos).registerCandidate(doubleEntity);
 407         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 408         clusterSingletonServiceProvider.ownershipChanged(getInitDoubleEntityToSlave());
 409         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 410         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 411         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 412         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToSlave());
 413         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 414         verify(mockEosDoubleEntityListReg, never()).close();
 415         verify(mockEntityCandReg, never()).close();
 416         verify(mockDoubleEntityCandReg, never()).close();
 417         reg.close();
 418         verify(mockEosEntityListReg, never()).close();
 419         verify(mockEosDoubleEntityListReg, never()).close();
 420         verify(mockEntityCandReg, atLeastOnce()).close();
 421         verify(mockDoubleEntityCandReg, never()).close();
 422         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 423         clusterSingletonServiceProvider.ownershipChanged(getEntityToSlave());
 424         verify(mockEntityCandReg, atLeastOnce()).close();
 425         verify(mockDoubleEntityCandReg, atLeastOnce()).close();
 426         verify(mockEosDoubleEntityListReg, never()).close();
 427         Assert.assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
 428     }
 429
 430     /**
 431      * Test checks inJeopardy Cluster Node state for Master Instance
 432      *
 433      * @throws Exception
 434      */
 435     @Test
 436     public void inJeopardyMasterTest() throws Exception {
 437         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 438                 .registerClusterSingletonService(clusterSingletonService);
 439         Assert.assertNotNull(reg);
 440         verify(mockEos).registerCandidate(entity);
 441         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 442         verify(mockEos).registerCandidate(doubleEntity);
 443         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 444         clusterSingletonServiceProvider.ownershipChanged(getInitDoubleEntityToSlave());
 445         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 446         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 447         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 448         clusterSingletonServiceProvider.ownershipChanged(getEntityToJeopardy());
 449         Assert.assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
 450         verify(mockEosEntityListReg, never()).close();
 451         verify(mockEosDoubleEntityListReg, never()).close();
 452         verify(mockEntityCandReg, never()).close();
 453         verify(mockDoubleEntityCandReg).close();
 454     }
 455
 456     /**
 457      * Test checks inJeopardy Cluster Node state for Slave Instance
 458      *
 459      * @throws Exception
 460      */
 461     @Test
 462     public void inJeopardySlaveTest() throws Exception {
 463         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 464                 .registerClusterSingletonService(clusterSingletonService);
 465         Assert.assertNotNull(reg);
 466         verify(mockEos).registerCandidate(entity);
 467         clusterSingletonServiceProvider.ownershipChanged(getInitEntityToSlave());
 468         verify(mockEos, never()).registerCandidate(doubleEntity);
 469         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 470         clusterSingletonServiceProvider.ownershipChanged(getEntityToJeopardy());
 471         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 472         verify(mockEosEntityListReg, never()).close();
 473         verify(mockEosDoubleEntityListReg, never()).close();
 474         verify(mockEntityCandReg, never()).close();
 475         verify(mockDoubleEntityCandReg, never()).close();
 476     }
 477
 478     /**
 479      * Test checks close procesing for {@link ClusterSingletonServiceRegistration}
 480      *
 481      * @throws Exception
 482      */
 483     @Test
 484     public void closeClusterSingletonServiceRegistrationNoRoleTest() throws Exception {
 485         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 486                 .registerClusterSingletonService(clusterSingletonService);
 487         Assert.assertNotNull(reg);
 488         verify(mockEos).registerCandidate(entity);
 489         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 490         reg.close();
 491         verify(mockEosEntityListReg, never()).close();
 492         verify(mockEosDoubleEntityListReg, never()).close();
 493         verify(mockEntityCandReg).close();
 494         verify(mockDoubleEntityCandReg, never()).close();
 495         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 496     }
 497
 498     /**
 499      * Test checks close procesing for {@link ClusterSingletonServiceRegistration}
 500      *
 501      * @throws Exception
 502      */
 503     @Test
 504     public void closeClusterSingletonServiceRegistrationNoRoleTwoServicesTest() throws Exception {
 505         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 506                 .registerClusterSingletonService(clusterSingletonService);
 507         Assert.assertNotNull(reg);
 508         verify(mockEos).registerCandidate(entity);
 509         final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
 510                 .registerClusterSingletonService(clusterSingletonService2);
 511         Assert.assertNotNull(reg2);
 512         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 513         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
 514         reg.close();
 515         verify(mockEosEntityListReg, never()).close();
 516         verify(mockEosDoubleEntityListReg, never()).close();
 517         verify(mockEntityCandReg, never()).close();
 518         verify(mockDoubleEntityCandReg, never()).close();
 519         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 520         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
 521     }
 522
 523     /**
 524      * Test checks close procesing for {@link ClusterSingletonServiceRegistration}
 525      *
 526      * @throws Exception
 527      */
 528     @Test
 529     public void closeClusterSingletonServiceRegistrationSlaveTest() throws Exception {
 530         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 531                 .registerClusterSingletonService(clusterSingletonService);
 532         Assert.assertNotNull(reg);
 533         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 534         verify(mockEos).registerCandidate(entity);
 535         clusterSingletonServiceProvider.ownershipChanged(getInitEntityToSlave());
 536         reg.close();
 537         verify(mockEosEntityListReg, never()).close();
 538         verify(mockEosDoubleEntityListReg, never()).close();
 539         verify(mockEntityCandReg).close();
 540         verify(mockDoubleEntityCandReg, never()).close();
 541         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 542     }
 543
 544     /**
 545      * Test checks close procesing for {@link ClusterSingletonServiceRegistration}
 546      *
 547      * @throws Exception
 548      */
 549     @Test
 550     public void closeClusterSingletonServiceRegistrationSlaveTwoServicesTest() throws Exception {
 551         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 552                 .registerClusterSingletonService(clusterSingletonService);
 553         Assert.assertNotNull(reg);
 554         verify(mockEos).registerCandidate(entity);
 555         final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
 556                 .registerClusterSingletonService(clusterSingletonService2);
 557         Assert.assertNotNull(reg2);
 558         clusterSingletonServiceProvider.ownershipChanged(getInitEntityToSlave());
 559         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 560         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
 561         reg.close();
 562         verify(mockEosEntityListReg, never()).close();
 563         verify(mockEosDoubleEntityListReg, never()).close();
 564         verify(mockEntityCandReg, never()).close();
 565         verify(mockDoubleEntityCandReg, never()).close();
 566         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 567         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
 568     }
 569
 570     /**
 571      * Test checks close procesing for {@link ClusterSingletonServiceRegistration}
 572      *
 573      * @throws Exception
 574      */
 575     @Test
 576     public void closeClusterSingletonServiceRegistrationMasterTest() throws Exception {
 577         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 578                 .registerClusterSingletonService(clusterSingletonService);
 579         Assert.assertNotNull(reg);
 580         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 581         verify(mockEos).registerCandidate(entity);
 582         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 583         verify(mockEos).registerCandidate(doubleEntity);
 584         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 585         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 586         reg.close();
 587         clusterSingletonServiceProvider.ownershipChanged(getEntityToSlave());
 588         verify(mockEosEntityListReg, never()).close();
 589         verify(mockEosDoubleEntityListReg, never()).close();
 590         verify(mockEntityCandReg).close();
 591         verify(mockDoubleEntityCandReg).close();
 592         Assert.assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
 593     }
 594
 595     /**
 596      * Test checks close processing for {@link ClusterSingletonServiceRegistration}.
 597      *
 598      * @throws Exception if the condition does not meet
 599      */
 600     @Test
 601     public void closeClusterSingletonServiceRegistrationMasterCloseWithNotificationTimesTest() throws Exception {
 602         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 603                 .registerClusterSingletonService(clusterSingletonService);
 604         Assert.assertNotNull(reg);
 605         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 606         verify(mockEos).registerCandidate(entity);
 607         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 608         verify(mockEos).registerCandidate(doubleEntity);
 609         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 610         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 611         reg.close();
 612         verify(mockEosEntityListReg, never()).close();
 613         verify(mockEosDoubleEntityListReg, never()).close();
 614         verify(mockEntityCandReg, atLeastOnce()).close();
 615         verify(mockDoubleEntityCandReg, never()).close();
 616         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 617         clusterSingletonServiceProvider.ownershipChanged(getEntityToSlave());
 618         verify(mockEntityCandReg, atLeastOnce()).close();
 619         verify(mockDoubleEntityCandReg, atLeastOnce()).close();
 620         verify(mockEosDoubleEntityListReg, never()).close();
 621         Assert.assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
 622     }
 623
 624     /**
 625      * Test checks close processing for {@link ClusterSingletonServiceRegistration}.
 626      *
 627      * @throws Exception if the condition does not meet
 628      */
 629     @Test
 630     public void closeClusterSingletonServiceRegistrationMasterCloseCoupleTimesTest() throws Exception {
 631         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 632                 .registerClusterSingletonService(clusterSingletonService);
 633         Assert.assertNotNull(reg);
 634         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 635         verify(mockEos).registerCandidate(entity);
 636         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 637         verify(mockEos).registerCandidate(doubleEntity);
 638         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 639         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 640         reg.close();
 641         reg.close();
 642         verify(mockEosEntityListReg, never()).close();
 643         verify(mockEosDoubleEntityListReg, never()).close();
 644         verify(mockEntityCandReg, atLeastOnce()).close();
 645         verify(mockDoubleEntityCandReg, never()).close();
 646         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 647         clusterSingletonServiceProvider.ownershipChanged(getEntityToSlave());
 648         verify(mockEntityCandReg, atLeastOnce()).close();
 649         verify(mockDoubleEntityCandReg, atLeastOnce()).close();
 650         verify(mockEosDoubleEntityListReg, never()).close();
 651         Assert.assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
 652     }
 653
 654     /**
 655      * Test checks close processing for {@link ClusterSingletonServiceRegistration}.
 656      *
 657      * @throws Exception
 658      */
 659     @Test
 660     public void closeClusterSingletonServiceRegistrationMasterTwoServicesTest() throws Exception {
 661         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 662                 .registerClusterSingletonService(clusterSingletonService);
 663         Assert.assertNotNull(reg);
 664         final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
 665                 .registerClusterSingletonService(clusterSingletonService2);
 666         Assert.assertNotNull(reg2);
 667         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 668         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
 669         verify(mockEos).registerCandidate(entity);
 670         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 671         verify(mockEos).registerCandidate(doubleEntity);
 672         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 673         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 674         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
 675         reg.close();
 676         verify(mockEosEntityListReg, never()).close();
 677         verify(mockEosDoubleEntityListReg, never()).close();
 678         verify(mockEntityCandReg, never()).close();
 679         verify(mockDoubleEntityCandReg, never()).close();
 680         Assert.assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
 681         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
 682     }
 683
 684     /**
 685      * Test checks validation Error processing for SLAVE-TO-MASTER entity Candidate role change
 686      *
 687      * @throws Exception
 688      */
 689     @Test
 690     public void tryToTakeLeaderForClosedServiceRegistrationTest() throws Exception {
 691         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 692                 .registerClusterSingletonService(clusterSingletonService);
 693         Assert.assertNotNull(reg);
 694         final ClusterSingletonServiceRegistration reg2 = clusterSingletonServiceProvider
 695                 .registerClusterSingletonService(clusterSingletonService2);
 696         Assert.assertNotNull(reg2);
 697         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 698         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
 699         verify(mockEos).registerCandidate(entity);
 700         reg.close();
 701         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 702         verify(mockEos).registerCandidate(doubleEntity);
 703         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 704         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 705         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
 706         verify(mockEosEntityListReg, never()).close();
 707         verify(mockEosDoubleEntityListReg, never()).close();
 708         verify(mockEntityCandReg, never()).close();
 709         verify(mockDoubleEntityCandReg, never()).close();
 710         Assert.assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 711         Assert.assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
 712     }
 713
 714     private DOMEntityOwnershipChange getEntityToMaster() {
 715         return new DOMEntityOwnershipChange(entity, EntityOwnershipChangeState.from(false, true, true));
 716     }
 717
 718     private DOMEntityOwnershipChange getEntityToSlave() {
 719         return new DOMEntityOwnershipChange(entity, EntityOwnershipChangeState.from(true, false, true));
 720     }
 721
 722     private DOMEntityOwnershipChange getInitEntityToSlave() {
 723         return new DOMEntityOwnershipChange(entity, EntityOwnershipChangeState.from(false, false, true));
 724     }
 725
 726     private DOMEntityOwnershipChange getInitEntityToSlaveNoMaster() {
 727         return new DOMEntityOwnershipChange(entity, EntityOwnershipChangeState.from(false, false, false));
 728     }
 729
 730     private DOMEntityOwnershipChange getDoubleEntityToMaster() {
 731         return new DOMEntityOwnershipChange(doubleEntity, EntityOwnershipChangeState.from(false, true, true));
 732     }
 733
 734     private DOMEntityOwnershipChange getInitDoubleEntityToSlave() {
 735         return new DOMEntityOwnershipChange(doubleEntity, EntityOwnershipChangeState.from(false, false, true));
 736     }
 737
 738     private DOMEntityOwnershipChange getDoubleEntityToSlave() {
 739         return new DOMEntityOwnershipChange(doubleEntity, EntityOwnershipChangeState.from(true, false, true));
 740     }
 741
 742     private DOMEntityOwnershipChange getEntityToJeopardy() {
 743         return new DOMEntityOwnershipChange(entity, EntityOwnershipChangeState.from(false, false, false), true);
 744     }
 745
 746     /**
 747      * Base states for AbstractClusterProjectProvider
 748      */
 749     enum TestClusterSingletonServiceState {
 750
 751         /**
 752          * State represents a correct Instantiated process
 753          */
 754
 755         STARTED,
 756         /**
 757          * State represents a correct call abstract method instantiatingProject
 758          */
 759         INITIALIZED,
 760
 761         /**
 762          * State represents a correct call abstract method destryingProject
 763          */
 764         DESTROYED;
 765     }
 766
 767     /**
 768      * Test implementation of {@link ClusterSingletonService}
 769      */
 770     class TestClusterSingletonServiceInstance implements ClusterSingletonService {
 771
 772         private final ServiceGroupIdentifier SERVICE_IDENT = ServiceGroupIdentifier.create(SERVICE_NAME);
 773         private TestClusterSingletonServiceState serviceState;
 774
 775         public TestClusterSingletonServiceInstance() {
 776             this.serviceState = TestClusterSingletonServiceState.INITIALIZED;
 777         }
 778
 779         @Override
 780         public void instantiateServiceInstance() {
 781             this.serviceState = TestClusterSingletonServiceState.STARTED;
 782         }
 783
 784         @Override
 785         public ListenableFuture<Void> closeServiceInstance() {
 786             this.serviceState = TestClusterSingletonServiceState.DESTROYED;
 787             return Futures.immediateFuture(null);
 788         }
 789
 790         public TestClusterSingletonServiceState getServiceState() {
 791             return serviceState;
 792         }
 793
 794         @Override
 795         public ServiceGroupIdentifier getIdentifier() {
 796             return SERVICE_IDENT;
 797         }
 798     }
 799 }