Decompose RPC implementation classes
[openflowplugin.git] / openflowplugin-impl / src / test / java / org / opendaylight / openflowplugin / impl / services / sal / SalGroupsBatchServiceImplTest.java
index 181681028594d3e4fe913094362b5bec4b12c7a0..e95c842173c1b95966cc7b092342540851140a9b 100644 (file)
@@ -5,47 +5,44 @@
  * 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.services.sal;
 
-import com.google.common.collect.Lists;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.inOrder;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
 import java.util.List;
-import java.util.concurrent.Future;
 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.InOrder;
 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.opendaylight.yang.gen.v1.urn.opendaylight.flow.transaction.rev150304.SendBarrierInput;
+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.SendBarrierOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.AddGroup;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.AddGroupInput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.AddGroupOutput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.AddGroupOutputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.RemoveGroup;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.RemoveGroupInput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.RemoveGroupOutput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.RemoveGroupOutputBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.SalGroupService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.UpdateGroup;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.UpdateGroupInput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.UpdateGroupOutput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.UpdateGroupOutputBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.AddGroupsBatchInput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.AddGroupsBatchInputBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.AddGroupsBatchOutput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.RemoveGroupsBatchInput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.RemoveGroupsBatchInputBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.RemoveGroupsBatchOutput;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.UpdateGroupsBatchInput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.UpdateGroupsBatchInputBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.UpdateGroupsBatchOutput;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.add.groups.batch.input.BatchAddGroups;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.add.groups.batch.input.BatchAddGroupsBuilder;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.batch.group.input.update.grouping.OriginalBatchedGroupBuilder;
@@ -60,25 +57,29 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.common.RpcError;
-import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.opendaylight.yangtools.yang.binding.util.BindingMap;
+import org.opendaylight.yangtools.yang.common.ErrorType;
 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
