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