opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/DistributedDataStoreTest.java

   1 package org.opendaylight.controller.cluster.datastore;
   2
   3 import static org.junit.Assert.assertTrue;
   4 import static org.mockito.Mockito.doReturn;
   5 import static org.mockito.Mockito.times;
   6 import static org.mockito.Mockito.verify;
   7 import akka.util.Timeout;
   8 import com.google.common.util.concurrent.Uninterruptibles;
   9 import java.util.concurrent.Executors;
  10 import java.util.concurrent.TimeUnit;
  11 import org.junit.Before;
  12 import org.junit.Test;
  13 import org.mockito.Mock;
  14 import org.mockito.MockitoAnnotations;
  15 import org.opendaylight.controller.cluster.datastore.utils.ActorContext;
  16 import org.opendaylight.controller.md.cluster.datastore.model.TestModel;
  17 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  18 import scala.concurrent.duration.FiniteDuration;
  19
  20 public class DistributedDataStoreTest extends AbstractActorTest {
  21
  22     private SchemaContext schemaContext;
  23
  24     @Mock
  25     private ActorContext actorContext;
  26
  27     @Mock
  28     private DatastoreContext datastoreContext;
  29
  30     @Mock
  31     private Timeout shardElectionTimeout;
  32
  33     @Before
  34     public void setUp() throws Exception {
  35         MockitoAnnotations.initMocks(this);
  36
  37         schemaContext = TestModel.createTestContext();
  38
  39         doReturn(schemaContext).when(actorContext).getSchemaContext();
  40         doReturn(DatastoreContext.newBuilder().build()).when(actorContext).getDatastoreContext();
  41     }
  42
  43     @Test
  44     public void testRateLimitingUsedInReadWriteTxCreation(){
  45         DistributedDataStore distributedDataStore = new DistributedDataStore(actorContext);
  46
  47         distributedDataStore.newReadWriteTransaction();
  48
  49         verify(actorContext, times(1)).acquireTxCreationPermit();
  50     }
  51
  52     @Test
  53     public void testRateLimitingUsedInWriteOnlyTxCreation(){
  54         DistributedDataStore distributedDataStore = new DistributedDataStore(actorContext);
  55
  56         distributedDataStore.newWriteOnlyTransaction();
  57
  58         verify(actorContext, times(1)).acquireTxCreationPermit();
  59     }
  60
  61
  62     @Test
  63     public void testRateLimitingNotUsedInReadOnlyTxCreation(){
  64         DistributedDataStore distributedDataStore = new DistributedDataStore(actorContext);
  65
  66         distributedDataStore.newReadOnlyTransaction();
  67         distributedDataStore.newReadOnlyTransaction();
  68         distributedDataStore.newReadOnlyTransaction();
  69
  70         verify(actorContext, times(0)).acquireTxCreationPermit();
  71     }
  72
  73     @Test
  74     public void testWaitTillReadyBlocking(){
  75         doReturn(datastoreContext).when(actorContext).getDatastoreContext();
  76         doReturn(shardElectionTimeout).when(datastoreContext).getShardLeaderElectionTimeout();
  77         doReturn(FiniteDuration.apply(50, TimeUnit.MILLISECONDS)).when(shardElectionTimeout).duration();
  78         DistributedDataStore distributedDataStore = new DistributedDataStore(actorContext);
  79
  80         long start = System.currentTimeMillis();
  81
  82         distributedDataStore.waitTillReady();
  83
  84         long end = System.currentTimeMillis();
  85
  86         assertTrue("Expected to be blocked for 50 millis", (end-start) >= 50);
  87     }
  88
  89     @Test
  90     public void testWaitTillReadyCountDown(){
  91         final DistributedDataStore distributedDataStore = new DistributedDataStore(actorContext);
  92         doReturn(datastoreContext).when(actorContext).getDatastoreContext();
  93         doReturn(shardElectionTimeout).when(datastoreContext).getShardLeaderElectionTimeout();
  94         doReturn(FiniteDuration.apply(5000, TimeUnit.MILLISECONDS)).when(shardElectionTimeout).duration();
  95
  96         Executors.newSingleThreadExecutor().submit(new Runnable() {
  97             @Override
  98             public void run() {
  99                 Uninterruptibles.sleepUninterruptibly(500, TimeUnit.MILLISECONDS);
 100                 distributedDataStore.getWaitTillReadyCountDownLatch().countDown();
 101             }
 102         });
 103
 104         long start = System.currentTimeMillis();
 105
 106         distributedDataStore.waitTillReady();
 107
 108         long end = System.currentTimeMillis();
 109
 110         assertTrue("Expected to be released in 500 millis", (end-start) < 5000);
 111
 112     }
 113
 114 }