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.junit.Assert.assertEquals;
  12 import static org.junit.Assert.assertNotNull;
  13 import static org.mockito.Mockito.atLeastOnce;
  14 import static org.mockito.Mockito.never;
  15 import static org.mockito.Mockito.times;
  16 import static org.mockito.Mockito.verify;
  17
  18 import org.junit.Before;
  19 import org.junit.Test;
  20 import org.junit.runner.RunWith;
  21 import org.mockito.junit.MockitoJUnitRunner;
  22 import org.opendaylight.mdsal.eos.common.api.CandidateAlreadyRegisteredException;
  23 import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonService;
  24 import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceRegistration;
  25
  26 /**
  27  * Synchronous test suite.
  28  */
  29 @RunWith(MockitoJUnitRunner.StrictStubs.class)
  30 public class DOMClusterSingletonServiceProviderImplTest extends AbstractDOMClusterServiceProviderTest {
  31     /**
  32      * Initialization functionality for every Tests in this suite.
  33      *
  34      * @throws CandidateAlreadyRegisteredException if the condition does not meet
  35      */
  36     @Override
  37     @Before
  38     public void setup() throws CandidateAlreadyRegisteredException {
  39         super.setup();
  40     }
  41
  42     /**
  43      * Test GoldPath for takeLeadership with ownership result MASTER {@link ClusterSingletonService}.
  44      *
  45      * @throws Exception if the condition does not meet
  46      */
  47     @Test
  48     public void takeDoubleLeadershipClusterSingletonServiceTest() throws Exception {
  49         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
  50                 .registerClusterSingletonService(clusterSingletonService);
  51         assertNotNull(reg);
  52         verify(mockEos).registerCandidate(ENTITY);
  53         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
  54         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
  55         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
  56         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
  57         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
  58         clusterSingletonServiceProvider.ownershipChanged(getEntityToSlave());
  59         assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
  60         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
  61         assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
  62         clusterSingletonServiceProvider.ownershipChanged(getInitDoubleEntityToSlave());
  63         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
  64         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
  65         verify(mockEosDoubleEntityListReg, never()).close();
  66         verify(mockEosEntityListReg, never()).close();
  67         verify(mockEntityCandReg, never()).close();
  68         verify(mockDoubleEntityCandReg).close();
  69     }
  70
  71     /**
  72      * Test checks unexpected change for MASTER-TO-SLAVE double Candidate role change.
  73      *
  74      * @throws Exception if the condition does not meet
  75      */
  76     @Test
  77     public void unexpectedLostLeadershipDoubleCandidateTest() throws Exception {
  78         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
  79                 .registerClusterSingletonService(clusterSingletonService);
  80         assertNotNull(reg);
  81         verify(mockEos).registerCandidate(ENTITY);
  82         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
  83         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
  84         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
  85         clusterSingletonServiceProvider.ownershipChanged(getInitDoubleEntityToSlave());
  86         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
  87         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
  88         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
  89         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToSlave());
  90         assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
  91         verify(mockEosDoubleEntityListReg, never()).close();
  92         verify(mockEntityCandReg, never()).close();
  93         verify(mockDoubleEntityCandReg, never()).close();
  94         reg.close();
  95         verify(mockEosEntityListReg, never()).close();
  96         verify(mockEosDoubleEntityListReg, never()).close();
  97         verify(mockEntityCandReg, atLeastOnce()).close();
  98         verify(mockDoubleEntityCandReg).close();
  99         assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
 100         clusterSingletonServiceProvider.ownershipChanged(getEntityToSlave());
 101         verify(mockEntityCandReg).close();
 102         verify(mockEosDoubleEntityListReg, never()).close();
 103     }
 104
 105     /**
 106      * Test checks inJeopardy Cluster Node state for Master Instance.
 107      *
 108      * @throws Exception if the condition does not meet
 109      */
 110     @Test
 111     public void inJeopardyMasterTest() throws Exception {
 112         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 113                 .registerClusterSingletonService(clusterSingletonService);
 114         assertNotNull(reg);
 115         verify(mockEos).registerCandidate(ENTITY);
 116         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 117         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
 118         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 119         clusterSingletonServiceProvider.ownershipChanged(getInitDoubleEntityToSlave());
 120         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 121         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 122         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 123         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToJeopardy());
 124         assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
 125         verify(mockEosEntityListReg, never()).close();
 126         verify(mockEosDoubleEntityListReg, never()).close();
 127         verify(mockEntityCandReg, never()).close();
 128         verify(mockDoubleEntityCandReg, never()).close();
 129     }
 130
 131     /**
 132      * Test checks close processing for {@link ClusterSingletonServiceRegistration}.
 133      *
 134      * @throws Exception if the condition does not meet
 135      */
 136     @Test
 137     public void closeClusterSingletonServiceRegistrationMasterTest() throws Exception {
 138         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 139                 .registerClusterSingletonService(clusterSingletonService);
 140         assertNotNull(reg);
 141         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 142         verify(mockEos).registerCandidate(ENTITY);
 143         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 144         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
 145         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 146         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 147         reg.close();
 148         clusterSingletonServiceProvider.ownershipChanged(getEntityToSlave());
 149         verify(mockEosEntityListReg, never()).close();
 150         verify(mockEosDoubleEntityListReg, never()).close();
 151         verify(mockEntityCandReg).close();
 152         verify(mockDoubleEntityCandReg).close();
 153         assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
 154     }
 155
 156     /**
 157      * Test checks close processing for {@link ClusterSingletonServiceRegistration}.
 158      *
 159      * @throws Exception if the condition does not meet
 160      */
 161     @Test
 162     public void closeClusterSingletonServiceRegistrationMasterCloseWithNotificationTimesTest() throws Exception {
 163         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 164                 .registerClusterSingletonService(clusterSingletonService);
 165         assertNotNull(reg);
 166         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 167         verify(mockEos).registerCandidate(ENTITY);
 168         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 169         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
 170         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 171         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 172         reg.close();
 173         verify(mockEosEntityListReg, never()).close();
 174         verify(mockEosDoubleEntityListReg, never()).close();
 175         verify(mockEntityCandReg, atLeastOnce()).close();
 176         verify(mockDoubleEntityCandReg).close();
 177         assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
 178     }
 179
 180     /**
 181      * Test checks close processing for {@link ClusterSingletonServiceRegistration}.
 182      *
 183      * @throws Exception if the condition does not meet
 184      */
 185     @Test
 186     public void closeClusterSingletonServiceRegistrationMasterCloseCoupleTimesTest() throws Exception {
 187         final ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 188                 .registerClusterSingletonService(clusterSingletonService);
 189         assertNotNull(reg);
 190         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 191         verify(mockEos).registerCandidate(ENTITY);
 192         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 193         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
 194         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 195         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 196         reg.close();
 197         reg.close();
 198         verify(mockEosEntityListReg, never()).close();
 199         verify(mockEosDoubleEntityListReg, never()).close();
 200         verify(mockEntityCandReg).close();
 201         verify(mockDoubleEntityCandReg).close();
 202         assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
 203         clusterSingletonServiceProvider.ownershipChanged(getEntityToSlave());
 204         verify(mockEosDoubleEntityListReg, never()).close();
 205     }
 206
 207     /**
 208      * Verify that closing a group does not prevent next incarnation of it to be registered and the next incarnation
 209      * will become active once the old incarnation finishes cleaning up.
 210      */
 211     @Test
 212     public void testTwoIncarnations() throws Exception {
 213         ClusterSingletonServiceRegistration reg = clusterSingletonServiceProvider
 214                 .registerClusterSingletonService(clusterSingletonService);
 215         assertNotNull(reg);
 216         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 217         verify(mockEos).registerCandidate(ENTITY);
 218         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 219         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
 220         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 221         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 222
 223         // Close, triggers unregistration, but we will not continue with it.
 224         reg.close();
 225         verify(mockEosEntityListReg, never()).close();
 226         verify(mockEosDoubleEntityListReg, never()).close();
 227         verify(mockEntityCandReg).close();
 228         verify(mockDoubleEntityCandReg).close();
 229         assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
 230
 231         // Instantiate the next incarnation
 232         reg = clusterSingletonServiceProvider.registerClusterSingletonService(clusterSingletonService2);
 233         verify(mockEos).registerCandidate(ENTITY);
 234         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService2.getServiceState());
 235
 236         // Drive the old incarnation to closure, resetting mocks as needed
 237         clusterSingletonServiceProvider.ownershipChanged(getEntityToSlave());
 238         verify(mockEosDoubleEntityListReg, never()).close();
 239
 240         // Reset mocks for reuse. The next change should see the previous group terminate and the next incarnation
 241         // to start coming up
 242         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToSlave());
 243         verify(mockEos, times(2)).registerCandidate(ENTITY);
 244         clusterSingletonServiceProvider.ownershipChanged(getEntityToMaster());
 245         verify(mockEos, times(2)).registerCandidate(DOUBLE_ENTITY);
 246         clusterSingletonServiceProvider.ownershipChanged(getDoubleEntityToMaster());
 247         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService2.getServiceState());
 248
 249         // Check for potential service mixup
 250         assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
 251
 252         verify(mockEosEntityListReg, never()).close();
 253         verify(mockEosDoubleEntityListReg, never()).close();
 254     }
 255 }