restconf/restconf-nb/src/test/java/org/opendaylight/restconf/nb/rfc8040/rests/services/impl/RestconfInvokeOperationsServiceImplTest.java

   1 /*
   2  * Copyright (c) 2016 Cisco 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 package org.opendaylight.restconf.nb.rfc8040.rests.services.impl;
   9
  10 import static org.junit.jupiter.api.Assertions.assertEquals;
  11 import static org.junit.jupiter.api.Assertions.assertInstanceOf;
  12 import static org.junit.jupiter.api.Assertions.assertSame;
  13 import static org.junit.jupiter.api.Assertions.assertThrows;
  14 import static org.mockito.ArgumentMatchers.any;
  15 import static org.mockito.ArgumentMatchers.eq;
  16 import static org.mockito.Mockito.doReturn;
  17 import static org.mockito.Mockito.mock;
  18 import static org.mockito.Mockito.verify;
  19
  20 import com.google.common.util.concurrent.Futures;
  21 import java.io.ByteArrayInputStream;
  22 import java.nio.charset.StandardCharsets;
  23 import java.util.List;
  24 import java.util.Optional;
  25 import java.util.concurrent.ExecutionException;
  26 import javax.ws.rs.container.AsyncResponse;
  27 import javax.ws.rs.core.Response;
  28 import javax.ws.rs.core.UriInfo;
  29 import org.junit.Before;
  30 import org.junit.BeforeClass;
  31 import org.junit.Test;
  32 import org.junit.runner.RunWith;
  33 import org.mockito.ArgumentCaptor;
  34 import org.mockito.Mock;
  35 import org.mockito.junit.MockitoJUnitRunner;
  36 import org.opendaylight.mdsal.dom.api.DOMDataBroker;
  37 import org.opendaylight.mdsal.dom.api.DOMMountPoint;
  38 import org.opendaylight.mdsal.dom.api.DOMMountPointService;
  39 import org.opendaylight.mdsal.dom.api.DOMRpcImplementationNotAvailableException;
  40 import org.opendaylight.mdsal.dom.api.DOMRpcResult;
  41 import org.opendaylight.mdsal.dom.api.DOMRpcService;
  42 import org.opendaylight.mdsal.dom.spi.DefaultDOMRpcResult;
  43 import org.opendaylight.netconf.dom.api.NetconfDataTreeService;
  44 import org.opendaylight.restconf.common.errors.RestconfDocumentedException;
  45 import org.opendaylight.restconf.nb.rfc8040.databind.DatabindContext;
  46 import org.opendaylight.restconf.nb.rfc8040.legacy.NormalizedNodePayload;
  47 import org.opendaylight.restconf.nb.rfc8040.streams.ListenersBroker;
  48 import org.opendaylight.yangtools.yang.common.ErrorTag;
  49 import org.opendaylight.yangtools.yang.common.ErrorType;
  50 import org.opendaylight.yangtools.yang.common.QName;
  51 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
  52 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
  53 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
  54 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
  55 import org.opendaylight.yangtools.yang.test.util.YangParserTestUtils;
  56
  57 @RunWith(MockitoJUnitRunner.StrictStubs.class)
  58 public class RestconfInvokeOperationsServiceImplTest {
  59     private static final QName RPC = QName.create("ns", "2015-02-28", "test-rpc");
  60     private static final ContainerNode INPUT = Builders.containerBuilder()
  61         .withNodeIdentifier(new NodeIdentifier(QName.create(RPC, "input")))
  62         .withChild(ImmutableNodes.leafNode(QName.create(RPC, "content"), "test"))
  63         .build();
  64     private static final ContainerNode OUTPUT = Builders.containerBuilder()
  65         .withNodeIdentifier(new NodeIdentifier(QName.create(RPC, "output")))
  66         .withChild(ImmutableNodes.leafNode(QName.create(RPC, "content"), "operation result"))
  67         .build();
  68
  69     private static DatabindContext CONTEXT;
  70
  71     @Mock
  72     private DOMDataBroker dataBroker;
  73     @Mock
  74     private DOMRpcService rpcService;
  75     @Mock
  76     private DOMMountPoint mountPoint;
  77     @Mock
  78     private DOMMountPointService mountPointService;
  79
  80     private RestconfInvokeOperationsServiceImpl invokeOperationsService;
  81     private MdsalRestconfServer server;
  82
  83     @BeforeClass
  84     public static void beforeClass() {
  85         CONTEXT = DatabindContext.ofModel(YangParserTestUtils.parseYangResourceDirectory("/invoke-rpc"));
  86     }
  87
  88     @Before
  89     public void setup() {
  90         server = new MdsalRestconfServer(dataBroker, rpcService, mountPointService);
  91         invokeOperationsService = new RestconfInvokeOperationsServiceImpl(() -> CONTEXT, server, mountPointService,
  92             new ListenersBroker.WebSockets(dataBroker));
  93     }
  94
  95     @Test
  96     public void testInvokeRpcWithNonEmptyOutput() {
  97         final var result = mock(ContainerNode.class);
  98         doReturn(false).when(result).isEmpty();
  99
 100         prepNNC(result);
 101         final var ar = mock(AsyncResponse.class);
 102         final var captor = ArgumentCaptor.forClass(Response.class);
 103         invokeOperationsService.invokeRpcXML("invoke-rpc-module:rpc-test", new ByteArrayInputStream("""
 104             <input xmlns="invoke:rpc:module"/>
 105             """.getBytes(StandardCharsets.UTF_8)), mock(UriInfo.class), ar);
 106         verify(ar).resume(captor.capture());
 107
 108         final var response = captor.getValue();
 109         assertEquals(200, response.getStatus());
 110         final var entity = (NormalizedNodePayload) response.getEntity();
 111         assertSame(result, entity.data());
 112     }
 113
 114     @Test
 115     public void testInvokeRpcWithEmptyOutput() {
 116         final var result = mock(ContainerNode.class);
 117         doReturn(true).when(result).isEmpty();
 118
 119         prepNNC(result);
 120         final var ar = mock(AsyncResponse.class);
 121         final var response = ArgumentCaptor.forClass(Response.class);
 122         invokeOperationsService.invokeRpcJSON("invoke-rpc-module:rpc-test", new ByteArrayInputStream("""
 123             {
 124               "invoke-rpc-module:input" : {
 125               }
 126             }
 127             """.getBytes(StandardCharsets.UTF_8)), mock(UriInfo.class), ar);
 128         verify(ar).resume(response.capture());
 129
 130         assertEquals(204, response.getValue().getStatus());
 131     }
 132
 133     @Test
 134     public void invokeRpcTest() throws Exception {
 135         doReturn(Futures.immediateFuture(new DefaultDOMRpcResult(OUTPUT, List.of()))).when(rpcService)
 136             .invokeRpc(RPC, INPUT);
 137         assertEquals(Optional.of(OUTPUT), Futures.getDone(server.getRestconfStrategy(CONTEXT.modelContext(), null)
 138             .invokeRpc(RPC, INPUT)));
 139     }
 140
 141     @Test
 142     public void invokeRpcErrorsAndCheckTestTest() throws Exception {
 143         final var errorRpc = QName.create(RPC, "error-rpc");
 144         final var exception = new DOMRpcImplementationNotAvailableException(
 145                 "No implementation of RPC " + errorRpc + " available.");
 146         doReturn(Futures.immediateFailedFuture(exception)).when(rpcService).invokeRpc(errorRpc, INPUT);
 147         final var ex = assertInstanceOf(RestconfDocumentedException.class,
 148             assertThrows(ExecutionException.class, () -> Futures.getDone(
 149                 server.getRestconfStrategy(CONTEXT.modelContext(), null).invokeRpc(errorRpc, INPUT))).getCause());
 150         final var errorList = ex.getErrors();
 151         assertEquals(1, errorList.size());
 152         final var actual = errorList.iterator().next();
 153         assertEquals("No implementation of RPC " + errorRpc + " available.", actual.getErrorMessage());
 154         assertEquals(ErrorType.RPC, actual.getErrorType());
 155         assertEquals(ErrorTag.OPERATION_FAILED, actual.getErrorTag());
 156     }
 157
 158     @Test
 159     public void invokeRpcViaMountPointTest() throws Exception {
 160         doReturn(Optional.of(rpcService)).when(mountPoint).getService(DOMRpcService.class);
 161         doReturn(Optional.empty()).when(mountPoint).getService(NetconfDataTreeService.class);
 162         doReturn(Optional.of(dataBroker)).when(mountPoint).getService(DOMDataBroker.class);
 163         doReturn(Futures.immediateFuture(new DefaultDOMRpcResult(OUTPUT, List.of()))).when(rpcService)
 164             .invokeRpc(RPC, INPUT);
 165         assertEquals(Optional.of(OUTPUT), Futures.getDone(
 166             server.getRestconfStrategy(CONTEXT.modelContext(), mountPoint).invokeRpc(RPC, INPUT)));
 167     }
 168
 169     @Test
 170     public void invokeRpcMissingMountPointServiceTest() {
 171         doReturn(Optional.empty()).when(mountPoint).getService(DOMRpcService.class);
 172         doReturn(Optional.empty()).when(mountPoint).getService(NetconfDataTreeService.class);
 173         doReturn(Optional.of(dataBroker)).when(mountPoint).getService(DOMDataBroker.class);
 174         final var strategy = server.getRestconfStrategy(CONTEXT.modelContext(), mountPoint);
 175         final var ex = assertInstanceOf(RestconfDocumentedException.class,
 176             assertThrows(ExecutionException.class, () -> Futures.getDone(strategy.invokeRpc(RPC, INPUT))).getCause());
 177         final var errors = ex.getErrors();
 178         assertEquals(1, errors.size());
 179         final var error = errors.get(0);
 180         assertEquals(ErrorType.PROTOCOL, error.getErrorType());
 181         assertEquals(ErrorTag.OPERATION_NOT_SUPPORTED, error.getErrorTag());
 182         assertEquals("RPC invocation is not available", error.getErrorMessage());
 183     }
 184
 185     @Test
 186     public void checkResponseTest() throws Exception {
 187         doReturn(Futures.immediateFuture(new DefaultDOMRpcResult(OUTPUT, List.of())))
 188             .when(rpcService).invokeRpc(RPC, INPUT);
 189         assertEquals(Optional.of(OUTPUT), Futures.getDone(
 190             server.getRestconfStrategy(CONTEXT.modelContext(), null).invokeRpc(RPC, INPUT)));
 191     }
 192
 193     private void prepNNC(final ContainerNode result) {
 194         final var qname = QName.create("invoke:rpc:module", "2013-12-03", "rpc-test");
 195         final var domRpcResult = mock(DOMRpcResult.class);
 196         doReturn(Futures.immediateFuture(domRpcResult)).when(rpcService).invokeRpc(eq(qname), any(ContainerNode.class));
 197         doReturn(result).when(domRpcResult).value();
 198     }
 199 }