applications/forwardingrules-sync/src/test/java/org/opendaylight/openflowplugin/applications/frsync/impl/strategy/SyncPlanPushStrategyFlatBatchImplTest.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.collect.Range;
  12 import com.google.common.util.concurrent.ListenableFuture;
  13 import java.util.ArrayList;
  14 import java.util.HashMap;
  15 import java.util.List;
  16 import java.util.Map;
  17 import org.junit.Assert;
  18 import org.junit.Before;
  19 import org.junit.Test;
  20 import org.junit.runner.RunWith;
  21 import org.mockito.ArgumentCaptor;
  22 import org.mockito.ArgumentMatchers;
  23 import org.mockito.Captor;
  24 import org.mockito.Mock;
  25 import org.mockito.Mockito;
  26 import org.mockito.junit.MockitoJUnitRunner;
  27 import org.opendaylight.openflowplugin.applications.frsync.util.ItemSyncBox;
  28 import org.opendaylight.openflowplugin.applications.frsync.util.SyncCrudCounters;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.ProcessFlatBatchInput;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.ProcessFlatBatchOutputBuilder;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.SalFlatBatchService;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.flat.batch.flow.crud._case.aug.FlatBatchAddFlowCase;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.flat.batch.flow.crud._case.aug.FlatBatchAddFlowCaseBuilder;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.flat.batch.flow.crud._case.aug.FlatBatchRemoveFlowCase;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.flat.batch.flow.crud._case.aug.FlatBatchRemoveFlowCaseBuilder;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.flat.batch.flow.crud._case.aug.FlatBatchUpdateFlowCase;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.flat.batch.flow.crud._case.aug.FlatBatchUpdateFlowCaseBuilder;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.flat.batch.group.crud._case.aug.FlatBatchAddGroupCase;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.flat.batch.group.crud._case.aug.FlatBatchAddGroupCaseBuilder;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.flat.batch.group.crud._case.aug.FlatBatchRemoveGroupCase;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.flat.batch.group.crud._case.aug.FlatBatchRemoveGroupCaseBuilder;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.flat.batch.group.crud._case.aug.FlatBatchUpdateGroupCase;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.flat.batch.group.crud._case.aug.FlatBatchUpdateGroupCaseBuilder;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.flat.batch.meter.crud._case.aug.FlatBatchAddMeterCase;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.flat.batch.meter.crud._case.aug.FlatBatchAddMeterCaseBuilder;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.flat.batch.meter.crud._case.aug.FlatBatchRemoveMeterCase;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.flat.batch.meter.crud._case.aug.FlatBatchRemoveMeterCaseBuilder;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.flat.batch.meter.crud._case.aug.FlatBatchUpdateMeterCase;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.flat.batch.meter.crud._case.aug.FlatBatchUpdateMeterCaseBuilder;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.process.flat.batch.input.Batch;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.flat.batch.service.rev160321.process.flat.batch.input.BatchBuilder;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.meters.Meter;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.TableKey;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.Group;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
  61 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  62 import org.opendaylight.yangtools.yang.common.RpcResult;
  63 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
  64 import org.opendaylight.yangtools.yang.common.Uint16;
  65 import org.opendaylight.yangtools.yang.common.Uint8;
  66
  67 /**
  68  * Test for {@link SyncPlanPushStrategyFlatBatchImpl}.
  69  */
  70 @RunWith(MockitoJUnitRunner.class)
  71 public class SyncPlanPushStrategyFlatBatchImplTest {
  72
  73     private static final NodeId NODE_ID = new NodeId("ut-node-id");
  74     private static final InstanceIdentifier<FlowCapableNode> NODE_IDENT = InstanceIdentifier.create(Nodes.class)
  75             .child(Node.class, new NodeKey(NODE_ID))
  76             .augmentation(FlowCapableNode.class);
  77     @Mock
  78     private SalFlatBatchService flatBatchService;
  79     @Mock
  80     private TableForwarder tableForwarder;
  81     @Captor
  82     private ArgumentCaptor<ProcessFlatBatchInput> processFlatBatchInputCpt;
  83
  84     private final List<ItemSyncBox<Group>> groupsToAddOrUpdate;
  85     private final List<ItemSyncBox<Group>> groupsToRemove;
  86     private final ItemSyncBox<Meter> metersToAddOrUpdate;
  87     private final ItemSyncBox<Meter> metersToRemove;
  88     private final Map<TableKey, ItemSyncBox<Flow>> flowsToAddOrUpdate;
  89     private final Map<TableKey, ItemSyncBox<Flow>> flowsToRemove;
  90     private List<Batch> batchBag;
  91
  92     private SyncPlanPushStrategyFlatBatchImpl syncPlanPushStrategy;
  93
  94     public SyncPlanPushStrategyFlatBatchImplTest() {
  95         groupsToAddOrUpdate = Lists.newArrayList(DiffInputFactory.createGroupSyncBox(1, 2, 3),
  96                 DiffInputFactory.createGroupSyncBoxWithUpdates(4, 5, 6));
  97         groupsToRemove = Lists.newArrayList(DiffInputFactory.createGroupSyncBox(1, 2, 3),
  98                 DiffInputFactory.createGroupSyncBox(4, 5, 6));
  99
 100         metersToAddOrUpdate = DiffInputFactory.createMeterSyncBoxWithUpdates(1, 2, 3);
 101         metersToRemove = DiffInputFactory.createMeterSyncBox(1, 2, 3);
 102
 103         flowsToAddOrUpdate = new HashMap<>();
 104         flowsToAddOrUpdate.put(new TableKey(Uint8.ZERO), DiffInputFactory.createFlowSyncBox("1", "2", "3"));
 105         flowsToAddOrUpdate.put(new TableKey(Uint8.ONE), DiffInputFactory.createFlowSyncBoxWithUpdates("4", "5", "6"));
 106         flowsToRemove = new HashMap<>();
 107         flowsToRemove.put(new TableKey(Uint8.ZERO), DiffInputFactory.createFlowSyncBox("1", "2", "3"));
 108         flowsToRemove.put(new TableKey(Uint8.ONE), DiffInputFactory.createFlowSyncBox("4", "5", "6"));
 109     }
 110
 111
 112     @Before
 113     public void setUp() {
 114         syncPlanPushStrategy = new SyncPlanPushStrategyFlatBatchImpl();
 115         syncPlanPushStrategy.setFlatBatchService(flatBatchService);
 116         syncPlanPushStrategy.setTableForwarder(tableForwarder);
 117
 118         batchBag = new ArrayList<>();
 119     }
 120
 121     @Test
 122     public void testExecuteSyncStrategy() throws Exception {
 123         final SynchronizationDiffInput diffInput = new SynchronizationDiffInput(NODE_IDENT,
 124                 groupsToAddOrUpdate, metersToAddOrUpdate, flowsToAddOrUpdate,
 125                 flowsToRemove, metersToRemove, groupsToRemove);
 126
 127         Mockito.when(flatBatchService.processFlatBatch(ArgumentMatchers.any()))
 128                 .thenReturn(RpcResultBuilder.success(new ProcessFlatBatchOutputBuilder().build()).buildFuture());
 129
 130         final SyncCrudCounters counters = new SyncCrudCounters();
 131         final ListenableFuture<RpcResult<Void>> rpcResult = syncPlanPushStrategy.executeSyncStrategy(
 132                 RpcResultBuilder.<Void>success().buildFuture(), diffInput, counters);
 133
 134         Mockito.verify(flatBatchService).processFlatBatch(processFlatBatchInputCpt.capture());
 135
 136         final ProcessFlatBatchInput processFlatBatchInput = processFlatBatchInputCpt.getValue();
 137         Assert.assertFalse(processFlatBatchInput.getExitOnFirstError());
 138         Assert.assertEquals(13, processFlatBatchInput.nonnullBatch().size());
 139
 140         Assert.assertTrue(rpcResult.isDone());
 141         Assert.assertTrue(rpcResult.get().isSuccessful());
 142
 143         Assert.assertEquals(6, counters.getFlowCrudCounts().getAdded());
 144         Assert.assertEquals(3, counters.getFlowCrudCounts().getUpdated());
 145         Assert.assertEquals(6, counters.getFlowCrudCounts().getRemoved());
 146
 147         Assert.assertEquals(6, counters.getGroupCrudCounts().getAdded());
 148         Assert.assertEquals(3, counters.getGroupCrudCounts().getUpdated());
 149         Assert.assertEquals(6, counters.getGroupCrudCounts().getRemoved());
 150
 151         Assert.assertEquals(3, counters.getMeterCrudCounts().getAdded());
 152         Assert.assertEquals(3, counters.getMeterCrudCounts().getUpdated());
 153         Assert.assertEquals(3, counters.getMeterCrudCounts().getRemoved());
 154     }
 155
 156     @Test
 157     public void testAssembleRemoveFlows() {
 158         final int lastOrder = SyncPlanPushStrategyFlatBatchImpl.assembleRemoveFlows(batchBag, 0, flowsToRemove);
 159
 160         Assert.assertEquals(6, lastOrder);
 161         Assert.assertEquals(2, batchBag.size());
 162         Assert.assertEquals(FlatBatchRemoveFlowCase.class, batchBag.get(0).getBatchChoice().implementedInterface());
 163         Assert.assertEquals(3, ((FlatBatchRemoveFlowCase) batchBag.get(0).getBatchChoice())
 164                 .nonnullFlatBatchRemoveFlow().size());
 165         Assert.assertEquals(FlatBatchRemoveFlowCase.class, batchBag.get(1).getBatchChoice().implementedInterface());
 166         Assert.assertEquals(3, ((FlatBatchRemoveFlowCase) batchBag.get(1).getBatchChoice())
 167                 .nonnullFlatBatchRemoveFlow().size());
 168     }
 169
 170     @Test
 171     public void testAssembleAddOrUpdateGroups() {
 172         final int lastOrder = SyncPlanPushStrategyFlatBatchImpl.assembleAddOrUpdateGroups(
 173                 batchBag, 0, groupsToAddOrUpdate);
 174
 175         Assert.assertEquals(9, lastOrder);
 176         Assert.assertEquals(3, batchBag.size());
 177         Assert.assertEquals(FlatBatchAddGroupCase.class, batchBag.get(0).getBatchChoice().implementedInterface());
 178         Assert.assertEquals(3, ((FlatBatchAddGroupCase) batchBag.get(0).getBatchChoice())
 179                 .nonnullFlatBatchAddGroup().size());
 180         Assert.assertEquals(FlatBatchAddGroupCase.class, batchBag.get(1).getBatchChoice().implementedInterface());
 181         Assert.assertEquals(3, ((FlatBatchAddGroupCase) batchBag.get(1).getBatchChoice())
 182                 .nonnullFlatBatchAddGroup().size());
 183         Assert.assertEquals(FlatBatchUpdateGroupCase.class, batchBag.get(2).getBatchChoice().implementedInterface());
 184         Assert.assertEquals(3, ((FlatBatchUpdateGroupCase) batchBag.get(2).getBatchChoice())
 185                 .nonnullFlatBatchUpdateGroup().size());
 186     }
 187
 188     @Test
 189     public void testAssembleRemoveGroups() {
 190         final int lastOrder = SyncPlanPushStrategyFlatBatchImpl.assembleRemoveGroups(batchBag, 0, groupsToRemove);
 191
 192         Assert.assertEquals(6, lastOrder);
 193         Assert.assertEquals(2, batchBag.size());
 194         Assert.assertEquals(FlatBatchRemoveGroupCase.class, batchBag.get(0).getBatchChoice().implementedInterface());
 195         Assert.assertEquals(3, ((FlatBatchRemoveGroupCase) batchBag.get(0).getBatchChoice())
 196                 .nonnullFlatBatchRemoveGroup().size());
 197         Assert.assertEquals(FlatBatchRemoveGroupCase.class, batchBag.get(1).getBatchChoice().implementedInterface());
 198         Assert.assertEquals(3, ((FlatBatchRemoveGroupCase) batchBag.get(1).getBatchChoice())
 199                 .nonnullFlatBatchRemoveGroup().size());
 200     }
 201
 202     @Test
 203     public void testAssembleAddOrUpdateMeters() {
 204         final int lastOrder = SyncPlanPushStrategyFlatBatchImpl.assembleAddOrUpdateMeters(
 205                 batchBag, 0, metersToAddOrUpdate);
 206
 207         Assert.assertEquals(6, lastOrder);
 208         Assert.assertEquals(2, batchBag.size());
 209         Assert.assertEquals(FlatBatchAddMeterCase.class, batchBag.get(0).getBatchChoice().implementedInterface());
 210         Assert.assertEquals(3, ((FlatBatchAddMeterCase) batchBag.get(0).getBatchChoice())
 211                 .nonnullFlatBatchAddMeter().size());
 212         Assert.assertEquals(FlatBatchUpdateMeterCase.class, batchBag.get(1).getBatchChoice().implementedInterface());
 213         Assert.assertEquals(3, ((FlatBatchUpdateMeterCase) batchBag.get(1).getBatchChoice())
 214                 .nonnullFlatBatchUpdateMeter().size());
 215     }
 216
 217     @Test
 218     public void testAssembleRemoveMeters() {
 219         final int lastOrder = SyncPlanPushStrategyFlatBatchImpl.assembleRemoveMeters(batchBag, 0, metersToRemove);
 220
 221         Assert.assertEquals(3, lastOrder);
 222         Assert.assertEquals(1, batchBag.size());
 223         Assert.assertEquals(FlatBatchRemoveMeterCase.class, batchBag.get(0).getBatchChoice().implementedInterface());
 224         Assert.assertEquals(3, ((FlatBatchRemoveMeterCase) batchBag.get(0).getBatchChoice())
 225                 .nonnullFlatBatchRemoveMeter().size());
 226     }
 227
 228     @Test
 229     public void testAssembleAddOrUpdateFlows() {
 230         final int lastOrder = SyncPlanPushStrategyFlatBatchImpl.assembleAddOrUpdateFlows(
 231                 batchBag, 0, flowsToAddOrUpdate);
 232
 233         Assert.assertEquals(9, lastOrder);
 234         Assert.assertEquals(3, batchBag.size());
 235         Assert.assertEquals(FlatBatchAddFlowCase.class, batchBag.get(0).getBatchChoice().implementedInterface());
 236         Assert.assertEquals(3, ((FlatBatchAddFlowCase) batchBag.get(0).getBatchChoice())
 237                 .nonnullFlatBatchAddFlow().size());
 238         Assert.assertEquals(FlatBatchUpdateFlowCase.class, batchBag.get(1).getBatchChoice().implementedInterface());
 239         Assert.assertEquals(3, ((FlatBatchUpdateFlowCase) batchBag.get(1).getBatchChoice())
 240                 .nonnullFlatBatchUpdateFlow().size());
 241         Assert.assertEquals(FlatBatchAddFlowCase.class, batchBag.get(2).getBatchChoice().implementedInterface());
 242         Assert.assertEquals(3, ((FlatBatchAddFlowCase) batchBag.get(2).getBatchChoice())
 243                 .nonnullFlatBatchAddFlow().size());
 244     }
 245
 246     @Test
 247     public void testDecrementCounters() {
 248         final SyncCrudCounters counters = new SyncCrudCounters();
 249         counters.getFlowCrudCounts().setAdded(100);
 250         counters.getFlowCrudCounts().setUpdated(100);
 251         counters.getFlowCrudCounts().setRemoved(100);
 252
 253         counters.getGroupCrudCounts().setAdded(100);
 254         counters.getGroupCrudCounts().setUpdated(100);
 255         counters.getGroupCrudCounts().setRemoved(100);
 256
 257         counters.getMeterCrudCounts().setAdded(100);
 258         counters.getMeterCrudCounts().setUpdated(100);
 259         counters.getMeterCrudCounts().setRemoved(100);
 260
 261         SyncPlanPushStrategyFlatBatchImpl.decrementCounters(new FlatBatchAddFlowCaseBuilder().build(), counters);
 262         SyncPlanPushStrategyFlatBatchImpl.decrementCounters(new FlatBatchUpdateFlowCaseBuilder().build(), counters);
 263         SyncPlanPushStrategyFlatBatchImpl.decrementCounters(new FlatBatchRemoveFlowCaseBuilder().build(), counters);
 264
 265         SyncPlanPushStrategyFlatBatchImpl.decrementCounters(new FlatBatchAddGroupCaseBuilder().build(), counters);
 266         SyncPlanPushStrategyFlatBatchImpl.decrementCounters(new FlatBatchUpdateGroupCaseBuilder().build(), counters);
 267         SyncPlanPushStrategyFlatBatchImpl.decrementCounters(new FlatBatchRemoveGroupCaseBuilder().build(), counters);
 268
 269         SyncPlanPushStrategyFlatBatchImpl.decrementCounters(new FlatBatchAddMeterCaseBuilder().build(), counters);
 270         SyncPlanPushStrategyFlatBatchImpl.decrementCounters(new FlatBatchUpdateMeterCaseBuilder().build(), counters);
 271         SyncPlanPushStrategyFlatBatchImpl.decrementCounters(new FlatBatchRemoveMeterCaseBuilder().build(), counters);
 272
 273         Assert.assertEquals(99, counters.getFlowCrudCounts().getAdded());
 274         Assert.assertEquals(99, counters.getFlowCrudCounts().getUpdated());
 275         Assert.assertEquals(99, counters.getFlowCrudCounts().getRemoved());
 276
 277         Assert.assertEquals(99, counters.getGroupCrudCounts().getAdded());
 278         Assert.assertEquals(99, counters.getGroupCrudCounts().getUpdated());
 279         Assert.assertEquals(99, counters.getGroupCrudCounts().getRemoved());
 280
 281         Assert.assertEquals(99, counters.getMeterCrudCounts().getAdded());
 282         Assert.assertEquals(99, counters.getMeterCrudCounts().getUpdated());
 283         Assert.assertEquals(99, counters.getMeterCrudCounts().getRemoved());
 284     }
 285
 286     @Test
 287     public void testMapBatchesToRanges() {
 288         final List<Batch> inputBatchBag = Lists.newArrayList(
 289                 new BatchBuilder().setBatchOrder(Uint16.ZERO).build(),
 290                 new BatchBuilder().setBatchOrder(Uint16.valueOf(5)).build(),
 291                 new BatchBuilder().setBatchOrder(Uint16.valueOf(9)).build(),
 292                 new BatchBuilder().setBatchOrder(Uint16.valueOf(15)).build()
 293         );
 294         final Map<Range<Uint16>, Batch> rangeBatchMap =
 295                 SyncPlanPushStrategyFlatBatchImpl.mapBatchesToRanges(inputBatchBag, 42);
 296
 297         Assert.assertEquals(4, rangeBatchMap.size());
 298         int idx = 0;
 299         final int[] lower = new int[]{0, 5, 9, 15};
 300         final int[] upper = new int[]{4, 8, 14, 41};
 301         for (Map.Entry<Range<Uint16>, Batch> rangeBatchEntry : rangeBatchMap.entrySet()) {
 302             Assert.assertEquals(lower[idx], rangeBatchEntry.getKey().lowerEndpoint().intValue());
 303             Assert.assertEquals(upper[idx], rangeBatchEntry.getKey().upperEndpoint().intValue());
 304             Assert.assertSame(inputBatchBag.get(idx), rangeBatchEntry.getValue());
 305             idx++;
 306         }
 307     }
 308 }