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=bcdbb98d1c6cf04cdb45aa7489fba5457c99d2cb;hpb=f83b2d36fdd7e953ba72492ffb684cd112aa04a6;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 bcdbb98d1c..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 @@ -8,16 +8,21 @@ package org.opendaylight.controller.cluster.databroker; 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 static org.mockito.Mockito.when; -import org.junit.AfterClass; +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.BeforeClass; 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; @@ -30,13 +35,10 @@ import org.opendaylight.controller.cluster.databroker.actors.dds.ClientTransacti import org.opendaylight.controller.cluster.databroker.actors.dds.DataStoreClient; import org.opendaylight.controller.cluster.datastore.DatastoreContext; import org.opendaylight.controller.cluster.datastore.utils.ActorUtils; -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.yangtools.yang.common.Empty; +import scala.concurrent.duration.FiniteDuration; +@RunWith(MockitoJUnitRunner.StrictStubs.class) public class ClientBackedDataStoreTest { private static final ClientIdentifier UNKNOWN_ID = ClientIdentifier.create( @@ -46,88 +48,98 @@ public class ClientBackedDataStoreTest { MemberName.forName("member"), FrontendType.forName("frontend")); private static final ClientIdentifier CLIENT_IDENTIFIER = ClientIdentifier.create(FRONTEND_IDENTIFIER, 0); - private static final LocalHistoryIdentifier HISTORY_ID = new LocalHistoryIdentifier(CLIENT_IDENTIFIER, 0); - private static final TransactionIdentifier TRANSACTION_IDENTIFIER = new TransactionIdentifier(HISTORY_ID, 0); - - private static SchemaContext SCHEMA_CONTEXT; + private static final TransactionIdentifier TRANSACTION_IDENTIFIER = + new TransactionIdentifier(new LocalHistoryIdentifier(CLIENT_IDENTIFIER, 0), 0); @Mock private DataStoreClient clientActor; - + @Mock + private DatastoreContext datastoreContext; + @Mock + private Timeout shardElectionTimeout; @Mock private ActorUtils actorUtils; - @Mock private ClientLocalHistory clientLocalHistory; - @Mock private ClientTransaction clientTransaction; - @Mock private ClientSnapshot clientSnapshot; - @BeforeClass - public static void beforeClass() { - SCHEMA_CONTEXT = TestModel.createTestContext(); - } - - @AfterClass - public static void afterClass() { - SCHEMA_CONTEXT = null; - } @Before public void setUp() { - MockitoAnnotations.initMocks(this); - - when(actorUtils.getSchemaContext()).thenReturn(SCHEMA_CONTEXT); - when(actorUtils.getDatastoreContext()).thenReturn(DatastoreContext.newBuilder().build()); - when(clientTransaction.getIdentifier()).thenReturn(TRANSACTION_IDENTIFIER); - when(clientSnapshot.getIdentifier()).thenReturn(TRANSACTION_IDENTIFIER); + doReturn(DatastoreContext.newBuilder().build()).when(actorUtils).getDatastoreContext(); + doReturn(TRANSACTION_IDENTIFIER).when(clientTransaction).getIdentifier(); + doReturn(TRANSACTION_IDENTIFIER).when(clientSnapshot).getIdentifier(); - when(clientActor.getIdentifier()).thenReturn(CLIENT_IDENTIFIER); - when(clientActor.createTransaction()).thenReturn(clientTransaction); - when(clientActor.createLocalHistory()).thenReturn(clientLocalHistory); - 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( - actorUtils, UNKNOWN_ID, clientActor)) { - final DOMStoreTransactionChain txChain = clientBackedDataStore.createTransactionChain(); - assertNotNull(txChain); - 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( - actorUtils, UNKNOWN_ID, clientActor)) { - final DOMStoreReadTransaction tx = clientBackedDataStore.newReadOnlyTransaction(); - assertNotNull(tx); - 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( - actorUtils, UNKNOWN_ID, clientActor)) { - final DOMStoreWriteTransaction tx = clientBackedDataStore.newWriteOnlyTransaction(); - assertNotNull(tx); - 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( - actorUtils, UNKNOWN_ID, clientActor)) { - final DOMStoreReadWriteTransaction tx = clientBackedDataStore.newReadWriteTransaction(); - assertNotNull(tx); - 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); } } }