opendaylight/md-sal/sal-rest-connector/src/test/java/org/opendaylight/controller/sal/restconf/impl/test/InvokeRpcMethodTest.java

   1 package org.opendaylight.controller.sal.restconf.impl.test;
   2
   3 import static org.junit.Assert.assertEquals;
   4 import static org.junit.Assert.assertNotNull;
   5 import static org.junit.Assert.assertTrue;
   6 import static org.mockito.Matchers.any;
   7 import static org.mockito.Mockito.mock;
   8 import static org.mockito.Mockito.when;
   9
  10 import java.net.*;
  11 import java.util.*;
  12
  13 import org.junit.*;
  14 import org.mockito.invocation.InvocationOnMock;
  15 import org.mockito.stubbing.Answer;
  16 import org.opendaylight.controller.sal.restconf.impl.*;
  17 import org.opendaylight.yangtools.yang.common.*;
  18 import org.opendaylight.yangtools.yang.data.api.*;
  19 import org.opendaylight.yangtools.yang.data.impl.NodeFactory;
  20 import org.opendaylight.yangtools.yang.model.api.Module;
  21
  22 public class InvokeRpcMethodTest {
  23
  24     private static Set<Module> modules;
  25
  26     private class RpcResultImpl<T> implements RpcResult<T> {
  27
  28         final T result;
  29
  30         public RpcResultImpl(T compNode) {
  31             this.result = compNode;
  32         }
  33
  34         @Override
  35         public boolean isSuccessful() {
  36             // TODO Auto-generated method stub
  37             return false;
  38         }
  39
  40         @Override
  41         public T getResult() {
  42             return result;
  43         }
  44
  45         @Override
  46         public Collection<RpcError> getErrors() {
  47             // TODO Auto-generated method stub
  48             return null;
  49         }
  50
  51     }
  52
  53     private class AnswerImpl implements Answer<RpcResult<CompositeNode>> {
  54         @Override
  55         public RpcResult<CompositeNode> answer(InvocationOnMock invocation) throws Throwable {
  56             CompositeNode compNode = (CompositeNode) invocation.getArguments()[1];
  57             return new RpcResultImpl<CompositeNode>(compNode);
  58         }
  59     }
  60
  61     @BeforeClass
  62     public static void initialization() {
  63         modules = TestUtils.resolveModules("/invoke-rpc");
  64         assertEquals(1, modules.size());
  65         Module module = TestUtils.resolveModule("invoke-rpc-module", modules);
  66         assertNotNull(module);
  67     }
  68
  69     /**
  70      * Test method invokeRpc in RestconfImpl class tests if composite node as
  71      * input parameter of method invokeRpc (second argument) is wrapped to
  72      * parent composite node which has QName equals to QName of rpc (resolved
  73      * from string - first argument).
  74      */
  75     @Test
  76     public void invokeRpcMethodTest() {
  77         ControllerContext contContext = ControllerContext.getInstance();
  78         contContext.onGlobalContextUpdated(TestUtils.loadSchemaContext(modules));
  79         try {
  80             contContext.findModuleByNamespace(new URI("invoke:rpc:module"));
  81         } catch (URISyntaxException e) {
  82             assertTrue("Uri wasn't created sucessfuly", false);
  83         }
  84
  85         BrokerFacade mockedBrokerFacade = mock(BrokerFacade.class);
  86
  87         RestconfImpl restconf = RestconfImpl.getInstance();
  88         restconf.setBroker(mockedBrokerFacade);
  89         restconf.setControllerContext(contContext);
  90
  91         when(mockedBrokerFacade.invokeRpc(any(QName.class), any(CompositeNode.class))).thenAnswer(new AnswerImpl());
  92
  93         StructuredData structData = restconf.invokeRpc("invoke-rpc-module:rpc-test", preparePayload());
  94
  95         CompositeNode rpcCompNode = structData.getData();
  96         CompositeNode cont = null;
  97         assertEquals("invoke:rpc:module", rpcCompNode.getNodeType().getNamespace().toString());
  98         assertEquals("rpc-test", rpcCompNode.getNodeType().getLocalName());
  99
 100         for (Node<?> node : rpcCompNode.getChildren()) {
 101             if (node.getNodeType().getLocalName().equals("cont")
 102                     && node.getNodeType().getNamespace().toString().equals("nmspc")) {
 103                 if (node instanceof CompositeNode) {
 104                     cont = (CompositeNode) node;
 105                 }
 106             }
 107         }
 108         assertNotNull(cont);
 109
 110     }
 111
 112     private CompositeNode preparePayload() {
 113         MutableCompositeNode cont = NodeFactory.createMutableCompositeNode(
 114                 TestUtils.buildQName("cont", "nmspc", "2013-12-04"), null, null, ModifyAction.CREATE, null);
 115         MutableSimpleNode<?> lf = NodeFactory.createMutableSimpleNode(
 116                 TestUtils.buildQName("lf", "nmspc", "2013-12-04"), cont, "any value", ModifyAction.CREATE, null);
 117         cont.getChildren().add(lf);
 118         cont.init();
 119
 120         return cont;
 121     }
 122
 123 }