*/
package org.opendaylight.openflowplugin.impl.services.sal;
+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.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
import com.google.common.collect.Lists;
import com.google.common.util.concurrent.AsyncFunction;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
-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.junit.MockitoJUnitRunner;
import org.opendaylight.openflowplugin.impl.services.batch.BatchPlanStep;
import org.opendaylight.openflowplugin.impl.services.batch.BatchStepJob;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.process.flat.batch.output.BatchFailure;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.process.flat.batch.output.BatchFailureBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flows.service.rev160314.AddFlowsBatch;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flows.service.rev160314.AddFlowsBatchInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flows.service.rev160314.AddFlowsBatchOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flows.service.rev160314.AddFlowsBatchOutputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flows.service.rev160314.RemoveFlowsBatch;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flows.service.rev160314.RemoveFlowsBatchOutput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flows.service.rev160314.RemoveFlowsBatchOutputBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.flows.service.rev160314.SalFlowsBatchService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flows.service.rev160314.UpdateFlowsBatch;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flows.service.rev160314.UpdateFlowsBatchOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.flows.service.rev160314.batch.flow.output.list.grouping.BatchFailedFlowsOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.AddGroupsBatch;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.AddGroupsBatchOutputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.RemoveGroupsBatch;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.RemoveGroupsBatchOutputBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.SalGroupsBatchService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.UpdateGroupsBatch;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.UpdateGroupsBatchOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.batch.group.input.update.grouping.OriginalBatchedGroupBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groups.service.rev160315.batch.group.input.update.grouping.UpdatedBatchedGroupBuilder;
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.yang.gen.v1.urn.opendaylight.meter.types.rev130918.MeterId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.meters.service.rev160316.AddMetersBatch;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meters.service.rev160316.AddMetersBatchOutputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.meters.service.rev160316.RemoveMetersBatch;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meters.service.rev160316.RemoveMetersBatchOutputBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.meters.service.rev160316.SalMetersBatchService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.meters.service.rev160316.UpdateMetersBatch;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meters.service.rev160316.UpdateMetersBatchOutputBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meters.service.rev160316.batch.meter.input.update.grouping.OriginalBatchedMeterBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.meters.service.rev160316.batch.meter.input.update.grouping.UpdatedBatchedMeterBuilder;
* Test for {@link org.opendaylight.openflowplugin.impl.services.sal.SalFlatBatchServiceImpl}.
*/
@RunWith(MockitoJUnitRunner.class)
-public class SalFlatBatchServiceImplTest {
-
+public class ProcessFlatBatchImplTest {
private static final NodeId NODE_ID = new NodeId("ut-node-id");
private static final InstanceIdentifier<Node> NODE_II = InstanceIdentifier.create(Nodes.class)
.child(Node.class, new NodeKey(NODE_ID));
private static final NodeRef NODE_REF = new NodeRef(NODE_II);
@Mock
- private SalFlowsBatchService salFlowsBatchService;
+ private AddFlowsBatch addFlowsBatch;
+ @Mock
+ private RemoveFlowsBatch removeFlowsBatch;
+ @Mock
+ private UpdateFlowsBatch updateFlowsBatch;
+ @Mock
+ private AddGroupsBatch addGroupsBatch;
+ @Mock
+ private RemoveGroupsBatch removeGroupsBatch;
+ @Mock
+ private UpdateGroupsBatch updateGroupsBatch;
@Mock
- private SalGroupsBatchService salGroupsBatchService;
+ private AddMetersBatch addMetersBatch;
@Mock
- private SalMetersBatchService salMetersBatchService;
+ private RemoveMetersBatch removeMetersBatch;
+ @Mock
+ private UpdateMetersBatch updateMetersBatch;
@Captor
private ArgumentCaptor<AddFlowsBatchInput> addFlowsBatchInputCpt;
- private SalFlatBatchServiceImpl salFlatBatchService;
+ private ProcessFlatBatchImpl processFlatBatch;
@Before
public void setUp() {
- salFlatBatchService =
- new SalFlatBatchServiceImpl(salFlowsBatchService, salGroupsBatchService, salMetersBatchService);
-
+ processFlatBatch = new ProcessFlatBatchImpl(addFlowsBatch, removeFlowsBatch, updateFlowsBatch, addGroupsBatch,
+ removeGroupsBatch, updateGroupsBatch, addMetersBatch, removeMetersBatch, updateMetersBatch);
}
@After
public void tearDown() {
- Mockito.verifyNoMoreInteractions(salFlowsBatchService, salGroupsBatchService, salMetersBatchService);
+ verifyNoMoreInteractions(addFlowsBatch, removeFlowsBatch, updateFlowsBatch, addGroupsBatch,
+ removeGroupsBatch, updateGroupsBatch, addMetersBatch, removeMetersBatch, updateMetersBatch);
}
@Test
public void testProcessFlatBatch_allSuccessFinished() throws Exception {
- Mockito.when(salFlowsBatchService.addFlowsBatch(ArgumentMatchers.any()))
+ when(addFlowsBatch.invoke(any()))
.thenReturn(RpcResultBuilder.success(new AddFlowsBatchOutputBuilder().build()).buildFuture());
- Mockito.when(salFlowsBatchService.removeFlowsBatch(ArgumentMatchers.any()))
+ when(removeFlowsBatch.invoke(any()))
.thenReturn(RpcResultBuilder.success(new RemoveFlowsBatchOutputBuilder().build()).buildFuture());
- Mockito.when(salFlowsBatchService.updateFlowsBatch(ArgumentMatchers.any()))
+ when(updateFlowsBatch.invoke(any()))
.thenReturn(RpcResultBuilder.success(new UpdateFlowsBatchOutputBuilder().build()).buildFuture());
- Mockito.when(salGroupsBatchService.addGroupsBatch(ArgumentMatchers.any()))
+ when(addGroupsBatch.invoke(any()))
.thenReturn(RpcResultBuilder.success(new AddGroupsBatchOutputBuilder().build()).buildFuture());
- Mockito.when(salGroupsBatchService.removeGroupsBatch(ArgumentMatchers.any()))
+ when(removeGroupsBatch.invoke(any()))
.thenReturn(RpcResultBuilder.success(new RemoveGroupsBatchOutputBuilder().build()).buildFuture());
- Mockito.when(salGroupsBatchService.updateGroupsBatch(ArgumentMatchers.any()))
+ when(updateGroupsBatch.invoke(any()))
.thenReturn(RpcResultBuilder.success(new UpdateGroupsBatchOutputBuilder().build()).buildFuture());
- Mockito.when(salMetersBatchService.addMetersBatch(ArgumentMatchers.any()))
+ when(addMetersBatch.invoke(any()))
.thenReturn(RpcResultBuilder.success(new AddMetersBatchOutputBuilder().build()).buildFuture());
- Mockito.when(salMetersBatchService.removeMetersBatch(ArgumentMatchers.any()))
+ when(removeMetersBatch.invoke(any()))
.thenReturn(RpcResultBuilder.success(new RemoveMetersBatchOutputBuilder().build()).buildFuture());
- Mockito.when(salMetersBatchService.updateMetersBatch(ArgumentMatchers.any()))
+ when(updateMetersBatch.invoke(any()))
.thenReturn(RpcResultBuilder.success(new UpdateMetersBatchOutputBuilder().build()).buildFuture());
.setExitOnFirstError(true)
.build();
- final Future<RpcResult<ProcessFlatBatchOutput>> rpcResultFuture =
- salFlatBatchService.processFlatBatch(batchInput);
- Assert.assertTrue(rpcResultFuture.isDone());
- final RpcResult<ProcessFlatBatchOutput> rpcResult = rpcResultFuture.get();
- Assert.assertTrue(rpcResult.isSuccessful());
- Assert.assertTrue(rpcResult.getErrors().isEmpty());
- Assert.assertTrue(rpcResult.getResult().nonnullBatchFailure().isEmpty());
-
- final InOrder inOrder = Mockito.inOrder(salFlowsBatchService, salGroupsBatchService, salMetersBatchService);
- inOrder.verify(salFlowsBatchService).addFlowsBatch(ArgumentMatchers.any());
- inOrder.verify(salFlowsBatchService).removeFlowsBatch(ArgumentMatchers.any());
- inOrder.verify(salFlowsBatchService).updateFlowsBatch(ArgumentMatchers.any());
-
- inOrder.verify(salGroupsBatchService).addGroupsBatch(ArgumentMatchers.any());
- inOrder.verify(salGroupsBatchService).removeGroupsBatch(ArgumentMatchers.any());
- inOrder.verify(salGroupsBatchService).updateGroupsBatch(ArgumentMatchers.any());
-
- inOrder.verify(salMetersBatchService).addMetersBatch(ArgumentMatchers.any());
- inOrder.verify(salMetersBatchService).removeMetersBatch(ArgumentMatchers.any());
- inOrder.verify(salMetersBatchService).updateMetersBatch(ArgumentMatchers.any());
+ final var rpcResultFuture = processFlatBatch.invoke(batchInput);
+ assertTrue(rpcResultFuture.isDone());
+ final var rpcResult = rpcResultFuture.get();
+ assertTrue(rpcResult.isSuccessful());
+ assertTrue(rpcResult.getErrors().isEmpty());
+ assertTrue(rpcResult.getResult().nonnullBatchFailure().isEmpty());
+
+ final var inOrder = inOrder(addFlowsBatch, removeFlowsBatch, updateFlowsBatch, addGroupsBatch,
+ removeGroupsBatch, updateGroupsBatch, addMetersBatch, removeMetersBatch, updateMetersBatch);
+ inOrder.verify(addFlowsBatch).invoke(any());
+ inOrder.verify(removeFlowsBatch).invoke(any());
+ inOrder.verify(updateFlowsBatch).invoke(any());
+
+ inOrder.verify(addGroupsBatch).invoke(any());
+ inOrder.verify(removeGroupsBatch).invoke(any());
+ inOrder.verify(updateGroupsBatch).invoke(any());
+
+ inOrder.verify(addMetersBatch).invoke(any());
+ inOrder.verify(removeMetersBatch).invoke(any());
+ inOrder.verify(updateMetersBatch).invoke(any());
}
@Test
.setExitOnFirstError(true)
.build();
- final Future<RpcResult<ProcessFlatBatchOutput>> rpcResultFuture =
- salFlatBatchService.processFlatBatch(batchInput);
- Assert.assertTrue(rpcResultFuture.isDone());
- final RpcResult<ProcessFlatBatchOutput> rpcResult = rpcResultFuture.get();
- Assert.assertFalse(rpcResult.isSuccessful());
- Assert.assertEquals(1, rpcResult.getErrors().size());
- Assert.assertEquals(1, rpcResult.getResult().nonnullBatchFailure().size());
- Assert.assertEquals(3, rpcResult.getResult().nonnullBatchFailure().values().iterator().next()
+ final var rpcResultFuture = processFlatBatch.invoke(batchInput);
+ assertTrue(rpcResultFuture.isDone());
+ final var rpcResult = rpcResultFuture.get();
+ assertFalse(rpcResult.isSuccessful());
+ assertEquals(1, rpcResult.getErrors().size());
+ assertEquals(1, rpcResult.getResult().nonnullBatchFailure().size());
+ assertEquals(3, rpcResult.getResult().nonnullBatchFailure().values().iterator().next()
.getBatchOrder().intValue());
- final InOrder inOrder = Mockito.inOrder(salFlowsBatchService, salGroupsBatchService, salMetersBatchService);
- inOrder.verify(salFlowsBatchService).addFlowsBatch(ArgumentMatchers.any());
- inOrder.verify(salFlowsBatchService).removeFlowsBatch(ArgumentMatchers.any());
- inOrder.verify(salFlowsBatchService).updateFlowsBatch(ArgumentMatchers.any());
- inOrder.verify(salGroupsBatchService).addGroupsBatch(ArgumentMatchers.any());
+ final var inOrder = inOrder(addFlowsBatch, removeFlowsBatch, updateFlowsBatch, addGroupsBatch);
+ inOrder.verify(addFlowsBatch).invoke(any());
+ inOrder.verify(removeFlowsBatch).invoke(any());
+ inOrder.verify(updateFlowsBatch).invoke(any());
+ inOrder.verify(addGroupsBatch).invoke(any());
}
@Test
.setExitOnFirstError(false)
.build();
- final Future<RpcResult<ProcessFlatBatchOutput>> rpcResultFuture =
- salFlatBatchService.processFlatBatch(batchInput);
- Assert.assertTrue(rpcResultFuture.isDone());
+ final var rpcResultFuture = processFlatBatch.invoke(batchInput);
+ assertTrue(rpcResultFuture.isDone());
final RpcResult<ProcessFlatBatchOutput> rpcResult = rpcResultFuture.get();
- Assert.assertFalse(rpcResult.isSuccessful());
- Assert.assertEquals(1, rpcResult.getErrors().size());
- Assert.assertEquals(1, rpcResult.getResult().nonnullBatchFailure().size());
- Assert.assertEquals(3, rpcResult.getResult().nonnullBatchFailure().values().iterator().next()
+ assertFalse(rpcResult.isSuccessful());
+ assertEquals(1, rpcResult.getErrors().size());
+ assertEquals(1, rpcResult.getResult().nonnullBatchFailure().size());
+ assertEquals(3, rpcResult.getResult().nonnullBatchFailure().values().iterator().next()
.getBatchOrder().intValue());
- final InOrder inOrder = Mockito.inOrder(salFlowsBatchService, salGroupsBatchService, salMetersBatchService);
- inOrder.verify(salFlowsBatchService).addFlowsBatch(ArgumentMatchers.any());
- inOrder.verify(salFlowsBatchService).removeFlowsBatch(ArgumentMatchers.any());
- inOrder.verify(salFlowsBatchService).updateFlowsBatch(ArgumentMatchers.any());
+ final var inOrder = inOrder(addFlowsBatch, removeFlowsBatch, updateFlowsBatch, addGroupsBatch,
+ removeGroupsBatch, updateGroupsBatch, addMetersBatch, removeMetersBatch, updateMetersBatch);
+ inOrder.verify(addFlowsBatch).invoke(any());
+ inOrder.verify(removeFlowsBatch).invoke(any());
+ inOrder.verify(updateFlowsBatch).invoke(any());
- inOrder.verify(salGroupsBatchService).addGroupsBatch(ArgumentMatchers.any());
- inOrder.verify(salGroupsBatchService).removeGroupsBatch(ArgumentMatchers.any());
- inOrder.verify(salGroupsBatchService).updateGroupsBatch(ArgumentMatchers.any());
+ inOrder.verify(addGroupsBatch).invoke(any());
+ inOrder.verify(removeGroupsBatch).invoke(any());
+ inOrder.verify(updateGroupsBatch).invoke(any());
- inOrder.verify(salMetersBatchService).addMetersBatch(ArgumentMatchers.any());
- inOrder.verify(salMetersBatchService).removeMetersBatch(ArgumentMatchers.any());
- inOrder.verify(salMetersBatchService).updateMetersBatch(ArgumentMatchers.any());
+ inOrder.verify(addMetersBatch).invoke(any());
+ inOrder.verify(removeMetersBatch).invoke(any());
+ inOrder.verify(updateMetersBatch).invoke(any());
}
private void prepareFirstFailingMockService() {
- Mockito.when(salFlowsBatchService.addFlowsBatch(ArgumentMatchers.any()))
+ when(addFlowsBatch.invoke(any()))
.thenReturn(RpcResultBuilder.success(new AddFlowsBatchOutputBuilder().build()).buildFuture());
- Mockito.when(salFlowsBatchService.removeFlowsBatch(ArgumentMatchers.any()))
+ when(removeFlowsBatch.invoke(any()))
.thenReturn(RpcResultBuilder.<RemoveFlowsBatchOutput>failed()
.withResult(new RemoveFlowsBatchOutputBuilder()
.setBatchFailedFlowsOutput(BindingMap.ordered(
.build())
.withError(ErrorType.APPLICATION, "ut-firstFlowAddError")
.buildFuture());
- Mockito.when(salFlowsBatchService.updateFlowsBatch(ArgumentMatchers.any()))
+ when(updateFlowsBatch.invoke(any()))
.thenReturn(RpcResultBuilder.success(new UpdateFlowsBatchOutputBuilder().build()).buildFuture());
- Mockito.when(salGroupsBatchService.addGroupsBatch(ArgumentMatchers.any()))
+ when(addGroupsBatch.invoke(any()))
.thenReturn(RpcResultBuilder.success(new AddGroupsBatchOutputBuilder().build()).buildFuture());
- Mockito.when(salGroupsBatchService.removeGroupsBatch(ArgumentMatchers.any()))
+ when(removeGroupsBatch.invoke(any()))
.thenReturn(RpcResultBuilder.success(new RemoveGroupsBatchOutputBuilder().build()).buildFuture());
- Mockito.when(salGroupsBatchService.updateGroupsBatch(ArgumentMatchers.any()))
+ when(updateGroupsBatch.invoke(any()))
.thenReturn(RpcResultBuilder.success(new UpdateGroupsBatchOutputBuilder().build()).buildFuture());
- Mockito.when(salMetersBatchService.addMetersBatch(ArgumentMatchers.any()))
+ when(addMetersBatch.invoke(any()))
.thenReturn(RpcResultBuilder.success(new AddMetersBatchOutputBuilder().build()).buildFuture());
- Mockito.when(salMetersBatchService.removeMetersBatch(ArgumentMatchers.any()))
+ when(removeMetersBatch.invoke(any()))
.thenReturn(RpcResultBuilder.success(new RemoveMetersBatchOutputBuilder().build()).buildFuture());
- Mockito.when(salMetersBatchService.updateMetersBatch(ArgumentMatchers.any()))
+ when(updateMetersBatch.invoke(any()))
.thenReturn(RpcResultBuilder.success(new UpdateMetersBatchOutputBuilder().build()).buildFuture());
}
@Test
public void testExecuteBatchPlan() throws Exception {
- BatchStepJob batchStepJob1 = Mockito.mock(BatchStepJob.class);
- BatchStepJob batchStepJob2 = Mockito.mock(BatchStepJob.class);
+ BatchStepJob batchStepJob1 = mock(BatchStepJob.class);
+ BatchStepJob batchStepJob2 = mock(BatchStepJob.class);
AsyncFunction<RpcResult<ProcessFlatBatchOutput>, RpcResult<ProcessFlatBatchOutput>> function1 =
- Mockito.mock(AsyncFunction.class);
+ mock(AsyncFunction.class);
AsyncFunction<RpcResult<ProcessFlatBatchOutput>, RpcResult<ProcessFlatBatchOutput>> function2 =
- Mockito.mock(AsyncFunction.class);
- Mockito.when(batchStepJob1.getStepFunction()).thenReturn(function1);
- Mockito.when(batchStepJob2.getStepFunction()).thenReturn(function2);
+ mock(AsyncFunction.class);
+ when(batchStepJob1.getStepFunction()).thenReturn(function1);
+ when(batchStepJob2.getStepFunction()).thenReturn(function2);
BatchPlanStep batchPlanStep1 = new BatchPlanStep(BatchStepType.GROUP_ADD);
batchPlanStep1.setBarrierAfter(true);
BatchPlanStep batchPlanStep2 = new BatchPlanStep(BatchStepType.FLOW_ADD);
batchPlanStep1.setBarrierAfter(false);
- Mockito.when(batchStepJob1.getPlanStep()).thenReturn(batchPlanStep1);
- Mockito.when(batchStepJob2.getPlanStep()).thenReturn(batchPlanStep2);
+ when(batchStepJob1.getPlanStep()).thenReturn(batchPlanStep1);
+ when(batchStepJob2.getPlanStep()).thenReturn(batchPlanStep2);
final ListenableFuture<RpcResult<ProcessFlatBatchOutput>> succeededChainOutput =
FlatBatchUtil.createEmptyRpcBatchResultFuture(true);
createFlowBatchFailure(Uint16.ONE, "f2")))
.buildFuture();
- Mockito.when(batchStepJob1.getStepFunction().apply(ArgumentMatchers.any()))
- .thenReturn(succeededChainOutput);
- Mockito.when(batchStepJob2.getStepFunction().apply(ArgumentMatchers.any()))
- .thenReturn(failedChainOutput);
+ when(batchStepJob1.getStepFunction().apply(any())).thenReturn(succeededChainOutput);
+ when(batchStepJob2.getStepFunction().apply(any())).thenReturn(failedChainOutput);
final List<BatchStepJob> batchChainElements = Lists.newArrayList(batchStepJob1, batchStepJob2);
- final Future<RpcResult<ProcessFlatBatchOutput>> rpcResultFuture =
- salFlatBatchService.executeBatchPlan(batchChainElements);
+ final var rpcResultFuture = processFlatBatch.executeBatchPlan(batchChainElements);
- Assert.assertTrue(rpcResultFuture.isDone());
- final RpcResult<ProcessFlatBatchOutput> rpcResult = rpcResultFuture.get();
- Assert.assertFalse(rpcResult.isSuccessful());
- Assert.assertEquals(1, rpcResult.getErrors().size());
- Assert.assertEquals(2, rpcResult.getResult().nonnullBatchFailure().size());
+ assertTrue(rpcResultFuture.isDone());
+ final var rpcResult = rpcResultFuture.get();
+ assertFalse(rpcResult.isSuccessful());
+ assertEquals(1, rpcResult.getErrors().size());
+ assertEquals(2, rpcResult.getResult().nonnullBatchFailure().size());
Iterator<BatchFailure> iterator = rpcResult.getResult().nonnullBatchFailure().values().iterator();
//Moving iterator two get second element
iterator.next();
- Assert.assertEquals("f2",
+ assertEquals("f2",
((FlatBatchFailureFlowIdCase) iterator.next().getBatchItemIdChoice())
.getFlowId().getValue());
}
batchPlanStep.getTaskBag().addAll(Lists.newArrayList(flatBatchAddFlow_1, flatBatchAddFlow_2));
final List<BatchPlanStep> batchPlan = Lists.newArrayList(batchPlanStep);
- final List<BatchStepJob> batchChain = salFlatBatchService.prepareBatchChain(batchPlan, NODE_REF, true);
+ final List<BatchStepJob> batchChain = processFlatBatch.prepareBatchChain(batchPlan, NODE_REF, true);
- Assert.assertEquals(1, batchChain.size());
+ assertEquals(1, batchChain.size());
- Mockito.when(salFlowsBatchService.addFlowsBatch(ArgumentMatchers.any()))
+ when(addFlowsBatch.invoke(any()))
.thenReturn(RpcResultBuilder
.success(new AddFlowsBatchOutputBuilder().build())
.buildFuture());
- final Future<RpcResult<ProcessFlatBatchOutput>> rpcResultFuture =
- salFlatBatchService.executeBatchPlan(batchChain);
- Assert.assertTrue(rpcResultFuture.isDone());
- final RpcResult<ProcessFlatBatchOutput> rpcResult = rpcResultFuture.get();
- Assert.assertTrue(rpcResult.isSuccessful());
- Assert.assertEquals(0, rpcResult.getErrors().size());
- Assert.assertEquals(0, rpcResult.getResult().nonnullBatchFailure().size());
+ final var rpcResultFuture = processFlatBatch.executeBatchPlan(batchChain);
+ assertTrue(rpcResultFuture.isDone());
+ final var rpcResult = rpcResultFuture.get();
+ assertTrue(rpcResult.isSuccessful());
+ assertEquals(0, rpcResult.getErrors().size());
+ assertEquals(0, rpcResult.getResult().nonnullBatchFailure().size());
- Mockito.verify(salFlowsBatchService).addFlowsBatch(ArgumentMatchers.any());
+ verify(addFlowsBatch).invoke(any());
}
@Test
final List<BatchPlanStep> batchPlan = Lists.newArrayList(batchPlanStep, batchPlanStep);
- final List<BatchStepJob> batchChain = salFlatBatchService.prepareBatchChain(batchPlan, NODE_REF, true);
+ final List<BatchStepJob> batchChain = processFlatBatch.prepareBatchChain(batchPlan, NODE_REF, true);
- Assert.assertEquals(2, batchChain.size());
+ assertEquals(2, batchChain.size());
- Mockito.when(salFlowsBatchService.addFlowsBatch(ArgumentMatchers.any()))
+ when(addFlowsBatch.invoke(any()))
.thenReturn(RpcResultBuilder
.<AddFlowsBatchOutput>failed()
.withResult(new AddFlowsBatchOutputBuilder()
.withError(ErrorType.APPLICATION, "ut-addFlowBatchError")
.buildFuture());
- final Future<RpcResult<ProcessFlatBatchOutput>> rpcResultFuture =
- salFlatBatchService.executeBatchPlan(batchChain);
- Assert.assertTrue(rpcResultFuture.isDone());
- final RpcResult<ProcessFlatBatchOutput> rpcResult = rpcResultFuture.get();
- Assert.assertFalse(rpcResult.isSuccessful());
- Assert.assertEquals(2, rpcResult.getErrors().size());
- Assert.assertEquals(4, rpcResult.getResult().getBatchFailure().size());
+ final var rpcResultFuture = processFlatBatch.executeBatchPlan(batchChain);
+ assertTrue(rpcResultFuture.isDone());
+ final var rpcResult = rpcResultFuture.get();
+ assertFalse(rpcResult.isSuccessful());
+ assertEquals(2, rpcResult.getErrors().size());
+ assertEquals(4, rpcResult.getResult().getBatchFailure().size());
- Mockito.verify(salFlowsBatchService, Mockito.times(2)).addFlowsBatch(addFlowsBatchInputCpt.capture());
- Assert.assertEquals(2, addFlowsBatchInputCpt.getValue().getBatchAddFlows().size());
+ verify(addFlowsBatch, times(2)).invoke(addFlowsBatchInputCpt.capture());
+ assertEquals(2, addFlowsBatchInputCpt.getValue().nonnullBatchAddFlows().size());
}
}
Code Review / openflowplugin.git / blobdiff