renderers/vpp/src/test/java/org/opendaylight/groupbasedpolicy/renderer/vpp/commands/TapPortCommandTest.java

   1 /*
   2  * Copyright (c) 2016 Cisco Systems. 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
   9 package org.opendaylight.groupbasedpolicy.renderer.vpp.commands;
  10
  11 import com.google.common.base.Optional;
  12 import org.junit.Assert;
  13 import org.junit.Before;
  14 import org.junit.Test;
  15 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  16 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  17 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
  18 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  19 import org.opendaylight.groupbasedpolicy.renderer.vpp.VppRendererDataBrokerTest;
  20 import org.opendaylight.groupbasedpolicy.renderer.vpp.util.General;
  21 import org.opendaylight.groupbasedpolicy.renderer.vpp.util.VppIidFactory;
  22 import org.opendaylight.groupbasedpolicy.util.DataStoreHelper;
  23 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
  24 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceBuilder;
  25 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
  26 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.PhysAddress;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.Tap;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.VppInterfaceAugmentation;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.VppInterfaceAugmentationBuilder;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.interfaces._interface.L2Builder;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.interfaces._interface.TapBuilder;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev170607.l2.config.attributes.interconnection.BridgeBasedBuilder;
  33
  34 import java.util.concurrent.ExecutionException;
  35
  36 public class TapPortCommandTest extends VppRendererDataBrokerTest {
  37
  38     private final static String DESCRIPTION = "used for testing";
  39     private final static String INTERFACE_NAME = "testInterface";
  40     private final static String TAP_NAME = "testTap00:11:22:33:44:55";
  41     private final static String BRIDGE_DOMAIN = "testBD";
  42     private final static Long DEVICE_ID = 0L;
  43     private final static PhysAddress MAC_ADDRESS = new PhysAddress("00:11:22:33:44:55");
  44
  45     private final static String UPD_DESCRIPTION = "updated description";
  46     private final static PhysAddress UPD_MAC_ADDRESS = new PhysAddress("55:44:33:22:11:00");
  47     private final static String UPD_TAP_NAME = "testTapUpd";
  48     private final static Long UPD_DEVICE_ID = 1L;
  49
  50     private final static VppInterfaceAugmentationBuilder vppAugmentationBuilder = new VppInterfaceAugmentationBuilder()
  51         .setTap(new TapBuilder().setMac(MAC_ADDRESS).setTapName(TAP_NAME).setDeviceInstance(DEVICE_ID).build());
  52
  53     private final static VppInterfaceAugmentationBuilder vppAugmentationBuilderWithBD =
  54             new VppInterfaceAugmentationBuilder(vppAugmentationBuilder.build())
  55                 .setL2(new L2Builder().setInterconnection(new BridgeBasedBuilder().setBridgeDomain(BRIDGE_DOMAIN)
  56                     .setBridgedVirtualInterface(false).setSplitHorizonGroup((short)0)
  57                     .build()).build());
  58
  59     private final static InterfaceBuilder interfaceBuilder =
  60             new InterfaceBuilder().setKey(new InterfaceKey(INTERFACE_NAME))
  61                 .setEnabled(true)
  62                 .setDescription(DESCRIPTION)
  63                 .setType(Tap.class)
  64                 .setName(INTERFACE_NAME)
  65                 .setLinkUpDownTrapEnable(Interface.LinkUpDownTrapEnable.Enabled);
  66
  67     private final static Interface BASIC_INTERFACE =
  68             interfaceBuilder.addAugmentation(VppInterfaceAugmentation.class, vppAugmentationBuilder.build()).build();
  69     private final static Interface BASIC_INTERFACE_WITH_BD = interfaceBuilder
  70         .addAugmentation(VppInterfaceAugmentation.class, vppAugmentationBuilderWithBD.build()).build();
  71
  72     private DataBroker dataBroker;
  73
  74     @Before
  75     public void init() {
  76         dataBroker = getDataBroker();
  77     }
  78
  79     @Test
  80     public void testAddTapPort() throws ExecutionException, InterruptedException {
  81         ReadWriteTransaction rwTx = dataBroker.newReadWriteTransaction();
  82         TapPortCommand addCommand = TapPortCommand.builder()
  83             .setOperation(General.Operations.PUT)
  84             .setInterfaceName(INTERFACE_NAME)
  85             .setTapName(TAP_NAME)
  86             .setDescription(DESCRIPTION)
  87             .setDeviceInstance(DEVICE_ID)
  88             .setPhysAddress(MAC_ADDRESS)
  89             .setEnabled(true)
  90             .build();
  91
  92         Optional<Interface> optional = executeCommand(rwTx, addCommand);
  93
  94         Assert.assertTrue(optional.isPresent());
  95         Assert.assertEquals(BASIC_INTERFACE, optional.get());
  96
  97     }
  98
  99     @Test
 100     public void testAddTapPort_WithBridgeDomain() throws ExecutionException, InterruptedException {
 101         ReadWriteTransaction rwTx = dataBroker.newReadWriteTransaction();
 102         TapPortCommand addCommand = TapPortCommand.builder()
 103             .setOperation(General.Operations.PUT)
 104             .setInterfaceName(INTERFACE_NAME)
 105             .setTapName(TAP_NAME)
 106             .setDescription(DESCRIPTION)
 107             .setDeviceInstance(DEVICE_ID)
 108             .setPhysAddress(MAC_ADDRESS)
 109             .setBridgeDomain(BRIDGE_DOMAIN)
 110             .setEnabled(true)
 111             .build();
 112
 113         Optional<Interface> optional = executeCommand(rwTx, addCommand);
 114
 115         Assert.assertTrue(optional.isPresent());
 116         Assert.assertEquals(BASIC_INTERFACE_WITH_BD, optional.get());
 117
 118     }
 119
 120     private Optional<Interface> executeCommand(ReadWriteTransaction rwTx, TapPortCommand addCommand)
 121             throws ExecutionException, InterruptedException {
 122         addCommand.execute(rwTx);
 123
 124         rwTx.submit().get();
 125
 126         ReadOnlyTransaction rTx = dataBroker.newReadOnlyTransaction();
 127
 128         return DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION,
 129                 VppIidFactory.getInterfaceIID(new InterfaceKey(INTERFACE_NAME)), rTx);
 130     }
 131
 132     @Test
 133     public void testDeleteTapPort() throws ExecutionException, InterruptedException {
 134         ReadWriteTransaction rwTx = dataBroker.newReadWriteTransaction();
 135
 136         rwTx.put(LogicalDatastoreType.CONFIGURATION, VppIidFactory.getInterfaceIID(BASIC_INTERFACE.getKey()),
 137                 BASIC_INTERFACE, true);
 138         rwTx.submit().get();
 139
 140         Optional<Interface> optional = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION,
 141                 VppIidFactory.getInterfaceIID(BASIC_INTERFACE.getKey()), dataBroker.newReadOnlyTransaction());
 142
 143         Assert.assertTrue(optional.isPresent());
 144
 145         TapPortCommand deleteCommand = TapPortCommand.builder()
 146             .setOperation(General.Operations.DELETE)
 147             .setInterfaceName(INTERFACE_NAME)
 148             .setTapName(TAP_NAME)
 149             .build();
 150
 151         ReadWriteTransaction rwTxDel = dataBroker.newReadWriteTransaction();
 152         deleteCommand.execute(rwTxDel);
 153         rwTxDel.submit();
 154
 155         Optional<Interface> optionalDeleted = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION,
 156                 VppIidFactory.getInterfaceIID(new InterfaceKey(deleteCommand.getName())),
 157                 dataBroker.newReadOnlyTransaction());
 158
 159         Assert.assertFalse(optionalDeleted.isPresent());
 160     }
 161
 162     @Test
 163     public void testUpdateTapPort() throws ExecutionException, InterruptedException {
 164         ReadWriteTransaction rwTx = dataBroker.newReadWriteTransaction();
 165
 166         rwTx.put(LogicalDatastoreType.CONFIGURATION, VppIidFactory.getInterfaceIID(BASIC_INTERFACE.getKey()),
 167                 BASIC_INTERFACE, true);
 168         rwTx.submit().get();
 169
 170         Optional<Interface> optional = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION,
 171                 VppIidFactory.getInterfaceIID(BASIC_INTERFACE.getKey()), dataBroker.newReadOnlyTransaction());
 172
 173         Assert.assertTrue(optional.isPresent());
 174
 175         TapPortCommand updateCommand = TapPortCommand.builder()
 176             .setOperation(General.Operations.MERGE)
 177             .setInterfaceName(INTERFACE_NAME)
 178             .setTapName(UPD_TAP_NAME)
 179             .setDescription(UPD_DESCRIPTION)
 180             .setPhysAddress(UPD_MAC_ADDRESS)
 181             .setDeviceInstance(UPD_DEVICE_ID)
 182             .setEnabled(false)
 183             .build();
 184
 185         ReadWriteTransaction rwTxUpd = dataBroker.newReadWriteTransaction();
 186         updateCommand.execute(rwTxUpd);
 187         rwTxUpd.submit().get();
 188
 189         Optional<Interface> optionalUpdated = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION,
 190                 VppIidFactory.getInterfaceIID(new InterfaceKey(updateCommand.getName())),
 191                 dataBroker.newReadOnlyTransaction());
 192
 193         Assert.assertTrue(optionalUpdated.isPresent());
 194         Interface updatedInterface = optionalUpdated.get();
 195
 196         Assert.assertEquals(UPD_DESCRIPTION, updatedInterface.getDescription());
 197         Assert.assertFalse(updatedInterface.isEnabled());
 198         VppInterfaceAugmentation augmentation = updatedInterface.getAugmentation(VppInterfaceAugmentation.class);
 199         Assert.assertEquals(INTERFACE_NAME, updatedInterface.getName());
 200         Assert.assertEquals(UPD_DEVICE_ID, augmentation.getTap().getDeviceInstance());
 201         Assert.assertEquals(UPD_MAC_ADDRESS, augmentation.getTap().getMac());
 202         Assert.assertEquals(UPD_TAP_NAME, augmentation.getTap().getTapName());
 203
 204     }
 205 }