applications/forwardingrules-manager/src/test/java/test/mock/MeterListenerTest.java

   1 /*
   2  * Copyright (c) 2014 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 test.mock;
   9
  10 import static org.junit.Assert.assertEquals;
  11
  12 import java.util.List;
  13 import org.junit.After;
  14 import org.junit.Before;
  15 import org.junit.Test;
  16 import org.junit.runner.RunWith;
  17 import org.mockito.Mock;
  18 import org.mockito.Mockito;
  19 import org.mockito.junit.MockitoJUnitRunner;
  20 import org.opendaylight.mdsal.binding.api.WriteTransaction;
  21 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  22 import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
  23 import org.opendaylight.openflowplugin.api.openflow.mastership.MastershipChangeServiceManager;
  24 import org.opendaylight.openflowplugin.applications.frm.impl.DeviceMastershipManager;
  25 import org.opendaylight.openflowplugin.applications.frm.impl.ForwardingRulesManagerImpl;
  26 import org.opendaylight.openflowplugin.applications.frm.recovery.OpenflowServiceRecoveryHandler;
  27 import org.opendaylight.openflowplugin.applications.reconciliation.ReconciliationManager;
  28 import org.opendaylight.serviceutils.srm.ServiceRecoveryRegistry;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.meters.Meter;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.meters.MeterBuilder;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.meters.MeterKey;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.meters.StaleMeter;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.meters.StaleMeterBuilder;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.meters.StaleMeterKey;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.service.rev130918.AddMeterInput;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.service.rev130918.RemoveMeterInput;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.service.rev130918.UpdateMeterInput;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.MeterId;
  44 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  45 import test.mock.util.FRMTest;
  46 import test.mock.util.RpcProviderRegistryMock;
  47 import test.mock.util.SalMeterServiceMock;
  48
  49 @RunWith(MockitoJUnitRunner.class)
  50 public class MeterListenerTest extends FRMTest {
  51     private ForwardingRulesManagerImpl forwardingRulesManager;
  52     private static final NodeId NODE_ID = new NodeId("testnode:1");
  53     private static final NodeKey NODE_KEY = new NodeKey(NODE_ID);
  54     RpcProviderRegistryMock rpcProviderRegistryMock = new RpcProviderRegistryMock();
  55     @Mock
  56     ClusterSingletonServiceProvider clusterSingletonService;
  57     @Mock
  58     DeviceMastershipManager deviceMastershipManager;
  59     @Mock
  60     private ReconciliationManager reconciliationManager;
  61     @Mock
  62     private OpenflowServiceRecoveryHandler openflowServiceRecoveryHandler;
  63     @Mock
  64     private ServiceRecoveryRegistry serviceRecoveryRegistry;
  65     @Mock
  66     private MastershipChangeServiceManager mastershipChangeServiceManager;
  67
  68     @Before
  69     public void setUp() {
  70         forwardingRulesManager = new ForwardingRulesManagerImpl(
  71                 getDataBroker(),
  72                 rpcProviderRegistryMock,
  73                 rpcProviderRegistryMock,
  74                 getConfig(),
  75                 mastershipChangeServiceManager,
  76                 clusterSingletonService,
  77                 getConfigurationService(),
  78                 reconciliationManager,
  79                 openflowServiceRecoveryHandler,
  80                 serviceRecoveryRegistry);
  81
  82         forwardingRulesManager.start();
  83         // TODO consider tests rewrite (added because of complicated access)
  84         forwardingRulesManager.setDeviceMastershipManager(deviceMastershipManager);
  85         Mockito.when(deviceMastershipManager.isDeviceMastered(NODE_ID)).thenReturn(true);
  86     }
  87
  88     @Test
  89     public void addTwoMetersTest() throws Exception {
  90         addFlowCapableNode(NODE_KEY);
  91
  92         MeterKey meterKey = new MeterKey(new MeterId((long) 2000));
  93         InstanceIdentifier<Meter> meterII = InstanceIdentifier.create(Nodes.class).child(Node.class, NODE_KEY)
  94                 .augmentation(FlowCapableNode.class).child(Meter.class, meterKey);
  95         Meter meter = new MeterBuilder().withKey(meterKey).setMeterName("meter_one").build();
  96
  97         WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
  98         writeTx.put(LogicalDatastoreType.CONFIGURATION, meterII, meter);
  99         assertCommit(writeTx.commit());
 100         SalMeterServiceMock salMeterService = (SalMeterServiceMock) forwardingRulesManager.getSalMeterService();
 101         List<AddMeterInput> addMeterCalls = salMeterService.getAddMeterCalls();
 102         assertEquals(1, addMeterCalls.size());
 103         assertEquals("DOM-0", addMeterCalls.get(0).getTransactionUri().getValue());
 104
 105         meterKey = new MeterKey(new MeterId((long) 2001));
 106         meterII = InstanceIdentifier.create(Nodes.class).child(Node.class, NODE_KEY)
 107                 .augmentation(FlowCapableNode.class).child(Meter.class, meterKey);
 108         meter = new MeterBuilder().withKey(meterKey).setMeterName("meter_two").setBarrier(true).build();
 109         writeTx = getDataBroker().newWriteOnlyTransaction();
 110         writeTx.put(LogicalDatastoreType.CONFIGURATION, meterII, meter);
 111         assertCommit(writeTx.commit());
 112         salMeterService = (SalMeterServiceMock) forwardingRulesManager.getSalMeterService();
 113         addMeterCalls = salMeterService.getAddMeterCalls();
 114         assertEquals(2, addMeterCalls.size());
 115         assertEquals("DOM-1", addMeterCalls.get(1).getTransactionUri().getValue());
 116         assertEquals(meterII, addMeterCalls.get(1).getMeterRef().getValue());
 117     }
 118
 119     @Test
 120     public void updateMeterTest() throws Exception {
 121         addFlowCapableNode(NODE_KEY);
 122
 123         MeterKey meterKey = new MeterKey(new MeterId((long) 2000));
 124         InstanceIdentifier<Meter> meterII = InstanceIdentifier.create(Nodes.class).child(Node.class, NODE_KEY)
 125                 .augmentation(FlowCapableNode.class).child(Meter.class, meterKey);
 126         Meter meter = new MeterBuilder().withKey(meterKey).setMeterName("meter_one").setBarrier(false).build();
 127
 128         WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
 129         writeTx.put(LogicalDatastoreType.CONFIGURATION, meterII, meter);
 130         assertCommit(writeTx.commit());
 131         SalMeterServiceMock salMeterService = (SalMeterServiceMock) forwardingRulesManager.getSalMeterService();
 132         List<AddMeterInput> addMeterCalls = salMeterService.getAddMeterCalls();
 133         assertEquals(1, addMeterCalls.size());
 134         assertEquals("DOM-0", addMeterCalls.get(0).getTransactionUri().getValue());
 135
 136         meter = new MeterBuilder().withKey(meterKey).setMeterName("meter_two").setBarrier(true).build();
 137         writeTx = getDataBroker().newWriteOnlyTransaction();
 138         writeTx.put(LogicalDatastoreType.CONFIGURATION, meterII, meter);
 139         assertCommit(writeTx.commit());
 140         salMeterService = (SalMeterServiceMock) forwardingRulesManager.getSalMeterService();
 141         List<UpdateMeterInput> updateMeterCalls = salMeterService.getUpdateMeterCalls();
 142         assertEquals(1, updateMeterCalls.size());
 143         assertEquals("DOM-1", updateMeterCalls.get(0).getTransactionUri().getValue());
 144         assertEquals(meterII, updateMeterCalls.get(0).getMeterRef().getValue());
 145     }
 146
 147     @Test
 148     public void removeMeterTest() throws Exception {
 149         addFlowCapableNode(NODE_KEY);
 150
 151         MeterKey meterKey = new MeterKey(new MeterId((long) 2000));
 152         InstanceIdentifier<Meter> meterII = InstanceIdentifier.create(Nodes.class).child(Node.class, NODE_KEY)
 153                 .augmentation(FlowCapableNode.class).child(Meter.class, meterKey);
 154         Meter meter = new MeterBuilder().withKey(meterKey).setMeterName("meter_one").build();
 155
 156         WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
 157         writeTx.put(LogicalDatastoreType.CONFIGURATION, meterII, meter);
 158         assertCommit(writeTx.commit());
 159         SalMeterServiceMock salMeterService = (SalMeterServiceMock) forwardingRulesManager.getSalMeterService();
 160         List<AddMeterInput> addMeterCalls = salMeterService.getAddMeterCalls();
 161         assertEquals(1, addMeterCalls.size());
 162         assertEquals("DOM-0", addMeterCalls.get(0).getTransactionUri().getValue());
 163
 164         writeTx = getDataBroker().newWriteOnlyTransaction();
 165         writeTx.delete(LogicalDatastoreType.CONFIGURATION, meterII);
 166         assertCommit(writeTx.commit());
 167         salMeterService = (SalMeterServiceMock) forwardingRulesManager.getSalMeterService();
 168         List<RemoveMeterInput> removeMeterCalls = salMeterService.getRemoveMeterCalls();
 169         assertEquals(1, removeMeterCalls.size());
 170         assertEquals("DOM-1", removeMeterCalls.get(0).getTransactionUri().getValue());
 171         assertEquals(meterII, removeMeterCalls.get(0).getMeterRef().getValue());
 172     }
 173
 174     @Test
 175     public void staleMeterCreationTest() throws Exception {
 176         addFlowCapableNode(NODE_KEY);
 177
 178         StaleMeterKey meterKey = new StaleMeterKey(new MeterId((long) 2000));
 179         InstanceIdentifier<StaleMeter> meterII = InstanceIdentifier.create(Nodes.class).child(Node.class, NODE_KEY)
 180                 .augmentation(FlowCapableNode.class).child(StaleMeter.class, meterKey);
 181         StaleMeter meter = new StaleMeterBuilder().withKey(meterKey).setMeterName("stale_meter_one").build();
 182
 183         WriteTransaction writeTx = getDataBroker().newWriteOnlyTransaction();
 184         writeTx.put(LogicalDatastoreType.CONFIGURATION, meterII, meter);
 185         assertCommit(writeTx.commit());
 186     }
 187
 188     @After
 189     public void tearDown() throws Exception {
 190         forwardingRulesManager.close();
 191     }
 192 }