BUG 1735 Registering a data change listener should be asynchronous

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

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 cb473cb9360e03656ea83d0212ef18b70237a92e..08c3ea9602adb9cd891f9e1fe573ded671e5d6d7 100644 (file)
--- 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,14 +1,20 @@
 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.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;
@@ -24,13 +30,23 @@ 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{
 
@@ -71,7 +87,7 @@ public class DistributedDataStoreTest extends AbstractActorTest{
 
         new DistributedDataStore(actorSystem, "config",
             mock(ClusterWrapper.class), mock(Configuration.class),
-            new DistributedDataStoreProperties());
+            new DatastoreContext());
 
         verify(actorSystem).actorOf(any(Props.class), eq("shardmanager-config"));
     }
@@ -95,20 +111,108 @@ public class DistributedDataStoreTest extends AbstractActorTest{
 
     @Test
     public void testRegisterChangeListenerWhenShardIsLocal() throws Exception {
+        ActorContext actorContext = mock(ActorContext.class);
+
+        distributedDataStore = new DistributedDataStore(actorContext);
+        distributedDataStore.onGlobalContextUpdated(TestModel.createTestContext());
 
-        mockActorContext.setExecuteLocalShardOperationResponse(new RegisterChangeListenerReply(doNothingActorRef.path()));
+        Future future = mock(Future.class);
+        when(actorContext.getOperationDuration()).thenReturn(FiniteDuration.apply(5, TimeUnit.SECONDS));
+        when(actorContext.getActorSystem()).thenReturn(getSystem());
+        when(actorContext
+            .executeLocalShardOperationAsync(anyString(), anyObject(), any(Timeout.class))).thenReturn(future);
 
         ListenerRegistration registration =
-            distributedDataStore.registerChangeListener(TestModel.TEST_PATH, new AsyncDataChangeListener<YangInstanceIdentifier, NormalizedNode<?, ?>>() {
-                @Override
-                public void onDataChanged(AsyncDataChangeEvent<YangInstanceIdentifier, NormalizedNode<?, ?>> change) {
-                    throw new UnsupportedOperationException("onDataChanged");
-                }
-            }, AsyncDataBroker.DataChangeScope.BASE);
+            distributedDataStore.registerChangeListener(TestModel.TEST_PATH,
+                mock(AsyncDataChangeListener.class),
+                AsyncDataBroker.DataChangeScope.BASE);
 
-        assertTrue(registration instanceof DataChangeListenerRegistrationProxy);
+        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());
+
+        // 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
+            .executeLocalShardOperationAsync(anyString(), 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();
+
+        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
+            .executeLocalShardOperationAsync(anyString(), 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);
+
     }