Remove RestconfInvokeOperationsUtilTest

We are about to remove RestconfInvokeOperationsUtil, integrate its test
into RestconfInvokeOperationsServiceImplTest.

JIRA: NETCONF-773
Change-Id: Ie04f07f0ebf3351a6ac0afc2cb3c1d697097f69f
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>

diff --git a/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfInvokeOperationsServiceImplTest.java b/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfInvokeOperationsServiceImplTest.java
index a891423394bed2b0e2d15a2a38637fbdc3dee427..99cf11c4a1794f10f1b24aece7cf69c96bfa4899 100644 (file)
--- a/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfInvokeOperationsServiceImplTest.java
+++ b/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfInvokeOperationsServiceImplTest.java
@@ -9,13 +9,19 @@ package org.opendaylight.restconf.nb.rfc8040.rests.services.impl;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
 import static org.mockito.Mockito.doCallRealMethod;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
+import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFailedFluentFuture;
 import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFluentFuture;
 
+import java.util.Collection;
 import java.util.List;
+import java.util.Optional;
 import javax.ws.rs.WebApplicationException;
 import javax.ws.rs.core.Response;
 import javax.ws.rs.core.UriInfo;
@@ -27,30 +33,50 @@ import org.mockito.junit.MockitoJUnitRunner;
 import org.opendaylight.mdsal.common.api.CommitInfo;
 import org.opendaylight.mdsal.dom.api.DOMDataBroker;
 import org.opendaylight.mdsal.dom.api.DOMDataTreeWriteTransaction;
+import org.opendaylight.mdsal.dom.api.DOMMountPoint;
+import org.opendaylight.mdsal.dom.api.DOMRpcException;
+import org.opendaylight.mdsal.dom.api.DOMRpcImplementationNotAvailableException;
 import org.opendaylight.mdsal.dom.api.DOMRpcResult;
 import org.opendaylight.mdsal.dom.api.DOMRpcService;
 import org.opendaylight.mdsal.dom.api.DOMSchemaService;
+import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
 import org.opendaylight.restconf.common.context.InstanceIdentifierContext;
 import org.opendaylight.restconf.common.context.NormalizedNodeContext;
+import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
 import org.opendaylight.restconf.nb.rfc8040.TestRestconfUtils;
 import org.opendaylight.restconf.nb.rfc8040.handlers.SchemaContextHandler;
+import org.opendaylight.restconf.nb.rfc8040.rests.utils.RestconfInvokeOperationsUtil;
 import org.opendaylight.yangtools.yang.common.QName;
