1 files changed, 56 insertions, 48 deletions
diff --git a/v3po/v3po2vpp/src/test/java/io/fd/honeycomb/v3po/translate/v3po/interfaces/VhostUserCustomizerTest.java b/v3po/v3po2vpp/src/test/java/io/fd/honeycomb/v3po/translate/v3po/interfaces/VhostUserCustomizerTest.java
index 660430690..714466ec8 100644
--- a/v3po/v3po2vpp/src/test/java/io/fd/honeycomb/v3po/translate/v3po/interfaces/VhostUserCustomizerTest.java
+++ b/v3po/v3po2vpp/src/test/java/io/fd/honeycomb/v3po/translate/v3po/interfaces/VhostUserCustomizerTest.java
@@ -18,30 +18,13 @@ package io.fd.honeycomb.v3po.translate.v3po.interfaces;
 
 import static io.fd.honeycomb.v3po.translate.v3po.test.ContextTestUtils.getMapping;
 import static io.fd.honeycomb.v3po.translate.v3po.test.ContextTestUtils.getMappingIid;
-import static org.junit.Assert.assertArrayEquals;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.fail;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyZeroInteractions;
-import static org.mockito.Mockito.when;
-import static org.mockito.MockitoAnnotations.initMocks;
-
 import io.fd.honeycomb.v3po.translate.MappingContext;
 import io.fd.honeycomb.v3po.translate.ModificationCache;
+import io.fd.honeycomb.v3po.translate.v3po.test.TestHelperUtils;
 import io.fd.honeycomb.v3po.translate.v3po.util.NamingContext;
-import io.fd.honeycomb.v3po.translate.v3po.util.VppApiInvocationException;
 import io.fd.honeycomb.v3po.translate.v3po.util.TranslateUtils;
 import io.fd.honeycomb.v3po.translate.write.WriteContext;
 import io.fd.honeycomb.v3po.translate.write.WriteFailedException;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.CompletionStage;
