X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-distributed-datastore%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fcluster%2Fdatabroker%2FClientBackedDataStoreTest.java;h=15fe8a417f066d95f0588a71d27d289446cd45f0;hb=HEAD;hp=a27bc540306bbde31cc3c7999206f54faf1bca6e;hpb=12fcdfe39aa26dcba7fd3bb4d4c68e3d02e65c51;p=controller.git diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/databroker/ClientBackedDataStoreTest.java b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/databroker/ClientBackedDataStoreTest.java index a27bc54030..15fe8a417f 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/databroker/ClientBackedDataStoreTest.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/databroker/ClientBackedDataStoreTest.java @@ -7,12 +7,22 @@ */ package org.opendaylight.controller.cluster.databroker; -import org.junit.Assert; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; + +import akka.util.Timeout; +import com.google.common.base.Stopwatch; +import com.google.common.util.concurrent.Uninterruptibles; +import java.util.concurrent.ForkJoinPool; +import java.util.concurrent.TimeUnit; import org.junit.Before; import org.junit.Test; +import org.junit.runner.RunWith; import org.mockito.Mock; -import org.mockito.Mockito; -import org.mockito.MockitoAnnotations; +import org.mockito.junit.MockitoJUnitRunner; import org.opendaylight.controller.cluster.access.concepts.ClientIdentifier; import org.opendaylight.controller.cluster.access.concepts.FrontendIdentifier; import org.opendaylight.controller.cluster.access.concepts.FrontendType; @@ -24,95 +34,112 @@ import org.opendaylight.controller.cluster.databroker.actors.dds.ClientSnapshot; import org.opendaylight.controller.cluster.databroker.actors.dds.ClientTransaction; import org.opendaylight.controller.cluster.databroker.actors.dds.DataStoreClient; import org.opendaylight.controller.cluster.datastore.DatastoreContext; -import org.opendaylight.controller.cluster.datastore.utils.ActorContext; -import org.opendaylight.controller.md.cluster.datastore.model.TestModel; -import org.opendaylight.mdsal.dom.spi.store.DOMStoreReadTransaction; -import org.opendaylight.mdsal.dom.spi.store.DOMStoreReadWriteTransaction; -import org.opendaylight.mdsal.dom.spi.store.DOMStoreTransactionChain; -import org.opendaylight.mdsal.dom.spi.store.DOMStoreWriteTransaction; -import org.opendaylight.yangtools.yang.model.api.SchemaContext; +import org.opendaylight.controller.cluster.datastore.utils.ActorUtils; +import org.opendaylight.yangtools.yang.common.Empty; +import scala.concurrent.duration.FiniteDuration; +@RunWith(MockitoJUnitRunner.StrictStubs.class) public class ClientBackedDataStoreTest { private static final ClientIdentifier UNKNOWN_ID = ClientIdentifier.create( FrontendIdentifier.create(MemberName.forName("local"), FrontendType.forName("unknown")), 0); - private static FrontendIdentifier FRONTEND_IDENTIFIER = FrontendIdentifier.create( + private static final FrontendIdentifier FRONTEND_IDENTIFIER = FrontendIdentifier.create( MemberName.forName("member"), FrontendType.forName("frontend")); private static final ClientIdentifier CLIENT_IDENTIFIER = ClientIdentifier.create(FRONTEND_IDENTIFIER, 0); - private static LocalHistoryIdentifier HISTORY_ID = new LocalHistoryIdentifier(CLIENT_IDENTIFIER, 0); - private static final TransactionIdentifier TRANSACTION_IDENTIFIER = new TransactionIdentifier(HISTORY_ID, 0); + private static final TransactionIdentifier TRANSACTION_IDENTIFIER = + new TransactionIdentifier(new LocalHistoryIdentifier(CLIENT_IDENTIFIER, 0), 0); @Mock private DataStoreClient clientActor; - @Mock - private ActorContext actorContext; - + private DatastoreContext datastoreContext; + @Mock + private Timeout shardElectionTimeout; + @Mock + private ActorUtils actorUtils; @Mock private ClientLocalHistory clientLocalHistory; - @Mock private ClientTransaction clientTransaction; - @Mock private ClientSnapshot clientSnapshot; + @Before public void setUp() { - MockitoAnnotations.initMocks(this); - - final SchemaContext schemaContext = TestModel.createTestContext(); + doReturn(DatastoreContext.newBuilder().build()).when(actorUtils).getDatastoreContext(); + doReturn(TRANSACTION_IDENTIFIER).when(clientTransaction).getIdentifier(); + doReturn(TRANSACTION_IDENTIFIER).when(clientSnapshot).getIdentifier(); - Mockito.when(actorContext.getSchemaContext()).thenReturn(schemaContext); - Mockito.when(actorContext.getDatastoreContext()).thenReturn(DatastoreContext.newBuilder().build()); - Mockito.when(clientTransaction.getIdentifier()).thenReturn(TRANSACTION_IDENTIFIER); - Mockito.when(clientSnapshot.getIdentifier()).thenReturn(TRANSACTION_IDENTIFIER); - - Mockito.when(clientActor.getIdentifier()).thenReturn(CLIENT_IDENTIFIER); - Mockito.when(clientActor.createTransaction()).thenReturn(clientTransaction); - Mockito.when(clientActor.createLocalHistory()).thenReturn(clientLocalHistory); - Mockito.when(clientActor.createSnapshot()).thenReturn(clientSnapshot); + doReturn(clientTransaction).when(clientActor).createTransaction(); + doReturn(clientLocalHistory).when(clientActor).createLocalHistory(); + doReturn(clientSnapshot).when(clientActor).createSnapshot(); } @Test public void testCreateTransactionChain() { - try (ClientBackedDataStore clientBackedDataStore = new ClientBackedDataStore( - actorContext, UNKNOWN_ID, clientActor)) { - final DOMStoreTransactionChain txChain = clientBackedDataStore.createTransactionChain(); - Assert.assertNotNull(txChain); - Mockito.verify(clientActor, Mockito.times(1)).createLocalHistory(); + try (var clientBackedDataStore = new ClientBackedDataStore(actorUtils, UNKNOWN_ID, clientActor)) { + assertNotNull(clientBackedDataStore.createTransactionChain()); + verify(clientActor, times(1)).createLocalHistory(); } } @Test public void testNewReadOnlyTransaction() { - try (ClientBackedDataStore clientBackedDataStore = new ClientBackedDataStore( - actorContext, UNKNOWN_ID, clientActor)) { - final DOMStoreReadTransaction tx = clientBackedDataStore.newReadOnlyTransaction(); - Assert.assertNotNull(tx); - Mockito.verify(clientActor, Mockito.times(1)).createSnapshot(); + try (var clientBackedDataStore = new ClientBackedDataStore(actorUtils, UNKNOWN_ID, clientActor)) { + assertNotNull(clientBackedDataStore.newReadOnlyTransaction()); + verify(clientActor, times(1)).createSnapshot(); } } @Test public void testNewWriteOnlyTransaction() { - try (ClientBackedDataStore clientBackedDataStore = new ClientBackedDataStore( - actorContext, UNKNOWN_ID, clientActor)) { - final DOMStoreWriteTransaction tx = clientBackedDataStore.newWriteOnlyTransaction(); - Assert.assertNotNull(tx); - Mockito.verify(clientActor, Mockito.times(1)).createTransaction(); + try (var clientBackedDataStore = new ClientBackedDataStore(actorUtils, UNKNOWN_ID, clientActor)) { + assertNotNull(clientBackedDataStore.newWriteOnlyTransaction()); + verify(clientActor, times(1)).createTransaction(); } } @Test public void testNewReadWriteTransaction() { - try (ClientBackedDataStore clientBackedDataStore = new ClientBackedDataStore( - actorContext, UNKNOWN_ID, clientActor)) { - final DOMStoreReadWriteTransaction tx = clientBackedDataStore.newReadWriteTransaction(); - Assert.assertNotNull(tx); - Mockito.verify(clientActor, Mockito.times(1)).createTransaction(); + try (var clientBackedDataStore = new ClientBackedDataStore(actorUtils, UNKNOWN_ID, clientActor)) { + assertNotNull(clientBackedDataStore.newReadWriteTransaction()); + verify(clientActor, times(1)).createTransaction(); + } + } + + @Test + public void testWaitTillReadyBlocking() { + doReturn(datastoreContext).when(actorUtils).getDatastoreContext(); + doReturn(shardElectionTimeout).when(datastoreContext).getShardLeaderElectionTimeout(); + doReturn(1).when(datastoreContext).getInitialSettleTimeoutMultiplier(); + doReturn(FiniteDuration.apply(50, TimeUnit.MILLISECONDS)).when(shardElectionTimeout).duration(); + try (var clientBackedDataStore = new ClientBackedDataStore(actorUtils, UNKNOWN_ID, clientActor)) { + final var sw = Stopwatch.createStarted(); + clientBackedDataStore.waitTillReady(); + final var elapsedMillis = sw.stop().elapsed(TimeUnit.MILLISECONDS); + + assertTrue("Expected to be blocked for 50 millis", elapsedMillis >= 50); + } + } + + @Test + public void testWaitTillReadyCountDown() { + try (var clientBackedDataStore = new ClientBackedDataStore(actorUtils, UNKNOWN_ID, clientActor)) { + doReturn(datastoreContext).when(actorUtils).getDatastoreContext(); + + ForkJoinPool.commonPool().submit(() -> { + Uninterruptibles.sleepUninterruptibly(500, TimeUnit.MILLISECONDS); + clientBackedDataStore.readinessFuture().set(Empty.value()); + }); + + final var sw = Stopwatch.createStarted(); + clientBackedDataStore.waitTillReady(); + final var elapsedMillis = sw.stop().elapsed(TimeUnit.MILLISECONDS); + + assertTrue("Expected to be released in 500 millis", elapsedMillis < 5000); } } }