import org.opendaylight.yangtools.yang.common.RpcError;
import org.opendaylight.yangtools.yang.common.RpcResult;
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.codec.BindingIndependentMappingService;
import org.opendaylight.yangtools.yang.data.impl.codec.DeserializationException;
import org.slf4j.Logger;
import com.google.common.base.Function;
import com.google.common.base.Optional;
import com.google.common.collect.FluentIterable;
-import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.ImmutableSet.Builder;
import com.google.common.util.concurrent.Futures;
}
}
checkState(targetMethod != null, "Rpc method not found");
- Optional<Class<?>> outputClass = BindingReflections.resolveRpcOutputClass(targetMethod);
- Optional<Class<? extends DataContainer>> inputClass = BindingReflections
- .resolveRpcInputClass(targetMethod);
-
- RpcInvocationStrategy strategy = null;
- if (outputClass.isPresent()) {
- if (inputClass.isPresent()) {
- strategy = new DefaultInvocationStrategy(rpc, targetMethod, outputClass.get(), inputClass
- .get());
- } else {
- strategy = new NoInputInvocationStrategy(rpc, targetMethod, outputClass.get());
- }
- } else if (inputClass.isPresent()) {
- strategy = new NoOutputInvocationStrategy(rpc, targetMethod, inputClass.get());
- } else {
- strategy = new NoInputNoOutputInvocationStrategy(rpc, targetMethod);
- }
- return strategy;
+ return new RpcInvocationStrategy(rpc,targetMethod, mappingService, biRpcRegistry);
}
});
}
}
- private abstract class RpcInvocationStrategy {
-
- protected final Method targetMethod;
- protected final QName rpc;
-
- public RpcInvocationStrategy(final QName rpc, final Method targetMethod) {
- this.targetMethod = targetMethod;
- this.rpc = rpc;
- }
-
- public abstract Future<RpcResult<?>> forwardToDomBroker(DataObject input);
-
- public abstract RpcResult<CompositeNode> uncheckedInvoke(RpcService rpcService, CompositeNode domInput)
- throws Exception;
-
- public RpcResult<CompositeNode> invokeOn(final RpcService rpcService, final CompositeNode domInput)
- throws Exception {
- return uncheckedInvoke(rpcService, domInput);
- }
- }
-
- private class DefaultInvocationStrategy extends RpcInvocationStrategy {
-
- @SuppressWarnings("rawtypes")
- private final WeakReference<Class> inputClass;
-
- @SuppressWarnings("rawtypes")
- private final WeakReference<Class> outputClass;
-
- @SuppressWarnings({ "rawtypes", "unchecked" })
- public DefaultInvocationStrategy(final QName rpc, final Method targetMethod, final Class<?> outputClass,
- final Class<? extends DataContainer> inputClass) {
- super(rpc, targetMethod);
- this.outputClass = new WeakReference(outputClass);
- this.inputClass = new WeakReference(inputClass);
- }
-
- @SuppressWarnings("unchecked")
- @Override
- public RpcResult<CompositeNode> uncheckedInvoke(final RpcService rpcService, final CompositeNode domInput)
- throws Exception {
- DataContainer bindingInput = mappingService.dataObjectFromDataDom(inputClass.get(), domInput);
- Future<RpcResult<?>> futureResult = (Future<RpcResult<?>>) targetMethod.invoke(rpcService, bindingInput);
- if (futureResult == null) {
- return Rpcs.getRpcResult(false);
- }
- RpcResult<?> bindingResult = futureResult.get();
- final Object resultObj = bindingResult.getResult();
- if (resultObj instanceof DataObject) {
- final CompositeNode output = mappingService.toDataDom((DataObject) resultObj);
- return Rpcs.getRpcResult(true, output, Collections.<RpcError> emptySet());
- }
- return Rpcs.getRpcResult(true);
- }
-
- @Override
- public ListenableFuture<RpcResult<?>> forwardToDomBroker(final DataObject input) {
- if (biRpcRegistry == null) {
- return Futures.<RpcResult<?>> immediateFuture(Rpcs.getRpcResult(false));
- }
-
- CompositeNode xml = mappingService.toDataDom(input);
- CompositeNode wrappedXml = ImmutableCompositeNode.create(rpc, ImmutableList.<Node<?>> of(xml));
-
- return Futures.transform(biRpcRegistry.invokeRpc(rpc, wrappedXml),
- new Function<RpcResult<CompositeNode>, RpcResult<?>>() {
- @Override
- public RpcResult<?> apply(final RpcResult<CompositeNode> input) {
- Object baResultValue = null;
- if (input.getResult() != null) {
- baResultValue = mappingService.dataObjectFromDataDom(outputClass.get(),
- input.getResult());
- }
- return Rpcs.getRpcResult(input.isSuccessful(), baResultValue, input.getErrors());
- }
- });
- }
- }
-
- private class NoInputInvocationStrategy extends RpcInvocationStrategy {
-
- @SuppressWarnings("rawtypes")
- private final WeakReference<Class> outputClass;
-
- @SuppressWarnings({ "rawtypes", "unchecked" })
- public NoInputInvocationStrategy(final QName rpc, final Method targetMethod, final Class<?> outputClass) {
- super(rpc, targetMethod);
- this.outputClass = new WeakReference(outputClass);
- }
-
- @SuppressWarnings("unchecked")
- @Override
- public RpcResult<CompositeNode> uncheckedInvoke(final RpcService rpcService, final CompositeNode domInput)
- throws Exception {
- Future<RpcResult<?>> futureResult = (Future<RpcResult<?>>) targetMethod.invoke(rpcService);
- if (futureResult == null) {
- return Rpcs.getRpcResult(false);
- }
- RpcResult<?> bindingResult = futureResult.get();
- final Object resultObj = bindingResult.getResult();
- if (resultObj instanceof DataObject) {
- final CompositeNode output = mappingService.toDataDom((DataObject) resultObj);
- return Rpcs.getRpcResult(true, output, Collections.<RpcError> emptySet());
- }
- return Rpcs.getRpcResult(true);
- }
-
- @Override
- public Future<RpcResult<?>> forwardToDomBroker(final DataObject input) {
- if (biRpcRegistry != null) {
- CompositeNode xml = mappingService.toDataDom(input);
- CompositeNode wrappedXml = ImmutableCompositeNode.create(rpc, ImmutableList.<Node<?>> of(xml));
- return Futures.transform(biRpcRegistry.invokeRpc(rpc, wrappedXml),
- new Function<RpcResult<CompositeNode>, RpcResult<?>>() {
- @Override
- public RpcResult<?> apply(final RpcResult<CompositeNode> input) {
- Object baResultValue = null;
- if (input.getResult() != null) {
- baResultValue = mappingService.dataObjectFromDataDom(outputClass.get(),
- input.getResult());
- }
- return Rpcs.getRpcResult(input.isSuccessful(), baResultValue, input.getErrors());
- }
- });
- } else {
- return Futures.<RpcResult<?>> immediateFuture(Rpcs.getRpcResult(false));
- }
- }
- }
-
- private class NoInputNoOutputInvocationStrategy extends RpcInvocationStrategy {
-
- public NoInputNoOutputInvocationStrategy(final QName rpc, final Method targetMethod) {
- super(rpc, targetMethod);
- }
-
- @Override
- public RpcResult<CompositeNode> uncheckedInvoke(final RpcService rpcService, final CompositeNode domInput)
- throws Exception {
- @SuppressWarnings("unchecked")
- Future<RpcResult<Void>> result = (Future<RpcResult<Void>>) targetMethod.invoke(rpcService);
- RpcResult<Void> bindingResult = result.get();
- return Rpcs.getRpcResult(bindingResult.isSuccessful(), bindingResult.getErrors());
- }
-
- @Override
- public Future<RpcResult<?>> forwardToDomBroker(final DataObject input) {
- return Futures.immediateFuture(null);
- }
- }
-
- private class NoOutputInvocationStrategy extends RpcInvocationStrategy {
-
- @SuppressWarnings("rawtypes")
- private final WeakReference<Class> inputClass;
-
- @SuppressWarnings({ "rawtypes", "unchecked" })
- public NoOutputInvocationStrategy(final QName rpc, final Method targetMethod,
- final Class<? extends DataContainer> inputClass) {
- super(rpc, targetMethod);
- this.inputClass = new WeakReference(inputClass);
- }
-
- @Override
- public RpcResult<CompositeNode> uncheckedInvoke(final RpcService rpcService, final CompositeNode domInput)
- throws Exception {
- DataContainer bindingInput = mappingService.dataObjectFromDataDom(inputClass.get(), domInput);
- Future<RpcResult<?>> result = (Future<RpcResult<?>>) targetMethod.invoke(rpcService, bindingInput);
- if (result == null) {
- return Rpcs.getRpcResult(false);
- }
- RpcResult<?> bindingResult = result.get();
- return Rpcs.getRpcResult(true);
- }
-
- @Override
- public ListenableFuture<RpcResult<?>> forwardToDomBroker(final DataObject input) {
- if (biRpcRegistry == null) {
- return Futures.<RpcResult<?>> immediateFuture(Rpcs.getRpcResult(false));
- }
-
- CompositeNode xml = mappingService.toDataDom(input);
- CompositeNode wrappedXml = ImmutableCompositeNode.create(rpc, ImmutableList.<Node<?>> of(xml));
-
- return Futures.transform(biRpcRegistry.invokeRpc(rpc, wrappedXml),
- new Function<RpcResult<CompositeNode>, RpcResult<?>>() {
- @Override
- public RpcResult<?> apply(final RpcResult<CompositeNode> input) {
- return Rpcs.<Void> getRpcResult(input.isSuccessful(), null, input.getErrors());
- }
- });
- }
- }
-
public boolean isRpcForwarding() {
return rpcForwarding;
}
--- /dev/null
+/*
+ ** Copyright (c) 2014 Brocade Communications 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.controller.sal.binding.impl.connect.dom;
+
+import java.lang.ref.WeakReference;
+import java.lang.reflect.Method;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.concurrent.Future;
+
+import org.opendaylight.controller.sal.common.util.Rpcs;
+import org.opendaylight.controller.sal.core.api.RpcProvisionRegistry;
+import org.opendaylight.yangtools.yang.binding.DataContainer;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.RpcService;
+import org.opendaylight.yangtools.yang.binding.util.BindingReflections;
+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.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.codec.BindingIndependentMappingService;
+
+import com.google.common.base.Function;
+import com.google.common.base.Optional;
+import com.google.common.collect.ImmutableList;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+
+/*
+ * RPC's can have both input, output, one or the other, or neither.
+ *
+ * This class handles the permutations and provides two means of invocation:
+ * 1. forwardToDomBroker
+ * 2.
+ *
+ * Weak References to the input and output classes are used to allow these classes to
+ * be from another OSGi bundle/class loader which may come and go.
+ *
+ */
+public class RpcInvocationStrategy {
+
+ private final BindingIndependentMappingService mappingService;
+ private final RpcProvisionRegistry biRpcRegistry;
+ protected final Method targetMethod;
+ protected final QName rpc;
+
+ @SuppressWarnings("rawtypes")
+ private final WeakReference<Class> inputClass;
+
+ @SuppressWarnings("rawtypes")
+ private final WeakReference<Class> outputClass;
+
+ @SuppressWarnings({ "rawtypes" })
+ public RpcInvocationStrategy(final QName rpc,
+ final Method targetMethod,
+ final BindingIndependentMappingService mappingService,
+ final RpcProvisionRegistry biRpcRegistry ) {
+
+ this.targetMethod = targetMethod;
+ this.rpc = rpc;
+
+ Optional<Class<?>> outputClassOption = BindingReflections.resolveRpcOutputClass(targetMethod);
+ Optional<Class<? extends DataContainer>> inputClassOption = BindingReflections.resolveRpcInputClass(targetMethod);
+
+ if ( outputClassOption != null && outputClassOption.isPresent() ) {
+ this.outputClass = new WeakReference(outputClassOption.get() ) ;
+ } else {
+ this.outputClass = null ;
+ }
+ if ( inputClassOption != null && inputClassOption.isPresent() ) {
+ this.inputClass = new WeakReference(inputClassOption.get() ) ;
+ } else {
+ this.inputClass = null ;
+ }
+
+ this.mappingService = mappingService;
+ this.biRpcRegistry = biRpcRegistry;
+ }
+
+ @SuppressWarnings({ "unchecked" })
+ public ListenableFuture<RpcResult<?>> forwardToDomBroker(final DataObject input) {
+
+ if(biRpcRegistry == null) {
+ return Futures.<RpcResult<?>> immediateFuture(Rpcs.getRpcResult(false));
+ }
+
+ CompositeNode inputXml = null;
+ if( input != null ) {
+ CompositeNode xml = mappingService.toDataDom(input);
+ inputXml = ImmutableCompositeNode.create(rpc, ImmutableList.<Node<?>> of(xml));
+ } else {
+ inputXml = ImmutableCompositeNode.create( rpc, Collections.<Node<?>>emptyList() );
+ }
+
+ Function<RpcResult<CompositeNode>, RpcResult<?>> transformationFunction =
+ new Function<RpcResult<CompositeNode>, RpcResult<?>>() {
+ @Override
+ public RpcResult<?> apply(RpcResult<CompositeNode> result) {
+
+ Object output = null;
+
+ if( getOutputClass() != null ) {
+ if (result.getResult() != null) {
+ output = mappingService.dataObjectFromDataDom(getOutputClass().get(),
+ result.getResult());
+ }
+ }
+
+ return Rpcs.getRpcResult(result.isSuccessful(), output, result.getErrors());
+ }
+ };
+
+ return Futures.transform(biRpcRegistry.invokeRpc(rpc, inputXml), transformationFunction);
+ }
+
+ @SuppressWarnings("unchecked")
+ private RpcResult<CompositeNode> uncheckedInvoke(final RpcService rpcService, final CompositeNode domInput) throws Exception {
+
+ Future<RpcResult<?>> futureResult = null;
+
+ if( inputClass != null ){
+ DataContainer bindingInput = mappingService.dataObjectFromDataDom(inputClass.get(), domInput);
+ futureResult = (Future<RpcResult<?>>) targetMethod.invoke(rpcService, bindingInput);
+
+ } else {
+ futureResult = (Future<RpcResult<?>>) targetMethod.invoke(rpcService);
+ }
+
+ if (futureResult == null) {
+ return Rpcs.getRpcResult(false);
+ }
+
+ RpcResult<?> bindingResult = futureResult.get();
+
+ Collection<RpcError> errors = bindingResult.getErrors();
+ if( errors == null ) {
+ errors = Collections.<RpcError>emptySet();
+ }
+
+ final Object resultObj = bindingResult.getResult();
+ CompositeNode output = null;
+ if (resultObj instanceof DataObject) {
+ output = mappingService.toDataDom((DataObject)resultObj);
+ }
+ return Rpcs.getRpcResult( bindingResult.isSuccessful(), output, errors);
+ }
+
+ public RpcResult<CompositeNode> invokeOn(final RpcService rpcService, final CompositeNode domInput) throws Exception {
+ return uncheckedInvoke(rpcService, domInput);
+ }
+
+ @SuppressWarnings("rawtypes")
+ public WeakReference<Class> getOutputClass() {
+ return outputClass;
+ }
+}
--- /dev/null
+/*
+* Copyright (c) 2014 Brocade Communications 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.controller.sal.binding.impl.connect.dom;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Date;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.opendaylight.controller.sal.common.util.Rpcs;
+import org.opendaylight.controller.sal.core.api.RpcProvisionRegistry;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.RpcService;
+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.data.api.CompositeNode;
+import org.opendaylight.yangtools.yang.data.impl.codec.BindingIndependentMappingService;
+
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+
+public class RpcInvocationStrategyTest {
+
+ @Mock
+ private BindingIndependentMappingService mockMappingService;
+ @Mock
+ private RpcProvisionRegistry mockbiRpcRegistry;
+
+ private RpcInvocationStrategy rpcInvocationStrategy;
+ private ListenableFuture<RpcResult<DataObject>> futureDataObj;
+ private ListenableFuture<RpcResult<CompositeNode>> futureCompNode;
+ private final RpcError rpcError = mock(RpcError.class);
+ private final Collection<RpcError> errors = new ArrayList<RpcError>();
+
+ private final CompositeNode inputInvokeOn = mock(CompositeNode.class);
+ private final CompositeNode outputInvokeOn = mock(CompositeNode.class);
+
+ private final DataObject toDataDomInput = mock(DataObject.class);
+ private final CompositeNode toDataDomReturn = mock(CompositeNode.class);
+ private final CompositeNode invokeRpcResult = mock(CompositeNode.class);
+
+ private final DataObject inputForward = mock(DataObject.class);
+ private final DataObject outputForward = mock(DataObject.class);
+
+ private QName mockQName;
+ private URI urn;
+
+ private final MockRpcService mockRpcService = new MockRpcService();
+
+ public class MockRpcService implements RpcService {
+
+ public Future<?> rpcnameWithInputNoOutput(DataObject input) {
+ return futureDataObj;
+ }
+
+ public Future<RpcResult<DataObject>> rpcnameWithInputWithOutput(DataObject input) {
+ return futureDataObj;
+ }
+
+ public Future<RpcResult<DataObject>> rpcnameNoInputWithOutput() {
+ return futureDataObj;
+ }
+
+ public Future<?> rpcnameNoInputNoOutput() {
+ return futureDataObj;
+ }
+ }
+
+ public RpcInvocationStrategyTest() {
+ MockitoAnnotations.initMocks(this);
+ }
+
+ @Before
+ public void testInit() throws Exception {
+ urn = new URI(new String("urn:a:valid:urn"));
+ }
+
+ private void setupForForwardToDom(boolean hasOutput, boolean hasInput, int expectedErrorSize) {
+
+ if (expectedErrorSize > 0)
+ errors.add(rpcError);
+ RpcResult<CompositeNode> result = Rpcs.getRpcResult(true, invokeRpcResult, errors);
+ futureCompNode = Futures.immediateFuture(result);
+ if( hasInput )
+ {
+ when(mockMappingService.toDataDom(inputForward)).thenReturn(toDataDomReturn);
+ }
+ when(mockbiRpcRegistry.invokeRpc(eq(mockQName), any(CompositeNode.class))).thenReturn(
+ futureCompNode);
+ if (hasOutput) {
+ when(
+ mockMappingService.dataObjectFromDataDom(eq(rpcInvocationStrategy
+ .getOutputClass().get()), any(CompositeNode.class))).thenReturn(
+ outputForward);
+ }
+
+ }
+
+ private void validateForwardToDomBroker(ListenableFuture<RpcResult<?>> forwardToDomBroker,
+ boolean expectedSuccess, DataObject expectedResult, int expectedErrorSize)
+ throws InterruptedException, ExecutionException {
+ assertNotNull(forwardToDomBroker);
+ assertEquals(expectedSuccess, forwardToDomBroker.get().isSuccessful());
+ assertEquals(expectedResult, forwardToDomBroker.get().getResult());
+ assertEquals(expectedErrorSize, forwardToDomBroker.get().getErrors().size());
+ }
+
+ private void setupTestMethod(String rpcName, String testMethodName, boolean hasInput)
+ throws NoSuchMethodException {
+ mockQName = new QName(urn, new Date(0L), new String("prefix"), new String(rpcName));
+ java.lang.reflect.Method rpcMethod = hasInput ? MockRpcService.class.getMethod(rpcName,
+ DataObject.class) : MockRpcService.class.getMethod(rpcName);
+ rpcInvocationStrategy = new RpcInvocationStrategy(mockQName, rpcMethod, mockMappingService,
+ mockbiRpcRegistry);
+ }
+
+ /*
+ * forwardToDomBroker tests
+ */
+ @Test
+ public void testForwardToDomBroker_WithInputNoOutput() throws Exception {
+ setupTestMethod("rpcnameWithInputNoOutput", "testForwardToDomBroker_WithInputNoOutput",
+ true);
+ setupForForwardToDom(false, true, 0);
+ ListenableFuture<RpcResult<?>> forwardToDomBroker = rpcInvocationStrategy
+ .forwardToDomBroker(inputForward);
+
+ validateForwardToDomBroker(forwardToDomBroker, true, null, 0);
+ }
+
+ @Test
+ public void testForwardToDomBroker_WithInputNoOutput_error() throws Exception {
+ setupTestMethod("rpcnameWithInputNoOutput",
+ "testForwardToDomBroker_WithInputNoOutput_error", true);
+ setupForForwardToDom(false, true, 1);
+ ListenableFuture<RpcResult<?>> forwardToDomBroker = rpcInvocationStrategy
+ .forwardToDomBroker(inputForward);
+
+ validateForwardToDomBroker(forwardToDomBroker, true, null, 1);
+ }
+
+ @Test
+ public void testForwardToDomBroker_WithInputWithOutput() throws Exception {
+ setupTestMethod("rpcnameWithInputWithOutput", "testForwardToDomBroker_WithInputWithOutput",
+ true);
+ setupForForwardToDom(true, true, 0);
+ ListenableFuture<RpcResult<?>> forwardToDomBroker = rpcInvocationStrategy
+ .forwardToDomBroker(inputForward);
+ validateForwardToDomBroker(forwardToDomBroker, true, outputForward, 0);
+ }
+
+ @Test
+ public void testForwardToDomBroker_NoInputWithOutput() throws Exception {
+ setupTestMethod("rpcnameNoInputWithOutput", "testForwardToDomBroker_NoInputWithOutput",
+ false);
+ setupForForwardToDom(true, false, 0);
+ ListenableFuture<RpcResult<?>> forwardToDomBroker = rpcInvocationStrategy
+ .forwardToDomBroker(null);
+ validateForwardToDomBroker(forwardToDomBroker, true, outputForward, 0);
+ }
+
+ @Test
+ public void testForwardToDomBroker_NoInputNoOutput() throws Exception {
+ setupTestMethod("rpcnameNoInputNoOutput", "testForwardToDomBroker_NoInputNoOutput", false);
+ setupForForwardToDom(false, false, 0);
+ ListenableFuture<RpcResult<?>> forwardToDomBroker = rpcInvocationStrategy
+ .forwardToDomBroker(null);
+ validateForwardToDomBroker(forwardToDomBroker, true, null, 0);
+ }
+
+ /*
+ * invokeOn Tests
+ */
+ private void setupRpcResultsWithOutput(int expectedErrorSize) {
+ if (expectedErrorSize > 0)
+ errors.add(rpcError);
+ RpcResult<CompositeNode> resultCompNode = Rpcs.getRpcResult(true, inputInvokeOn, errors);
+ futureCompNode = Futures.immediateFuture(resultCompNode);
+ RpcResult<DataObject> resultDataObj = Rpcs.getRpcResult(true, toDataDomInput, errors);
+ futureDataObj = Futures.immediateFuture(resultDataObj);
+
+ when(mockMappingService.toDataDom(toDataDomInput)).thenReturn(outputInvokeOn);
+ }
+
+ private void setupRpcResultsNoOutput(int expectedErrorSize) {
+ if (expectedErrorSize > 0)
+ errors.add(rpcError);
+ RpcResult<CompositeNode> resultCompNode = Rpcs.getRpcResult(true, inputInvokeOn, errors);
+ futureCompNode = Futures.immediateFuture(resultCompNode);
+ RpcResult<DataObject> resultDataObj = Rpcs.getRpcResult(true, null, errors);
+ futureDataObj = Futures.immediateFuture(resultDataObj);
+ }
+
+ private void validateReturnedImmediateFuture(
+ ListenableFuture<RpcResult<CompositeNode>> immediateFuture, boolean expectedSuccess,
+ CompositeNode expectedReturn, int expectedErrorSize) throws InterruptedException,
+ ExecutionException {
+ assertNotNull(immediateFuture);
+ assertEquals(expectedSuccess, immediateFuture.get().isSuccessful());
+ assertEquals(expectedReturn, immediateFuture.get().getResult());
+ assertEquals(expectedErrorSize, immediateFuture.get().getErrors().size());
+ }
+
+ @Test
+ public void testInvokeOn_NoInputNoOutput() throws Exception {
+ setupTestMethod("rpcnameNoInputNoOutput", "testInvokeOn_NoInputNoOutput", false);
+ setupRpcResultsNoOutput(0);
+ ListenableFuture<RpcResult<CompositeNode>> immediateFuture = Futures
+ .immediateFuture(rpcInvocationStrategy.invokeOn(mockRpcService, inputInvokeOn));
+ validateReturnedImmediateFuture(immediateFuture, true, null, 0);
+ }
+
+ @Test
+ public void testInvokeOn_NoInputNoOutput_errors() throws Exception {
+ setupTestMethod("rpcnameNoInputNoOutput", "testInvokeOn_NoInputNoOutput", false);
+ setupRpcResultsNoOutput(1);
+ ListenableFuture<RpcResult<CompositeNode>> immediateFuture = Futures
+ .immediateFuture(rpcInvocationStrategy.invokeOn(mockRpcService, inputInvokeOn));
+ validateReturnedImmediateFuture(immediateFuture, true, null, 1);
+ }
+
+ @Test
+ public void testInvokeOn_WithInputNoOutput() throws Exception {
+ setupTestMethod("rpcnameWithInputNoOutput", "testInvokeOn_WithInputNoOutput", true);
+ setupRpcResultsNoOutput(0);
+ ListenableFuture<RpcResult<CompositeNode>> immediateFuture = Futures
+ .immediateFuture(rpcInvocationStrategy.invokeOn(mockRpcService, inputInvokeOn));
+ validateReturnedImmediateFuture(immediateFuture, true, null, 0);
+ }
+
+ @Test
+ public void testInvokeOn_WithInputWithOutput() throws Exception {
+ setupTestMethod("rpcnameWithInputWithOutput", "testInvokeOn_WithInputWithOutput", true);
+ setupRpcResultsWithOutput(0);
+ ListenableFuture<RpcResult<CompositeNode>> immediateFuture = Futures
+ .immediateFuture(rpcInvocationStrategy.invokeOn(mockRpcService, inputInvokeOn));
+ validateReturnedImmediateFuture(immediateFuture, true, outputInvokeOn, 0);
+ }
+
+ @Test
+ public void testInvokeOn_NoInputWithOutput() throws Exception {
+ setupTestMethod("rpcnameNoInputWithOutput", "testInvokeOn_NoInputWithOutput", false);
+ setupRpcResultsWithOutput(0);
+ ListenableFuture<RpcResult<CompositeNode>> immediateFuture = Futures
+ .immediateFuture(rpcInvocationStrategy.invokeOn(mockRpcService, inputInvokeOn));
+ validateReturnedImmediateFuture(immediateFuture, true, outputInvokeOn, 0);
+ }
+}
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.data.api.CompositeNode;
-public class MultipleAugmentationPuts extends AbstractDataServiceTest implements DataChangeListener {
+public class MultipleAugmentationPutsTest extends AbstractDataServiceTest implements DataChangeListener {
private static final QName NODE_ID_QNAME = QName.create(Node.QNAME, "id");
private static final String NODE_ID = "openflow:1";
*
* @throws Exception
*/
- @Test
+ @Test( timeout = 15000)
public void testAugmentSerialization() throws Exception {
baDataService.registerDataChangeListener(NODES_INSTANCE_ID_BA, this);
Code Review / controller.git / commitdiff