X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-remoterpc-connector%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fremote%2Frpc%2FAbstractRpcTest.java;h=e512938b712f070c956d131e4c8f4d304f72002b;hp=8d886829aa4edceee15a2ac30aa3c358b02f2343;hb=0f02b7edeb1454c1a568f0f1b050757e7503ddf7;hpb=7f8512fcbe4ac373995b7e2e370d38a01f4eaeec diff --git a/opendaylight/md-sal/sal-remoterpc-connector/src/test/java/org/opendaylight/controller/remote/rpc/AbstractRpcTest.java b/opendaylight/md-sal/sal-remoterpc-connector/src/test/java/org/opendaylight/controller/remote/rpc/AbstractRpcTest.java index 8d886829aa..e512938b71 100644 --- a/opendaylight/md-sal/sal-remoterpc-connector/src/test/java/org/opendaylight/controller/remote/rpc/AbstractRpcTest.java +++ b/opendaylight/md-sal/sal-remoterpc-connector/src/test/java/org/opendaylight/controller/remote/rpc/AbstractRpcTest.java @@ -13,35 +13,32 @@ import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertNull; import static org.junit.Assert.assertTrue; -import java.io.File; +import akka.actor.ActorRef; +import akka.actor.ActorSystem; +import akka.testkit.javadsl.TestKit; import java.net.URI; -import java.util.Arrays; import java.util.Collection; -import java.util.List; - import org.junit.AfterClass; import org.junit.Before; import org.junit.BeforeClass; -import org.mockito.Mockito; -import org.opendaylight.controller.sal.core.api.Broker; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.opendaylight.mdsal.dom.api.DOMRpcIdentifier; +import org.opendaylight.mdsal.dom.api.DOMRpcResult; +import org.opendaylight.mdsal.dom.api.DOMRpcService; import org.opendaylight.yangtools.yang.common.QName; import org.opendaylight.yangtools.yang.common.RpcError; -import org.opendaylight.yangtools.yang.common.RpcResult; import org.opendaylight.yangtools.yang.common.RpcError.ErrorSeverity; import org.opendaylight.yangtools.yang.common.RpcError.ErrorType; -import org.opendaylight.yangtools.yang.data.api.CompositeNode; -import org.opendaylight.yangtools.yang.data.api.Node; -import org.opendaylight.yangtools.yang.data.impl.ImmutableCompositeNode; -import org.opendaylight.yangtools.yang.data.impl.util.CompositeNodeBuilder; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier; +import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode; +import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; +import org.opendaylight.yangtools.yang.data.impl.schema.Builders; +import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes; import org.opendaylight.yangtools.yang.model.api.SchemaContext; -import org.opendaylight.yangtools.yang.parser.impl.YangParserImpl; - -import akka.actor.ActorRef; -import akka.actor.ActorSystem; -import akka.testkit.JavaTestKit; - -import com.google.common.collect.ImmutableList; -import com.typesafe.config.ConfigFactory; +import org.opendaylight.yangtools.yang.model.api.SchemaPath; +import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils; /** * Base class for RPC tests. @@ -56,48 +53,65 @@ public class AbstractRpcTest { static final QName TEST_RPC_INPUT = QName.create(TEST_NS, TEST_REV, "input"); static final QName TEST_RPC_INPUT_DATA = QName.create(TEST_NS, TEST_REV, "input-data"); static final QName TEST_RPC_OUTPUT = QName.create(TEST_NS, TEST_REV, "output"); - static final QName TEST_RPC_OUTPUT_DATA = new QName(TEST_URI, "output-data"); + static final QName TEST_RPC_OUTPUT_DATA = QName.create(TEST_URI, "output-data"); + + + static final SchemaPath TEST_RPC_TYPE = SchemaPath.create(true, TEST_RPC); + static final YangInstanceIdentifier TEST_PATH = YangInstanceIdentifier.create( + new YangInstanceIdentifier.NodeIdentifier(TEST_RPC)); + public static final DOMRpcIdentifier TEST_RPC_ID = DOMRpcIdentifier.create(TEST_RPC_TYPE, TEST_PATH); static ActorSystem node1; static ActorSystem node2; + static RemoteRpcProviderConfig config1; + static RemoteRpcProviderConfig config2; - protected ActorRef rpcBroker1; - protected JavaTestKit probeReg1; - protected ActorRef rpcBroker2; - protected JavaTestKit probeReg2; - protected Broker.ProviderSession brokerSession; + protected ActorRef rpcInvoker1; + protected TestKit rpcRegistry1Probe; + protected ActorRef rpcInvoker2; + protected TestKit rpcRegistry2Probe; protected SchemaContext schemaContext; + protected RemoteRpcImplementation remoteRpcImpl1; + protected RemoteRpcImplementation remoteRpcImpl2; + + @Mock + protected DOMRpcService domRpcService1; + @Mock + protected DOMRpcService domRpcService2; @BeforeClass - public static void setup() throws InterruptedException { - node1 = ActorSystem.create("opendaylight-rpc", ConfigFactory.load().getConfig("memberA")); - node2 = ActorSystem.create("opendaylight-rpc", ConfigFactory.load().getConfig("memberB")); + public static void setup() { + config1 = new RemoteRpcProviderConfig.Builder("memberA").build(); + config2 = new RemoteRpcProviderConfig.Builder("memberB").build(); + node1 = ActorSystem.create("opendaylight-rpc", config1.get()); + node2 = ActorSystem.create("opendaylight-rpc", config2.get()); } @AfterClass public static void teardown() { - JavaTestKit.shutdownActorSystem(node1); - JavaTestKit.shutdownActorSystem(node2); + TestKit.shutdownActorSystem(node1); + TestKit.shutdownActorSystem(node2); node1 = null; node2 = null; } @Before public void setUp() { - schemaContext = new YangParserImpl().parseFiles(Arrays.asList( - new File(RpcBrokerTest.class.getResource("/test-rpc.yang").getPath()))); + schemaContext = YangParserTestUtils.parseYangResources(AbstractRpcTest.class, "/test-rpc.yang"); - brokerSession = Mockito.mock(Broker.ProviderSession.class); - probeReg1 = new JavaTestKit(node1); - rpcBroker1 = node1.actorOf(RpcBroker.props(brokerSession, probeReg1.getRef(), schemaContext)); - probeReg2 = new JavaTestKit(node2); - rpcBroker2 = node2.actorOf(RpcBroker.props(brokerSession, probeReg2.getRef(), schemaContext)); + MockitoAnnotations.initMocks(this); + rpcRegistry1Probe = new TestKit(node1); + rpcInvoker1 = node1.actorOf(RpcInvoker.props(domRpcService1)); + rpcRegistry2Probe = new TestKit(node2); + rpcInvoker2 = node2.actorOf(RpcInvoker.props(domRpcService2)); + remoteRpcImpl1 = new RemoteRpcImplementation(rpcInvoker2, config1); + remoteRpcImpl2 = new RemoteRpcImplementation(rpcInvoker1, config2); } - static void assertRpcErrorEquals(RpcError rpcError, ErrorSeverity severity, - ErrorType errorType, String tag, String message, String applicationTag, String info, - String causeMsg) { + static void assertRpcErrorEquals(final RpcError rpcError, final ErrorSeverity severity, + final ErrorType errorType, final String tag, final String message, final String applicationTag, + final String info, final String causeMsg) { assertEquals("getSeverity", severity, rpcError.getSeverity()); assertEquals("getErrorType", errorType, rpcError.getErrorType()); assertEquals("getTag", tag, rpcError.getTag()); @@ -105,61 +119,41 @@ public class AbstractRpcTest { assertEquals("getApplicationTag", applicationTag, rpcError.getApplicationTag()); assertEquals("getInfo", info, rpcError.getInfo()); - if(causeMsg == null) { + if (causeMsg == null) { assertNull("Unexpected cause " + rpcError.getCause(), rpcError.getCause()); } else { assertEquals("Cause message", causeMsg, rpcError.getCause().getMessage()); } } - static void assertCompositeNodeEquals(CompositeNode exp, CompositeNode actual) { - assertEquals("NodeType getNamespace", exp.getNodeType().getNamespace(), - actual.getNodeType().getNamespace()); - assertEquals("NodeType getLocalName", exp.getNodeType().getLocalName(), - actual.getNodeType().getLocalName()); - for(Node child: exp.getValue()) { - List> c = actual.get(child.getNodeType()); - assertNotNull("Missing expected child " + child.getNodeType(), c); - if(child instanceof CompositeNode) { - assertCompositeNodeEquals((CompositeNode) child, (CompositeNode)c.get(0)); - } else { - assertEquals("Value for Node " + child.getNodeType(), child.getValue(), - c.get(0).getValue()); - } - } + static void assertCompositeNodeEquals(final NormalizedNode exp, final NormalizedNode actual) { + assertEquals(exp, actual); } - static CompositeNode makeRPCInput(String data) { - CompositeNodeBuilder builder = ImmutableCompositeNode.builder() - .setQName(TEST_RPC_INPUT).addLeaf(TEST_RPC_INPUT_DATA, data); - return ImmutableCompositeNode.create( - TEST_RPC, ImmutableList.>of(builder.toInstance())); - } + public static ContainerNode makeRPCInput(final String data) { + return Builders.containerBuilder().withNodeIdentifier(new NodeIdentifier(TEST_RPC_INPUT)) + .withChild(ImmutableNodes.leafNode(TEST_RPC_INPUT_DATA, data)).build(); - static CompositeNode makeRPCOutput(String data) { - CompositeNodeBuilder builder = ImmutableCompositeNode.builder() - .setQName(TEST_RPC_OUTPUT).addLeaf(TEST_RPC_OUTPUT_DATA, data); - return ImmutableCompositeNode.create( - TEST_RPC, ImmutableList.>of(builder.toInstance())); } - static void assertFailedRpcResult(RpcResult rpcResult, ErrorSeverity severity, - ErrorType errorType, String tag, String message, String applicationTag, String info, - String causeMsg) { + public static ContainerNode makeRPCOutput(final String data) { + return Builders.containerBuilder().withNodeIdentifier(new NodeIdentifier(TEST_RPC_OUTPUT)) + .withChild(ImmutableNodes.leafNode(TEST_RPC_OUTPUT, data)).build(); + } + static void assertFailedRpcResult(final DOMRpcResult rpcResult, final ErrorSeverity severity, + final ErrorType errorType, final String tag, final String message, final String applicationTag, + final String info, final String causeMsg) { assertNotNull("RpcResult was null", rpcResult); - assertEquals("isSuccessful", false, rpcResult.isSuccessful()); - Collection rpcErrors = rpcResult.getErrors(); + final Collection rpcErrors = rpcResult.getErrors(); assertEquals("RpcErrors count", 1, rpcErrors.size()); assertRpcErrorEquals(rpcErrors.iterator().next(), severity, errorType, tag, message, applicationTag, info, causeMsg); } - static void assertSuccessfulRpcResult(RpcResult rpcResult, - CompositeNode expOutput) { - + static void assertSuccessfulRpcResult(final DOMRpcResult rpcResult, + final NormalizedNode expOutput) { assertNotNull("RpcResult was null", rpcResult); - assertEquals("isSuccessful", true, rpcResult.isSuccessful()); assertCompositeNodeEquals(expOutput, rpcResult.getResult()); }