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.md.sal.dom.api.DOMRpcException;
  30 import org.opendaylight.controller.md.sal.dom.api.DOMRpcImplementationNotAvailableException;
  31 import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
  32 import org.opendaylight.controller.md.sal.dom.spi.DefaultDOMRpcResult;
  33 import org.opendaylight.controller.remote.rpc.registry.RpcRegistry;
  34 import org.opendaylight.controller.remote.rpc.registry.RpcRegistry.Messages.FindRouters;
  35 import org.opendaylight.controller.sal.connector.api.RpcRouter.RouteIdentifier;
  36 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
  37 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  38
  39 /**
  40  * Unit tests for RemoteRpcImplementation.
  41  *
  42  * @author Thomas Pantelis
  43  */
  44 public class RemoteRpcImplementationTest extends AbstractRpcTest {
  45
  46
  47
  48     @Test(expected = DOMRpcImplementationNotAvailableException.class)
  49     public void testInvokeRpcWithNoRemoteActor() throws Exception {
  50         final ContainerNode input = makeRPCInput("foo");
  51         final CheckedFuture<DOMRpcResult, DOMRpcException> failedFuture = remoteRpcImpl1.invokeRpc(TEST_RPC_ID, input);
  52         rpcRegistry1Probe.expectMsgClass(JavaTestKit.duration("5 seconds"), RpcRegistry.Messages.FindRouters.class);
  53         rpcRegistry1Probe
  54                 .reply(new RpcRegistry.Messages.FindRoutersReply(Collections.<Pair<ActorRef, Long>>emptyList()));
  55         failedFuture.checkedGet(5, TimeUnit.SECONDS);
  56     }
  57
  58
  59     /**
  60      * This test method invokes and executes the remote rpc.
  61      */
  62     @Test
  63     public void testInvokeRpc() throws Exception {
  64         final ContainerNode rpcOutput = makeRPCOutput("bar");
  65         final DOMRpcResult rpcResult = new DefaultDOMRpcResult(rpcOutput);
  66
  67         final NormalizedNode<?, ?> invokeRpcInput = makeRPCInput("foo");
  68         @SuppressWarnings({"unchecked", "rawtypes"})
  69         final ArgumentCaptor<NormalizedNode<?, ?>> inputCaptor =
  70                 (ArgumentCaptor) ArgumentCaptor.forClass(NormalizedNode.class);
  71
  72         when(domRpcService2.invokeRpc(eq(TEST_RPC_TYPE), inputCaptor.capture())).thenReturn(
  73                 Futures.<DOMRpcResult, DOMRpcException>immediateCheckedFuture(rpcResult));
  74
  75         final CheckedFuture<DOMRpcResult, DOMRpcException> frontEndFuture =
  76                 remoteRpcImpl1.invokeRpc(TEST_RPC_ID, invokeRpcInput);
  77         assertTrue(frontEndFuture instanceof RemoteDOMRpcFuture);
  78         final FindRouters findRouters = rpcRegistry1Probe.expectMsgClass(RpcRegistry.Messages.FindRouters.class);
  79         final RouteIdentifier<?, ?, ?> routeIdentifier = findRouters.getRouteIdentifier();
  80         assertEquals("getType", TEST_RPC, routeIdentifier.getType());
  81         assertEquals("getRoute", TEST_PATH, routeIdentifier.getRoute());
  82
  83         rpcRegistry1Probe.reply(new RpcRegistry.Messages.FindRoutersReply(Arrays.asList(new Pair<>(
  84                 rpcBroker2, 200L))));
  85
  86         final DOMRpcResult result = frontEndFuture.checkedGet(5, TimeUnit.SECONDS);
  87         assertEquals(rpcOutput, result.getResult());
  88     }
  89
  90     /**
  91      * This test method invokes and executes the remote rpc.
  92      */
  93     @Test
  94     public void testInvokeRpcWithNullInput() throws Exception {
  95         final ContainerNode rpcOutput = makeRPCOutput("bar");
  96         final DOMRpcResult rpcResult = new DefaultDOMRpcResult(rpcOutput);
  97
  98         @SuppressWarnings({"unchecked", "rawtypes"})
  99         final ArgumentCaptor<NormalizedNode<?, ?>> inputCaptor =
 100                 (ArgumentCaptor) ArgumentCaptor.forClass(NormalizedNode.class);
 101
 102         when(domRpcService2.invokeRpc(eq(TEST_RPC_TYPE), inputCaptor.capture())).thenReturn(
 103                 Futures.<DOMRpcResult, DOMRpcException>immediateCheckedFuture(rpcResult));
 104
 105         final CheckedFuture<DOMRpcResult, DOMRpcException> frontEndFuture =
 106                 remoteRpcImpl1.invokeRpc(TEST_RPC_ID, null);
 107         assertTrue(frontEndFuture instanceof RemoteDOMRpcFuture);
 108         final FindRouters findRouters = rpcRegistry1Probe.expectMsgClass(RpcRegistry.Messages.FindRouters.class);
 109         final RouteIdentifier<?, ?, ?> routeIdentifier = findRouters.getRouteIdentifier();
 110         assertEquals("getType", TEST_RPC, routeIdentifier.getType());
 111         assertEquals("getRoute", TEST_PATH, routeIdentifier.getRoute());
 112
 113         rpcRegistry1Probe.reply(new RpcRegistry.Messages.FindRoutersReply(Arrays.asList(new Pair<>(
 114                 rpcBroker2, 200L))));
 115
 116         final DOMRpcResult result = frontEndFuture.checkedGet(5, TimeUnit.SECONDS);
 117         assertEquals(rpcOutput, result.getResult());
 118     }
 119
 120
 121     /**
 122      * This test method invokes and executes the remote rpc.
 123      */
 124     @Test
 125     public void testInvokeRpcWithNoOutput() throws Exception {
 126         final ContainerNode rpcOutput = null;
 127         final DOMRpcResult rpcResult = new DefaultDOMRpcResult(rpcOutput);
 128
 129         final NormalizedNode<?, ?> invokeRpcInput = makeRPCInput("foo");
 130         @SuppressWarnings({"unchecked", "rawtypes"})
 131         final ArgumentCaptor<NormalizedNode<?, ?>> inputCaptor =
 132                 (ArgumentCaptor) ArgumentCaptor.forClass(NormalizedNode.class);
 133
 134         when(domRpcService2.invokeRpc(eq(TEST_RPC_TYPE), inputCaptor.capture())).thenReturn(
 135                 Futures.<DOMRpcResult, DOMRpcException>immediateCheckedFuture(rpcResult));
 136
 137         final CheckedFuture<DOMRpcResult, DOMRpcException> frontEndFuture =
 138                 remoteRpcImpl1.invokeRpc(TEST_RPC_ID, invokeRpcInput);
 139         assertTrue(frontEndFuture instanceof RemoteDOMRpcFuture);
 140         final FindRouters findRouters = rpcRegistry1Probe.expectMsgClass(RpcRegistry.Messages.FindRouters.class);
 141         final RouteIdentifier<?, ?, ?> routeIdentifier = findRouters.getRouteIdentifier();
 142         assertEquals("getType", TEST_RPC, routeIdentifier.getType());
 143         assertEquals("getRoute", TEST_PATH, routeIdentifier.getRoute());
 144
 145         rpcRegistry1Probe.reply(new RpcRegistry.Messages.FindRoutersReply(Arrays.asList(new Pair<>(
 146                 rpcBroker2, 200L))));
 147
 148         final DOMRpcResult result = frontEndFuture.checkedGet(5, TimeUnit.SECONDS);
 149         assertNull(result.getResult());
 150     }
 151
 152
 153     /**
 154      * This test method invokes and executes the remote rpc.
 155      */
 156     @Test(expected = DOMRpcException.class)
 157     public void testInvokeRpcWithRemoteFailedFuture() throws Exception {
 158         final NormalizedNode<?, ?> invokeRpcInput = makeRPCInput("foo");
 159         @SuppressWarnings({"unchecked", "rawtypes"})
 160         final ArgumentCaptor<NormalizedNode<?, ?>> inputCaptor =
 161                 (ArgumentCaptor) ArgumentCaptor.forClass(NormalizedNode.class);
 162
 163         when(domRpcService2.invokeRpc(eq(TEST_RPC_TYPE), inputCaptor.capture())).thenReturn(
 164                 Futures.<DOMRpcResult, DOMRpcException>immediateFailedCheckedFuture(new RemoteDOMRpcException(
 165                         "Test Exception", null)));
 166
 167         final CheckedFuture<DOMRpcResult, DOMRpcException> frontEndFuture =
 168                 remoteRpcImpl1.invokeRpc(TEST_RPC_ID, invokeRpcInput);
 169         assertTrue(frontEndFuture instanceof RemoteDOMRpcFuture);
 170         final FindRouters findRouters = rpcRegistry1Probe.expectMsgClass(RpcRegistry.Messages.FindRouters.class);
 171         final RouteIdentifier<?, ?, ?> routeIdentifier = findRouters.getRouteIdentifier();
 172         assertEquals("getType", TEST_RPC, routeIdentifier.getType());
 173         assertEquals("getRoute", TEST_PATH, routeIdentifier.getRoute());
 174
 175         rpcRegistry1Probe.reply(new RpcRegistry.Messages.FindRoutersReply(Arrays.asList(new Pair<>(
 176                 rpcBroker2, 200L))));
 177         frontEndFuture.checkedGet(5, TimeUnit.SECONDS);
 178     }
 179
 180     /**
 181      * This test method invokes and tests exceptions when akka timeout occured
 182      * Currently ignored since this test with current config takes around 15 seconds to complete.
 183      */
 184     @Ignore
 185     @Test(expected = RemoteDOMRpcException.class)
 186     public void testInvokeRpcWithAkkaTimeoutException() throws Exception {
 187         final NormalizedNode<?, ?> invokeRpcInput = makeRPCInput("foo");
 188         final CheckedFuture<DOMRpcResult, DOMRpcException> frontEndFuture =
 189                 remoteRpcImpl1.invokeRpc(TEST_RPC_ID, invokeRpcInput);
 190         assertTrue(frontEndFuture instanceof RemoteDOMRpcFuture);
 191         final FindRouters findRouters = rpcRegistry1Probe.expectMsgClass(RpcRegistry.Messages.FindRouters.class);
 192         final RouteIdentifier<?, ?, ?> routeIdentifier = findRouters.getRouteIdentifier();
 193         assertEquals("getType", TEST_RPC, routeIdentifier.getType());
 194         assertEquals("getRoute", TEST_PATH, routeIdentifier.getRoute());
 195
 196         frontEndFuture.checkedGet(20, TimeUnit.SECONDS);
 197     }
 198
 199     /**
 200      * This test method invokes remote rpc and lookup failed
 201      * with runtime exception.
 202      */
 203     @Test(expected = DOMRpcException.class)
 204     public void testInvokeRpcWithLookupException() throws Exception {
 205         final NormalizedNode<?, ?> invokeRpcInput = makeRPCInput("foo");
 206         final CheckedFuture<DOMRpcResult, DOMRpcException> frontEndFuture =
 207                 remoteRpcImpl1.invokeRpc(TEST_RPC_ID, invokeRpcInput);
 208         assertTrue(frontEndFuture instanceof RemoteDOMRpcFuture);
 209         final FindRouters findRouters = rpcRegistry1Probe.expectMsgClass(RpcRegistry.Messages.FindRouters.class);
 210         final RouteIdentifier<?, ?, ?> routeIdentifier = findRouters.getRouteIdentifier();
 211         assertEquals("getType", TEST_RPC, routeIdentifier.getType());
 212         assertEquals("getRoute", TEST_PATH, routeIdentifier.getRoute());
 213         rpcRegistry1Probe.reply( new Status.Failure(new RuntimeException("test")));
 214         frontEndFuture.checkedGet(5, TimeUnit.SECONDS);
 215     }
 216
 217     /**
 218      * This test method invokes and executes the remote rpc.
 219      */
 220     @Test(expected = DOMRpcImplementationNotAvailableException.class)
 221     public void testInvokeRpcWithLoopException() throws Exception {
 222         final NormalizedNode<?, ?> invokeRpcInput = RemoteRpcInput.from(makeRPCInput("foo"));
 223         final CheckedFuture<DOMRpcResult, DOMRpcException> frontEndFuture =
 224                 remoteRpcImpl1.invokeRpc(TEST_RPC_ID, invokeRpcInput);
 225
 226         frontEndFuture.checkedGet(5, TimeUnit.SECONDS);
 227     }
 228 }