binding2/mdsal-binding2-dom-adapter/src/test/java/org/opendaylight/mdsal/binding/javav2/dom/adapter/impl/operation/BindingDOMOperationAdapterTest.java

   1 /*
   2  * Copyright (c) 2018 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.mdsal.binding.javav2.dom.adapter.impl.operation;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertNotNull;
  12 import static org.junit.Assert.assertTrue;
  13
  14 import com.google.common.collect.ImmutableSet;
  15 import java.util.concurrent.CountDownLatch;
  16 import java.util.concurrent.Executors;
  17 import java.util.concurrent.TimeUnit;
  18 import org.junit.Before;
  19 import org.junit.Test;
  20 import org.opendaylight.mdsal.binding.javav2.api.DataTreeIdentifier;
  21 import org.opendaylight.mdsal.binding.javav2.dom.adapter.test.BindingBrokerTestFactory;
  22 import org.opendaylight.mdsal.binding.javav2.dom.adapter.test.BindingTestContext;
  23 import org.opendaylight.mdsal.binding.javav2.spec.base.InstanceIdentifier;
  24 import org.opendaylight.mdsal.binding.javav2.spec.base.RpcCallback;
  25 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  26 import org.opendaylight.mdsal.dom.api.DOMActionNotAvailableException;
  27 import org.opendaylight.mdsal.dom.api.DOMRpcImplementationNotAvailableException;
  28 import org.opendaylight.mdsal.gen.javav2.urn.test.operation.rev170621.TestOperationServiceInContAction;
  29 import org.opendaylight.mdsal.gen.javav2.urn.test.operation.rev170621.TestOperationServiceMyRpcRpc;
  30 import org.opendaylight.mdsal.gen.javav2.urn.test.operation.rev170621.data.MyCont;
  31 import org.opendaylight.mdsal.gen.javav2.urn.test.operation.rev170621.data.my_cont.in_cont.InContInput;
  32 import org.opendaylight.mdsal.gen.javav2.urn.test.operation.rev170621.data.my_cont.in_cont.InContOutput;
  33 import org.opendaylight.mdsal.gen.javav2.urn.test.operation.rev170621.data.my_rpc.MyRpcInput;
  34 import org.opendaylight.mdsal.gen.javav2.urn.test.operation.rev170621.data.my_rpc.MyRpcOutput;
  35 import org.opendaylight.mdsal.gen.javav2.urn.test.operation.rev170621.dto.my_cont.in_cont.InContInputBuilder;
  36 import org.opendaylight.mdsal.gen.javav2.urn.test.operation.rev170621.dto.my_cont.in_cont.InContOutputBuilder;
  37 import org.opendaylight.mdsal.gen.javav2.urn.test.operation.rev170621.dto.my_rpc.MyRpcInputBuilder;
  38 import org.opendaylight.mdsal.gen.javav2.urn.test.operation.rev170621.dto.my_rpc.MyRpcOutputBuilder;
  39 import org.opendaylight.yangtools.concepts.ObjectRegistration;
  40
  41
  42 public class BindingDOMOperationAdapterTest {
  43     private static final MyRpcOutput RPC_OUTPUT = new MyRpcOutputBuilder().setRpcOutputLeaf("rpc_output_leaf").build();
  44     private static final InContOutput ACTION_OUTPUT =
  45         new InContOutputBuilder().setOutputLeaf("action_output_leaf").build();
  46     private BindingDOMOperationProviderServiceAdapter adapter;
  47     private BindingDOMOperationServiceAdapter serviceAdapter;
  48
  49     @Before
  50     public void setUp() throws Exception {
  51         final BindingBrokerTestFactory testFactory = new BindingBrokerTestFactory();
  52         testFactory.setExecutor(Executors.newCachedThreadPool());
  53
  54         final BindingTestContext testContext = testFactory.getTestContext();
  55         testContext.start();
  56
  57         this.adapter = new BindingDOMOperationProviderServiceAdapter(testContext.getDomRpcRegistry(),
  58                 testContext.getDomActionRegistry(), testContext.getCodec());
  59
  60         this.serviceAdapter = new BindingDOMOperationServiceAdapter(testContext.getDomRpcInvoker(),
  61                 testContext.getDomActionService(), testContext.getCodec());
  62     }
  63
  64     @Test
  65     public void actionTest() throws Exception {
  66         final CountDownLatch invokeLatch = new CountDownLatch(1);
  67         final ObjectRegistration<?> registration = adapter.registerActionImplementation(
  68             TestOperationServiceInContAction.class, new TestActionImpl(), LogicalDatastoreType.OPERATIONAL,
  69             ImmutableSet.of(
  70                 DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(MyCont.class))));
  71         assertNotNull(registration);
  72
  73         final TestOperationServiceInContAction action =
  74             serviceAdapter.getActionService(TestOperationServiceInContAction.class);
  75         assertNotNull(action);
  76
  77         action.invoke(new InContInputBuilder().setInputLeaf("in").build(),
  78             InstanceIdentifier.create(MyCont.class),
  79             new RpcCallback<InContOutput>() {
  80                 @Override
  81                 public void onSuccess(InContOutput output) {
  82                     assertEquals(ACTION_OUTPUT, output);
  83                     invokeLatch.countDown();
  84                 }
  85
  86                 @Override
  87                 public void onFailure(Throwable cause) {
  88                     assertNotNull(cause);
  89                 }
  90             });
  91         assertEquals("Invoke complete", true, invokeLatch.await(5, TimeUnit.SECONDS));
  92     }
  93
  94     @Test
  95     public void actionFailedTest() throws Exception {
  96
  97         final CountDownLatch invokeLatch = new CountDownLatch(1);
  98
  99         final ObjectRegistration<?> registration =  adapter.registerActionImplementation(
 100             TestOperationServiceInContAction.class, new TestActionFailedImpl(), LogicalDatastoreType.OPERATIONAL,
 101             ImmutableSet.of(DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL,
 102                 InstanceIdentifier.create(MyCont.class))));
 103         assertNotNull(registration);
 104
 105         final TestOperationServiceInContAction action =
 106             serviceAdapter.getActionService(TestOperationServiceInContAction.class);
 107         assertNotNull(action);
 108
 109         action.invoke(new InContInputBuilder().setInputLeaf("in").build(),
 110             InstanceIdentifier.create(MyCont.class),
 111             new RpcCallback<InContOutput>() {
 112                 @Override
 113                 public void onSuccess(InContOutput output) {
 114
 115                 }
 116
 117                 @Override
 118                 public void onFailure(Throwable cause) {
 119                     assertTrue(cause instanceof RuntimeException);
 120                     assertEquals(cause.getMessage(), "TestActionFailedImpl invoke failed.");
 121                     invokeLatch.countDown();
 122                 }
 123             });
 124         assertEquals("Invoke complete", true, invokeLatch.await(5, TimeUnit.SECONDS));
 125     }
 126
 127     @Test
 128     public void actionNotAvaliableTest() throws Exception {
 129
 130         final CountDownLatch invokeLatch = new CountDownLatch(1);
 131
 132         final TestOperationServiceInContAction action =
 133             serviceAdapter.getActionService(TestOperationServiceInContAction.class);
 134         assertNotNull(action);
 135
 136         action.invoke(new InContInputBuilder().setInputLeaf("in").build(),
 137             InstanceIdentifier.create(MyCont.class),
 138             new RpcCallback<InContOutput>() {
 139                 @Override
 140                 public void onSuccess(InContOutput output) {
 141
 142                 }
 143
 144                 @Override
 145                 public void onFailure(Throwable cause) {
 146                     assertTrue(cause instanceof DOMActionNotAvailableException);
 147                     invokeLatch.countDown();
 148                 }
 149             });
 150         assertEquals("Invoke complete", true, invokeLatch.await(5, TimeUnit.SECONDS));
 151     }
 152
 153     @Test
 154     public void rpcTest() throws Exception {
 155         final CountDownLatch invokeLatch = new CountDownLatch(1);
 156
 157         assertNotNull(adapter.registerRpcImplementation(TestOperationServiceMyRpcRpc.class,
 158             new TestRpcImpl()));
 159         final TestOperationServiceMyRpcRpc rpc =
 160             serviceAdapter.getRpcService(TestOperationServiceMyRpcRpc.class);
 161         assertNotNull(rpc);
 162
 163         rpc.invoke(new MyRpcInputBuilder().setRpcInputLeaf("123").build(),
 164                 new RpcCallback<MyRpcOutput>() {
 165                     @Override
 166                     public void onSuccess(MyRpcOutput output) {
 167                         assertEquals(RPC_OUTPUT, output);
 168                         invokeLatch.countDown();
 169                     }
 170
 171                     @Override
 172                     public void onFailure(Throwable cause) {
 173                     }
 174                 });
 175         assertEquals("Invoke complete", true, invokeLatch.await(5, TimeUnit.SECONDS));
 176     }
 177
 178     @Test
 179     public void rpcFailedTest() throws Exception {
 180
 181         final CountDownLatch invokeLatch = new CountDownLatch(1);
 182
 183         assertNotNull(adapter.registerRpcImplementation(TestOperationServiceMyRpcRpc.class,
 184             new TestRpcFailedImpl()));
 185         final TestOperationServiceMyRpcRpc rpc =
 186             serviceAdapter.getRpcService(TestOperationServiceMyRpcRpc.class);
 187         assertNotNull(rpc);
 188
 189         rpc.invoke(new MyRpcInputBuilder().setRpcInputLeaf("123").build(),
 190             new RpcCallback<MyRpcOutput>() {
 191                 @Override
 192                 public void onSuccess(MyRpcOutput output) {
 193
 194                 }
 195
 196                 @Override
 197                 public void onFailure(Throwable cause) {
 198                     assertTrue(cause instanceof RuntimeException);
 199                     assertEquals(cause.getMessage(), "TestRpcFailedImpl invoke failed.");
 200                     invokeLatch.countDown();
 201                 }
 202             });
 203         assertEquals("Invoke complete", true, invokeLatch.await(5, TimeUnit.SECONDS));
 204     }
 205
 206     @Test
 207     public void rpcNotAvaliableTest() throws Exception {
 208         final CountDownLatch invokeLatch = new CountDownLatch(1);
 209
 210         final TestOperationServiceMyRpcRpc rpc =
 211             serviceAdapter.getRpcService(TestOperationServiceMyRpcRpc.class);
 212         assertNotNull(rpc);
 213
 214         rpc.invoke(new MyRpcInputBuilder().setRpcInputLeaf("123").build(),
 215             new RpcCallback<MyRpcOutput>() {
 216                 @Override
 217                 public void onSuccess(MyRpcOutput output) {
 218
 219                 }
 220
 221                 @Override
 222                 public void onFailure(Throwable cause) {
 223                     assertTrue(cause instanceof DOMRpcImplementationNotAvailableException);
 224                     invokeLatch.countDown();
 225                 }
 226             });
 227         assertEquals("Invoke complete", true, invokeLatch.await(5, TimeUnit.SECONDS));
 228     }
 229
 230     private class TestRpcImpl implements TestOperationServiceMyRpcRpc {
 231
 232         @Override
 233         public void invoke(MyRpcInput input, RpcCallback<MyRpcOutput> callback) {
 234             callback.onSuccess(RPC_OUTPUT);
 235         }
 236     }
 237
 238     private class TestRpcFailedImpl implements TestOperationServiceMyRpcRpc {
 239
 240         @Override
 241         public void invoke(MyRpcInput input, RpcCallback<MyRpcOutput> callback) {
 242             callback.onFailure(new RuntimeException("TestRpcFailedImpl invoke failed."));
 243         }
 244     }
 245
 246     private class TestActionImpl implements TestOperationServiceInContAction {
 247
 248         @Override
 249         public void invoke(InContInput input, InstanceIdentifier<MyCont> ii, RpcCallback<InContOutput> callback) {
 250             callback.onSuccess(ACTION_OUTPUT);
 251         }
 252     }
 253
 254     private class TestActionFailedImpl implements TestOperationServiceInContAction {
 255
 256         @Override
 257         public void invoke(InContInput input, InstanceIdentifier<MyCont> ii, RpcCallback<InContOutput> callback) {
 258             callback.onFailure(new RuntimeException("TestActionFailedImpl invoke failed."));
 259         }
 260     }
 261 }