-import java.util.concurrent.ExecutionException;
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.ArgumentCaptor;
@@ -54,14 +37,21 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.interfaces._interface.VhostUser;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.interfaces._interface.VhostUserBuilder;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.openvpp.jvpp.dto.CreateVhostUserIf;
-import org.openvpp.jvpp.dto.CreateVhostUserIfReply;
-import org.openvpp.jvpp.dto.DeleteVhostUserIf;
-import org.openvpp.jvpp.dto.DeleteVhostUserIfReply;
-import org.openvpp.jvpp.dto.ModifyVhostUserIf;
-import org.openvpp.jvpp.dto.ModifyVhostUserIfReply;
+import org.openvpp.jvpp.VppBaseCallException;
+import org.openvpp.jvpp.VppInvocationException;
+import org.openvpp.jvpp.dto.*;
 import org.openvpp.jvpp.future.FutureJVpp;
 
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.ExecutionException;
+
+import static org.junit.Assert.*;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.*;
+import static org.mockito.MockitoAnnotations.initMocks;
+
 public class VhostUserCustomizerTest {
 
     @Mock
@@ -92,61 +82,79 @@ public class VhostUserCustomizerTest {
         customizer = new VhostUserCustomizer(api, namingContext);
     }
 
-    private void whenCreateVhostUserIfThen(final int retval) throws ExecutionException, InterruptedException {
+    private void whenCreateVhostUserIfThen() throws ExecutionException, InterruptedException, VppInvocationException {
         final CompletionStage<CreateVhostUserIfReply> replyCS = mock(CompletionStage.class);
         final CompletableFuture<CreateVhostUserIfReply> replyFuture = mock(CompletableFuture.class);
         when(replyCS.toCompletableFuture()).thenReturn(replyFuture);
         final CreateVhostUserIfReply reply = new CreateVhostUserIfReply();
-        reply.retval = retval;
         when(replyFuture.get()).thenReturn(reply);
         when(api.createVhostUserIf(any(CreateVhostUserIf.class))).thenReturn(replyCS);
     }
 
-    private void whenCreateVhostUserIfThenSuccess() throws ExecutionException, InterruptedException {
-        whenCreateVhostUserIfThen(0);
+    /**
+     * Failure response send
+     */
+    private void whenCreateVhostUserIfFailedThen(final int retval) throws ExecutionException, InterruptedException, VppInvocationException {
+        doReturn(TestHelperUtils.<CreateVhostUserIfReply>createFutureException(retval)).when(api).createVhostUserIf(any(CreateVhostUserIf.class));
+    }
+
+    private void whenCreateVhostUserIfThenSuccess() throws ExecutionException, InterruptedException, VppInvocationException {
+        whenCreateVhostUserIfThen();
     }
 
-    private void whenVxlanAddDelTunnelThenFailure() throws ExecutionException, InterruptedException {
-        whenCreateVhostUserIfThen(-1);
+    private void whenVxlanAddDelTunnelThenFailure() throws ExecutionException, InterruptedException, VppInvocationException {
+        whenCreateVhostUserIfFailedThen(-1);
     }
 
-    private void whenModifyVhostUserIfThen(final int retval) throws ExecutionException, InterruptedException {
+    private void whenModifyVhostUserIfThen() throws ExecutionException, InterruptedException, VppInvocationException {
         final CompletionStage<ModifyVhostUserIfReply> replyCS = mock(CompletionStage.class);
         final CompletableFuture<ModifyVhostUserIfReply> replyFuture = mock(CompletableFuture.class);
         when(replyCS.toCompletableFuture()).thenReturn(replyFuture);
         final ModifyVhostUserIfReply reply = new ModifyVhostUserIfReply();
-        reply.retval = retval;
         when(replyFuture.get()).thenReturn(reply);
         when(api.modifyVhostUserIf(any(ModifyVhostUserIf.class))).thenReturn(replyCS);
     }
 
-    private void whenModifyVhostUserIfThenSuccess() throws ExecutionException, InterruptedException {
-        whenModifyVhostUserIfThen(0);
+    /**
+     * Failure response send
+     */
+    private void whenModifyVhostUserIfFailedThen(final int retval) throws ExecutionException, InterruptedException, VppInvocationException {
+        doReturn(TestHelperUtils.<ModifyVhostUserIfReply>createFutureException(retval)).when(api).modifyVhostUserIf(any(ModifyVhostUserIf.class));
+    }
+
+    private void whenModifyVhostUserIfThenSuccess() throws ExecutionException, InterruptedException, VppInvocationException {
+        whenModifyVhostUserIfThen();
     }
 
-    private void whenModifyVhostUserIfThenFailure() throws ExecutionException, InterruptedException {
-        whenModifyVhostUserIfThen(-1);
+    private void whenModifyVhostUserIfThenFailure() throws ExecutionException, InterruptedException, VppInvocationException {
+        whenModifyVhostUserIfFailedThen(-1);
     }
 
-    private void whenDeleteVhostUserIfThen(final int retval) throws ExecutionException, InterruptedException {
+    private void whenDeleteVhostUserIfThen() throws ExecutionException, InterruptedException, VppInvocationException {
         final CompletionStage<DeleteVhostUserIfReply> replyCS = mock(CompletionStage.class);
         final CompletableFuture<DeleteVhostUserIfReply> replyFuture = mock(CompletableFuture.class);
         when(replyCS.toCompletableFuture()).thenReturn(replyFuture);
         final DeleteVhostUserIfReply reply = new DeleteVhostUserIfReply();
-        reply.retval = retval;
         when(replyFuture.get()).thenReturn(reply);
         when(api.deleteVhostUserIf(any(DeleteVhostUserIf.class))).thenReturn(replyCS);
     }
 
-    private void whenDeleteVhostUserIfThenSuccess() throws ExecutionException, InterruptedException {
-        whenDeleteVhostUserIfThen(0);
+    /**
+     * Failure response send
+     */
+    private void whenDeleteVhostUserIfFailedThen(final int retval) throws ExecutionException, InterruptedException, VppInvocationException {
+        doReturn(TestHelperUtils.<DeleteVhostUserIfReply>createFutureException(retval)).when(api).deleteVhostUserIf(any(DeleteVhostUserIf.class));
+    }
+
+    private void whenDeleteVhostUserIfThenSuccess() throws ExecutionException, InterruptedException, VppInvocationException {
+        whenDeleteVhostUserIfThen();
     }
 
-    private void whenDeleteVhostUserIfThenFailure() throws ExecutionException, InterruptedException {
-        whenDeleteVhostUserIfThen(-1);
+    private void whenDeleteVhostUserIfThenFailure() throws ExecutionException, InterruptedException, VppInvocationException {
+        whenDeleteVhostUserIfFailedThen(-1);
     }
 
-    private CreateVhostUserIf verifyCreateVhostUserIfWasInvoked(final VhostUser vhostUser) {
+    private CreateVhostUserIf verifyCreateVhostUserIfWasInvoked(final VhostUser vhostUser) throws VppInvocationException {
         ArgumentCaptor<CreateVhostUserIf> argumentCaptor = ArgumentCaptor.forClass(CreateVhostUserIf.class);
         verify(api).createVhostUserIf(argumentCaptor.capture());
         final CreateVhostUserIf actual = argumentCaptor.getValue();
@@ -160,7 +168,7 @@ public class VhostUserCustomizerTest {
         return actual;
     }
 
-    private ModifyVhostUserIf verifyModifyVhostUserIfWasInvoked(final VhostUser vhostUser, final int swIfIndex) {
+    private ModifyVhostUserIf verifyModifyVhostUserIfWasInvoked(final VhostUser vhostUser, final int swIfIndex) throws VppInvocationException {
         ArgumentCaptor<ModifyVhostUserIf> argumentCaptor = ArgumentCaptor.forClass(ModifyVhostUserIf.class);
         verify(api).modifyVhostUserIf(argumentCaptor.capture());
         final ModifyVhostUserIf actual = argumentCaptor.getValue();
@@ -173,7 +181,7 @@ public class VhostUserCustomizerTest {
         return actual;
     }
 
-    private DeleteVhostUserIf verifyDeleteVhostUserIfWasInvoked(final int swIfIndex) {
+    private DeleteVhostUserIf verifyDeleteVhostUserIfWasInvoked(final int swIfIndex) throws VppInvocationException {
         ArgumentCaptor<DeleteVhostUserIf> argumentCaptor = ArgumentCaptor.forClass(DeleteVhostUserIf.class);
         verify(api).deleteVhostUserIf(argumentCaptor.capture());
         final DeleteVhostUserIf actual = argumentCaptor.getValue();
@@ -208,7 +216,7 @@ public class VhostUserCustomizerTest {
         try {
             customizer.writeCurrentAttributes(ID, vhostUser, writeContext);
         } catch (WriteFailedException.CreateFailedException e) {
-            assertEquals(VppApiInvocationException.class, e.getCause().getClass());
+            assertTrue(e.getCause() instanceof VppBaseCallException);
             verifyCreateVhostUserIfWasInvoked(vhostUser);
             verifyZeroInteractions(mappingContext);
             return;
@@ -239,7 +247,7 @@ public class VhostUserCustomizerTest {
         try {
             customizer.updateCurrentAttributes(ID, vhostUserBefore, vhostUserAfter, writeContext);
         } catch (WriteFailedException.UpdateFailedException e) {
-            assertEquals(VppApiInvocationException.class, e.getCause().getClass());
+            assertTrue(e.getCause() instanceof VppBaseCallException);
             verifyModifyVhostUserIfWasInvoked(vhostUserAfter, IFACE_ID);
             return;
         }
@@ -268,7 +276,7 @@ public class VhostUserCustomizerTest {
         try {
             customizer.deleteCurrentAttributes(ID, vhostUser, writeContext);
         } catch (WriteFailedException.DeleteFailedException e) {
-            assertEquals(VppApiInvocationException.class, e.getCause().getClass());
+            assertTrue(e.getCause() instanceof VppBaseCallException);
             verifyDeleteVhostUserIfWasInvoked(IFACE_ID);
             // Delete from context not invoked if delete from VPP failed
             verify(mappingContext, times(0)).delete(eq(getMappingIid(IFACE_NAME, "test-instance")));