OpenApi add POST request to device root

[netconf.git] / restconf / restconf-nb / src / test / java / org / opendaylight / restconf / nb / jaxrs / RestconfOperationsPostTest.java

diff --git a/restconf/restconf-nb/src/test/java/org/opendaylight/restconf/nb/jaxrs/RestconfOperationsPostTest.java b/restconf/restconf-nb/src/test/java/org/opendaylight/restconf/nb/jaxrs/RestconfOperationsPostTest.java
index c14aae9cf1264005e2597eb2cc1e8e476d1a3ba2..5608301930d5d1cc8055faa60f585a4d6863820f 100644 (file)
--- a/restconf/restconf-nb/src/test/java/org/opendaylight/restconf/nb/jaxrs/RestconfOperationsPostTest.java
+++ b/restconf/restconf-nb/src/test/java/org/opendaylight/restconf/nb/jaxrs/RestconfOperationsPostTest.java
@@ -7,8 +7,8 @@
  */
 package org.opendaylight.restconf.nb.jaxrs;
 
-import static org.junit.Assert.assertNull;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertSame;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.eq;
@@ -18,11 +18,15 @@ import static org.mockito.Mockito.mock;
 import com.google.common.util.concurrent.Futures;
 import java.util.List;
 import java.util.Optional;
+import javax.ws.rs.core.MultivaluedHashMap;
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
+import org.opendaylight.mdsal.dom.api.DOMActionService;
 import org.opendaylight.mdsal.dom.api.DOMDataBroker;
+import org.opendaylight.mdsal.dom.api.DOMMountPointService;
 import org.opendaylight.mdsal.dom.api.DOMNotificationService;
 import org.opendaylight.mdsal.dom.api.DOMRpcImplementationNotAvailableException;
 import org.opendaylight.mdsal.dom.api.DOMRpcResult;
@@ -37,24 +41,26 @@ import org.opendaylight.yangtools.yang.common.QName;
 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.impl.schema.Builders;
