X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-distributed-datastore%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fcluster%2Fdatastore%2FDistributedDataStoreTest.java;h=00243ea5d1d1e9e52cff5dfc21335d7a5cbdc13f;hp=69590e62fb1b5886fc0b5fb1223706d02c1706cd;hb=531621aac4cff9d39cbd8668a53bdeba8a0e6d81;hpb=51e91f6bdcc88c5aa96f956e516d31dbb5e5d5e0 diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/DistributedDataStoreTest.java b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/DistributedDataStoreTest.java index 69590e62fb..00243ea5d1 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/DistributedDataStoreTest.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/DistributedDataStoreTest.java @@ -1,13 +1,21 @@ package org.opendaylight.controller.cluster.datastore; +import akka.actor.ActorPath; import akka.actor.ActorRef; +import akka.actor.ActorSelection; import akka.actor.ActorSystem; import akka.actor.Props; +import akka.dispatch.ExecutionContexts; +import akka.dispatch.Futures; +import akka.util.Timeout; +import com.google.common.base.Optional; +import com.google.common.util.concurrent.MoreExecutors; import org.junit.After; import org.junit.Before; import org.junit.Test; import org.opendaylight.controller.cluster.datastore.messages.RegisterChangeListenerReply; import org.opendaylight.controller.cluster.datastore.shardstrategy.ShardStrategyFactory; +import org.opendaylight.controller.cluster.datastore.utils.ActorContext; import org.opendaylight.controller.cluster.datastore.utils.DoNothingActor; import org.opendaylight.controller.cluster.datastore.utils.MockActorContext; import org.opendaylight.controller.cluster.datastore.utils.MockConfiguration; @@ -23,13 +31,21 @@ import org.opendaylight.controller.sal.core.spi.data.DOMStoreWriteTransaction; import org.opendaylight.yangtools.concepts.ListenerRegistration; import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; - +import scala.concurrent.ExecutionContextExecutor; +import scala.concurrent.Future; +import scala.concurrent.duration.FiniteDuration; +import java.util.concurrent.TimeUnit; +import static junit.framework.TestCase.assertEquals; +import static junit.framework.TestCase.assertNull; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertTrue; import static org.mockito.Matchers.any; +import static org.mockito.Matchers.anyObject; +import static org.mockito.Matchers.anyString; import static org.mockito.Matchers.eq; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; public class DistributedDataStoreTest extends AbstractActorTest{ @@ -63,12 +79,14 @@ public class DistributedDataStoreTest extends AbstractActorTest{ } + @SuppressWarnings("resource") @Test public void testConstructor(){ ActorSystem actorSystem = mock(ActorSystem.class); new DistributedDataStore(actorSystem, "config", - mock(ClusterWrapper.class), mock(Configuration.class), null); + mock(ClusterWrapper.class), mock(Configuration.class), + DatastoreContext.newBuilder().build()); verify(actorSystem).actorOf(any(Props.class), eq("shardmanager-config")); } @@ -78,11 +96,11 @@ public class DistributedDataStoreTest extends AbstractActorTest{ ListenerRegistration registration = distributedDataStore.registerChangeListener(TestModel.TEST_PATH, new AsyncDataChangeListener>() { - @Override - public void onDataChanged(AsyncDataChangeEvent> change) { - throw new UnsupportedOperationException("onDataChanged"); - } - }, AsyncDataBroker.DataChangeScope.BASE); + @Override + public void onDataChanged(AsyncDataChangeEvent> change) { + throw new UnsupportedOperationException("onDataChanged"); + } + }, AsyncDataBroker.DataChangeScope.BASE); // Since we do not expect the shard to be local registration will return a NoOpRegistration assertTrue(registration instanceof NoOpDataChangeListenerRegistration); @@ -92,20 +110,111 @@ public class DistributedDataStoreTest extends AbstractActorTest{ @Test public void testRegisterChangeListenerWhenShardIsLocal() throws Exception { + ActorContext actorContext = mock(ActorContext.class); + + distributedDataStore = new DistributedDataStore(actorContext); + distributedDataStore.onGlobalContextUpdated(TestModel.createTestContext()); + + Future future = mock(Future.class); + when(actorContext.getOperationDuration()).thenReturn(FiniteDuration.apply(5, TimeUnit.SECONDS)); + when(actorContext.getActorSystem()).thenReturn(getSystem()); + when(actorContext.findLocalShard(anyString())).thenReturn(Optional.of(doNothingActorRef)); + when(actorContext + .executeOperationAsync(eq(doNothingActorRef), anyObject(), any(Timeout.class))).thenReturn(future); + + ListenerRegistration registration = + distributedDataStore.registerChangeListener(TestModel.TEST_PATH, + mock(AsyncDataChangeListener.class), + AsyncDataBroker.DataChangeScope.BASE); + + assertNotNull(registration); + + assertEquals(DataChangeListenerRegistrationProxy.class, registration.getClass()); + } + + @Test + public void testRegisterChangeListenerWhenSuccessfulReplyReceived() throws Exception { + ActorContext actorContext = mock(ActorContext.class); + + distributedDataStore = new DistributedDataStore(actorContext); + distributedDataStore.onGlobalContextUpdated( + TestModel.createTestContext()); + + ExecutionContextExecutor executor = ExecutionContexts.fromExecutor(MoreExecutors.sameThreadExecutor()); - mockActorContext.setExecuteLocalShardOperationResponse(new RegisterChangeListenerReply(doNothingActorRef.path())); + // Make Future successful + Future f = Futures.successful(new RegisterChangeListenerReply(doNothingActorRef.path())); + + // Setup the mocks + ActorSystem actorSystem = mock(ActorSystem.class); + ActorSelection actorSelection = mock(ActorSelection.class); + + when(actorContext.getOperationDuration()).thenReturn(FiniteDuration.apply(5, TimeUnit.SECONDS)); + when(actorSystem.dispatcher()).thenReturn(executor); + when(actorSystem.actorOf(any(Props.class))).thenReturn(doNothingActorRef); + when(actorContext.getActorSystem()).thenReturn(actorSystem); + when(actorContext.findLocalShard(anyString())).thenReturn(Optional.of(doNothingActorRef)); + when(actorContext + .executeOperationAsync(eq(doNothingActorRef), anyObject(), any(Timeout.class))).thenReturn(f); + when(actorContext.actorSelection(any(ActorPath.class))).thenReturn(actorSelection); ListenerRegistration registration = - distributedDataStore.registerChangeListener(TestModel.TEST_PATH, new AsyncDataChangeListener>() { - @Override - public void onDataChanged(AsyncDataChangeEvent> change) { - throw new UnsupportedOperationException("onDataChanged"); - } - }, AsyncDataBroker.DataChangeScope.BASE); + distributedDataStore.registerChangeListener(TestModel.TEST_PATH, + mock(AsyncDataChangeListener.class), + AsyncDataBroker.DataChangeScope.BASE); + + assertNotNull(registration); - assertTrue(registration instanceof DataChangeListenerRegistrationProxy); + assertEquals(DataChangeListenerRegistrationProxy.class, registration.getClass()); + + ActorSelection listenerRegistrationActor = + ((DataChangeListenerRegistrationProxy) registration).getListenerRegistrationActor(); + + assertNotNull(listenerRegistrationActor); + + assertEquals(actorSelection, listenerRegistrationActor); + } + + @Test + public void testRegisterChangeListenerWhenSuccessfulReplyFailed() throws Exception { + ActorContext actorContext = mock(ActorContext.class); + + distributedDataStore = new DistributedDataStore(actorContext); + distributedDataStore.onGlobalContextUpdated( + TestModel.createTestContext()); + + ExecutionContextExecutor executor = ExecutionContexts.fromExecutor(MoreExecutors.sameThreadExecutor()); + + // Make Future fail + Future f = Futures.failed(new IllegalArgumentException()); + + // Setup the mocks + ActorSystem actorSystem = mock(ActorSystem.class); + ActorSelection actorSelection = mock(ActorSelection.class); + + when(actorContext.getOperationDuration()).thenReturn(FiniteDuration.apply(5, TimeUnit.SECONDS)); + when(actorSystem.dispatcher()).thenReturn(executor); + when(actorSystem.actorOf(any(Props.class))).thenReturn(doNothingActorRef); + when(actorContext.getActorSystem()).thenReturn(actorSystem); + when(actorContext.findLocalShard(anyString())).thenReturn(Optional.of(doNothingActorRef)); + when(actorContext + .executeOperationAsync(eq(doNothingActorRef), anyObject(), any(Timeout.class))).thenReturn(f); + when(actorContext.actorSelection(any(ActorPath.class))).thenReturn(actorSelection); + + ListenerRegistration registration = + distributedDataStore.registerChangeListener(TestModel.TEST_PATH, + mock(AsyncDataChangeListener.class), + AsyncDataBroker.DataChangeScope.BASE); assertNotNull(registration); + + assertEquals(DataChangeListenerRegistrationProxy.class, registration.getClass()); + + ActorSelection listenerRegistrationActor = + ((DataChangeListenerRegistrationProxy) registration).getListenerRegistrationActor(); + + assertNull(listenerRegistrationActor); + }