applications/forwardingrules-sync/src/test/java/org/opendaylight/openflowplugin/applications/frsync/impl/strategy/SyncPlanPushStrategyIncrementalImplTest.java

   1 /*
   2  * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
   3  *
   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
   7  */
   8 package org.opendaylight.openflowplugin.applications.frsync.impl.strategy;
   9
  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;
  16 import java.util.Map;
  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
  63 /**
  64  * Test for {@link SyncPlanPushStrategyIncrementalImpl}.
  65  */
  66 @RunWith(MockitoJUnitRunner.class)
  67 public class SyncPlanPushStrategyIncrementalImplTest {
  68
  69     private static final NodeId NODE_ID = new NodeId("unit-nodeId");
  70     private static final InstanceIdentifier<FlowCapableNode> NODE_IDENT = InstanceIdentifier.create(Nodes.class)
  71             .child(Node.class, new NodeKey(NODE_ID)).augmentation(FlowCapableNode.class);
  72
  73     private SyncPlanPushStrategyIncrementalImpl syncPlanPushStrategy;
  74
  75     @Mock
  76     private DataBroker db;
  77     @Mock
  78     private GroupForwarder groupCommitter;
  79     @Mock
  80     private FlowForwarder flowCommitter;
  81     @Mock
  82     private MeterForwarder meterCommitter;
  83     @Mock
  84     private TableForwarder tableCommitter;
  85     @Mock
  86     private FlowCapableTransactionService flowCapableTxService;
  87
  88     @Captor
  89     private ArgumentCaptor<Group> groupCaptor;
  90     @Captor
  91     private ArgumentCaptor<Group> groupUpdateCaptor;
  92     @Captor
  93     private ArgumentCaptor<Flow> flowCaptor;
  94     @Captor
  95     private ArgumentCaptor<Flow> flowUpdateCaptor;
  96     @Captor
  97     private ArgumentCaptor<Meter> meterCaptor;
  98     @Captor
  99     private ArgumentCaptor<Meter> meterUpdateCaptor;
 100     @Captor
 101     private ArgumentCaptor<TableFeatures> tableFeaturesCaptor;
 102
 103     private SyncCrudCounters counters;
 104
 105     private final List<ItemSyncBox<Group>> groupsToAddOrUpdate;
 106     private final List<ItemSyncBox<Group>> groupsToRemove;
 107     private final ItemSyncBox<Meter> metersToAddOrUpdate;
 108     private final ItemSyncBox<Meter> metersToRemove;
 109     private final Map<TableKey, ItemSyncBox<Flow>> flowsToAddOrUpdate;
 110     private final Map<TableKey, ItemSyncBox<Flow>> flowsToRemove;
 111
 112     public SyncPlanPushStrategyIncrementalImplTest() {
 113         groupsToAddOrUpdate = Lists.newArrayList(DiffInputFactory.createGroupSyncBox(1, 2, 3),
 114                 DiffInputFactory.createGroupSyncBoxWithUpdates(4, 5, 6));
 115         groupsToRemove = Lists.newArrayList(DiffInputFactory.createGroupSyncBox(1, 2, 3),
 116                 DiffInputFactory.createGroupSyncBox(4, 5, 6));
 117
 118         metersToAddOrUpdate = DiffInputFactory.createMeterSyncBoxWithUpdates(1, 2, 3);
 119         metersToRemove = DiffInputFactory.createMeterSyncBox(1, 2, 3);
 120
 121         flowsToAddOrUpdate = new HashMap<>();
 122         flowsToAddOrUpdate.put(new TableKey((short) 0), DiffInputFactory.createFlowSyncBox("1", "2", "3"));
 123         flowsToAddOrUpdate.put(new TableKey((short) 1), DiffInputFactory.createFlowSyncBoxWithUpdates("4", "5", "6"));
 124         flowsToRemove = new HashMap<>();
 125         flowsToRemove.put(new TableKey((short) 0), DiffInputFactory.createFlowSyncBox("1", "2", "3"));
 126         flowsToRemove.put(new TableKey((short) 1), DiffInputFactory.createFlowSyncBox("4", "5", "6"));
 127     }
 128
 129     @Test
 130     public void testExecuteSyncStrategy() throws Exception {
 131         final SynchronizationDiffInput diffInput = new SynchronizationDiffInput(NODE_IDENT,
 132                 groupsToAddOrUpdate, metersToAddOrUpdate, flowsToAddOrUpdate, flowsToRemove,
 133                 metersToRemove, groupsToRemove);
 134
 135         final SyncCrudCounters syncCounters = new SyncCrudCounters();
 136         final ListenableFuture<RpcResult<Void>> rpcResult = syncPlanPushStrategy.executeSyncStrategy(
 137                 RpcResultBuilder.<Void>success().buildFuture(), diffInput, syncCounters);
 138
 139         Mockito.verify(groupCommitter, Mockito.times(6)).add(ArgumentMatchers.any(),
 140                 ArgumentMatchers.any(), ArgumentMatchers.any());
 141         Mockito.verify(groupCommitter, Mockito.times(3)).update(ArgumentMatchers.any(),
 142                 ArgumentMatchers.any(), ArgumentMatchers.any(),
 143                 ArgumentMatchers.any());
 144         Mockito.verify(groupCommitter, Mockito.times(6)).remove(ArgumentMatchers.any(),
 145                 ArgumentMatchers.any(), ArgumentMatchers.any());
 146         Mockito.verify(flowCommitter, Mockito.times(6)).add(ArgumentMatchers.any(),
 147                 ArgumentMatchers.any(), ArgumentMatchers.any());
 148         Mockito.verify(flowCommitter, Mockito.times(3)).update(ArgumentMatchers.any(),
 149                 ArgumentMatchers.any(), ArgumentMatchers.any(),
 150                 ArgumentMatchers.any());
 151         Mockito.verify(flowCommitter, Mockito.times(6)).remove(ArgumentMatchers.any(),
 152                 ArgumentMatchers.any(), ArgumentMatchers.any());
 153         Mockito.verify(meterCommitter, Mockito.times(3)).add(ArgumentMatchers.any(),
 154                 ArgumentMatchers.any(), ArgumentMatchers.any());
 155         Mockito.verify(meterCommitter, Mockito.times(3)).update(ArgumentMatchers.any(),
 156                 ArgumentMatchers.any(), ArgumentMatchers.any(),
 157                 ArgumentMatchers.any());
 158         Mockito.verify(meterCommitter, Mockito.times(3)).remove(ArgumentMatchers.any(),
 159                 ArgumentMatchers.any(), ArgumentMatchers.any());
 160
 161         Assert.assertTrue(rpcResult.isDone());
 162         Assert.assertTrue(rpcResult.get().isSuccessful());
 163
 164         Assert.assertEquals(6, syncCounters.getFlowCrudCounts().getAdded());
 165         Assert.assertEquals(3, syncCounters.getFlowCrudCounts().getUpdated());
 166         Assert.assertEquals(6, syncCounters.getFlowCrudCounts().getRemoved());
 167
 168         Assert.assertEquals(6, syncCounters.getGroupCrudCounts().getAdded());
 169         Assert.assertEquals(3, syncCounters.getGroupCrudCounts().getUpdated());
 170         Assert.assertEquals(6, syncCounters.getGroupCrudCounts().getRemoved());
 171
 172         Assert.assertEquals(3, syncCounters.getMeterCrudCounts().getAdded());
 173         Assert.assertEquals(3, syncCounters.getMeterCrudCounts().getUpdated());
 174         Assert.assertEquals(3, syncCounters.getMeterCrudCounts().getRemoved());
 175     }
 176
 177     @Before
 178     public void setUp() {
 179         Mockito.when(flowCapableTxService.sendBarrier(ArgumentMatchers.any()))
 180                 .thenReturn(RpcResultBuilder.success((SendBarrierOutput) null).buildFuture());
 181
 182         Mockito.doAnswer(createSalServiceFutureAnswer()).when(groupCommitter).add(
 183                 ArgumentMatchers.any(), ArgumentMatchers.any(),
 184                 ArgumentMatchers.any());
 185         Mockito.doAnswer(createSalServiceFutureAnswer()).when(groupCommitter).update(
 186                 ArgumentMatchers.any(), ArgumentMatchers.any(),
 187                 ArgumentMatchers.any(),
 188                 ArgumentMatchers.any());
 189         Mockito.doAnswer(createSalServiceFutureAnswer()).when(groupCommitter).remove(
 190                 ArgumentMatchers.any(), ArgumentMatchers.any(),
 191                 ArgumentMatchers.any());
 192
 193         Mockito.doAnswer(createSalServiceFutureAnswer()).when(flowCommitter).add(
 194                 ArgumentMatchers.any(), ArgumentMatchers.any(),
 195                 ArgumentMatchers.any());
 196         Mockito.doAnswer(createSalServiceFutureAnswer()).when(flowCommitter).update(
 197                 ArgumentMatchers.any(), ArgumentMatchers.any(),
 198                 ArgumentMatchers.any(), ArgumentMatchers.any());
 199         Mockito.doAnswer(createSalServiceFutureAnswer()).when(flowCommitter).remove(
 200                 ArgumentMatchers.any(), ArgumentMatchers.any(),
 201                 ArgumentMatchers.any());
 202
 203         Mockito.doAnswer(createSalServiceFutureAnswer()).when(meterCommitter).add(
 204                 ArgumentMatchers.any(), ArgumentMatchers.any(),
 205                 ArgumentMatchers.any());
 206         Mockito.doAnswer(createSalServiceFutureAnswer()).when(meterCommitter).update(
 207                 ArgumentMatchers.any(), ArgumentMatchers.any(),
 208                 ArgumentMatchers.any(), ArgumentMatchers.any());
 209         Mockito.doAnswer(createSalServiceFutureAnswer()).when(meterCommitter).remove(
 210                 ArgumentMatchers.any(), ArgumentMatchers.any(),
 211                 ArgumentMatchers.any());
 212
 213         Mockito.doAnswer(createSalServiceFutureAnswer()).when(tableCommitter).update(
 214                 ArgumentMatchers.any(), ArgumentMatchers.any(),
 215                 ArgumentMatchers.any(), ArgumentMatchers.any());
 216
 217         syncPlanPushStrategy = new SyncPlanPushStrategyIncrementalImpl()
 218                 .setMeterForwarder(meterCommitter)
 219                 .setTableForwarder(tableCommitter)
 220                 .setGroupForwarder(groupCommitter)
 221                 .setFlowForwarder(flowCommitter)
 222                 .setTransactionService(flowCapableTxService);
 223
 224         counters = new SyncCrudCounters();
 225     }
 226
 227     private <O> Answer<Future<RpcResult<O>>> createSalServiceFutureAnswer() {
 228         return invocation -> RpcResultBuilder.<O>success().buildFuture();
 229     }
 230
 231     @Test
 232     public void testAddMissingFlows() throws Exception {
 233         Mockito.when(flowCommitter.add(ArgumentMatchers.any(), flowCaptor.capture(),
 234                 ArgumentMatchers.same(NODE_IDENT)))
 235                 .thenReturn(RpcResultBuilder.success(new AddFlowOutputBuilder().build()).buildFuture());
 236
 237         final ItemSyncBox<Flow> flowBox = new ItemSyncBox<>();
 238         flowBox.getItemsToPush().add(DSInputFactory.createFlow("f3", 3));
 239         flowBox.getItemsToPush().add(DSInputFactory.createFlow("f4", 4));
 240
 241         final Map<TableKey, ItemSyncBox<Flow>> flowBoxMap = new LinkedHashMap<>();
 242         flowBoxMap.put(new TableKey((short) 0), flowBox);
 243
 244         final ListenableFuture<RpcResult<Void>> result = syncPlanPushStrategy.addMissingFlows(
 245                 NODE_ID, NODE_IDENT, flowBoxMap, counters);
 246
 247         Assert.assertTrue(result.isDone());
 248         Assert.assertTrue(result.get().isSuccessful());
 249
 250         final List<Flow> flowCaptorAllValues = flowCaptor.getAllValues();
 251         Assert.assertEquals(2, flowCaptorAllValues.size());
 252         Assert.assertEquals("f3", flowCaptorAllValues.get(0).getId().getValue());
 253         Assert.assertEquals("f4", flowCaptorAllValues.get(1).getId().getValue());
 254
 255         final InOrder inOrderFlow = Mockito.inOrder(flowCapableTxService, flowCommitter);
 256         inOrderFlow.verify(flowCommitter, Mockito.times(2)).add(ArgumentMatchers.any(),
 257                 ArgumentMatchers.any(), ArgumentMatchers.eq(NODE_IDENT));
 258         //TODO: uncomment when enabled in impl
 259 //        inOrderFlow.verify(flowCapableTxService).sendBarrier(Matchers.<SendBarrierInput>any());
 260         inOrderFlow.verifyNoMoreInteractions();
 261     }
 262
 263     @Test
 264     public void testRemoveRedundantFlows() throws Exception {
 265         Mockito.when(flowCommitter.remove(ArgumentMatchers.any(), flowCaptor.capture(),
 266                 ArgumentMatchers.same(NODE_IDENT)))
 267                 .thenReturn(RpcResultBuilder.success(new RemoveFlowOutputBuilder().build()).buildFuture());
 268
 269         final ItemSyncBox<Flow> flowBox = new ItemSyncBox<>();
 270         flowBox.getItemsToPush().add(DSInputFactory.createFlow("f3", 3));
 271         flowBox.getItemsToPush().add(DSInputFactory.createFlow("f4", 4));
 272
 273         final Map<TableKey, ItemSyncBox<Flow>> flowBoxMap = new LinkedHashMap<>();
 274         flowBoxMap.put(new TableKey((short) 0), flowBox);
 275
 276         final ListenableFuture<RpcResult<Void>> result = syncPlanPushStrategy.removeRedundantFlows(
 277                 NODE_ID, NODE_IDENT, flowBoxMap, counters);
 278
 279         Assert.assertTrue(result.isDone());
 280         Assert.assertTrue(result.get().isSuccessful());
 281
 282         final List<Flow> flowCaptorAllValues = flowCaptor.getAllValues();
 283         Assert.assertEquals(2, flowCaptorAllValues.size());
 284         Assert.assertEquals("f3", flowCaptorAllValues.get(0).getId().getValue());
 285         Assert.assertEquals("f4", flowCaptorAllValues.get(1).getId().getValue());
 286
 287         final InOrder inOrderFlow = Mockito.inOrder(flowCapableTxService, flowCommitter);
 288         inOrderFlow.verify(flowCommitter, Mockito.times(2)).remove(ArgumentMatchers.any(),
 289                 ArgumentMatchers.any(), ArgumentMatchers.eq(NODE_IDENT));
 290         inOrderFlow.verify(flowCapableTxService).sendBarrier(ArgumentMatchers.any());
 291         inOrderFlow.verifyNoMoreInteractions();
 292     }
 293
 294
 295     @Test
 296     public void testAddMissingFlows_withUpdate() throws Exception {
 297         Mockito.when(flowCommitter.add(ArgumentMatchers.any(), flowCaptor.capture(),
 298                 ArgumentMatchers.same(NODE_IDENT)))
 299                 .thenReturn(RpcResultBuilder.success(new AddFlowOutputBuilder().build()).buildFuture());
 300
 301         Mockito.when(flowCommitter.update(ArgumentMatchers.any(),
 302                 flowUpdateCaptor.capture(), flowUpdateCaptor.capture(),
 303                 ArgumentMatchers.same(NODE_IDENT)))
 304                 .thenReturn(RpcResultBuilder.success(new UpdateFlowOutputBuilder().build()).buildFuture());
 305
 306         final ItemSyncBox<Flow> flowBox = new ItemSyncBox<>();
 307         flowBox.getItemsToPush().add(DSInputFactory.createFlow("f3", 3));
 308         flowBox.getItemsToPush().add(DSInputFactory.createFlow("f4", 4));
 309         flowBox.getItemsToUpdate().add(new ItemSyncBox.ItemUpdateTuple<>(
 310                 DSInputFactory.createFlow("f1", 1), DSInputFactory.createFlowWithInstruction("f1", 1)));
 311
 312         final Map<TableKey, ItemSyncBox<Flow>> flowBoxMap = new LinkedHashMap<>();
 313         flowBoxMap.put(new TableKey((short) 0), flowBox);
 314
 315
 316         //TODO: replace null
 317         final ListenableFuture<RpcResult<Void>> result = syncPlanPushStrategy.addMissingFlows(
 318                 NODE_ID, NODE_IDENT, flowBoxMap, counters);
 319
 320         Assert.assertTrue(result.isDone());
 321         Assert.assertTrue(result.get().isSuccessful());
 322
 323         final List<Flow> flowCaptorAllValues = flowCaptor.getAllValues();
 324         Assert.assertEquals(2, flowCaptorAllValues.size());
 325         Assert.assertEquals("f3", flowCaptorAllValues.get(0).getId().getValue());
 326         Assert.assertEquals("f4", flowCaptorAllValues.get(1).getId().getValue());
 327
 328         final List<Flow> flowUpdateCaptorAllValues = flowUpdateCaptor.getAllValues();
 329         Assert.assertEquals(2, flowUpdateCaptorAllValues.size());
 330         Assert.assertEquals("f1", flowUpdateCaptorAllValues.get(0).getId().getValue());
 331         Assert.assertEquals("f1", flowUpdateCaptorAllValues.get(1).getId().getValue());
 332
 333         final InOrder inOrderFlow = Mockito.inOrder(flowCapableTxService, flowCommitter);
 334         // add f3, f4
 335         inOrderFlow.verify(flowCommitter, Mockito.times(2)).add(ArgumentMatchers.any(),
 336                 ArgumentMatchers.any(), ArgumentMatchers.eq(NODE_IDENT));
 337         // update f1
 338         inOrderFlow.verify(flowCommitter).update(ArgumentMatchers.any(),
 339                 ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.eq(NODE_IDENT));
 340         //TODO: uncomment when enabled in impl
 341 //        inOrderFlow.verify(flowCapableTxService).sendBarrier(Matchers.<SendBarrierInput>any());
 342
 343         inOrderFlow.verifyNoMoreInteractions();
 344     }
 345
 346     @Test
 347     public void testAddMissingMeters() throws Exception {
 348         Mockito.when(meterCommitter.add(ArgumentMatchers.any(), meterCaptor.capture(),
 349                 ArgumentMatchers.same(NODE_IDENT)))
 350                 .thenReturn(RpcResultBuilder.success(new AddMeterOutputBuilder().build()).buildFuture());
 351
 352         final ItemSyncBox<Meter> meterSyncBox = new ItemSyncBox<>();
 353         meterSyncBox.getItemsToPush().add(DSInputFactory.createMeter(2L));
 354         meterSyncBox.getItemsToPush().add(DSInputFactory.createMeter(4L));
 355
 356         final ListenableFuture<RpcResult<Void>> result = syncPlanPushStrategy.addMissingMeters(
 357                 NODE_ID, NODE_IDENT, meterSyncBox, counters);
 358
 359         Assert.assertTrue(result.isDone());
 360         Assert.assertTrue(result.get().isSuccessful());
 361
 362         final List<Meter> metercaptorAllValues = meterCaptor.getAllValues();
 363         Assert.assertEquals(2, metercaptorAllValues.size());
 364         Assert.assertEquals(2L, metercaptorAllValues.get(0).getMeterId().getValue().longValue());
 365         Assert.assertEquals(4L, metercaptorAllValues.get(1).getMeterId().getValue().longValue());
 366
 367         final InOrder inOrderMeter = Mockito.inOrder(flowCapableTxService, meterCommitter);
 368         inOrderMeter.verify(meterCommitter, Mockito.times(2)).add(ArgumentMatchers.any(),
 369                 ArgumentMatchers.any(), ArgumentMatchers.eq(NODE_IDENT));
 370         //TODO: uncomment when enabled in impl
 371 //        inOrderMeter.verify(flowCapableTxService).sendBarrier(Matchers.<SendBarrierInput>any());
 372         inOrderMeter.verifyNoMoreInteractions();
 373     }
 374
 375     @Test
 376     public void testAddMissingMeters_withUpdate() throws Exception {
 377         Mockito.when(meterCommitter.add(ArgumentMatchers.any(), meterCaptor.capture(),
 378                 ArgumentMatchers.same(NODE_IDENT)))
 379                 .thenReturn(RpcResultBuilder.success(new AddMeterOutputBuilder().build()).buildFuture());
 380
 381         Mockito.when(meterCommitter.update(ArgumentMatchers.any(),
 382                 meterUpdateCaptor.capture(), meterUpdateCaptor.capture(), ArgumentMatchers.same(NODE_IDENT)))
 383                 .thenReturn(RpcResultBuilder.success(new UpdateMeterOutputBuilder().build()).buildFuture());
 384
 385         final ItemSyncBox<Meter> meterSyncBox = new ItemSyncBox<>();
 386         meterSyncBox.getItemsToPush().add(DSInputFactory.createMeter(2L));
 387         meterSyncBox.getItemsToPush().add(DSInputFactory.createMeter(4L));
 388         meterSyncBox.getItemsToUpdate().add(new ItemSyncBox.ItemUpdateTuple<>(
 389                 DSInputFactory.createMeter(1L), DSInputFactory.createMeterWithBody(1L)));
 390
 391         final ListenableFuture<RpcResult<Void>> result = syncPlanPushStrategy.addMissingMeters(
 392                 NODE_ID, NODE_IDENT, meterSyncBox, counters);
 393
 394         Assert.assertTrue(result.isDone());
 395         Assert.assertTrue(result.get().isSuccessful());
 396
 397         final List<Meter> meterCaptorAllValues = meterCaptor.getAllValues();
 398         Assert.assertEquals(2, meterCaptorAllValues.size());
 399         Assert.assertEquals(2L, meterCaptorAllValues.get(0).getMeterId().getValue().longValue());
 400         Assert.assertEquals(4L, meterCaptorAllValues.get(1).getMeterId().getValue().longValue());
 401
 402
 403         final List<Meter> meterUpdateCaptorAllValues = meterUpdateCaptor.getAllValues();
 404         Assert.assertEquals(2, meterUpdateCaptorAllValues.size());
 405         Assert.assertEquals(1L, meterUpdateCaptorAllValues.get(0).getMeterId().getValue().longValue());
 406         Assert.assertEquals(1L, meterUpdateCaptorAllValues.get(1).getMeterId().getValue().longValue());
 407
 408         final InOrder inOrderMeters = Mockito.inOrder(flowCapableTxService, meterCommitter);
 409         inOrderMeters.verify(meterCommitter, Mockito.times(2)).add(ArgumentMatchers.any(),
 410                 ArgumentMatchers.any(), ArgumentMatchers.eq(NODE_IDENT));
 411         inOrderMeters.verify(meterCommitter).update(ArgumentMatchers.any(),
 412                 ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.eq(NODE_IDENT));
 413         //TODO: uncomment when enabled in impl
 414 //        inOrderMeters.verify(flowCapableTxService).sendBarrier(Matchers.<SendBarrierInput>any());
 415
 416         inOrderMeters.verifyNoMoreInteractions();
 417     }
 418
 419     @Test
 420     public void testRemoveRedundantMeters() throws Exception {
 421         Mockito.when(meterCommitter.remove(ArgumentMatchers.any(), meterCaptor.capture(),
 422                 ArgumentMatchers.same(NODE_IDENT)))
 423                 .thenReturn(RpcResultBuilder.success(new RemoveMeterOutputBuilder().build()).buildFuture());
 424
 425         final ItemSyncBox<Meter> meterSyncBox = new ItemSyncBox<>();
 426         meterSyncBox.getItemsToPush().add(DSInputFactory.createMeter(2L));
 427         meterSyncBox.getItemsToPush().add(DSInputFactory.createMeter(4L));
 428         meterSyncBox.getItemsToUpdate().add(new ItemSyncBox.ItemUpdateTuple<>(
 429                 DSInputFactory.createMeter(1L), DSInputFactory.createMeterWithBody(1L)));
 430
 431         final ListenableFuture<RpcResult<Void>> result = syncPlanPushStrategy.removeRedundantMeters(
 432                 NODE_ID, NODE_IDENT, meterSyncBox, counters);
 433
 434         Assert.assertTrue(result.isDone());
 435         Assert.assertTrue(result.get().isSuccessful());
 436
 437         final List<Meter> metercaptorAllValues = meterCaptor.getAllValues();
 438         Assert.assertEquals(2, metercaptorAllValues.size());
 439         Assert.assertEquals(2L, metercaptorAllValues.get(0).getMeterId().getValue().longValue());
 440         Assert.assertEquals(4L, metercaptorAllValues.get(1).getMeterId().getValue().longValue());
 441
 442         final InOrder inOrderMeter = Mockito.inOrder(flowCapableTxService, meterCommitter);
 443         inOrderMeter.verify(meterCommitter, Mockito.times(2)).remove(ArgumentMatchers.any(),
 444                 ArgumentMatchers.any(), ArgumentMatchers.eq(NODE_IDENT));
 445         //TODO: uncomment when enabled in impl
 446 //        inOrderMeter.verify(flowCapableTxService).sendBarrier(Matchers.<SendBarrierInput>any());
 447         inOrderMeter.verifyNoMoreInteractions();
 448     }
 449
 450     @Test
 451     public void testAddMissingGroups() throws Exception {
 452         Mockito.when(groupCommitter.add(ArgumentMatchers.any(), groupCaptor.capture(),
 453                 ArgumentMatchers.same(NODE_IDENT)))
 454                 .thenReturn(RpcResultBuilder.success(new AddGroupOutputBuilder().build()).buildFuture());
 455
 456         ItemSyncBox<Group> groupBox1 = new ItemSyncBox<>();
 457         groupBox1.getItemsToPush().add(DSInputFactory.createGroup(2L));
 458
 459         ItemSyncBox<Group> groupBox2 = new ItemSyncBox<>();
 460         groupBox2.getItemsToPush().add(DSInputFactory.createGroupWithPreconditions(3L, 2L));
 461         groupBox2.getItemsToPush().add(DSInputFactory.createGroupWithPreconditions(4L, 2L));
 462
 463         ItemSyncBox<Group> groupBox3 = new ItemSyncBox<>();
 464         groupBox3.getItemsToPush().add(DSInputFactory.createGroupWithPreconditions(5L, 3L, 4L));
 465
 466         final List<ItemSyncBox<Group>> groupBoxLot = Lists.newArrayList(groupBox1, groupBox2, groupBox3);
 467
 468         final ListenableFuture<RpcResult<Void>> result = syncPlanPushStrategy.addMissingGroups(
 469                 NODE_ID, NODE_IDENT, groupBoxLot, counters);
 470
 471         Assert.assertTrue(result.isDone());
 472         Assert.assertTrue(result.get().isSuccessful());
 473
 474         final List<Group> groupCaptorAllValues = groupCaptor.getAllValues();
 475         Assert.assertEquals(4, groupCaptorAllValues.size());
 476         Assert.assertEquals(2L, groupCaptorAllValues.get(0).getGroupId().getValue().longValue());
 477         Assert.assertEquals(3L, groupCaptorAllValues.get(1).getGroupId().getValue().longValue());
 478         Assert.assertEquals(4L, groupCaptorAllValues.get(2).getGroupId().getValue().longValue());
 479         Assert.assertEquals(5L, groupCaptorAllValues.get(3).getGroupId().getValue().longValue());
 480
 481         final InOrder inOrderGroups = Mockito.inOrder(flowCapableTxService, groupCommitter);
 482         // add 2
 483         inOrderGroups.verify(groupCommitter).add(ArgumentMatchers.any(),
 484                 ArgumentMatchers.any(), ArgumentMatchers.eq(NODE_IDENT));
 485         inOrderGroups.verify(flowCapableTxService).sendBarrier(ArgumentMatchers.any());
 486         // add 3, 4
 487         inOrderGroups.verify(groupCommitter, Mockito.times(2)).add(ArgumentMatchers.any(),
 488                 ArgumentMatchers.any(), ArgumentMatchers.eq(NODE_IDENT));
 489         inOrderGroups.verify(flowCapableTxService).sendBarrier(ArgumentMatchers.any());
 490         // add 5
 491         inOrderGroups.verify(groupCommitter).add(ArgumentMatchers.any(),
 492                 ArgumentMatchers.any(), ArgumentMatchers.eq(NODE_IDENT));
 493         inOrderGroups.verify(flowCapableTxService).sendBarrier(ArgumentMatchers.any());
 494
 495         inOrderGroups.verifyNoMoreInteractions();
 496     }
 497
 498     @Test
 499     public void testAddMissingGroups_withUpdate() throws Exception {
 500         Mockito.when(groupCommitter.add(ArgumentMatchers.any(), groupCaptor.capture(),
 501                 ArgumentMatchers.same(NODE_IDENT)))
 502                 .thenReturn(RpcResultBuilder.success(new AddGroupOutputBuilder().build()).buildFuture());
 503
 504         Mockito.when(groupCommitter.update(ArgumentMatchers.any(),
 505                 groupUpdateCaptor.capture(), groupUpdateCaptor.capture(),
 506                 ArgumentMatchers.same(NODE_IDENT)))
 507                 .thenReturn(RpcResultBuilder.success(new UpdateGroupOutputBuilder().build()).buildFuture());
 508
 509         ItemSyncBox<Group> groupBox1 = new ItemSyncBox<>();
 510         groupBox1.getItemsToPush().add(DSInputFactory.createGroup(2L));
 511         groupBox1.getItemsToUpdate().add(new ItemSyncBox.ItemUpdateTuple<>(
 512                 DSInputFactory.createGroup(1L), DSInputFactory.createGroupWithAction(1L)));
 513
 514         ItemSyncBox<Group> groupBox2 = new ItemSyncBox<>();
 515         groupBox2.getItemsToPush().add(DSInputFactory.createGroupWithPreconditions(3L, 2L));
 516         groupBox2.getItemsToPush().add(DSInputFactory.createGroupWithPreconditions(4L, 2L));
 517
 518         ItemSyncBox<Group> groupBox3 = new ItemSyncBox<>();
 519         groupBox3.getItemsToPush().add(DSInputFactory.createGroupWithPreconditions(5L, 3L, 4L));
 520
 521         final List<ItemSyncBox<Group>> groupBoxLot = Lists.newArrayList(groupBox1, groupBox2, groupBox3);
 522         final ListenableFuture<RpcResult<Void>> result = syncPlanPushStrategy.addMissingGroups(
 523                 NODE_ID, NODE_IDENT, groupBoxLot, counters);
 524
 525         Assert.assertTrue(result.isDone());
 526         Assert.assertTrue(result.get().isSuccessful());
 527
 528         final List<Group> groupCaptorAllValues = groupCaptor.getAllValues();
 529         Assert.assertEquals(4, groupCaptorAllValues.size());
 530         Assert.assertEquals(2L, groupCaptorAllValues.get(0).getGroupId().getValue().longValue());
 531         Assert.assertEquals(3L, groupCaptorAllValues.get(1).getGroupId().getValue().longValue());
 532         Assert.assertEquals(4L, groupCaptorAllValues.get(2).getGroupId().getValue().longValue());
 533         Assert.assertEquals(5L, groupCaptorAllValues.get(3).getGroupId().getValue().longValue());
 534
 535         final List<Group> groupUpdateCaptorAllValues = groupUpdateCaptor.getAllValues();
 536         Assert.assertEquals(2, groupUpdateCaptorAllValues.size());
 537         Assert.assertEquals(1L, groupUpdateCaptorAllValues.get(0).getGroupId().getValue().longValue());
 538         Assert.assertEquals(1L, groupUpdateCaptorAllValues.get(1).getGroupId().getValue().longValue());
 539
 540         final InOrder inOrderGroups = Mockito.inOrder(flowCapableTxService, groupCommitter);
 541
 542         // add 2, update 1
 543         inOrderGroups.verify(groupCommitter).add(ArgumentMatchers.any(),
 544                 ArgumentMatchers.any(), ArgumentMatchers.eq(NODE_IDENT));
 545         inOrderGroups.verify(groupCommitter).update(ArgumentMatchers.any(),
 546                 ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.eq(NODE_IDENT));
 547         inOrderGroups.verify(flowCapableTxService).sendBarrier(ArgumentMatchers.any());
 548
 549         // add 3, 4
 550         inOrderGroups.verify(groupCommitter, Mockito.times(2)).add(ArgumentMatchers.any(),
 551                 ArgumentMatchers.any(), ArgumentMatchers.eq(NODE_IDENT));
 552         inOrderGroups.verify(flowCapableTxService).sendBarrier(ArgumentMatchers.any());
 553         // add 5
 554         inOrderGroups.verify(groupCommitter).add(ArgumentMatchers.any(),
 555                 ArgumentMatchers.any(), ArgumentMatchers.eq(NODE_IDENT));
 556         inOrderGroups.verify(flowCapableTxService).sendBarrier(ArgumentMatchers.any());
 557
 558         inOrderGroups.verifyNoMoreInteractions();
 559     }
 560
 561     @Test
 562     public void testRemoveRedundantGroups() throws Exception {
 563         Mockito.when(groupCommitter.remove(ArgumentMatchers.any(), groupCaptor.capture(),
 564                 ArgumentMatchers.same(NODE_IDENT)))
 565                 .thenReturn(RpcResultBuilder.success(new RemoveGroupOutputBuilder().build()).buildFuture());
 566
 567         ItemSyncBox<Group> groupBox1 = new ItemSyncBox<>();
 568         groupBox1.getItemsToPush().add(DSInputFactory.createGroup(2L));
 569         groupBox1.getItemsToUpdate().add(new ItemSyncBox.ItemUpdateTuple<>(
 570                 DSInputFactory.createGroup(1L), DSInputFactory.createGroupWithAction(1L)));
 571
 572         ItemSyncBox<Group> groupBox2 = new ItemSyncBox<>();
 573         groupBox2.getItemsToPush().add(DSInputFactory.createGroupWithPreconditions(3L, 2L));
 574         groupBox2.getItemsToPush().add(DSInputFactory.createGroupWithPreconditions(4L, 2L));
 575
 576         ItemSyncBox<Group> groupBox3 = new ItemSyncBox<>();
 577         groupBox3.getItemsToPush().add(DSInputFactory.createGroupWithPreconditions(5L, 3L, 4L));
 578
 579         final List<ItemSyncBox<Group>> groupBoxLot = Lists.newArrayList(groupBox1, groupBox2, groupBox3);
 580         final ListenableFuture<RpcResult<Void>> result = syncPlanPushStrategy.removeRedundantGroups(
 581                 NODE_ID, NODE_IDENT, groupBoxLot, counters);
 582
 583         Assert.assertTrue(result.isDone());
 584         Assert.assertTrue(result.get().isSuccessful());
 585
 586         final List<Group> groupCaptorAllValues = groupCaptor.getAllValues();
 587         Assert.assertEquals(4, groupCaptorAllValues.size());
 588         Assert.assertEquals(5L, groupCaptorAllValues.get(0).getGroupId().getValue().longValue());
 589         Assert.assertEquals(3L, groupCaptorAllValues.get(1).getGroupId().getValue().longValue());
 590         Assert.assertEquals(4L, groupCaptorAllValues.get(2).getGroupId().getValue().longValue());
 591         Assert.assertEquals(2L, groupCaptorAllValues.get(3).getGroupId().getValue().longValue());
 592
 593         final InOrder inOrderGroup = Mockito.inOrder(flowCapableTxService, groupCommitter);
 594         // remove 5
 595         inOrderGroup.verify(groupCommitter).remove(ArgumentMatchers.any(),
 596                 ArgumentMatchers.any(), ArgumentMatchers.eq(NODE_IDENT));
 597         inOrderGroup.verify(flowCapableTxService).sendBarrier(ArgumentMatchers.any());
 598         // remove 3, 4
 599         inOrderGroup.verify(groupCommitter, Mockito.times(2)).remove(ArgumentMatchers.any(),
 600                 ArgumentMatchers.any(), ArgumentMatchers.eq(NODE_IDENT));
 601         inOrderGroup.verify(flowCapableTxService).sendBarrier(ArgumentMatchers.any());
 602         // remove 2
 603         inOrderGroup.verify(groupCommitter).remove(ArgumentMatchers.any(),
 604                 ArgumentMatchers.any(), ArgumentMatchers.eq(NODE_IDENT));
 605         inOrderGroup.verify(flowCapableTxService).sendBarrier(ArgumentMatchers.any());
 606
 607         inOrderGroup.verifyNoMoreInteractions();
 608     }
 609
 610     @Test
 611     public void testUpdateTableFeatures() throws Exception {
 612         Mockito.lenient().when(tableCommitter.update(ArgumentMatchers.any(),
 613                 ArgumentMatchers.isNull(TableFeatures.class), tableFeaturesCaptor.capture(),
 614                 ArgumentMatchers.same(NODE_IDENT)))
 615                 .thenReturn(RpcResultBuilder.success(new UpdateTableOutputBuilder().build()).buildFuture());
 616
 617         final FlowCapableNode operational = new FlowCapableNodeBuilder()
 618                 .setTable(Collections.singletonList(new TableBuilder()
 619                         .setId((short) 1)
 620                         .build()))
 621                 .setTableFeatures(Collections.singletonList(new TableFeaturesBuilder()
 622                         .setName("test table features")
 623                         .setTableId((short) 1)
 624                         .build()))
 625                 .build();
 626
 627         final ListenableFuture<RpcResult<Void>> result = syncPlanPushStrategy.updateTableFeatures(
 628                 NODE_IDENT, operational);
 629
 630         Assert.assertTrue(result.isDone());
 631         Assert.assertTrue(result.get().isSuccessful());
 632
 633         final List<TableFeatures> groupCaptorAllValues = tableFeaturesCaptor.getAllValues();
 634         //TODO: uncomment when enabled in impl
 635 //        Assert.assertEquals(1, groupCaptorAllValues.size());
 636 //        Assert.assertEquals("test table features", groupCaptorAllValues.get(0).getName());
 637 //        Assert.assertEquals(1, groupCaptorAllValues.get(0).getTableId().intValue());
 638
 639         Mockito.verify(flowCapableTxService).sendBarrier(ArgumentMatchers.any());
 640     }
 641 }