opendaylight/md-sal/sal-remoterpc-connector/src/test/java/org/opendaylight/controller/remote/rpc/RemoteRpcImplementationTest.java

   1 /*
   2  * Copyright (c) 2014 Brocade Communications Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.controller.remote.rpc;
  10
  11 import static org.junit.Assert.assertEquals;
  12 import static org.junit.Assert.assertNull;
  13 import static org.junit.Assert.assertTrue;
  14 import static org.mockito.Matchers.eq;
  15 import static org.mockito.Mockito.when;
  16
  17 import akka.actor.ActorRef;
  18 import akka.actor.Status;
  19 import akka.japi.Pair;
  20 import akka.testkit.JavaTestKit;
  21 import com.google.common.util.concurrent.CheckedFuture;
  22 import com.google.common.util.concurrent.Futures;
  23 import java.util.Arrays;
  24 import java.util.Collections;
  25 import java.util.concurrent.TimeUnit;
  26 import org.junit.Ignore;
  27 import org.junit.Test;
  28 import org.mockito.ArgumentCaptor;
  29 import org.opendaylight.controller.cluster.datastore.node.utils.serialization.NormalizedNodeSerializer;
  30 import org.opendaylight.controller.md.sal.dom.api.DOMRpcException;
  31 import org.opendaylight.controller.md.sal.dom.api.DOMRpcImplementationNotAvailableException;
  32 import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
  33 import org.opendaylight.controller.md.sal.dom.spi.DefaultDOMRpcResult;
  34 import org.opendaylight.controller.remote.rpc.registry.RpcRegistry;
  35 import org.opendaylight.controller.remote.rpc.registry.RpcRegistry.Messages.FindRouters;
  36 import org.opendaylight.controller.sal.connector.api.RpcRouter.RouteIdentifier;
  37 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
  38 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  39
  40 /***
  41  * Unit tests for RemoteRpcImplementation.
  42  *
  43  * @author Thomas Pantelis
  44  */
  45 public class RemoteRpcImplementationTest extends AbstractRpcTest {
  46
  47
  48
  49     @Test(expected = DOMRpcImplementationNotAvailableException.class)
  50     public void testInvokeRpcWithNoRemoteActor() throws Exception {
  51         final ContainerNode input = makeRPCInput("foo");
  52         final CheckedFuture<DOMRpcResult, DOMRpcException> failedFuture = remoteRpcImpl1.invokeRpc(TEST_RPC_ID, input);
  53         rpcRegistry1Probe.expectMsgClass(JavaTestKit.duration("5 seconds"), RpcRegistry.Messages.FindRouters.class);
  54         rpcRegistry1Probe
  55                 .reply(new RpcRegistry.Messages.FindRoutersReply(Collections.<Pair<ActorRef, Long>>emptyList()));
  56         failedFuture.checkedGet(5, TimeUnit.SECONDS);
  57     }
  58
  59
  60     /**
  61      * This test method invokes and executes the remote rpc
  62      */
  63     @Test
  64     public void testInvokeRpc() throws Exception {
  65         final ContainerNode rpcOutput = makeRPCOutput("bar");
  66         final DOMRpcResult rpcResult = new DefaultDOMRpcResult(rpcOutput);
  67
  68         final NormalizedNode<?, ?> invokeRpcInput = makeRPCInput("foo");
  69         @SuppressWarnings({"unchecked", "rawtypes"})
  70         final ArgumentCaptor<NormalizedNode<?, ?>> inputCaptor =
  71                 (ArgumentCaptor) ArgumentCaptor.forClass(NormalizedNode.class);
  72
  73         when(domRpcService2.invokeRpc(eq(TEST_RPC_TYPE), inputCaptor.capture())).thenReturn(
  74                 Futures.<DOMRpcResult, DOMRpcException>immediateCheckedFuture(rpcResult));
  75
  76         final CheckedFuture<DOMRpcResult, DOMRpcException> frontEndFuture =
  77                 remoteRpcImpl1.invokeRpc(TEST_RPC_ID, invokeRpcInput);
  78         assertTrue(frontEndFuture instanceof RemoteDOMRpcFuture);
  79         final FindRouters findRouters = rpcRegistry1Probe.expectMsgClass(RpcRegistry.Messages.FindRouters.class);
  80         final RouteIdentifier<?, ?, ?> routeIdentifier = findRouters.getRouteIdentifier();
  81         assertEquals("getType", TEST_RPC, routeIdentifier.getType());
  82         assertEquals("getRoute", TEST_PATH, routeIdentifier.getRoute());
  83
  84         rpcRegistry1Probe.reply(new RpcRegistry.Messages.FindRoutersReply(Arrays.asList(new Pair<ActorRef, Long>(
  85                 rpcBroker2, 200L))));
  86
  87         final DOMRpcResult result = frontEndFuture.checkedGet(5, TimeUnit.SECONDS);
  88         assertEquals(rpcOutput, result.getResult());
  89     }
  90
  91     /**
  92      * This test method invokes and executes the remote rpc
  93      */
  94     @Test
  95     public void testInvokeRpcWithNullInput() throws Exception {
  96         final ContainerNode rpcOutput = makeRPCOutput("bar");
  97         final DOMRpcResult rpcResult = new DefaultDOMRpcResult(rpcOutput);
  98
  99         @SuppressWarnings({"unchecked", "rawtypes"})
 100         final ArgumentCaptor<NormalizedNode<?, ?>> inputCaptor =
 101                 (ArgumentCaptor) ArgumentCaptor.forClass(NormalizedNode.class);
 102
 103         when(domRpcService2.invokeRpc(eq(TEST_RPC_TYPE), inputCaptor.capture())).thenReturn(
 104                 Futures.<DOMRpcResult, DOMRpcException>immediateCheckedFuture(rpcResult));
 105
 106         final CheckedFuture<DOMRpcResult, DOMRpcException> frontEndFuture =
 107                 remoteRpcImpl1.invokeRpc(TEST_RPC_ID, null);
 108         assertTrue(frontEndFuture instanceof RemoteDOMRpcFuture);
 109         final FindRouters findRouters = rpcRegistry1Probe.expectMsgClass(RpcRegistry.Messages.FindRouters.class);
 110         final RouteIdentifier<?, ?, ?> routeIdentifier = findRouters.getRouteIdentifier();
 111         assertEquals("getType", TEST_RPC, routeIdentifier.getType());
 112         assertEquals("getRoute", TEST_PATH, routeIdentifier.getRoute());
 113
 114         rpcRegistry1Probe.reply(new RpcRegistry.Messages.FindRoutersReply(Arrays.asList(new Pair<ActorRef, Long>(
 115                 rpcBroker2, 200L))));
 116
 117         final DOMRpcResult result = frontEndFuture.checkedGet(5, TimeUnit.SECONDS);
 118         assertEquals(rpcOutput, result.getResult());
 119     }
 120
 121
 122     /**
 123      * This test method invokes and executes the remote rpc
 124      */
 125     @Test
 126     public void testInvokeRpcWithNoOutput() throws Exception {
 127         final ContainerNode rpcOutput = null;
 128         final DOMRpcResult rpcResult = new DefaultDOMRpcResult(rpcOutput);
 129
 130         final NormalizedNode<?, ?> invokeRpcInput = makeRPCInput("foo");
 131         @SuppressWarnings({"unchecked", "rawtypes"})
 132         final ArgumentCaptor<NormalizedNode<?, ?>> inputCaptor =
 133                 (ArgumentCaptor) ArgumentCaptor.forClass(NormalizedNode.class);
 134
 135         when(domRpcService2.invokeRpc(eq(TEST_RPC_TYPE), inputCaptor.capture())).thenReturn(
 136                 Futures.<DOMRpcResult, DOMRpcException>immediateCheckedFuture(rpcResult));
 137
 138         final CheckedFuture<DOMRpcResult, DOMRpcException> frontEndFuture =
 139                 remoteRpcImpl1.invokeRpc(TEST_RPC_ID, invokeRpcInput);
 140         assertTrue(frontEndFuture instanceof RemoteDOMRpcFuture);
 141         final FindRouters findRouters = rpcRegistry1Probe.expectMsgClass(RpcRegistry.Messages.FindRouters.class);
 142         final RouteIdentifier<?, ?, ?> routeIdentifier = findRouters.getRouteIdentifier();
 143         assertEquals("getType", TEST_RPC, routeIdentifier.getType());
 144         assertEquals("getRoute", TEST_PATH, routeIdentifier.getRoute());
 145
 146         rpcRegistry1Probe.reply(new RpcRegistry.Messages.FindRoutersReply(Arrays.asList(new Pair<ActorRef, Long>(
 147                 rpcBroker2, 200L))));
 148
 149         final DOMRpcResult result = frontEndFuture.checkedGet(5, TimeUnit.SECONDS);
 150         assertNull(result.getResult());
 151     }
 152
 153
 154     /**
 155      * This test method invokes and executes the remote rpc
 156      */
 157     @Test(expected = DOMRpcException.class)
 158     public void testInvokeRpcWithRemoteFailedFuture() throws Exception {
 159         final ContainerNode rpcOutput = null;
 160         final DOMRpcResult rpcResult = new DefaultDOMRpcResult(rpcOutput);
 161
 162         final NormalizedNode<?, ?> invokeRpcInput = makeRPCInput("foo");
 163         @SuppressWarnings({"unchecked", "rawtypes"})
 164         final ArgumentCaptor<NormalizedNode<?, ?>> inputCaptor =
 165                 (ArgumentCaptor) ArgumentCaptor.forClass(NormalizedNode.class);
 166
 167         when(domRpcService2.invokeRpc(eq(TEST_RPC_TYPE), inputCaptor.capture())).thenReturn(
 168                 Futures.<DOMRpcResult, DOMRpcException>immediateFailedCheckedFuture(new DOMRpcException(
 169                         "Test Exception") {}));
 170
 171         final CheckedFuture<DOMRpcResult, DOMRpcException> frontEndFuture =
 172                 remoteRpcImpl1.invokeRpc(TEST_RPC_ID, invokeRpcInput);
 173         assertTrue(frontEndFuture instanceof RemoteDOMRpcFuture);
 174         final FindRouters findRouters = rpcRegistry1Probe.expectMsgClass(RpcRegistry.Messages.FindRouters.class);
 175         final RouteIdentifier<?, ?, ?> routeIdentifier = findRouters.getRouteIdentifier();
 176         assertEquals("getType", TEST_RPC, routeIdentifier.getType());
 177         assertEquals("getRoute", TEST_PATH, routeIdentifier.getRoute());
 178
 179         rpcRegistry1Probe.reply(new RpcRegistry.Messages.FindRoutersReply(Arrays.asList(new Pair<ActorRef, Long>(
 180                 rpcBroker2, 200L))));
 181         frontEndFuture.checkedGet(5, TimeUnit.SECONDS);
 182     }
 183
 184     /**
 185      * This test method invokes and tests exceptions when akka timeout occured
 186      *
 187      * Currently ignored since this test with current config takes around 15 seconds
 188      * to complete.
 189      *
 190      */
 191     @Ignore
 192     @Test(expected = RemoteDOMRpcException.class)
 193     public void testInvokeRpcWithAkkaTimeoutException() throws Exception {
 194         final NormalizedNode<?, ?> invokeRpcInput = makeRPCInput("foo");
 195         @SuppressWarnings({"unchecked", "rawtypes"})
 196         final ArgumentCaptor<NormalizedNode<?, ?>> inputCaptor =
 197                 (ArgumentCaptor) ArgumentCaptor.forClass(NormalizedNode.class);
 198         final CheckedFuture<DOMRpcResult, DOMRpcException> frontEndFuture =
 199                 remoteRpcImpl1.invokeRpc(TEST_RPC_ID, invokeRpcInput);
 200         assertTrue(frontEndFuture instanceof RemoteDOMRpcFuture);
 201         final FindRouters findRouters = rpcRegistry1Probe.expectMsgClass(RpcRegistry.Messages.FindRouters.class);
 202         final RouteIdentifier<?, ?, ?> routeIdentifier = findRouters.getRouteIdentifier();
 203         assertEquals("getType", TEST_RPC, routeIdentifier.getType());
 204         assertEquals("getRoute", TEST_PATH, routeIdentifier.getRoute());
 205
 206         frontEndFuture.checkedGet(20, TimeUnit.SECONDS);
 207     }
 208
 209     /**
 210      * This test method invokes remote rpc and lookup failed
 211      * with runtime exception.
 212      */
 213     @Test(expected = DOMRpcException.class)
 214     public void testInvokeRpcWithLookupException() throws Exception {
 215         final NormalizedNode<?, ?> invokeRpcInput = makeRPCInput("foo");
 216         @SuppressWarnings({"unchecked", "rawtypes"})
 217         final ArgumentCaptor<NormalizedNode<?, ?>> inputCaptor =
 218                 (ArgumentCaptor) ArgumentCaptor.forClass(NormalizedNode.class);
 219         final CheckedFuture<DOMRpcResult, DOMRpcException> frontEndFuture =
 220                 remoteRpcImpl1.invokeRpc(TEST_RPC_ID, invokeRpcInput);
 221         assertTrue(frontEndFuture instanceof RemoteDOMRpcFuture);
 222         final FindRouters findRouters = rpcRegistry1Probe.expectMsgClass(RpcRegistry.Messages.FindRouters.class);
 223         final RouteIdentifier<?, ?, ?> routeIdentifier = findRouters.getRouteIdentifier();
 224         assertEquals("getType", TEST_RPC, routeIdentifier.getType());
 225         assertEquals("getRoute", TEST_PATH, routeIdentifier.getRoute());
 226         rpcRegistry1Probe.reply( new Status.Failure(new RuntimeException("test")));
 227         frontEndFuture.checkedGet(5, TimeUnit.SECONDS);
 228     }
 229
 230     /**
 231      * This test method invokes and executes the remote rpc
 232      */
 233     @Test(expected = DOMRpcImplementationNotAvailableException.class)
 234     public void testInvokeRpcWithLoopException() throws Exception {
 235         final NormalizedNode<?, ?> invokeRpcInput = RemoteRpcInput.from(NormalizedNodeSerializer.serialize(makeRPCInput("foo")));
 236         final CheckedFuture<DOMRpcResult, DOMRpcException> frontEndFuture = remoteRpcImpl1.invokeRpc(TEST_RPC_ID, invokeRpcInput);
 237
 238         frontEndFuture.checkedGet(5, TimeUnit.SECONDS);
 239     }
 240
 241
 242     private RemoteRpcProviderConfig getConfig() {
 243         return new RemoteRpcProviderConfig.Builder("unit-test").build();
 244     }
 245 }