2 * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
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
8 package org.opendaylight.openflowplugin.applications.frsync.impl.strategy;
10 import com.google.common.collect.Lists;
11 import com.google.common.util.concurrent.ListenableFuture;
12 import java.util.Collections;
13 import java.util.HashMap;
14 import java.util.LinkedHashMap;
15 import java.util.List;
17 import java.util.concurrent.Future;
18 import org.junit.Assert;
19 import org.junit.Before;
20 import org.junit.Test;
21 import org.junit.runner.RunWith;
22 import org.mockito.ArgumentCaptor;
23 import org.mockito.ArgumentMatchers;
24 import org.mockito.Captor;
25 import org.mockito.InOrder;
26 import org.mockito.Mock;
27 import org.mockito.Mockito;
28 import org.mockito.junit.MockitoJUnitRunner;
29 import org.mockito.stubbing.Answer;
30 import org.opendaylight.mdsal.binding.api.DataBroker;
31 import org.opendaylight.openflowplugin.applications.frsync.impl.DSInputFactory;
32 import org.opendaylight.openflowplugin.applications.frsync.util.ItemSyncBox;
33 import org.opendaylight.openflowplugin.applications.frsync.util.SyncCrudCounters;
34 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
35 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeBuilder;
36 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.meters.Meter;
37 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.TableBuilder;
38 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.TableKey;
39 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
40 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.AddFlowOutputBuilder;
41 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.RemoveFlowOutputBuilder;
42 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.UpdateFlowOutputBuilder;
43 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.transaction.rev150304.FlowCapableTransactionService;
44 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.transaction.rev150304.SendBarrierOutput;
45 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.AddGroupOutputBuilder;
46 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.RemoveGroupOutputBuilder;
47 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.UpdateGroupOutputBuilder;
48 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.Group;
49 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
50 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
51 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
52 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
53 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.service.rev130918.AddMeterOutputBuilder;
54 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.service.rev130918.RemoveMeterOutputBuilder;
55 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.service.rev130918.UpdateMeterOutputBuilder;
56 import org.opendaylight.yang.gen.v1.urn.opendaylight.table.service.rev131026.UpdateTableOutputBuilder;
57 import org.opendaylight.yang.gen.v1.urn.opendaylight.table.types.rev131026.table.features.TableFeatures;
58 import org.opendaylight.yang.gen.v1.urn.opendaylight.table.types.rev131026.table.features.TableFeaturesBuilder;
59 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
60 import org.opendaylight.yangtools.yang.common.RpcResult;
61 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
62 import org.opendaylight.yangtools.yang.common.Uint32;
63 import org.opendaylight.yangtools.yang.common.Uint8;
66 * Test for {@link SyncPlanPushStrategyIncrementalImpl}.
68 @RunWith(MockitoJUnitRunner.class)
69 public class SyncPlanPushStrategyIncrementalImplTest {
71 private static final NodeId NODE_ID = new NodeId("unit-nodeId");
72 private static final InstanceIdentifier<FlowCapableNode> NODE_IDENT = InstanceIdentifier.create(Nodes.class)
73 .child(Node.class, new NodeKey(NODE_ID)).augmentation(FlowCapableNode.class);
75 private SyncPlanPushStrategyIncrementalImpl syncPlanPushStrategy;
78 private DataBroker db;
80 private GroupForwarder groupCommitter;
82 private FlowForwarder flowCommitter;
84 private MeterForwarder meterCommitter;
86 private TableForwarder tableCommitter;
88 private FlowCapableTransactionService flowCapableTxService;
91 private ArgumentCaptor<Group> groupCaptor;
93 private ArgumentCaptor<Group> groupUpdateCaptor;
95 private ArgumentCaptor<Flow> flowCaptor;
97 private ArgumentCaptor<Flow> flowUpdateCaptor;
99 private ArgumentCaptor<Meter> meterCaptor;
101 private ArgumentCaptor<Meter> meterUpdateCaptor;
103 private ArgumentCaptor<TableFeatures> tableFeaturesCaptor;
105 private SyncCrudCounters counters;
107 private final List<ItemSyncBox<Group>> groupsToAddOrUpdate;
108 private final List<ItemSyncBox<Group>> groupsToRemove;
109 private final ItemSyncBox<Meter> metersToAddOrUpdate;
110 private final ItemSyncBox<Meter> metersToRemove;
111 private final Map<TableKey, ItemSyncBox<Flow>> flowsToAddOrUpdate;
112 private final Map<TableKey, ItemSyncBox<Flow>> flowsToRemove;
114 public SyncPlanPushStrategyIncrementalImplTest() {
115 groupsToAddOrUpdate = Lists.newArrayList(DiffInputFactory.createGroupSyncBox(1, 2, 3),
116 DiffInputFactory.createGroupSyncBoxWithUpdates(4, 5, 6));
117 groupsToRemove = Lists.newArrayList(DiffInputFactory.createGroupSyncBox(1, 2, 3),
118 DiffInputFactory.createGroupSyncBox(4, 5, 6));
120 metersToAddOrUpdate = DiffInputFactory.createMeterSyncBoxWithUpdates(1, 2, 3);
121 metersToRemove = DiffInputFactory.createMeterSyncBox(1, 2, 3);
123 flowsToAddOrUpdate = new HashMap<>();
124 flowsToAddOrUpdate.put(new TableKey(Uint8.ZERO), DiffInputFactory.createFlowSyncBox("1", "2", "3"));
125 flowsToAddOrUpdate.put(new TableKey(Uint8.ONE), DiffInputFactory.createFlowSyncBoxWithUpdates("4", "5", "6"));
126 flowsToRemove = new HashMap<>();
127 flowsToRemove.put(new TableKey(Uint8.ZERO), DiffInputFactory.createFlowSyncBox("1", "2", "3"));
128 flowsToRemove.put(new TableKey(Uint8.ONE), DiffInputFactory.createFlowSyncBox("4", "5", "6"));
132 public void testExecuteSyncStrategy() throws Exception {
133 final SynchronizationDiffInput diffInput = new SynchronizationDiffInput(NODE_IDENT,
134 groupsToAddOrUpdate, metersToAddOrUpdate, flowsToAddOrUpdate, flowsToRemove,
135 metersToRemove, groupsToRemove);
137 final SyncCrudCounters syncCounters = new SyncCrudCounters();
138 final ListenableFuture<RpcResult<Void>> rpcResult = syncPlanPushStrategy.executeSyncStrategy(
139 RpcResultBuilder.<Void>success().buildFuture(), diffInput, syncCounters);
141 Mockito.verify(groupCommitter, Mockito.times(6)).add(ArgumentMatchers.any(),
142 ArgumentMatchers.any(), ArgumentMatchers.any());
143 Mockito.verify(groupCommitter, Mockito.times(3)).update(ArgumentMatchers.any(),
144 ArgumentMatchers.any(), ArgumentMatchers.any(),
145 ArgumentMatchers.any());
146 Mockito.verify(groupCommitter, Mockito.times(6)).remove(ArgumentMatchers.any(),
147 ArgumentMatchers.any(), ArgumentMatchers.any());
148 Mockito.verify(flowCommitter, Mockito.times(6)).add(ArgumentMatchers.any(),
149 ArgumentMatchers.any(), ArgumentMatchers.any());
150 Mockito.verify(flowCommitter, Mockito.times(3)).update(ArgumentMatchers.any(),
151 ArgumentMatchers.any(), ArgumentMatchers.any(),
152 ArgumentMatchers.any());
153 Mockito.verify(flowCommitter, Mockito.times(6)).remove(ArgumentMatchers.any(),
154 ArgumentMatchers.any(), ArgumentMatchers.any());
155 Mockito.verify(meterCommitter, Mockito.times(3)).add(ArgumentMatchers.any(),
156 ArgumentMatchers.any(), ArgumentMatchers.any());
157 Mockito.verify(meterCommitter, Mockito.times(3)).update(ArgumentMatchers.any(),
158 ArgumentMatchers.any(), ArgumentMatchers.any(),
159 ArgumentMatchers.any());
160 Mockito.verify(meterCommitter, Mockito.times(3)).remove(ArgumentMatchers.any(),
161 ArgumentMatchers.any(), ArgumentMatchers.any());
163 Assert.assertTrue(rpcResult.isDone());
164 Assert.assertTrue(rpcResult.get().isSuccessful());
166 Assert.assertEquals(6, syncCounters.getFlowCrudCounts().getAdded());
167 Assert.assertEquals(3, syncCounters.getFlowCrudCounts().getUpdated());
168 Assert.assertEquals(6, syncCounters.getFlowCrudCounts().getRemoved());
170 Assert.assertEquals(6, syncCounters.getGroupCrudCounts().getAdded());
171 Assert.assertEquals(3, syncCounters.getGroupCrudCounts().getUpdated());
172 Assert.assertEquals(6, syncCounters.getGroupCrudCounts().getRemoved());
174 Assert.assertEquals(3, syncCounters.getMeterCrudCounts().getAdded());
175 Assert.assertEquals(3, syncCounters.getMeterCrudCounts().getUpdated());
176 Assert.assertEquals(3, syncCounters.getMeterCrudCounts().getRemoved());
180 public void setUp() {
181 Mockito.when(flowCapableTxService.sendBarrier(ArgumentMatchers.any()))
182 .thenReturn(RpcResultBuilder.success((SendBarrierOutput) null).buildFuture());
184 Mockito.doAnswer(createSalServiceFutureAnswer()).when(groupCommitter).add(
185 ArgumentMatchers.any(), ArgumentMatchers.any(),
186 ArgumentMatchers.any());
187 Mockito.doAnswer(createSalServiceFutureAnswer()).when(groupCommitter).update(
188 ArgumentMatchers.any(), ArgumentMatchers.any(),
189 ArgumentMatchers.any(),
190 ArgumentMatchers.any());
191 Mockito.doAnswer(createSalServiceFutureAnswer()).when(groupCommitter).remove(
192 ArgumentMatchers.any(), ArgumentMatchers.any(),
193 ArgumentMatchers.any());
195 Mockito.doAnswer(createSalServiceFutureAnswer()).when(flowCommitter).add(
196 ArgumentMatchers.any(), ArgumentMatchers.any(),
197 ArgumentMatchers.any());
198 Mockito.doAnswer(createSalServiceFutureAnswer()).when(flowCommitter).update(
199 ArgumentMatchers.any(), ArgumentMatchers.any(),
200 ArgumentMatchers.any(), ArgumentMatchers.any());
201 Mockito.doAnswer(createSalServiceFutureAnswer()).when(flowCommitter).remove(
202 ArgumentMatchers.any(), ArgumentMatchers.any(),
203 ArgumentMatchers.any());
205 Mockito.doAnswer(createSalServiceFutureAnswer()).when(meterCommitter).add(
206 ArgumentMatchers.any(), ArgumentMatchers.any(),
207 ArgumentMatchers.any());
208 Mockito.doAnswer(createSalServiceFutureAnswer()).when(meterCommitter).update(
209 ArgumentMatchers.any(), ArgumentMatchers.any(),
210 ArgumentMatchers.any(), ArgumentMatchers.any());
211 Mockito.doAnswer(createSalServiceFutureAnswer()).when(meterCommitter).remove(
212 ArgumentMatchers.any(), ArgumentMatchers.any(),
213 ArgumentMatchers.any());
215 Mockito.doAnswer(createSalServiceFutureAnswer()).when(tableCommitter).update(
216 ArgumentMatchers.any(), ArgumentMatchers.any(),
217 ArgumentMatchers.any(), ArgumentMatchers.any());
219 syncPlanPushStrategy = new SyncPlanPushStrategyIncrementalImpl()
220 .setMeterForwarder(meterCommitter)
221 .setTableForwarder(tableCommitter)
222 .setGroupForwarder(groupCommitter)
223 .setFlowForwarder(flowCommitter)
224 .setTransactionService(flowCapableTxService);
226 counters = new SyncCrudCounters();
229 private static <O> Answer<Future<RpcResult<O>>> createSalServiceFutureAnswer() {
230 return invocation -> RpcResultBuilder.<O>success().buildFuture();
234 public void testAddMissingFlows() throws Exception {
235 Mockito.when(flowCommitter.add(ArgumentMatchers.any(), flowCaptor.capture(),
236 ArgumentMatchers.same(NODE_IDENT)))
237 .thenReturn(RpcResultBuilder.success(new AddFlowOutputBuilder().build()).buildFuture());
239 final ItemSyncBox<Flow> flowBox = new ItemSyncBox<>();
240 flowBox.getItemsToPush().add(DSInputFactory.createFlow("f3", 3));
241 flowBox.getItemsToPush().add(DSInputFactory.createFlow("f4", 4));
243 final Map<TableKey, ItemSyncBox<Flow>> flowBoxMap = new LinkedHashMap<>();
244 flowBoxMap.put(new TableKey(Uint8.ZERO), flowBox);
246 final ListenableFuture<RpcResult<Void>> result = syncPlanPushStrategy.addMissingFlows(
247 NODE_ID, NODE_IDENT, flowBoxMap, counters);
249 Assert.assertTrue(result.isDone());
250 Assert.assertTrue(result.get().isSuccessful());
252 final List<Flow> flowCaptorAllValues = flowCaptor.getAllValues();
253 Assert.assertEquals(2, flowCaptorAllValues.size());
254 Assert.assertEquals("f3", flowCaptorAllValues.get(0).getId().getValue());
255 Assert.assertEquals("f4", flowCaptorAllValues.get(1).getId().getValue());
257 final InOrder inOrderFlow = Mockito.inOrder(flowCapableTxService, flowCommitter);
258 inOrderFlow.verify(flowCommitter, Mockito.times(2)).add(ArgumentMatchers.any(),
259 ArgumentMatchers.any(), ArgumentMatchers.eq(NODE_IDENT));
260 //TODO: uncomment when enabled in impl
261 // inOrderFlow.verify(flowCapableTxService).sendBarrier(Matchers.<SendBarrierInput>any());
262 inOrderFlow.verifyNoMoreInteractions();
266 public void testRemoveRedundantFlows() throws Exception {
267 Mockito.when(flowCommitter.remove(ArgumentMatchers.any(), flowCaptor.capture(),
268 ArgumentMatchers.same(NODE_IDENT)))
269 .thenReturn(RpcResultBuilder.success(new RemoveFlowOutputBuilder().build()).buildFuture());
271 final ItemSyncBox<Flow> flowBox = new ItemSyncBox<>();
272 flowBox.getItemsToPush().add(DSInputFactory.createFlow("f3", 3));
273 flowBox.getItemsToPush().add(DSInputFactory.createFlow("f4", 4));
275 final Map<TableKey, ItemSyncBox<Flow>> flowBoxMap = new LinkedHashMap<>();
276 flowBoxMap.put(new TableKey(Uint8.ZERO), flowBox);
278 final ListenableFuture<RpcResult<Void>> result = syncPlanPushStrategy.removeRedundantFlows(
279 NODE_ID, NODE_IDENT, flowBoxMap, counters);
281 Assert.assertTrue(result.isDone());
282 Assert.assertTrue(result.get().isSuccessful());
284 final List<Flow> flowCaptorAllValues = flowCaptor.getAllValues();
285 Assert.assertEquals(2, flowCaptorAllValues.size());
286 Assert.assertEquals("f3", flowCaptorAllValues.get(0).getId().getValue());
287 Assert.assertEquals("f4", flowCaptorAllValues.get(1).getId().getValue());
289 final InOrder inOrderFlow = Mockito.inOrder(flowCapableTxService, flowCommitter);
290 inOrderFlow.verify(flowCommitter, Mockito.times(2)).remove(ArgumentMatchers.any(),
291 ArgumentMatchers.any(), ArgumentMatchers.eq(NODE_IDENT));
292 inOrderFlow.verify(flowCapableTxService).sendBarrier(ArgumentMatchers.any());
293 inOrderFlow.verifyNoMoreInteractions();
298 public void testAddMissingFlows_withUpdate() throws Exception {
299 Mockito.when(flowCommitter.add(ArgumentMatchers.any(), flowCaptor.capture(),
300 ArgumentMatchers.same(NODE_IDENT)))
301 .thenReturn(RpcResultBuilder.success(new AddFlowOutputBuilder().build()).buildFuture());
303 Mockito.when(flowCommitter.update(ArgumentMatchers.any(),
304 flowUpdateCaptor.capture(), flowUpdateCaptor.capture(),
305 ArgumentMatchers.same(NODE_IDENT)))
306 .thenReturn(RpcResultBuilder.success(new UpdateFlowOutputBuilder().build()).buildFuture());
308 final ItemSyncBox<Flow> flowBox = new ItemSyncBox<>();
309 flowBox.getItemsToPush().add(DSInputFactory.createFlow("f3", 3));
310 flowBox.getItemsToPush().add(DSInputFactory.createFlow("f4", 4));
311 flowBox.getItemsToUpdate().add(new ItemSyncBox.ItemUpdateTuple<>(
312 DSInputFactory.createFlow("f1", 1), DSInputFactory.createFlowWithInstruction("f1", 1)));
314 final Map<TableKey, ItemSyncBox<Flow>> flowBoxMap = new LinkedHashMap<>();
315 flowBoxMap.put(new TableKey(Uint8.ZERO), flowBox);
319 final ListenableFuture<RpcResult<Void>> result = syncPlanPushStrategy.addMissingFlows(
320 NODE_ID, NODE_IDENT, flowBoxMap, counters);
322 Assert.assertTrue(result.isDone());
323 Assert.assertTrue(result.get().isSuccessful());
325 final List<Flow> flowCaptorAllValues = flowCaptor.getAllValues();
326 Assert.assertEquals(2, flowCaptorAllValues.size());
327 Assert.assertEquals("f3", flowCaptorAllValues.get(0).getId().getValue());
328 Assert.assertEquals("f4", flowCaptorAllValues.get(1).getId().getValue());
330 final List<Flow> flowUpdateCaptorAllValues = flowUpdateCaptor.getAllValues();
331 Assert.assertEquals(2, flowUpdateCaptorAllValues.size());
332 Assert.assertEquals("f1", flowUpdateCaptorAllValues.get(0).getId().getValue());
333 Assert.assertEquals("f1", flowUpdateCaptorAllValues.get(1).getId().getValue());
335 final InOrder inOrderFlow = Mockito.inOrder(flowCapableTxService, flowCommitter);
337 inOrderFlow.verify(flowCommitter, Mockito.times(2)).add(ArgumentMatchers.any(),
338 ArgumentMatchers.any(), ArgumentMatchers.eq(NODE_IDENT));
340 inOrderFlow.verify(flowCommitter).update(ArgumentMatchers.any(),
341 ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.eq(NODE_IDENT));
342 //TODO: uncomment when enabled in impl
343 // inOrderFlow.verify(flowCapableTxService).sendBarrier(Matchers.<SendBarrierInput>any());
345 inOrderFlow.verifyNoMoreInteractions();
349 public void testAddMissingMeters() throws Exception {
350 Mockito.when(meterCommitter.add(ArgumentMatchers.any(), meterCaptor.capture(),
351 ArgumentMatchers.same(NODE_IDENT)))
352 .thenReturn(RpcResultBuilder.success(new AddMeterOutputBuilder().build()).buildFuture());
354 final ItemSyncBox<Meter> meterSyncBox = new ItemSyncBox<>();
355 meterSyncBox.getItemsToPush().add(DSInputFactory.createMeter(Uint32.TWO));
356 meterSyncBox.getItemsToPush().add(DSInputFactory.createMeter(Uint32.valueOf(4L)));
358 final ListenableFuture<RpcResult<Void>> result = syncPlanPushStrategy.addMissingMeters(
359 NODE_ID, NODE_IDENT, meterSyncBox, counters);
361 Assert.assertTrue(result.isDone());
362 Assert.assertTrue(result.get().isSuccessful());
364 final List<Meter> metercaptorAllValues = meterCaptor.getAllValues();
365 Assert.assertEquals(2, metercaptorAllValues.size());
366 Assert.assertEquals(2L, metercaptorAllValues.get(0).getMeterId().getValue().longValue());
367 Assert.assertEquals(4L, metercaptorAllValues.get(1).getMeterId().getValue().longValue());
369 final InOrder inOrderMeter = Mockito.inOrder(flowCapableTxService, meterCommitter);
370 inOrderMeter.verify(meterCommitter, Mockito.times(2)).add(ArgumentMatchers.any(),
371 ArgumentMatchers.any(), ArgumentMatchers.eq(NODE_IDENT));
372 //TODO: uncomment when enabled in impl
373 // inOrderMeter.verify(flowCapableTxService).sendBarrier(Matchers.<SendBarrierInput>any());
374 inOrderMeter.verifyNoMoreInteractions();
378 public void testAddMissingMeters_withUpdate() throws Exception {
379 Mockito.when(meterCommitter.add(ArgumentMatchers.any(), meterCaptor.capture(),
380 ArgumentMatchers.same(NODE_IDENT)))
381 .thenReturn(RpcResultBuilder.success(new AddMeterOutputBuilder().build()).buildFuture());
383 Mockito.when(meterCommitter.update(ArgumentMatchers.any(),
384 meterUpdateCaptor.capture(), meterUpdateCaptor.capture(), ArgumentMatchers.same(NODE_IDENT)))
385 .thenReturn(RpcResultBuilder.success(new UpdateMeterOutputBuilder().build()).buildFuture());
387 final ItemSyncBox<Meter> meterSyncBox = new ItemSyncBox<>();
388 meterSyncBox.getItemsToPush().add(DSInputFactory.createMeter(Uint32.TWO));
389 meterSyncBox.getItemsToPush().add(DSInputFactory.createMeter(Uint32.valueOf(4)));
390 meterSyncBox.getItemsToUpdate().add(new ItemSyncBox.ItemUpdateTuple<>(
391 DSInputFactory.createMeter(Uint32.ONE), DSInputFactory.createMeterWithBody(Uint32.ONE)));
393 final ListenableFuture<RpcResult<Void>> result = syncPlanPushStrategy.addMissingMeters(
394 NODE_ID, NODE_IDENT, meterSyncBox, counters);
396 Assert.assertTrue(result.isDone());
397 Assert.assertTrue(result.get().isSuccessful());
399 final List<Meter> meterCaptorAllValues = meterCaptor.getAllValues();
400 Assert.assertEquals(2, meterCaptorAllValues.size());
401 Assert.assertEquals(2L, meterCaptorAllValues.get(0).getMeterId().getValue().longValue());
402 Assert.assertEquals(4L, meterCaptorAllValues.get(1).getMeterId().getValue().longValue());
405 final List<Meter> meterUpdateCaptorAllValues = meterUpdateCaptor.getAllValues();
406 Assert.assertEquals(2, meterUpdateCaptorAllValues.size());
407 Assert.assertEquals(1L, meterUpdateCaptorAllValues.get(0).getMeterId().getValue().longValue());
408 Assert.assertEquals(1L, meterUpdateCaptorAllValues.get(1).getMeterId().getValue().longValue());
410 final InOrder inOrderMeters = Mockito.inOrder(flowCapableTxService, meterCommitter);
411 inOrderMeters.verify(meterCommitter, Mockito.times(2)).add(ArgumentMatchers.any(),
412 ArgumentMatchers.any(), ArgumentMatchers.eq(NODE_IDENT));
413 inOrderMeters.verify(meterCommitter).update(ArgumentMatchers.any(),
414 ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.eq(NODE_IDENT));
415 //TODO: uncomment when enabled in impl
416 // inOrderMeters.verify(flowCapableTxService).sendBarrier(Matchers.<SendBarrierInput>any());
418 inOrderMeters.verifyNoMoreInteractions();
422 public void testRemoveRedundantMeters() throws Exception {
423 Mockito.when(meterCommitter.remove(ArgumentMatchers.any(), meterCaptor.capture(),
424 ArgumentMatchers.same(NODE_IDENT)))
425 .thenReturn(RpcResultBuilder.success(new RemoveMeterOutputBuilder().build()).buildFuture());
427 final ItemSyncBox<Meter> meterSyncBox = new ItemSyncBox<>();
428 meterSyncBox.getItemsToPush().add(DSInputFactory.createMeter(Uint32.TWO));
429 meterSyncBox.getItemsToPush().add(DSInputFactory.createMeter(Uint32.valueOf(4)));
430 meterSyncBox.getItemsToUpdate().add(new ItemSyncBox.ItemUpdateTuple<>(
431 DSInputFactory.createMeter(Uint32.ONE), DSInputFactory.createMeterWithBody(Uint32.ONE)));
433 final ListenableFuture<RpcResult<Void>> result = syncPlanPushStrategy.removeRedundantMeters(
434 NODE_ID, NODE_IDENT, meterSyncBox, counters);
436 Assert.assertTrue(result.isDone());
437 Assert.assertTrue(result.get().isSuccessful());
439 final List<Meter> metercaptorAllValues = meterCaptor.getAllValues();
440 Assert.assertEquals(2, metercaptorAllValues.size());
441 Assert.assertEquals(2L, metercaptorAllValues.get(0).getMeterId().getValue().longValue());
442 Assert.assertEquals(4L, metercaptorAllValues.get(1).getMeterId().getValue().longValue());
444 final InOrder inOrderMeter = Mockito.inOrder(flowCapableTxService, meterCommitter);
445 inOrderMeter.verify(meterCommitter, Mockito.times(2)).remove(ArgumentMatchers.any(),
446 ArgumentMatchers.any(), ArgumentMatchers.eq(NODE_IDENT));
447 //TODO: uncomment when enabled in impl
448 // inOrderMeter.verify(flowCapableTxService).sendBarrier(Matchers.<SendBarrierInput>any());
449 inOrderMeter.verifyNoMoreInteractions();
453 public void testAddMissingGroups() throws Exception {
454 Mockito.when(groupCommitter.add(ArgumentMatchers.any(), groupCaptor.capture(),
455 ArgumentMatchers.same(NODE_IDENT)))
456 .thenReturn(RpcResultBuilder.success(new AddGroupOutputBuilder().build()).buildFuture());
458 ItemSyncBox<Group> groupBox1 = new ItemSyncBox<>();
459 groupBox1.getItemsToPush().add(DSInputFactory.createGroup(Uint32.TWO));
461 ItemSyncBox<Group> groupBox2 = new ItemSyncBox<>();
462 groupBox2.getItemsToPush().add(DSInputFactory.createGroupWithPreconditions(3L, 2L));
463 groupBox2.getItemsToPush().add(DSInputFactory.createGroupWithPreconditions(4L, 2L));
465 ItemSyncBox<Group> groupBox3 = new ItemSyncBox<>();
466 groupBox3.getItemsToPush().add(DSInputFactory.createGroupWithPreconditions(5L, 3L, 4L));
468 final List<ItemSyncBox<Group>> groupBoxLot = Lists.newArrayList(groupBox1, groupBox2, groupBox3);
470 final ListenableFuture<RpcResult<Void>> result = syncPlanPushStrategy.addMissingGroups(
471 NODE_ID, NODE_IDENT, groupBoxLot, counters);
473 Assert.assertTrue(result.isDone());
474 Assert.assertTrue(result.get().isSuccessful());
476 final List<Group> groupCaptorAllValues = groupCaptor.getAllValues();
477 Assert.assertEquals(4, groupCaptorAllValues.size());
478 Assert.assertEquals(2L, groupCaptorAllValues.get(0).getGroupId().getValue().longValue());
479 Assert.assertEquals(3L, groupCaptorAllValues.get(1).getGroupId().getValue().longValue());
480 Assert.assertEquals(4L, groupCaptorAllValues.get(2).getGroupId().getValue().longValue());
481 Assert.assertEquals(5L, groupCaptorAllValues.get(3).getGroupId().getValue().longValue());
483 final InOrder inOrderGroups = Mockito.inOrder(flowCapableTxService, groupCommitter);
485 inOrderGroups.verify(groupCommitter).add(ArgumentMatchers.any(),
486 ArgumentMatchers.any(), ArgumentMatchers.eq(NODE_IDENT));
487 inOrderGroups.verify(flowCapableTxService).sendBarrier(ArgumentMatchers.any());
489 inOrderGroups.verify(groupCommitter, Mockito.times(2)).add(ArgumentMatchers.any(),
490 ArgumentMatchers.any(), ArgumentMatchers.eq(NODE_IDENT));
491 inOrderGroups.verify(flowCapableTxService).sendBarrier(ArgumentMatchers.any());
493 inOrderGroups.verify(groupCommitter).add(ArgumentMatchers.any(),
494 ArgumentMatchers.any(), ArgumentMatchers.eq(NODE_IDENT));
495 inOrderGroups.verify(flowCapableTxService).sendBarrier(ArgumentMatchers.any());
497 inOrderGroups.verifyNoMoreInteractions();
501 public void testAddMissingGroups_withUpdate() throws Exception {
502 Mockito.when(groupCommitter.add(ArgumentMatchers.any(), groupCaptor.capture(),
503 ArgumentMatchers.same(NODE_IDENT)))
504 .thenReturn(RpcResultBuilder.success(new AddGroupOutputBuilder().build()).buildFuture());
506 Mockito.when(groupCommitter.update(ArgumentMatchers.any(),
507 groupUpdateCaptor.capture(), groupUpdateCaptor.capture(),
508 ArgumentMatchers.same(NODE_IDENT)))
509 .thenReturn(RpcResultBuilder.success(new UpdateGroupOutputBuilder().build()).buildFuture());
511 ItemSyncBox<Group> groupBox1 = new ItemSyncBox<>();
512 groupBox1.getItemsToPush().add(DSInputFactory.createGroup(Uint32.TWO));
513 groupBox1.getItemsToUpdate().add(new ItemSyncBox.ItemUpdateTuple<>(
514 DSInputFactory.createGroup(Uint32.ONE), DSInputFactory.createGroupWithAction(Uint32.ONE)));
516 ItemSyncBox<Group> groupBox2 = new ItemSyncBox<>();
517 groupBox2.getItemsToPush().add(DSInputFactory.createGroupWithPreconditions(3L, 2L));
518 groupBox2.getItemsToPush().add(DSInputFactory.createGroupWithPreconditions(4L, 2L));
520 ItemSyncBox<Group> groupBox3 = new ItemSyncBox<>();
521 groupBox3.getItemsToPush().add(DSInputFactory.createGroupWithPreconditions(5L, 3L, 4L));
523 final List<ItemSyncBox<Group>> groupBoxLot = Lists.newArrayList(groupBox1, groupBox2, groupBox3);
524 final ListenableFuture<RpcResult<Void>> result = syncPlanPushStrategy.addMissingGroups(
525 NODE_ID, NODE_IDENT, groupBoxLot, counters);
527 Assert.assertTrue(result.isDone());
528 Assert.assertTrue(result.get().isSuccessful());
530 final List<Group> groupCaptorAllValues = groupCaptor.getAllValues();
531 Assert.assertEquals(4, groupCaptorAllValues.size());
532 Assert.assertEquals(2L, groupCaptorAllValues.get(0).getGroupId().getValue().longValue());
533 Assert.assertEquals(3L, groupCaptorAllValues.get(1).getGroupId().getValue().longValue());
534 Assert.assertEquals(4L, groupCaptorAllValues.get(2).getGroupId().getValue().longValue());
535 Assert.assertEquals(5L, groupCaptorAllValues.get(3).getGroupId().getValue().longValue());
537 final List<Group> groupUpdateCaptorAllValues = groupUpdateCaptor.getAllValues();
538 Assert.assertEquals(2, groupUpdateCaptorAllValues.size());
539 Assert.assertEquals(1L, groupUpdateCaptorAllValues.get(0).getGroupId().getValue().longValue());
540 Assert.assertEquals(1L, groupUpdateCaptorAllValues.get(1).getGroupId().getValue().longValue());
542 final InOrder inOrderGroups = Mockito.inOrder(flowCapableTxService, groupCommitter);
545 inOrderGroups.verify(groupCommitter).add(ArgumentMatchers.any(),
546 ArgumentMatchers.any(), ArgumentMatchers.eq(NODE_IDENT));
547 inOrderGroups.verify(groupCommitter).update(ArgumentMatchers.any(),
548 ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.eq(NODE_IDENT));
549 inOrderGroups.verify(flowCapableTxService).sendBarrier(ArgumentMatchers.any());
552 inOrderGroups.verify(groupCommitter, Mockito.times(2)).add(ArgumentMatchers.any(),
553 ArgumentMatchers.any(), ArgumentMatchers.eq(NODE_IDENT));
554 inOrderGroups.verify(flowCapableTxService).sendBarrier(ArgumentMatchers.any());
556 inOrderGroups.verify(groupCommitter).add(ArgumentMatchers.any(),
557 ArgumentMatchers.any(), ArgumentMatchers.eq(NODE_IDENT));
558 inOrderGroups.verify(flowCapableTxService).sendBarrier(ArgumentMatchers.any());
560 inOrderGroups.verifyNoMoreInteractions();
564 public void testRemoveRedundantGroups() throws Exception {
565 Mockito.when(groupCommitter.remove(ArgumentMatchers.any(), groupCaptor.capture(),
566 ArgumentMatchers.same(NODE_IDENT)))
567 .thenReturn(RpcResultBuilder.success(new RemoveGroupOutputBuilder().build()).buildFuture());
569 ItemSyncBox<Group> groupBox1 = new ItemSyncBox<>();
570 groupBox1.getItemsToPush().add(DSInputFactory.createGroup(Uint32.TWO));
571 groupBox1.getItemsToUpdate().add(new ItemSyncBox.ItemUpdateTuple<>(
572 DSInputFactory.createGroup(Uint32.ONE), DSInputFactory.createGroupWithAction(Uint32.ONE)));
574 ItemSyncBox<Group> groupBox2 = new ItemSyncBox<>();
575 groupBox2.getItemsToPush().add(DSInputFactory.createGroupWithPreconditions(3L, 2L));
576 groupBox2.getItemsToPush().add(DSInputFactory.createGroupWithPreconditions(4L, 2L));
578 ItemSyncBox<Group> groupBox3 = new ItemSyncBox<>();
579 groupBox3.getItemsToPush().add(DSInputFactory.createGroupWithPreconditions(5L, 3L, 4L));
581 final List<ItemSyncBox<Group>> groupBoxLot = Lists.newArrayList(groupBox1, groupBox2, groupBox3);
582 final ListenableFuture<RpcResult<Void>> result = syncPlanPushStrategy.removeRedundantGroups(
583 NODE_ID, NODE_IDENT, groupBoxLot, counters);
585 Assert.assertTrue(result.isDone());
586 Assert.assertTrue(result.get().isSuccessful());
588 final List<Group> groupCaptorAllValues = groupCaptor.getAllValues();
589 Assert.assertEquals(4, groupCaptorAllValues.size());
590 Assert.assertEquals(5L, groupCaptorAllValues.get(0).getGroupId().getValue().longValue());
591 Assert.assertEquals(3L, groupCaptorAllValues.get(1).getGroupId().getValue().longValue());
592 Assert.assertEquals(4L, groupCaptorAllValues.get(2).getGroupId().getValue().longValue());
593 Assert.assertEquals(2L, groupCaptorAllValues.get(3).getGroupId().getValue().longValue());
595 final InOrder inOrderGroup = Mockito.inOrder(flowCapableTxService, groupCommitter);
597 inOrderGroup.verify(groupCommitter).remove(ArgumentMatchers.any(),
598 ArgumentMatchers.any(), ArgumentMatchers.eq(NODE_IDENT));
599 inOrderGroup.verify(flowCapableTxService).sendBarrier(ArgumentMatchers.any());
601 inOrderGroup.verify(groupCommitter, Mockito.times(2)).remove(ArgumentMatchers.any(),
602 ArgumentMatchers.any(), ArgumentMatchers.eq(NODE_IDENT));
603 inOrderGroup.verify(flowCapableTxService).sendBarrier(ArgumentMatchers.any());
605 inOrderGroup.verify(groupCommitter).remove(ArgumentMatchers.any(),
606 ArgumentMatchers.any(), ArgumentMatchers.eq(NODE_IDENT));
607 inOrderGroup.verify(flowCapableTxService).sendBarrier(ArgumentMatchers.any());
609 inOrderGroup.verifyNoMoreInteractions();
613 public void testUpdateTableFeatures() throws Exception {
614 Mockito.lenient().when(tableCommitter.update(ArgumentMatchers.any(), ArgumentMatchers.isNull(),
615 tableFeaturesCaptor.capture(), ArgumentMatchers.same(NODE_IDENT)))
616 .thenReturn(RpcResultBuilder.success(new UpdateTableOutputBuilder().build()).buildFuture());
618 final FlowCapableNode operational = new FlowCapableNodeBuilder()
619 .setTable(Collections.singletonList(new TableBuilder()
622 .setTableFeatures(Collections.singletonList(new TableFeaturesBuilder()
623 .setName("test table features")
624 .setTableId(Uint8.ONE)
628 final ListenableFuture<RpcResult<Void>> result = syncPlanPushStrategy.updateTableFeatures(
629 NODE_IDENT, operational);
631 Assert.assertTrue(result.isDone());
632 Assert.assertTrue(result.get().isSuccessful());
634 final List<TableFeatures> groupCaptorAllValues = tableFeaturesCaptor.getAllValues();
635 //TODO: uncomment when enabled in impl
636 // Assert.assertEquals(1, groupCaptorAllValues.size());
637 // Assert.assertEquals("test table features", groupCaptorAllValues.get(0).getName());
638 // Assert.assertEquals(1, groupCaptorAllValues.get(0).getTableId().intValue());
640 Mockito.verify(flowCapableTxService).sendBarrier(ArgumentMatchers.any());