+import org.opendaylight.yangtools.yang.common.RpcError;
+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.LeafNode;
 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.EffectiveModelContext;
 import org.opendaylight.yangtools.yang.model.api.RpcDefinition;
 import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
 
 @RunWith(MockitoJUnitRunner.StrictStubs.class)
 public class RestconfInvokeOperationsServiceImplTest {
-
     private static final String PATH_FOR_NEW_SCHEMA_CONTEXT = "/invoke-rpc";
 
-    private RestconfInvokeOperationsServiceImpl invokeOperationsService;
+    private static final QName RPC = QName.create("ns", "2015-02-28", "test-rpc");
+    private static final ContainerNode INPUT = Builders.containerBuilder()
+        .withNodeIdentifier(new NodeIdentifier(QName.create(RPC, "input")))
+        .withChild(ImmutableNodes.leafNode(QName.create(RPC, "content"), "test"))
+        .build();
+    private static final ContainerNode OUTPUT = Builders.containerBuilder()
+        .withNodeIdentifier(new NodeIdentifier(QName.create(RPC, "output")))
+        .withChild(ImmutableNodes.leafNode(QName.create(RPC, "content"), "operation result"))
+        .build();
 
     @Mock
     private DOMRpcService rpcService;
+    @Mock
+    private DOMMountPoint mountPoint;
+    private RestconfInvokeOperationsServiceImpl invokeOperationsService;
 
     @Before
     public void setup() throws Exception {
@@ -102,6 +128,60 @@ public class RestconfInvokeOperationsServiceImplTest {
         assertEquals(Response.Status.NO_CONTENT.getStatusCode(), exceptionToBeThrown.getResponse().getStatus());
     }
 
+    @Test
+    public void invokeRpcTest() {
+        final DOMRpcResult mockResult = new DefaultDOMRpcResult(OUTPUT, List.of());
+        doReturn(immediateFluentFuture(mockResult)).when(rpcService).invokeRpc(RPC, INPUT);
+        final DOMRpcResult rpcResult = RestconfInvokeOperationsUtil.invokeRpc(INPUT, RPC, rpcService);
+        assertTrue(rpcResult.getErrors().isEmpty());
+        assertEquals(OUTPUT, rpcResult.getResult());
+    }
+
+    @Test
+    public void invokeRpcErrorsAndCheckTestTest() {
+        final QName errorRpc = QName.create(RPC, "error-rpc");
+        final DOMRpcException exception = new DOMRpcImplementationNotAvailableException(
+                "No implementation of RPC " + errorRpc + " available.");
+        doReturn(immediateFailedFluentFuture(exception)).when(rpcService).invokeRpc(errorRpc, INPUT);
+        final DOMRpcResult rpcResult = RestconfInvokeOperationsUtil.invokeRpc(INPUT, errorRpc, rpcService);
+        assertNull(rpcResult.getResult());
+        final Collection<? extends RpcError> errorList = rpcResult.getErrors();
+        assertEquals(1, errorList.size());
+        final RpcError actual = errorList.iterator().next();
+        assertEquals("No implementation of RPC " + errorRpc + " available.", actual.getMessage());
+        assertEquals("operation-failed", actual.getTag());
+        assertEquals(RpcError.ErrorType.RPC, actual.getErrorType());
+
+        assertThrows(RestconfDocumentedException.class, () -> RestconfInvokeOperationsUtil.checkResponse(rpcResult));
+    }
+
+    @Test
+    public void invokeRpcViaMountPointTest() {
+        doReturn(Optional.ofNullable(rpcService)).when(mountPoint).getService(DOMRpcService.class);
+        final DOMRpcResult mockResult = new DefaultDOMRpcResult(OUTPUT, List.of());
+        doReturn(immediateFluentFuture(mockResult)).when(rpcService).invokeRpc(RPC, INPUT);
+        final DOMRpcResult rpcResult = RestconfInvokeOperationsUtil.invokeRpc(INPUT, RPC, mountPoint);
+        assertTrue(rpcResult.getErrors().isEmpty());
+        assertEquals(OUTPUT, rpcResult.getResult());
+    }
+
+    @Test
+    public void invokeRpcMissingMountPointServiceTest() {
+        doReturn(Optional.empty()).when(mountPoint).getService(DOMRpcService.class);
+        assertThrows(RestconfDocumentedException.class,
+            () -> RestconfInvokeOperationsUtil.invokeRpc(INPUT, RPC, mountPoint));
+    }
+
+    @Test
+    public void checkResponseTest() {
+        final DOMRpcResult mockResult = new DefaultDOMRpcResult(OUTPUT, List.of());
+        doReturn(immediateFluentFuture(mockResult)).when(rpcService).invokeRpc(RPC, INPUT);
+        final DOMRpcResult rpcResult = RestconfInvokeOperationsUtil.invokeRpc(INPUT, RPC, rpcService);
+        assertTrue(rpcResult.getErrors().isEmpty());
+        assertEquals(OUTPUT, rpcResult.getResult());
+        assertNotNull(RestconfInvokeOperationsUtil.checkResponse(rpcResult));
+    }
+
     private NormalizedNodeContext prepNNC(final NormalizedNode result) {
         final InstanceIdentifierContext<?> context = mock(InstanceIdentifierContext.class);
         final RpcDefinition schemaNode = mock(RpcDefinition.class);
@@ -110,7 +190,7 @@ public class RestconfInvokeOperationsServiceImplTest {
         doReturn(schemaNode).when(context).getSchemaNode();
         final NormalizedNode data = mock(NormalizedNode.class);
         final DOMRpcResult domRpcResult = mock(DOMRpcResult.class);
-        doReturn(immediateFluentFuture(domRpcResult)).when(this.rpcService).invokeRpc(qname, data);
+        doReturn(immediateFluentFuture(domRpcResult)).when(rpcService).invokeRpc(qname, data);
         doReturn(result).when(domRpcResult).getResult();
         return new NormalizedNodeContext(context, data);
     }

diff --git a/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/utils/RestconfInvokeOperationsUtilTest.java b/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/utils/RestconfInvokeOperationsUtilTest.java
deleted file mode 100644 (file)
index 4195037..0000000
--- a/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/utils/RestconfInvokeOperationsUtilTest.java
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
- * Copyright (c) 2016 Cisco Systems, Inc. and others.  All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.restconf.nb.rfc8040.rests.utils;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertThrows;
-import static org.junit.Assert.assertTrue;
-import static org.mockito.Mockito.doReturn;
-import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFailedFluentFuture;
-import static org.opendaylight.yangtools.util.concurrent.FluentFutures.immediateFluentFuture;
-
-import java.util.Collection;
-import java.util.List;
-import java.util.Optional;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-import org.opendaylight.mdsal.dom.api.DOMMountPoint;
-import org.opendaylight.mdsal.dom.api.DOMRpcException;
-import org.opendaylight.mdsal.dom.api.DOMRpcImplementationNotAvailableException;
-import org.opendaylight.mdsal.dom.api.DOMRpcResult;
-import org.opendaylight.mdsal.dom.api.DOMRpcService;
-import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
-import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
-import org.opendaylight.yangtools.yang.common.RpcError;
-
-@RunWith(MockitoJUnitRunner.StrictStubs.class)
-public class RestconfInvokeOperationsUtilTest {
-
-    private static final TestData DATA = new TestData();
-
-    @Mock
-    private DOMRpcService rpcService;
-    @Mock
-    private DOMMountPoint mountPoint;
-
-    @Test
-    public void invokeRpcTest() {
-        final DOMRpcResult mockResult = new DefaultDOMRpcResult(DATA.output, List.of());
-        doReturn(immediateFluentFuture(mockResult)).when(rpcService).invokeRpc(DATA.rpc, DATA.input);
-        final DOMRpcResult rpcResult = RestconfInvokeOperationsUtil.invokeRpc(DATA.input, DATA.rpc, rpcService);
-        assertTrue(rpcResult.getErrors().isEmpty());
-        assertEquals(DATA.output, rpcResult.getResult());
-    }
-
-    @Test
-    public void invokeRpcErrorsAndCheckTestTest() {
-        final DOMRpcException exception = new DOMRpcImplementationNotAvailableException(
-                "No implementation of RPC " + DATA.errorRpc.toString() + " available.");
-        doReturn(immediateFailedFluentFuture(exception)).when(rpcService).invokeRpc(DATA.errorRpc, DATA.input);
-        final DOMRpcResult rpcResult = RestconfInvokeOperationsUtil.invokeRpc(DATA.input, DATA.errorRpc, rpcService);
-        assertNull(rpcResult.getResult());
-        final Collection<? extends RpcError> errorList = rpcResult.getErrors();
-        assertEquals(1, errorList.size());
-        final RpcError actual = errorList.iterator().next();
-        assertEquals("No implementation of RPC " + DATA.errorRpc.toString() + " available.", actual.getMessage());
-        assertEquals("operation-failed", actual.getTag());
-        assertEquals(RpcError.ErrorType.RPC, actual.getErrorType());
-
-        assertThrows(RestconfDocumentedException.class, () -> RestconfInvokeOperationsUtil.checkResponse(rpcResult));
-    }
-
-    @Test
-    public void invokeRpcViaMountPointTest() {
-        doReturn(Optional.ofNullable(rpcService)).when(mountPoint).getService(DOMRpcService.class);
-        final DOMRpcResult mockResult = new DefaultDOMRpcResult(DATA.output, List.of());
-        doReturn(immediateFluentFuture(mockResult)).when(rpcService).invokeRpc(DATA.rpc, DATA.input);
-        final DOMRpcResult rpcResult = RestconfInvokeOperationsUtil.invokeRpc(DATA.input, DATA.rpc, mountPoint);
-        assertTrue(rpcResult.getErrors().isEmpty());
-        assertEquals(DATA.output, rpcResult.getResult());
-    }
-
-    @Test
-    public void invokeRpcMissingMountPointServiceTest() {
-        doReturn(Optional.empty()).when(mountPoint).getService(DOMRpcService.class);
-        assertThrows(RestconfDocumentedException.class,
-            () -> RestconfInvokeOperationsUtil.invokeRpc(DATA.input, DATA.rpc, mountPoint));
-    }
-
-    @Test
-    public void checkResponseTest() {
-        final DOMRpcResult mockResult = new DefaultDOMRpcResult(DATA.output, List.of());
-        doReturn(immediateFluentFuture(mockResult)).when(rpcService).invokeRpc(DATA.rpc, DATA.input);
-        final DOMRpcResult rpcResult = RestconfInvokeOperationsUtil.invokeRpc(DATA.input, DATA.rpc, rpcService);
-        assertTrue(rpcResult.getErrors().isEmpty());
-        assertEquals(DATA.output, rpcResult.getResult());
-        assertNotNull(RestconfInvokeOperationsUtil.checkResponse(rpcResult));
-    }
-}

diff --git a/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/utils/TestData.java b/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/utils/TestData.java
index fd7431797b0462a3ef0600b8ca4310ba3469d128..31bc06b9ac5d5ddc47f4adf78de308812779f0bd 100644 (file)
--- a/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/utils/TestData.java
+++ b/restconf/restconf-nb-rfc8040/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/utils/TestData.java
@@ -22,7 +22,7 @@ import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode;
 import org.opendaylight.yangtools.yang.data.api.schema.UserMapNode;
 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
 
-class TestData {
+final class TestData {
 
     final YangInstanceIdentifier path;
     final YangInstanceIdentifier path2;
@@ -38,10 +38,6 @@ class TestData {
     final LeafNode<?> contentLeaf;
     final LeafNode<?> contentLeaf2;
     final MapEntryNode checkData;
-    final QName rpc;
-    final QName errorRpc;
-    final ContainerNode input;
-    final ContainerNode output;
     final LeafSetNode<String> leafSetNode1;
     final LeafSetNode<String> leafSetNode2;
     final LeafSetNode<String> orderedLeafSetNode1;
@@ -158,24 +154,5 @@ class TestData {
                 new YangInstanceIdentifier.NodeIdentifier(listQname)).withChild(content2).build();
         unkeyedListNode2 = Builders.unkeyedListBuilder().withNodeIdentifier(
                 new YangInstanceIdentifier.NodeIdentifier(listQname)).withChild(unkeyedListEntryNode2).build();
-
-        rpc = QName.create("ns", "2015-02-28", "test-rpc");
-        errorRpc = QName.create(rpc, "error-rpc");
-        final LeafNode<?> contentLeafNode = Builders.leafBuilder()
-                .withNodeIdentifier(new NodeIdentifier(QName.create(rpc, "content")))
-                .withValue("test")
-                .build();
-        input = Builders.containerBuilder()
-                .withNodeIdentifier(new NodeIdentifier(QName.create(rpc, "input")))
-                .withChild(contentLeafNode)
-                .build();
-        final LeafNode<?> resultLeafNode = Builders.leafBuilder()
-                .withNodeIdentifier(new NodeIdentifier(QName.create(rpc, "content")))
-                .withValue("operation result")
-                .build();
-        output = Builders.containerBuilder()
-                .withNodeIdentifier(new NodeIdentifier(QName.create(rpc, "output")))
-                .withChild(resultLeafNode)
-                .build();
     }
 }