Coverage - rpc manager and context

Change-Id: I8ee20f13633e2010767758447a66b80cb026faeb
Signed-off-by: Michal Rehak <mirehak@cisco.com>

diff --git a/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/rpc/RpcContextImplTest.java b/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/rpc/RpcContextImplTest.java
index d0ecc93fd7040b3ae9cc72886a3608e9ca51c954..e5cd598c4a5a4752c4b35c77006220c4be1f9c1f 100644 (file)
--- a/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/rpc/RpcContextImplTest.java
+++ b/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/rpc/RpcContextImplTest.java
@@ -14,7 +14,9 @@ import static org.mockito.Mockito.when;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
+import org.mockito.Matchers;
 import org.mockito.Mock;
+import org.mockito.Mockito;
 import org.mockito.runners.MockitoJUnitRunner;
 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
 import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
@@ -22,6 +24,8 @@ import org.opendaylight.openflowplugin.api.openflow.device.DeviceState;
 import org.opendaylight.openflowplugin.api.openflow.device.RequestContext;
 import org.opendaylight.openflowplugin.api.openflow.rpc.RpcContext;
 import org.opendaylight.openflowplugin.api.openflow.statistics.ofpspecific.MessageSpy;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.SalFlowService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeContext;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
@@ -43,6 +47,10 @@ public class RpcContextImplTest {
     private DeviceContext deviceContext;
     @Mock
     private MessageSpy messageSpy;
+    @Mock
+    private SalFlowService salFlowServiceInstance;
+    @Mock
+    BindingAwareBroker.RoutedRpcRegistration<SalFlowService> routedRpcRegistration;
 
     private KeyedInstanceIdentifier<Node, NodeKey> nodeInstanceIdentifier;
 
@@ -53,26 +61,52 @@ public class RpcContextImplTest {
 
         when(deviceState.getNodeInstanceIdentifier()).thenReturn(nodeInstanceIdentifier);
         when(deviceContext.getDeviceState()).thenReturn(deviceState);
+        when(mockedRpcProviderRegistry.addRoutedRpcImplementation(
+                Matchers.<Class<SalFlowService>>any(), Matchers.any(SalFlowService.class)))
+                .thenReturn(routedRpcRegistration);
     }
 
     @Test
-    public void invokeRpcTest() {
+    public void testCreateRequestContext() throws Exception {
+        try (final RpcContext rpcContext = new RpcContextImpl(messageSpy, mockedRpcProviderRegistry, deviceContext, 1)) {
+            RequestContext<?> requestContext1 = rpcContext.createRequestContext();
+            assertNotNull(requestContext1);
+
+            // quota exceeded
+            RequestContext<?> requestContext2 = rpcContext.createRequestContext();
+            assertNull(requestContext2);
+
+            requestContext1.close();
+            RequestContext<?> requestContext3 = rpcContext.createRequestContext();
+            assertNotNull(requestContext3);
+        }
+    }
 
+    @Test
+    public void testRegisterRpcServiceImplementation() throws Exception {
+        try (final RpcContext rpcContext = new RpcContextImpl(messageSpy, mockedRpcProviderRegistry, deviceContext, 10)) {
+            rpcContext.registerRpcServiceImplementation(SalFlowService.class, salFlowServiceInstance);
+            Mockito.verify(routedRpcRegistration).registerPath(NodeContext.class, nodeInstanceIdentifier);
+        }
     }
 
     @Test
-    public void testStoreOrFail() throws Exception {
-        try (final RpcContext rpcContext = new RpcContextImpl(messageSpy, mockedRpcProviderRegistry, deviceContext, 100)) {
-            RequestContext<?> requestContext = rpcContext.createRequestContext();
-            assertNotNull(requestContext);
+    public void testClose() throws Exception {
+        try (final RpcContext rpcContext = new RpcContextImpl(messageSpy, mockedRpcProviderRegistry, deviceContext, 10)) {
+            rpcContext.registerRpcServiceImplementation(SalFlowService.class, salFlowServiceInstance);
+            rpcContext.close();
+            Mockito.verify(routedRpcRegistration).unregisterPath(NodeContext.class, nodeInstanceIdentifier);
+            Mockito.verify(routedRpcRegistration).close();
         }
     }
 
     @Test
-    public void testStoreOrFailThatFails() throws Exception {
-        try (final RpcContext rpcContext = new RpcContextImpl(messageSpy, mockedRpcProviderRegistry, deviceContext, 0)) {
-            RequestContext<?> requestContext = rpcContext.createRequestContext();
-            assertNull(requestContext);
+    public void testOnDeviceContextClosed() throws Exception {
+        try (final RpcContext rpcContext = new RpcContextImpl(messageSpy, mockedRpcProviderRegistry, deviceContext, 10)) {
+            rpcContext.registerRpcServiceImplementation(SalFlowService.class, salFlowServiceInstance);
+            rpcContext.onDeviceContextClosed(deviceContext);
+            Mockito.verify(routedRpcRegistration).unregisterPath(NodeContext.class, nodeInstanceIdentifier);
+            Mockito.verify(routedRpcRegistration).close();
         }
     }
 }

diff --git a/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/rpc/RpcManagerImplTest.java b/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/rpc/RpcManagerImplTest.java
index 4af2f0e8ce7610f190781c424dd46d00d1ca60fe..aacc8e26290e52276658026c98b6050327d8f597 100644 (file)
--- a/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/rpc/RpcManagerImplTest.java
+++ b/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/rpc/RpcManagerImplTest.java
@@ -7,107 +7,79 @@
  */
 package org.opendaylight.openflowplugin.impl.rpc;
 
-import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
 
-import java.math.BigInteger;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Future;
-import org.junit.Ignore;
+import org.junit.Before;
 import org.junit.Test;
+import org.junit.runner.RunWith;
 import org.mockito.Matchers;
 import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext;
-import org.opendaylight.openflowjava.protocol.api.connection.ConnectionAdapter;
+import org.opendaylight.openflowplugin.api.OFConstants;
 import org.opendaylight.openflowplugin.api.openflow.connection.ConnectionContext;
 import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
-import org.opendaylight.openflowplugin.api.openflow.device.Xid;
-import org.opendaylight.openflowplugin.api.openflow.statistics.ofpspecific.MessageSpy;
-import org.opendaylight.openflowplugin.impl.services.SalFlowServiceImpl;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.AddFlowInput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.AddFlowInputBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.AddFlowOutput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.SalFlowService;
+import org.opendaylight.openflowplugin.api.openflow.device.DeviceState;
+import org.opendaylight.openflowplugin.api.openflow.device.handlers.DeviceInitializationPhaseHandler;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeContext;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.FeaturesReply;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.GetFeaturesOutputBuilder;
 import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
 import org.opendaylight.yangtools.yang.binding.RpcService;
-import org.opendaylight.yangtools.yang.common.RpcResult;
 
+@RunWith(MockitoJUnitRunner.class)
 public class RpcManagerImplTest {
 
-    private static final int AWAITED_NUM_OF_CALL_ADD_ROUTED_RPC = 12;
+    private static final int AWAITED_NUM_OF_CALL_ADD_ROUTED_RPC = 9;
 
-
-    final ProviderContext mockedProviderContext = mock(ProviderContext.class);
-    final RpcManagerImpl rpcManager = new RpcManagerImpl(mockedProviderContext, 500);
-    final DeviceContext mockedDeviceContext = mock(DeviceContext.class);
+    private RpcManagerImpl rpcManager;
     @Mock
-    private MessageSpy messageSpy;
-
-    @Ignore
-    @Test
-    public void deviceConnectedTest() {
-
-        rpcManager.onDeviceContextLevelUp(mockedDeviceContext);
-
-        verify(mockedProviderContext, times(AWAITED_NUM_OF_CALL_ADD_ROUTED_RPC)).addRoutedRpcImplementation(
-                Matchers.any(Class.class), Matchers.any(RpcService.class));
+    private ProviderContext rpcProviderRegistry;
+    @Mock
+    private DeviceContext deviceContext;
+    @Mock
+    private DeviceInitializationPhaseHandler deviceINitializationPhaseHandler;
+    @Mock
+    private ConnectionContext connectionContext;
+    @Mock
+    private BindingAwareBroker.RoutedRpcRegistration<RpcService> routedRpcRegistration;
+    @Mock
+    private DeviceState deviceState;
+    private KeyedInstanceIdentifier<Node, NodeKey> nodePath;
+
+    @Before
+    public void setUp() {
+        nodePath = KeyedInstanceIdentifier.create(Nodes.class).child(Node.class, new NodeKey(new NodeId("openflow-junit:1")));
+        rpcManager = new RpcManagerImpl(rpcProviderRegistry, 5);
+        rpcManager.setDeviceInitializationPhaseHandler(deviceINitializationPhaseHandler);
+        FeaturesReply features = new GetFeaturesOutputBuilder()
+                .setVersion(OFConstants.OFP_VERSION_1_3)
+                .build();
+        Mockito.when(connectionContext.getFeatures()).thenReturn(features);
+        Mockito.when(deviceContext.getPrimaryConnectionContext()).thenReturn(connectionContext);
+        Mockito.when(deviceContext.getDeviceState()).thenReturn(deviceState);
+        Mockito.when(deviceState.getNodeInstanceIdentifier()).thenReturn(nodePath);
     }
 
-
-    /**
-     * Tests behavior of RpcContextImpl when calling rpc from MD-SAL
-     */
-    @Ignore
     @Test
-    public void invokeRpcTestExistsCapacityTest() throws InterruptedException, ExecutionException {
-        final ConnectionContext mockedConnectionContext = mock(ConnectionContext.class);
-        final FeaturesReply mockedFeatures = mock(FeaturesReply.class);
-        final BigInteger dummyDatapathId = BigInteger.ONE;
-        final Short dummyVersion = 1;
-        final ConnectionAdapter mockedConnectionAdapter = mock(ConnectionAdapter.class);
-
-        when(mockedFeatures.getDatapathId()).thenReturn(dummyDatapathId);
-        when(mockedFeatures.getVersion()).thenReturn(dummyVersion);
-        when(mockedConnectionContext.getFeatures()).thenReturn(mockedFeatures);
-        when(mockedConnectionContext.getConnectionAdapter()).thenReturn(mockedConnectionAdapter);
-        when(mockedDeviceContext.getPrimaryConnectionContext()).thenReturn(mockedConnectionContext);
-        final Xid mockedXid = mock(Xid.class);
-        final Long dummyXid = 1l;
-        when(mockedXid.getValue()).thenReturn(dummyXid);
-        when(mockedDeviceContext.getReservedXid()).thenReturn(dummyXid);
+    public void testOnDeviceContextLevelUp() {
 
-        invokeRpcTestExistsCapacity(10, true);
-        invokeRpcTestExistsCapacity(0, false);
-    }
-
-    private void invokeRpcTestExistsCapacity(final int capacity, final boolean result) throws InterruptedException,
-            ExecutionException {
-        // TODO: how to invoke service remotely?
-        NodeId nodeId = new NodeId("openflow:1");
-        KeyedInstanceIdentifier<Node, NodeKey> nodeInstanceIdentifier = InstanceIdentifier.create(Nodes.class).child(Node.class, new NodeKey(nodeId));
-        final RpcContextImpl rpcContext = new RpcContextImpl(messageSpy, mockedProviderContext, mockedDeviceContext, capacity);
-        when(mockedProviderContext.getRpcService(SalFlowService.class)).thenReturn(new SalFlowServiceImpl(rpcContext, mockedDeviceContext));
-
-        final SalFlowService salFlowService = mockedProviderContext.getRpcService(SalFlowService.class);
-        final Future<RpcResult<AddFlowOutput>> addedFlow = salFlowService.addFlow(prepareTestingAddFlow());
-    }
+        Mockito.when(rpcProviderRegistry.addRoutedRpcImplementation(
+                Matchers.<Class<RpcService>>any(), Matchers.any(RpcService.class)))
+                .thenReturn(routedRpcRegistration);
 
-    /**
-     * @return
-     */
-    private static AddFlowInput prepareTestingAddFlow() {
-        final AddFlowInputBuilder builder = new AddFlowInputBuilder();
-        builder.setFlowName("dummy flow");
-        builder.setHardTimeout(10000);
+        rpcManager.onDeviceContextLevelUp(deviceContext);
 
-        return builder.build();
+        Mockito.verify(rpcProviderRegistry, times(AWAITED_NUM_OF_CALL_ADD_ROUTED_RPC)).addRoutedRpcImplementation(
+                Matchers.<Class<RpcService>>any(), Matchers.any(RpcService.class));
+        Mockito.verify(routedRpcRegistration, times(AWAITED_NUM_OF_CALL_ADD_ROUTED_RPC)).registerPath(
+                NodeContext.class, nodePath);
+        Mockito.verify(deviceINitializationPhaseHandler).onDeviceContextLevelUp(deviceContext);
     }
 }