+import org.opendaylight.yangtools.yang.common.Uint32;
 
 /**
  * Test for {@link org.opendaylight.openflowplugin.impl.services.sal.SalGroupsBatchServiceImpl}.
  */
 @RunWith(MockitoJUnitRunner.class)
 public class SalGroupsBatchServiceImplTest {
-
     public static final NodeId NODE_ID = new NodeId("ut-dummy-node");
     public static final NodeKey NODE_KEY = new NodeKey(NODE_ID);
     public static final NodeRef NODE_REF =
             new NodeRef(InstanceIdentifier.create(Nodes.class).child(Node.class, NODE_KEY));
 
     @Mock
-    private SalGroupService salGroupService;
+    private AddGroup addGroup;
     @Mock
-    private FlowCapableTransactionService transactionService;
+    private RemoveGroup removeGroup;
+    @Mock
+    private UpdateGroup updateGroup;
+    @Mock
+    private SendBarrier sendBarrier;
     @Captor
     private ArgumentCaptor<RemoveGroupInput> removeGroupInputCpt;
     @Captor
@@ -86,232 +87,232 @@ public class SalGroupsBatchServiceImplTest {
     @Captor
     private ArgumentCaptor<AddGroupInput> addGroupInputCpt;
 
-    private SalGroupsBatchServiceImpl salGroupsBatchService;
-
+    private AddGroupsBatchImpl addGroupsBatch;
+    private RemoveGroupsBatchImpl removeGroupsBatch;
+    private UpdateGroupsBatchImpl updateGroupsBatch;
 
     @Before
-    public void setUp() throws Exception {
-        salGroupsBatchService = new SalGroupsBatchServiceImpl(salGroupService, transactionService);
+    public void setUp() {
+        addGroupsBatch = new AddGroupsBatchImpl(addGroup, sendBarrier);
+        removeGroupsBatch = new RemoveGroupsBatchImpl(removeGroup, sendBarrier);
+        updateGroupsBatch = new UpdateGroupsBatchImpl(updateGroup, sendBarrier);
 
-        Mockito.when(transactionService.sendBarrier(ArgumentMatchers.<SendBarrierInput>any()))
-                .thenReturn(RpcResultBuilder.<SendBarrierOutput>success().buildFuture());
+        when(sendBarrier.invoke(any())).thenReturn(RpcResultBuilder.<SendBarrierOutput>success().buildFuture());
     }
 
     @After
-    public void tearDown() throws Exception {
-        Mockito.verifyNoMoreInteractions(salGroupService, transactionService);
+    public void tearDown() {
+        verifyNoMoreInteractions(addGroup, removeGroup, updateGroup, sendBarrier);
     }
 
     @Test
     public void testUpdateGroupsBatch_success() throws Exception {
-        Mockito.when(salGroupService.updateGroup(Mockito.<UpdateGroupInput>any()))
+        when(updateGroup.invoke(any()))
                 .thenReturn(RpcResultBuilder.success(new UpdateGroupOutputBuilder().build()).buildFuture());
 
-        final UpdateGroupsBatchInput input = new UpdateGroupsBatchInputBuilder()
+        final var input = new UpdateGroupsBatchInputBuilder()
                 .setNode(NODE_REF)
                 .setBarrierAfter(true)
-                .setBatchUpdateGroups(Lists.newArrayList(
+                .setBatchUpdateGroups(List.of(
                         createEmptyBatchUpdateGroup(42L),
                         createEmptyBatchUpdateGroup(44L)))
                 .build();
 
-        final Future<RpcResult<UpdateGroupsBatchOutput>> resultFuture = salGroupsBatchService.updateGroupsBatch(input);
+        final var resultFuture = updateGroupsBatch.invoke(input);
 
-        Assert.assertTrue(resultFuture.isDone());
-        Assert.assertTrue(resultFuture.get().isSuccessful());
+        assertTrue(resultFuture.isDone());
+        assertTrue(resultFuture.get().isSuccessful());
 
-        final InOrder inOrder = Mockito.inOrder(salGroupService, transactionService);
-        inOrder.verify(salGroupService, Mockito.times(2)).updateGroup(updateGroupInputCpt.capture());
-        final List<UpdateGroupInput> allValues = updateGroupInputCpt.getAllValues();
-        Assert.assertEquals(2, allValues.size());
-        Assert.assertEquals(42, allValues.get(0).getOriginalGroup().getGroupId().getValue().longValue());
-        Assert.assertEquals(43, allValues.get(0).getUpdatedGroup().getGroupId().getValue().longValue());
-        Assert.assertEquals(44, allValues.get(1).getOriginalGroup().getGroupId().getValue().longValue());
-        Assert.assertEquals(45, allValues.get(1).getUpdatedGroup().getGroupId().getValue().longValue());
+        final var inOrder = inOrder(updateGroup, sendBarrier);
+        inOrder.verify(updateGroup, times(2)).invoke(updateGroupInputCpt.capture());
+        final var allValues = updateGroupInputCpt.getAllValues();
+        assertEquals(2, allValues.size());
+        assertEquals(42, allValues.get(0).getOriginalGroup().getGroupId().getValue().longValue());
+        assertEquals(43, allValues.get(0).getUpdatedGroup().getGroupId().getValue().longValue());
+        assertEquals(44, allValues.get(1).getOriginalGroup().getGroupId().getValue().longValue());
+        assertEquals(45, allValues.get(1).getUpdatedGroup().getGroupId().getValue().longValue());
 
-        inOrder.verify(transactionService).sendBarrier(ArgumentMatchers.<SendBarrierInput>any());
+        inOrder.verify(sendBarrier).invoke(any());
     }
 
     @Test
     public void testUpdateGroupsBatch_failure() throws Exception {
-        Mockito.when(salGroupService.updateGroup(Mockito.<UpdateGroupInput>any()))
+        when(updateGroup.invoke(any()))
                 .thenReturn(RpcResultBuilder.<UpdateGroupOutput>failed()
-                        .withError(RpcError.ErrorType.APPLICATION, "ur-groupUpdateError")
+                        .withError(ErrorType.APPLICATION, "ur-groupUpdateError")
                         .buildFuture());
 
-        final UpdateGroupsBatchInput input = new UpdateGroupsBatchInputBuilder()
+        final var input = new UpdateGroupsBatchInputBuilder()
                 .setNode(NODE_REF)
                 .setBarrierAfter(true)
-                .setBatchUpdateGroups(Lists.newArrayList(
+                .setBatchUpdateGroups(List.of(
                         createEmptyBatchUpdateGroup(42L),
                         createEmptyBatchUpdateGroup(44L)))
                 .build();
 
-        final Future<RpcResult<UpdateGroupsBatchOutput>> resultFuture = salGroupsBatchService.updateGroupsBatch(input);
+        final var resultFuture = updateGroupsBatch.invoke(input);
+        final var iterator = resultFuture.get().getResult().nonnullBatchFailedGroupsOutput()
+                .values().iterator();
 
-        Assert.assertTrue(resultFuture.isDone());
-        Assert.assertFalse(resultFuture.get().isSuccessful());
-        Assert.assertEquals(2, resultFuture.get().getResult().getBatchFailedGroupsOutput().size());
-        Assert.assertEquals(43L,
-                resultFuture.get().getResult().getBatchFailedGroupsOutput().get(0).getGroupId().getValue().longValue());
-        Assert.assertEquals(45L,
-                resultFuture.get().getResult().getBatchFailedGroupsOutput().get(1).getGroupId().getValue().longValue());
-        Assert.assertEquals(2, resultFuture.get().getErrors().size());
+        assertTrue(resultFuture.isDone());
+        assertFalse(resultFuture.get().isSuccessful());
+        assertEquals(2, resultFuture.get().getResult().nonnullBatchFailedGroupsOutput().size());
+        assertEquals(43L, iterator.next().getGroupId().getValue().longValue());
+        assertEquals(45L, iterator.next().getGroupId().getValue().longValue());
+        assertEquals(2, resultFuture.get().getErrors().size());
 
 
-        final InOrder inOrder = Mockito.inOrder(salGroupService, transactionService);
-        inOrder.verify(salGroupService, Mockito.times(2)).updateGroup(updateGroupInputCpt.capture());
-        final List<UpdateGroupInput> allValues = updateGroupInputCpt.getAllValues();
-        Assert.assertEquals(2, allValues.size());
-        Assert.assertEquals(42, allValues.get(0).getOriginalGroup().getGroupId().getValue().longValue());
-        Assert.assertEquals(43, allValues.get(0).getUpdatedGroup().getGroupId().getValue().longValue());
-        Assert.assertEquals(44, allValues.get(1).getOriginalGroup().getGroupId().getValue().longValue());
-        Assert.assertEquals(45, allValues.get(1).getUpdatedGroup().getGroupId().getValue().longValue());
+        final var inOrder = inOrder(updateGroup, sendBarrier);
+        inOrder.verify(updateGroup, times(2)).invoke(updateGroupInputCpt.capture());
+        final var allValues = updateGroupInputCpt.getAllValues();
+        assertEquals(2, allValues.size());
+        assertEquals(42, allValues.get(0).getOriginalGroup().getGroupId().getValue().longValue());
+        assertEquals(43, allValues.get(0).getUpdatedGroup().getGroupId().getValue().longValue());
+        assertEquals(44, allValues.get(1).getOriginalGroup().getGroupId().getValue().longValue());
+        assertEquals(45, allValues.get(1).getUpdatedGroup().getGroupId().getValue().longValue());
 
-        inOrder.verify(transactionService).sendBarrier(ArgumentMatchers.<SendBarrierInput>any());
+        inOrder.verify(sendBarrier).invoke(any());
     }
 
 
     @Test
     public void testAddGroupsBatch_success() throws Exception {
-        Mockito.when(salGroupService.addGroup(Mockito.<AddGroupInput>any()))
+        when(addGroup.invoke(any()))
                 .thenReturn(RpcResultBuilder.success(new AddGroupOutputBuilder().build()).buildFuture());
 
-        final AddGroupsBatchInput input = new AddGroupsBatchInputBuilder()
+        final var input = new AddGroupsBatchInputBuilder()
                 .setNode(NODE_REF)
                 .setBarrierAfter(true)
-                .setBatchAddGroups(Lists.newArrayList(
+                .setBatchAddGroups(BindingMap.ordered(
                         createEmptyBatchAddGroup(42L),
                         createEmptyBatchAddGroup(43L)))
                 .build();
 
-        final Future<RpcResult<AddGroupsBatchOutput>> resultFuture = salGroupsBatchService.addGroupsBatch(input);
+        final var resultFuture = addGroupsBatch.invoke(input);
 
-        Assert.assertTrue(resultFuture.isDone());
-        Assert.assertTrue(resultFuture.get().isSuccessful());
+        assertTrue(resultFuture.isDone());
+        assertTrue(resultFuture.get().isSuccessful());
 
-        final InOrder inOrder = Mockito.inOrder(salGroupService, transactionService);
-        inOrder.verify(salGroupService, Mockito.times(2)).addGroup(addGroupInputCpt.capture());
-        final List<AddGroupInput> allValues = addGroupInputCpt.getAllValues();
-        Assert.assertEquals(2, allValues.size());
-        Assert.assertEquals(42L, allValues.get(0).getGroupId().getValue().longValue());
-        Assert.assertEquals(43L, allValues.get(1).getGroupId().getValue().longValue());
+        final var inOrder = inOrder(addGroup, sendBarrier);
+        inOrder.verify(addGroup, times(2)).invoke(addGroupInputCpt.capture());
+        final var allValues = addGroupInputCpt.getAllValues();
+        assertEquals(2, allValues.size());
+        assertEquals(42L, allValues.get(0).getGroupId().getValue().longValue());
+        assertEquals(43L, allValues.get(1).getGroupId().getValue().longValue());
 
-        inOrder.verify(transactionService).sendBarrier(ArgumentMatchers.<SendBarrierInput>any());
+        inOrder.verify(sendBarrier).invoke(any());
     }
 
     @Test
     public void testAddGroupsBatch_failure() throws Exception {
-        Mockito.when(salGroupService.addGroup(Mockito.<AddGroupInput>any()))
+        when(addGroup.invoke(any()))
                 .thenReturn(RpcResultBuilder.<AddGroupOutput>failed()
-                        .withError(RpcError.ErrorType.APPLICATION, "ut-groupAddError")
+                        .withError(ErrorType.APPLICATION, "ut-groupAddError")
                         .buildFuture());
 
-        final AddGroupsBatchInput input = new AddGroupsBatchInputBuilder()
+        final var input = new AddGroupsBatchInputBuilder()
                 .setNode(NODE_REF)
                 .setBarrierAfter(true)
-                .setBatchAddGroups(Lists.newArrayList(
+                .setBatchAddGroups(BindingMap.ordered(
                         createEmptyBatchAddGroup(42L),
                         createEmptyBatchAddGroup(43L)))
                 .build();
 
-        final Future<RpcResult<AddGroupsBatchOutput>> resultFuture = salGroupsBatchService.addGroupsBatch(input);
+        final var resultFuture = addGroupsBatch.invoke(input);
+        final var iterator = resultFuture.get().getResult().nonnullBatchFailedGroupsOutput().values().iterator();
 
-        Assert.assertTrue(resultFuture.isDone());
-        Assert.assertFalse(resultFuture.get().isSuccessful());
-        Assert.assertEquals(2, resultFuture.get().getResult().getBatchFailedGroupsOutput().size());
-        Assert.assertEquals(42L,
-                resultFuture.get().getResult().getBatchFailedGroupsOutput().get(0).getGroupId().getValue().longValue());
-        Assert.assertEquals(43L,
-                resultFuture.get().getResult().getBatchFailedGroupsOutput().get(1).getGroupId().getValue().longValue());
-        Assert.assertEquals(2, resultFuture.get().getErrors().size());
+        assertTrue(resultFuture.isDone());
+        assertFalse(resultFuture.get().isSuccessful());
+        assertEquals(2, resultFuture.get().getResult().nonnullBatchFailedGroupsOutput().size());
+        assertEquals(42L, iterator.next().getGroupId().getValue().longValue());
+        assertEquals(43L, iterator.next().getGroupId().getValue().longValue());
+        assertEquals(2, resultFuture.get().getErrors().size());
 
 
-        final InOrder inOrder = Mockito.inOrder(salGroupService, transactionService);
-        inOrder.verify(salGroupService, Mockito.times(2)).addGroup(addGroupInputCpt.capture());
-        final List<AddGroupInput> allValues = addGroupInputCpt.getAllValues();
-        Assert.assertEquals(2, allValues.size());
-        Assert.assertEquals(42L, allValues.get(0).getGroupId().getValue().longValue());
-        Assert.assertEquals(43L, allValues.get(1).getGroupId().getValue().longValue());
+        final var inOrder = inOrder(addGroup, sendBarrier);
+        inOrder.verify(addGroup, times(2)).invoke(addGroupInputCpt.capture());
+        final var allValues = addGroupInputCpt.getAllValues();
+        assertEquals(2, allValues.size());
+        assertEquals(42L, allValues.get(0).getGroupId().getValue().longValue());
+        assertEquals(43L, allValues.get(1).getGroupId().getValue().longValue());
 
-        inOrder.verify(transactionService).sendBarrier(ArgumentMatchers.<SendBarrierInput>any());
+        inOrder.verify(sendBarrier).invoke(any());
     }
 
     @Test
     public void testRemoveGroupsBatch_success() throws Exception {
-        Mockito.when(salGroupService.removeGroup(Mockito.<RemoveGroupInput>any()))
+        when(removeGroup.invoke(any()))
                 .thenReturn(RpcResultBuilder.success(new RemoveGroupOutputBuilder().build()).buildFuture());
 
-        final RemoveGroupsBatchInput input = new RemoveGroupsBatchInputBuilder()
+        final var input = new RemoveGroupsBatchInputBuilder()
                 .setNode(NODE_REF)
                 .setBarrierAfter(true)
-                .setBatchRemoveGroups(Lists.newArrayList(
+                .setBatchRemoveGroups(BindingMap.ordered(
                         createEmptyBatchRemoveGroup(42L),
                         createEmptyBatchRemoveGroup(43L)))
                 .build();
 
-        final Future<RpcResult<RemoveGroupsBatchOutput>> resultFuture = salGroupsBatchService.removeGroupsBatch(input);
+        final var resultFuture = removeGroupsBatch.invoke(input);
 
-        Assert.assertTrue(resultFuture.isDone());
-        Assert.assertTrue(resultFuture.get().isSuccessful());
+        assertTrue(resultFuture.isDone());
+        assertTrue(resultFuture.get().isSuccessful());
 
-        final InOrder inOrder = Mockito.inOrder(salGroupService, transactionService);
+        final var inOrder = inOrder(removeGroup, sendBarrier);
 
-        inOrder.verify(salGroupService, Mockito.times(2)).removeGroup(removeGroupInputCpt.capture());
-        final List<RemoveGroupInput> allValues = removeGroupInputCpt.getAllValues();
-        Assert.assertEquals(2, allValues.size());
-        Assert.assertEquals(42L, allValues.get(0).getGroupId().getValue().longValue());
-        Assert.assertEquals(43L, allValues.get(1).getGroupId().getValue().longValue());
+        inOrder.verify(removeGroup, times(2)).invoke(removeGroupInputCpt.capture());
+        final var allValues = removeGroupInputCpt.getAllValues();
+        assertEquals(2, allValues.size());
+        assertEquals(42L, allValues.get(0).getGroupId().getValue().longValue());
+        assertEquals(43L, allValues.get(1).getGroupId().getValue().longValue());
 
-        inOrder.verify(transactionService).sendBarrier(ArgumentMatchers.<SendBarrierInput>any());
+        inOrder.verify(sendBarrier).invoke(any());
     }
 
     @Test
     public void testRemoveGroupsBatch_failure() throws Exception {
-        Mockito.when(salGroupService.removeGroup(Mockito.<RemoveGroupInput>any()))
+        when(removeGroup.invoke(any()))
                 .thenReturn(RpcResultBuilder.<RemoveGroupOutput>failed()
-                        .withError(RpcError.ErrorType.APPLICATION, "ut-groupRemoveError")
+                        .withError(ErrorType.APPLICATION, "ut-groupRemoveError")
                         .buildFuture());
 
-        final RemoveGroupsBatchInput input = new RemoveGroupsBatchInputBuilder()
+        final var input = new RemoveGroupsBatchInputBuilder()
                 .setNode(NODE_REF)
                 .setBarrierAfter(true)
-                .setBatchRemoveGroups(Lists.newArrayList(
+                .setBatchRemoveGroups(BindingMap.ordered(
                         createEmptyBatchRemoveGroup(42L),
                         createEmptyBatchRemoveGroup(43L)))
                 .build();
 
-        final Future<RpcResult<RemoveGroupsBatchOutput>> resultFuture = salGroupsBatchService.removeGroupsBatch(input);
+        final var resultFuture = removeGroupsBatch.invoke(input);
+        final var iterator = resultFuture.get().getResult().nonnullBatchFailedGroupsOutput().values().iterator();
 
-        Assert.assertTrue(resultFuture.isDone());
-        Assert.assertFalse(resultFuture.get().isSuccessful());
-        Assert.assertEquals(2, resultFuture.get().getResult().getBatchFailedGroupsOutput().size());
-        Assert.assertEquals(42L,
-                resultFuture.get().getResult().getBatchFailedGroupsOutput().get(0).getGroupId().getValue().longValue());
-        Assert.assertEquals(43L,
-                resultFuture.get().getResult().getBatchFailedGroupsOutput().get(1).getGroupId().getValue().longValue());
-        Assert.assertEquals(2, resultFuture.get().getErrors().size());
+        assertTrue(resultFuture.isDone());
+        assertFalse(resultFuture.get().isSuccessful());
+        assertEquals(2, resultFuture.get().getResult().nonnullBatchFailedGroupsOutput().size());
+        assertEquals(42L, iterator.next().getGroupId().getValue().longValue());
+        assertEquals(43L, iterator.next().getGroupId().getValue().longValue());
+        assertEquals(2, resultFuture.get().getErrors().size());
 
-        final InOrder inOrder = Mockito.inOrder(salGroupService, transactionService);
+        final var inOrder = inOrder(removeGroup, sendBarrier);
 
-        inOrder.verify(salGroupService, Mockito.times(2)).removeGroup(removeGroupInputCpt.capture());
-        final List<RemoveGroupInput> allValues = removeGroupInputCpt.getAllValues();
-        Assert.assertEquals(2, allValues.size());
-        Assert.assertEquals(42L, allValues.get(0).getGroupId().getValue().longValue());
-        Assert.assertEquals(43L, allValues.get(1).getGroupId().getValue().longValue());
+        inOrder.verify(removeGroup, times(2)).invoke(removeGroupInputCpt.capture());
+        final var allValues = removeGroupInputCpt.getAllValues();
+        assertEquals(2, allValues.size());
+        assertEquals(42L, allValues.get(0).getGroupId().getValue().longValue());
+        assertEquals(43L, allValues.get(1).getGroupId().getValue().longValue());
 
-        inOrder.verify(transactionService).sendBarrier(ArgumentMatchers.<SendBarrierInput>any());
+        inOrder.verify(sendBarrier).invoke(any());
     }
 
     private static BatchAddGroups createEmptyBatchAddGroup(final long groupIdValue) {
         return new BatchAddGroupsBuilder()
-                .setGroupId(new GroupId(groupIdValue))
+                .setGroupId(new GroupId(Uint32.valueOf(groupIdValue)))
                 .build();
     }
 
     private static BatchRemoveGroups createEmptyBatchRemoveGroup(final long groupIdValue) {
         return new BatchRemoveGroupsBuilder()
-                .setGroupId(new GroupId(groupIdValue))
+                .setGroupId(new GroupId(Uint32.valueOf(groupIdValue)))
                 .build();
     }