singleton-service/mdsal-singleton-impl/src/test/java/org/opendaylight/mdsal/singleton/impl/AsyncEOSClusterSingletonServiceProviderTest.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 package org.opendaylight.mdsal.singleton.impl;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertNotNull;
  12 import static org.mockito.Mockito.never;
  13 import static org.mockito.Mockito.verify;
  14 import static org.opendaylight.mdsal.eos.common.api.EntityOwnershipStateChange.LOCAL_OWNERSHIP_GRANTED;
  15 import static org.opendaylight.mdsal.eos.common.api.EntityOwnershipStateChange.LOCAL_OWNERSHIP_LOST_NEW_OWNER;
  16 import static org.opendaylight.mdsal.eos.common.api.EntityOwnershipStateChange.LOCAL_OWNERSHIP_RETAINED_WITH_NO_CHANGE;
  17 import static org.opendaylight.mdsal.eos.common.api.EntityOwnershipStateChange.REMOTE_OWNERSHIP_CHANGED;
  18
  19 import com.google.common.util.concurrent.ListenableFuture;
  20 import com.google.common.util.concurrent.SettableFuture;
  21 import java.util.Timer;
  22 import java.util.TimerTask;
  23 import org.junit.AfterClass;
  24 import org.junit.BeforeClass;
  25 import org.junit.Test;
  26 import org.junit.runner.RunWith;
  27 import org.mockito.junit.MockitoJUnitRunner;
  28 import org.opendaylight.mdsal.singleton.api.ClusterSingletonService;
  29
  30 /*
  31  * Testing {@link DOMClusterSingletonServiceProviderImpl} implementation
  32  */
  33 @RunWith(MockitoJUnitRunner.StrictStubs.class)
  34 public final class AsyncEOSClusterSingletonServiceProviderTest extends AbstractEOSClusterSingletonServiceProviderTest {
  35     /*
  36      * Test implementation of {@link ClusterSingletonService}
  37      */
  38     public static class TestClusterSingletonAsyncServiceInstance extends TestClusterSingletonService {
  39         @Override
  40         public ListenableFuture<Void> closeServiceInstance() {
  41             super.closeServiceInstance();
  42
  43             final var future = SettableFuture.<Void>create();
  44             TIMER.schedule(new TimerTask() {
  45                 @Override
  46                 public void run() {
  47                     future.set(null);
  48                 }
  49             }, ASYNC_TIME_DELAY_MILLIS);
  50             return future;
  51         }
  52     }
  53
  54     public static final long ASYNC_TIME_DELAY_MILLIS = 100L;
  55     public static Timer TIMER;
  56
  57     @BeforeClass
  58     public static void asyncInitTest() {
  59         TIMER = new Timer();
  60     }
  61
  62     @AfterClass
  63     public static void cleanTest() {
  64         TIMER.cancel();
  65     }
  66
  67     @Override
  68     TestClusterSingletonService instantiateService() {
  69         return new TestClusterSingletonAsyncServiceInstance();
  70     }
  71
  72     /**
  73      * Test GoldPath for takeLeadership with ownership result MASTER {@link ClusterSingletonService}.
  74      *
  75      * @throws Exception if the condition does not meet
  76      */
  77     @Test
  78     public void takeDoubleLeadershipClusterSingletonServiceTest() throws Exception {
  79         final var reg = clusterSingletonServiceProvider.registerClusterSingletonService(clusterSingletonService);
  80         assertNotNull(reg);
  81         verify(mockEos).registerCandidate(ENTITY);
  82         clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
  83         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
  84         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
  85         clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
  86         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
  87         clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_LOST_NEW_OWNER, false);
  88         assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
  89         Thread.sleep(ASYNC_TIME_DELAY_MILLIS * 2);
  90         verify(mockDoubleEntityCandReg).close();
  91         clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
  92         assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
  93         clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, REMOTE_OWNERSHIP_CHANGED, false);
  94         clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
  95         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
  96         verify(mockEosDoubleEntityListReg, never()).close();
  97         verify(mockEosEntityListReg, never()).close();
  98         verify(mockEntityCandReg, never()).close();
  99     }
 100
 101     /**
 102      * Test checks unexpected change for MASTER-TO-SLAVE double Candidate role change.
 103      *
 104      * @throws Exception if the condition does not meet
 105      */
 106     @Test
 107     public void unexpectedLostLeadershipDoubleCandidateTest() throws Exception {
 108         final var reg = clusterSingletonServiceProvider.registerClusterSingletonService(clusterSingletonService);
 109         assertNotNull(reg);
 110         verify(mockEos).registerCandidate(ENTITY);
 111         clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
 112         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
 113         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 114         clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, REMOTE_OWNERSHIP_CHANGED, false);
 115         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 116         clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
 117         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 118         clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, LOCAL_OWNERSHIP_LOST_NEW_OWNER, false);
 119         assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
 120         Thread.sleep(ASYNC_TIME_DELAY_MILLIS * 2);
 121         verify(mockEosDoubleEntityListReg, never()).close();
 122         verify(mockEntityCandReg, never()).close();
 123         verify(mockDoubleEntityCandReg, never()).close();
 124         reg.close();
 125         verify(mockEosDoubleEntityListReg, never()).close();
 126         verify(mockEntityCandReg).close();
 127         verify(mockDoubleEntityCandReg).close();
 128     }
 129
 130     /**
 131      * Test checks inJeopardy Cluster Node state for Master Instance.
 132      *
 133      * @throws Exception if the condition does not meet
 134      */
 135     @Test
 136     public void inJeopardyMasterTest() throws Exception {
 137         final var reg = clusterSingletonServiceProvider.registerClusterSingletonService(clusterSingletonService);
 138         assertNotNull(reg);
 139         verify(mockEos).registerCandidate(ENTITY);
 140         clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
 141         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
 142         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 143         clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, REMOTE_OWNERSHIP_CHANGED, false);
 144         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 145         clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
 146         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 147         clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_RETAINED_WITH_NO_CHANGE, true);
 148         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 149         clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, LOCAL_OWNERSHIP_RETAINED_WITH_NO_CHANGE, true);
 150         assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
 151         Thread.sleep(ASYNC_TIME_DELAY_MILLIS * 2);
 152         verify(mockEosEntityListReg, never()).close();
 153         verify(mockEosDoubleEntityListReg, never()).close();
 154         verify(mockEntityCandReg, never()).close();
 155         verify(mockDoubleEntityCandReg, never()).close();
 156     }
 157
 158     /**
 159      * Test checks close processing for {@link ServiceRegistration}.
 160      *
 161      * @throws Exception if the condition does not meet
 162      */
 163     @Test
 164     public void closeClusterSingletonServiceRegistrationMasterTest() throws Exception {
 165         final var reg = clusterSingletonServiceProvider.registerClusterSingletonService(clusterSingletonService);
 166         assertNotNull(reg);
 167         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 168         verify(mockEos).registerCandidate(ENTITY);
 169         clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
 170         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
 171         clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
 172         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 173         reg.close();
 174         verify(mockEntityCandReg).close();
 175         verify(mockDoubleEntityCandReg, never()).close();
 176         assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
 177         Thread.sleep(ASYNC_TIME_DELAY_MILLIS * 2);
 178         verify(mockDoubleEntityCandReg).close();
 179         verify(mockEosEntityListReg, never()).close();
 180         verify(mockEosDoubleEntityListReg, never()).close();
 181     }
 182
 183     /**
 184      * Test checks close processing for {@link ServiceRegistration}.
 185      *
 186      * @throws Exception if the condition does not meet
 187      */
 188     @Test
 189     public void closeClusterSingletonServiceRegistrationMasterCloseWithNotificationTimesTest() throws Exception {
 190         final var reg = clusterSingletonServiceProvider.registerClusterSingletonService(clusterSingletonService);
 191         assertNotNull(reg);
 192         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 193         verify(mockEos).registerCandidate(ENTITY);
 194         clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
 195         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
 196         clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
 197         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 198         reg.close();
 199         verify(mockEntityCandReg).close();
 200         verify(mockDoubleEntityCandReg, never()).close();
 201         assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
 202         Thread.sleep(ASYNC_TIME_DELAY_MILLIS * 2);
 203         verify(mockDoubleEntityCandReg).close();
 204         verify(mockEosEntityListReg, never()).close();
 205         verify(mockEosDoubleEntityListReg, never()).close();
 206     }
 207
 208     /**
 209      * Test checks close processing for {@link ServiceRegistration}.
 210      *
 211      * @throws Exception if the condition does not meet
 212      */
 213     @Test
 214     public void closeClusterSingletonServiceRegistrationMasterCloseCoupleTimesTest() throws Exception {
 215         final var reg = clusterSingletonServiceProvider.registerClusterSingletonService(clusterSingletonService);
 216         assertNotNull(reg);
 217         assertEquals(TestClusterSingletonServiceState.INITIALIZED, clusterSingletonService.getServiceState());
 218         verify(mockEos).registerCandidate(ENTITY);
 219         clusterSingletonServiceProvider.ownershipChanged(ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
 220         verify(mockEos).registerCandidate(DOUBLE_ENTITY);
 221         clusterSingletonServiceProvider.ownershipChanged(DOUBLE_ENTITY, LOCAL_OWNERSHIP_GRANTED, false);
 222         assertEquals(TestClusterSingletonServiceState.STARTED, clusterSingletonService.getServiceState());
 223         reg.close();
 224         reg.close();
 225         verify(mockEntityCandReg).close();
 226         verify(mockDoubleEntityCandReg, never()).close();
 227         assertEquals(TestClusterSingletonServiceState.DESTROYED, clusterSingletonService.getServiceState());
 228
 229         Thread.sleep(ASYNC_TIME_DELAY_MILLIS * 2);
 230         verify(mockEosEntityListReg, never()).close();
 231         verify(mockEosDoubleEntityListReg, never()).close();
 232         verify(mockDoubleEntityCandReg).close();
 233     }
 234 }