Decompose RPC implementation classes

[openflowplugin.git] / openflowplugin-impl / src / test / java / org / opendaylight / openflowplugin / impl / util / BarrierUtilTest.java

diff --git a/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/util/BarrierUtilTest.java b/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/util/BarrierUtilTest.java
index 4a366ce0f88fd02a7cb9f2b1fd1240f3cb6afa10..4a12b0969a22a817bcc71c029cfb0f7880716558 100644 (file)
--- a/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/util/BarrierUtilTest.java
+++ b/openflowplugin-impl/src/test/java/org/opendaylight/openflowplugin/impl/util/BarrierUtilTest.java
@@ -5,24 +5,28 @@
  * 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.openflowplugin.impl.util;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
 import com.google.common.base.Function;
 import com.google.common.util.concurrent.ListenableFuture;
 import org.apache.commons.lang3.tuple.Pair;
 import org.junit.After;
-import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.ArgumentCaptor;
-import org.mockito.ArgumentMatchers;
 import org.mockito.Captor;
 import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.mockito.runners.MockitoJUnitRunner;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.transaction.rev150304.FlowCapableTransactionService;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.transaction.rev150304.SendBarrier;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.transaction.rev150304.SendBarrierInput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.transaction.rev150304.SendBarrierOutput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
@@ -39,52 +43,50 @@ import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
  */
 @RunWith(MockitoJUnitRunner.class)
 public class BarrierUtilTest {
-
     public static final NodeKey NODE_KEY = new NodeKey(new NodeId("ut-dummy-node"));
     private static final NodeRef NODE_REF = new NodeRef(InstanceIdentifier.create(Nodes.class)
             .child(Node.class, NODE_KEY));
 
     @Mock
-    private FlowCapableTransactionService transactionService;
+    private SendBarrier sendBarrier;
     @Mock
     private Function<Pair<RpcResult<String>, RpcResult<SendBarrierOutput>>, RpcResult<String>> compositeTransform;
     @Captor
     private ArgumentCaptor<Pair<RpcResult<String>, RpcResult<SendBarrierOutput>>> pairCpt;
 
     @Before
-    public void setUp() throws Exception {
-        Mockito.when(transactionService.sendBarrier(ArgumentMatchers.<SendBarrierInput>any()))
+    public void setUp() {
+        when(sendBarrier.invoke(any()))
                 .thenReturn(RpcResultBuilder.<SendBarrierOutput>success().buildFuture());
     }
 
     @After
-    public void tearDown() throws Exception {
-        Mockito.verifyNoMoreInteractions(transactionService, compositeTransform);
+    public void tearDown() {
+        verifyNoMoreInteractions(sendBarrier, compositeTransform);
     }
 
     @Test
-    public void testChainBarrier() throws Exception {
+    public void testChainBarrier() {
         final String data = "ut-data1";
         final ListenableFuture<RpcResult<String>> input = RpcResultBuilder.success(data).buildFuture();
         final ListenableFuture<RpcResult<String>> chainResult =
-                BarrierUtil.chainBarrier(input, NODE_REF, transactionService, compositeTransform);
+                BarrierUtil.chainBarrier(input, NODE_REF, sendBarrier, compositeTransform);
 
-        Mockito.verify(transactionService).sendBarrier(ArgumentMatchers.<SendBarrierInput>any());
-        Mockito.verify(compositeTransform).apply(pairCpt.capture());
+        verify(sendBarrier).invoke(any());
+        verify(compositeTransform).apply(pairCpt.capture());
 
         final Pair<RpcResult<String>, RpcResult<SendBarrierOutput>> value = pairCpt.getValue();
-        Assert.assertTrue(value.getLeft().isSuccessful());
-        Assert.assertEquals(data, value.getLeft().getResult());
-        Assert.assertTrue(value.getRight().isSuccessful());
-        Assert.assertNull(value.getRight().getResult());
-
+        assertTrue(value.getLeft().isSuccessful());
+        assertEquals(data, value.getLeft().getResult());
+        assertTrue(value.getRight().isSuccessful());
+        assertNull(value.getRight().getResult());
     }
 
     @Test
-    public void testCreateSendBarrierInput() throws Exception {
+    public void testCreateSendBarrierInput() {
         final SendBarrierInput barrierInput = BarrierUtil.createSendBarrierInput(NODE_REF);
 
-        Assert.assertEquals(NODE_REF, barrierInput.getNode());
-        Assert.assertEquals(SendBarrierInput.class, barrierInput.getImplementedInterface());
+        assertEquals(NODE_REF, barrierInput.getNode());
+        assertEquals(SendBarrierInput.class, barrierInput.implementedInterface());
     }
 }