2 * Copyright (c) 2016, 2017 Cisco Systems, Inc. and others. All rights reserved.
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
8 package org.opendaylight.mdsal.dom.broker;
10 import static org.hamcrest.CoreMatchers.instanceOf;
11 import static org.hamcrest.MatcherAssert.assertThat;
12 import static org.junit.Assert.assertEquals;
13 import static org.junit.Assert.assertNotEquals;
14 import static org.junit.Assert.assertNotNull;
15 import static org.junit.Assert.assertThrows;
16 import static org.mockito.ArgumentMatchers.any;
17 import static org.mockito.Mockito.doCallRealMethod;
18 import static org.mockito.Mockito.doNothing;
19 import static org.mockito.Mockito.doReturn;
20 import static org.mockito.Mockito.mock;
21 import static org.mockito.Mockito.timeout;
22 import static org.mockito.Mockito.verify;
23 import static org.opendaylight.mdsal.dom.broker.TestUtils.getTestRpcImplementation;
25 import com.google.common.util.concurrent.Futures;
26 import com.google.common.util.concurrent.ListenableFuture;
27 import java.util.List;
29 import java.util.concurrent.ExecutionException;
30 import java.util.concurrent.RejectedExecutionException;
31 import org.junit.Test;
32 import org.junit.runner.RunWith;
33 import org.mockito.junit.MockitoJUnitRunner;
34 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
35 import org.opendaylight.mdsal.dom.api.DOMActionAvailabilityExtension;
36 import org.opendaylight.mdsal.dom.api.DOMActionAvailabilityExtension.AvailabilityListener;
37 import org.opendaylight.mdsal.dom.api.DOMActionImplementation;
38 import org.opendaylight.mdsal.dom.api.DOMActionInstance;
39 import org.opendaylight.mdsal.dom.api.DOMActionNotAvailableException;
40 import org.opendaylight.mdsal.dom.api.DOMActionProviderService;
41 import org.opendaylight.mdsal.dom.api.DOMActionResult;
42 import org.opendaylight.mdsal.dom.api.DOMActionService;
43 import org.opendaylight.mdsal.dom.api.DOMDataTreeIdentifier;
44 import org.opendaylight.mdsal.dom.api.DOMRpcAvailabilityListener;
45 import org.opendaylight.mdsal.dom.api.DOMRpcIdentifier;
46 import org.opendaylight.mdsal.dom.api.DOMRpcImplementationNotAvailableException;
47 import org.opendaylight.mdsal.dom.api.DOMRpcProviderService;
48 import org.opendaylight.mdsal.dom.api.DOMSchemaService;
49 import org.opendaylight.mdsal.dom.spi.SimpleDOMActionResult;
50 import org.opendaylight.yangtools.concepts.ListenerRegistration;
51 import org.opendaylight.yangtools.concepts.ObjectRegistration;
52 import org.opendaylight.yangtools.concepts.Registration;
53 import org.opendaylight.yangtools.yang.common.QName;
54 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
55 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
56 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifierWithPredicates;
57 import org.opendaylight.yangtools.yang.data.impl.schema.Builders;
58 import org.opendaylight.yangtools.yang.model.api.EffectiveModelContextListener;
60 @RunWith(MockitoJUnitRunner.StrictStubs.class)
61 public class DOMRpcRouterTest {
62 private static final YangInstanceIdentifier BAZ_PATH_BAD = YangInstanceIdentifier.create(
63 new NodeIdentifier(Actions.FOO), NodeIdentifierWithPredicates.of(Actions.FOO, Actions.BAR, "bad"));
64 private static final YangInstanceIdentifier BAZ_PATH_GOOD = YangInstanceIdentifier.create(
65 new NodeIdentifier(Actions.FOO), NodeIdentifierWithPredicates.of(Actions.FOO, Actions.BAR, "good"));
67 private static final DOMActionImplementation IMPL =
68 (type, path, input) -> Futures.immediateFuture(new SimpleDOMActionResult(
69 Builders.containerBuilder().withNodeIdentifier(new NodeIdentifier(Actions.OUTPUT)).build()));
72 public void registerRpcImplementation() {
73 try (DOMRpcRouter rpcRouter = rpcsRouter()) {
74 assertOperationKeys(rpcRouter);
76 final Registration fooReg = rpcRouter.getRpcProviderService().registerRpcImplementation(
77 getTestRpcImplementation(), DOMRpcIdentifier.create(Rpcs.FOO, null));
78 assertOperationKeys(rpcRouter, Rpcs.FOO);
80 final Registration barReg = rpcRouter.getRpcProviderService().registerRpcImplementation(
81 getTestRpcImplementation(), DOMRpcIdentifier.create(Rpcs.BAR, null));
82 assertOperationKeys(rpcRouter, Rpcs.FOO, Rpcs.BAR);
85 assertOperationKeys(rpcRouter, Rpcs.BAR);
87 assertOperationKeys(rpcRouter);
91 private static void assertOperationKeys(final DOMRpcRouter router, final QName... keys) {
92 assertEquals(Set.of(keys), router.routingTable().getOperations().keySet());
96 public void testFailedInvokeRpc() {
97 try (DOMRpcRouter rpcRouter = rpcsRouter()) {
98 final ListenableFuture<?> future = rpcRouter.getRpcService().invokeRpc(Rpcs.FOO, null);
99 final Throwable cause = assertThrows(ExecutionException.class, () -> Futures.getDone(future)).getCause();
100 assertThat(cause, instanceOf(DOMRpcImplementationNotAvailableException.class));
101 assertEquals("No implementation of RPC (rpcs)foo available", cause.getMessage());
106 public void testRpcListener() {
107 try (DOMRpcRouter rpcRouter = new DOMRpcRouter()) {
108 assertEquals(List.of(), rpcRouter.listeners());
110 final DOMRpcAvailabilityListener listener = mock(DOMRpcAvailabilityListener.class);
111 doCallRealMethod().when(listener).acceptsImplementation(any());
112 doNothing().when(listener).onRpcAvailable(any());
113 doNothing().when(listener).onRpcUnavailable(any());
115 final Registration reg = rpcRouter.getRpcService().registerRpcListener(listener);
117 assertEquals(List.of(reg), rpcRouter.listeners());
119 final Registration implReg = rpcRouter.getRpcProviderService().registerRpcImplementation(
120 getTestRpcImplementation(), DOMRpcIdentifier.create(Rpcs.FOO, null));
121 verify(listener, timeout(1000)).onRpcAvailable(any());
124 verify(listener, timeout(1000)).onRpcUnavailable(any());
127 assertEquals(List.of(), rpcRouter.listeners());
132 public void testActionListener() {
133 try (DOMRpcRouter rpcRouter = new DOMRpcRouter()) {
134 assertEquals(List.of(), rpcRouter.actionListeners());
136 final AvailabilityListener listener = mock(AvailabilityListener.class);
137 final Registration reg = rpcRouter.getActionService().getExtensions()
138 .getInstance(DOMActionAvailabilityExtension.class).registerAvailabilityListener(listener);
140 assertEquals(List.of(reg), rpcRouter.actionListeners());
142 // FIXME: register implementation and verify notification
145 assertEquals(List.of(), rpcRouter.actionListeners());
150 public void onGlobalContextUpdated() {
151 try (DOMRpcRouter rpcRouter = new DOMRpcRouter()) {
152 final DOMRpcRoutingTable routingTableOriginal = rpcRouter.routingTable();
153 rpcRouter.onModelContextUpdated(TestModel.createTestContext());
154 assertNotEquals(routingTableOriginal, rpcRouter.routingTable());
159 public void testClose() {
160 final ListenerRegistration<EffectiveModelContextListener> reg = mock(ListenerRegistration.class);
161 doNothing().when(reg).close();
162 final DOMSchemaService schema = mock(DOMSchemaService.class);
163 doReturn(reg).when(schema).registerSchemaContextListener(any());
165 final DOMRpcRouter rpcRouter = new DOMRpcRouter(schema);
168 final DOMRpcProviderService svc = rpcRouter.getRpcProviderService();
169 assertThrows(RejectedExecutionException.class, () -> svc.registerRpcImplementation(getTestRpcImplementation(),
170 DOMRpcIdentifier.create(Rpcs.FOO, null)));
174 public void testActionInstanceRouting() throws ExecutionException {
175 try (DOMRpcRouter rpcRouter = actionsRouter()) {
176 final DOMActionProviderService actionProvider = rpcRouter.getActionProviderService();
177 assertNotNull(actionProvider);
178 final DOMActionService actionConsumer = rpcRouter.getActionService();
179 assertNotNull(actionConsumer);
181 try (ObjectRegistration<?> reg = actionProvider.registerActionImplementation(IMPL,
182 DOMActionInstance.of(Actions.BAZ_TYPE, LogicalDatastoreType.OPERATIONAL, BAZ_PATH_GOOD))) {
184 assertAvailable(actionConsumer, BAZ_PATH_GOOD);
185 assertUnavailable(actionConsumer, BAZ_PATH_BAD);
188 assertUnavailable(actionConsumer, BAZ_PATH_BAD);
189 assertUnavailable(actionConsumer, BAZ_PATH_GOOD);
194 public void testActionDatastoreRouting() throws ExecutionException {
195 try (DOMRpcRouter rpcRouter = actionsRouter()) {
196 final DOMActionProviderService actionProvider = rpcRouter.getActionProviderService();
197 assertNotNull(actionProvider);
198 final DOMActionService actionConsumer = rpcRouter.getActionService();
199 assertNotNull(actionConsumer);
201 try (ObjectRegistration<?> reg = actionProvider.registerActionImplementation(IMPL,
202 DOMActionInstance.of(Actions.BAZ_TYPE, LogicalDatastoreType.OPERATIONAL,
203 YangInstanceIdentifier.empty()))) {
205 assertAvailable(actionConsumer, BAZ_PATH_GOOD);
206 assertAvailable(actionConsumer, BAZ_PATH_BAD);
209 assertUnavailable(actionConsumer, BAZ_PATH_BAD);
210 assertUnavailable(actionConsumer, BAZ_PATH_GOOD);
214 private static DOMRpcRouter actionsRouter() {
215 final DOMRpcRouter router = new DOMRpcRouter();
216 router.onModelContextUpdated(Actions.CONTEXT);
220 private static DOMRpcRouter rpcsRouter() {
221 final DOMRpcRouter router = new DOMRpcRouter();
222 router.onModelContextUpdated(Rpcs.CONTEXT);
226 private static void assertAvailable(final DOMActionService actionService, final YangInstanceIdentifier path) {
227 final DOMActionResult result;
229 result = Futures.getDone(invokeBaz(actionService, path));
230 } catch (ExecutionException e) {
231 throw new AssertionError("Unexpected invocation failure", e);
233 assertEquals(List.of(), result.getErrors());
236 private static void assertUnavailable(final DOMActionService actionService, final YangInstanceIdentifier path) {
237 final ListenableFuture<? extends DOMActionResult> future = invokeBaz(actionService, path);
238 final ExecutionException ex = assertThrows(ExecutionException.class, () -> Futures.getDone(future));
239 assertThat(ex.getCause(), instanceOf(DOMActionNotAvailableException.class));
242 private static ListenableFuture<? extends DOMActionResult> invokeBaz(final DOMActionService actionService,
243 final YangInstanceIdentifier path) {
244 return actionService.invokeAction(Actions.BAZ_TYPE,
245 new DOMDataTreeIdentifier(LogicalDatastoreType.OPERATIONAL, path),
246 Builders.containerBuilder().withNodeIdentifier(new NodeIdentifier(Actions.INPUT)).build());