-import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
+import org.opendaylight.yangtools.yang.data.spi.node.ImmutableNodes;
 import org.opendaylight.yangtools.yang.model.api.EffectiveModelContext;
 import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
 
 @ExtendWith(MockitoExtension.class)
 class RestconfOperationsPostTest extends AbstractRestconfTest {
     private static final QName RPC = QName.create("invoke:rpc:module", "2013-12-03", "rpc-test");
-    private static final ContainerNode INPUT = Builders.containerBuilder()
+    private static final ContainerNode INPUT = ImmutableNodes.newContainerBuilder()
         .withNodeIdentifier(new NodeIdentifier(QName.create(RPC, "input")))
-        .withChild(Builders.containerBuilder()
+        .withChild(ImmutableNodes.newContainerBuilder()
             .withNodeIdentifier(new NodeIdentifier(QName.create(RPC, "cont")))
             .withChild(ImmutableNodes.leafNode(QName.create(RPC, "lf"), "test"))
             .build())
         .build();
-    private static final ContainerNode OUTPUT = Builders.containerBuilder()
+    private static final ContainerNode OUTPUT = ImmutableNodes.newContainerBuilder()
         .withNodeIdentifier(new NodeIdentifier(QName.create(RPC, "output")))
-        .withChild(ImmutableNodes.leafNode(QName.create(RPC, "content"), "operation result"))
+        .withChild(ImmutableNodes.newContainerBuilder()
+            .withNodeIdentifier(new NodeIdentifier(QName.create(RPC, "cont-out")))
+            .withChild(ImmutableNodes.leafNode(QName.create(RPC, "lf-out"), "operation result"))
+            .build())
         .build();
     private static final EffectiveModelContext MODEL_CONTEXT =
         YangParserTestUtils.parseYangResourceDirectory("/invoke-rpc");
@@ -67,14 +73,19 @@ class RestconfOperationsPostTest extends AbstractRestconfTest {
         return MODEL_CONTEXT;
     }
 
+    @BeforeEach
+    void setupUriInfo() {
+        doReturn(new MultivaluedHashMap<>()).when(uriInfo).getQueryParameters();
+    }
+
     @Test
     void testInvokeRpcWithNonEmptyOutput() {
         final var result = mock(ContainerNode.class);
         doReturn(false).when(result).isEmpty();
 
         prepNNC(result);
-        assertSame(result, assertNormalizedNode(200, ar -> restconf.operationsXmlPOST("invoke-rpc-module:rpc-test",
-            stringInputStream("""
+        assertSame(result, assertOperationOutput(200, ar -> restconf.operationsXmlPOST(
+            apiPath("invoke-rpc-module:rpc-test"), stringInputStream("""
                 <input xmlns="invoke:rpc:module"/>"""), uriInfo, ar)));
     }
 
@@ -84,7 +95,7 @@ class RestconfOperationsPostTest extends AbstractRestconfTest {
         doReturn(true).when(result).isEmpty();
 
         prepNNC(result);
-        assertNull(assertEntity(204, ar -> restconf.operationsJsonPOST("invoke-rpc-module:rpc-test",
+        assertNull(assertEntity(204, ar -> restconf.operationsJsonPOST(apiPath("invoke-rpc-module:rpc-test"),
             stringInputStream("""
                 {
                   "invoke-rpc-module:input" : {
@@ -97,8 +108,8 @@ class RestconfOperationsPostTest extends AbstractRestconfTest {
         doReturn(Futures.immediateFuture(new DefaultDOMRpcResult(OUTPUT, List.of()))).when(rpcService)
             .invokeRpc(RPC, INPUT);
 
-        assertEquals(OUTPUT, assertNormalizedNode(200, ar -> restconf.operationsXmlPOST("invoke-rpc-module:rpc-test",
-            stringInputStream("""
+        assertEquals(OUTPUT, assertOperationOutput(200, ar -> restconf.operationsXmlPOST(
+            apiPath("invoke-rpc-module:rpc-test"), stringInputStream("""
                 <input xmlns="invoke:rpc:module">
                   <cont>
                     <lf>test</lf>
@@ -112,7 +123,7 @@ class RestconfOperationsPostTest extends AbstractRestconfTest {
                 "No implementation of RPC " + RPC + " available.");
         doReturn(Futures.immediateFailedFuture(exception)).when(rpcService).invokeRpc(RPC, INPUT);
 
-        final var error = assertError(ar -> restconf.operationsJsonPOST("invoke-rpc-module:rpc-test",
+        final var error = assertError(ar -> restconf.operationsJsonPOST(apiPath("invoke-rpc-module:rpc-test"),
             stringInputStream("""
                 {
                   "invoke-rpc-module:input" : {
@@ -129,42 +140,46 @@ class RestconfOperationsPostTest extends AbstractRestconfTest {
 
     @Test
     void invokeRpcViaMountPointTest() throws Exception {
-        doReturn(Optional.of(FixedDOMSchemaService.of(MODEL_CONTEXT))).when(mountPoint)
+        doReturn(Optional.of(new FixedDOMSchemaService(MODEL_CONTEXT))).when(mountPoint)
             .getService(DOMSchemaService.class);
         doReturn(Optional.of(rpcService)).when(mountPoint).getService(DOMRpcService.class);
+        doReturn(Optional.empty()).when(mountPoint).getService(DOMActionService.class);
+        doReturn(Optional.empty()).when(mountPoint).getService(DOMMountPointService.class);
         doReturn(Optional.empty()).when(mountPoint).getService(NetconfDataTreeService.class);
         doReturn(Optional.of(dataBroker)).when(mountPoint).getService(DOMDataBroker.class);
         doReturn(Optional.of(mountPoint)).when(mountPointService).getMountPoint(YangInstanceIdentifier.of(
-            QName.create("urn:ietf:params:xml:ns:yang:ietf-yang-library", "2016-06-21", "modules-state")));
+            QName.create("urn:ietf:params:xml:ns:yang:ietf-yang-library", "2019-01-04", "modules-state")));
         doReturn(Futures.immediateFuture(new DefaultDOMRpcResult(OUTPUT, List.of()))).when(rpcService)
             .invokeRpc(RPC, INPUT);
 
-        assertEquals(OUTPUT, assertNormalizedNode(200,
+        assertEquals(OUTPUT, assertOperationOutput(200,
             ar -> restconf.operationsJsonPOST(
-                "ietf-yang-library:modules-state/yang-ext:mount/invoke-rpc-module:rpc-test",
-            stringInputStream("""
-                {
-                  "invoke-rpc-module:input" : {
-                    "cont" : {
-                      "lf" : "test"
-                    }
-                  }
-                }"""), uriInfo, ar)));
+                apiPath("ietf-yang-library:modules-state/yang-ext:mount/invoke-rpc-module:rpc-test"),
+                stringInputStream("""
+                    {
+                      "invoke-rpc-module:input" : {
+                        "cont" : {
+                          "lf" : "test"
+                        }
+                      }
+                    }"""), uriInfo, ar)));
     }
 
     @Test
     void invokeRpcMissingMountPointServiceTest() {
-        doReturn(Optional.of(FixedDOMSchemaService.of(MODEL_CONTEXT))).when(mountPoint)
+        doReturn(Optional.of(new FixedDOMSchemaService(MODEL_CONTEXT))).when(mountPoint)
             .getService(DOMSchemaService.class);
         doReturn(Optional.empty()).when(mountPoint).getService(DOMRpcService.class);
+        doReturn(Optional.empty()).when(mountPoint).getService(DOMActionService.class);
+        doReturn(Optional.empty()).when(mountPoint).getService(DOMMountPointService.class);
         doReturn(Optional.empty()).when(mountPoint).getService(NetconfDataTreeService.class);
         doReturn(Optional.of(dataBroker)).when(mountPoint).getService(DOMDataBroker.class);
         doReturn(Optional.of(mountPoint)).when(mountPointService).getMountPoint(YangInstanceIdentifier.of(
-            QName.create("urn:ietf:params:xml:ns:yang:ietf-yang-library", "2016-06-21", "modules-state")));
+            QName.create("urn:ietf:params:xml:ns:yang:ietf-yang-library", "2019-01-04", "modules-state")));
 
         final var error = assertError(
             ar -> restconf.operationsJsonPOST(
-                "ietf-yang-library:modules-state/yang-ext:mount/invoke-rpc-module:rpc-test",
+                apiPath("ietf-yang-library:modules-state/yang-ext:mount/invoke-rpc-module:rpc-test"),
                 stringInputStream("""
                     {
                       "invoke-rpc-module:input" : {
@@ -180,7 +195,8 @@ class RestconfOperationsPostTest extends AbstractRestconfTest {
         doReturn(Futures.immediateFuture(new DefaultDOMRpcResult(OUTPUT, List.of())))
             .when(rpcService).invokeRpc(RPC, INPUT);
 
-        assertEquals(OUTPUT, assertNormalizedNode(200, ar -> restconf.operationsJsonPOST("invoke-rpc-module:rpc-test",
+        final var body = assertOperationOutputBody(200, ar -> restconf.operationsJsonPOST(
+            apiPath("invoke-rpc-module:rpc-test"),
             stringInputStream("""
                 {
                   "invoke-rpc-module:input" : {
@@ -188,7 +204,12 @@ class RestconfOperationsPostTest extends AbstractRestconfTest {
                       "lf" : "test"
                     }
                   }
-                }"""), uriInfo, ar)));
+                }"""), uriInfo, ar));
+        assertEquals(OUTPUT, body.data());
+        assertJson("""
+            {"invoke-rpc-module:output":{"cont-out":{"lf-out":"operation result"}}}""", body);
+        assertXml("""
+            <output xmlns="invoke:rpc:module"><cont-out><lf-out>operation result</lf-out></cont-out></output>""", body);
     }
 
     private void prepNNC(final ContainerNode result) {