itm/itm-impl/src/test/java/org/opendaylight/genius/itm/cli/TepCommandHelperTest.java

   1 /*
   2  * Copyright (c) 2016 Ericsson India Global Services Pvt Ltd. 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
   9 package org.opendaylight.genius.itm.cli;
  10
  11 import com.google.common.base.Optional;
  12 import com.google.common.util.concurrent.Futures;
  13 import static org.junit.Assert.*;
  14 import org.junit.After;
  15 import org.junit.Before;
  16 import org.junit.Test;
  17 import org.junit.runner.RunWith;
  18 import org.mockito.Mock;
  19 import org.mockito.runners.MockitoJUnitRunner;
  20 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  21 import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
  22 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  23 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  24 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker;
  25 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  26 import org.opendaylight.genius.itm.globals.ITMConstants;
  27 import org.opendaylight.genius.itm.impl.ItmUtils;
  28 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev140508.L2vlan;
  29 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
  30 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddressBuilder;
  31 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpPrefix;
  32 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpPrefixBuilder;
  33 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
  34 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state
  35         .InterfaceBuilder;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelMonitoringTypeBase;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeBase;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeGre;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeVxlan;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.TunnelMonitorInterval;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.TunnelMonitorIntervalBuilder;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.TunnelMonitorParams;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.TunnelMonitorParamsBuilder;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TunnelList;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TunnelListBuilder;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnel.list.InternalTunnel;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnel.list.InternalTunnelBuilder;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnel.list.InternalTunnelKey;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.TransportZones;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.TransportZonesBuilder;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZone;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZoneBuilder;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZoneKey;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.Subnets;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone
  56         .SubnetsBuilder;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.SubnetsKey;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.subnets.*;
  59 import org.opendaylight.yangtools.concepts.ListenerRegistration;
  60 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  61 import org.slf4j.Logger;
  62 import org.slf4j.LoggerFactory;
  63
  64 import java.io.ByteArrayOutputStream;
  65 import java.io.PrintStream;
  66 import java.math.BigInteger;
  67 import java.util.ArrayList;
  68 import java.util.HashMap;
  69 import java.util.List;
  70 import java.util.Map;
  71
  72 import static org.mockito.Matchers.any;
  73 import static org.mockito.Mockito.*;
  74
  75 @RunWith(MockitoJUnitRunner.class)
  76 public class TepCommandHelperTest {
  77
  78     private static final Logger LOG = LoggerFactory.getLogger(TepCommandHelper.class);
  79
  80     int vlanId = 100 ;
  81     int interval = 1000;
  82     Boolean enabled = false ;
  83     Class<? extends TunnelMonitoringTypeBase> monitorProtocol = ITMConstants.DEFAULT_MONITOR_PROTOCOL;
  84     String tepIp1 = "192.168.56.30";
  85     String tepIp2 = "192.168.56.102";
  86     String tepIp3 = "168.56.102";
  87     String tepIp4 = "150.168.56.102";
  88     String gwyIp1 = "192.168.56.105";
  89     String gwyIp2 = "192.168.56.106";
  90     String subnetMask = "192.168.56.100/24";
  91     String tunnelInterfaceName =  "1:phy0:100" ;
  92     String sourceDevice = "hwvtep://192.168.101.30:6640/physicalswitch/s3";
  93     String newline = System.getProperty("line.separator");
  94     String destinationDevice = "hwvtep:1";
  95     String portName1 = "phy0";
  96     String transportZone1 = "TZA" ;
  97     BigInteger dpId1 = BigInteger.valueOf(1);
  98     BigInteger dpId2 = BigInteger.valueOf(2);
  99     IpAddress gtwyIp1 = IpAddressBuilder.getDefaultInstance(gwyIp1);
 100     IpAddress ipAddress1 = IpAddressBuilder.getDefaultInstance(tepIp1);
 101     IpAddress ipAddress2 = IpAddressBuilder.getDefaultInstance(tepIp2);
 102     IpPrefix ipPrefixTest = IpPrefixBuilder.getDefaultInstance(subnetMask);
 103     ByteArrayOutputStream outContent = new ByteArrayOutputStream();
 104     TransportZone transportZone = null;
 105     TransportZone transportZoneNew = null;
 106     TransportZones transportZones = null;
 107     TransportZones transportZonesNew = null;
 108     TunnelMonitorInterval tunnelMonitorInterval = null;
 109     TunnelMonitorParams tunnelMonitorParams = null;
 110     Subnets subnetsTest = null;
 111     DeviceVteps deviceVteps = null;
 112     Vteps vteps = null;
 113     Vteps vtepsNew = null;
 114     Vteps vtepsTest = null;
 115     InternalTunnel internalTunnelTest = null;
 116     TunnelList tunnelList = null;
 117     TunnelList tunnelListTest = null;
 118     org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface
 119             interfaceTest = null;
 120     org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface
 121             interfaceTestNew = null;
 122     org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface
 123             interfaceTestNewCase = null;
 124     List<Subnets> subnetsList = new ArrayList<>() ;
 125     List<DeviceVteps> deviceVtepsList = new ArrayList<>();
 126     List<Vteps> vtepsList = new ArrayList<>();
 127     List<TransportZone> transportZoneList = new ArrayList<>();
 128     List<TransportZone> transportZoneListNew = new ArrayList<>();
 129     List<InternalTunnel> internalTunnelList = new ArrayList<>();
 130     List<String> lowerLayerIfList = new ArrayList<>();
 131     List<InstanceIdentifier> instanceIdentifierList = new ArrayList<>();
 132     java.lang.Class<? extends TunnelTypeBase> tunnelType1 = TunnelTypeVxlan.class;
 133     java.lang.Class<? extends TunnelTypeBase> tunnelType2 = TunnelTypeGre.class;
 134
 135     InstanceIdentifier<TransportZone> transportZoneIdentifier = InstanceIdentifier.builder(TransportZones.class)
 136             .child(TransportZone.class, new TransportZoneKey(transportZone1)).build();
 137     InstanceIdentifier<TransportZones> transportZonesIdentifier = InstanceIdentifier.builder(TransportZones.class).build();
 138     InstanceIdentifier<TunnelMonitorInterval> tunnelMonitorIntervalIdentifier = InstanceIdentifier.builder(TunnelMonitorInterval.class).build();
 139     InstanceIdentifier<TunnelMonitorParams> tunnelMonitorParamsIdentifier = InstanceIdentifier.builder(TunnelMonitorParams.class).build();
 140     InstanceIdentifier<Vteps> vtepsIdentifier = InstanceIdentifier.builder(TransportZones.class).child(TransportZone.class, new
 141             TransportZoneKey(transportZone1))
 142             .child(Subnets.class, new SubnetsKey(ipPrefixTest)).child(Vteps.class, new VtepsKey(dpId1,portName1)).build();
 143     InstanceIdentifier<Vteps> vtepsIdentifierNew = InstanceIdentifier.builder(TransportZones.class).child(TransportZone
 144             .class, new TransportZoneKey(transportZone1))
 145             .child(Subnets.class, new SubnetsKey(ipPrefixTest)).child(Vteps.class, new VtepsKey(dpId2,portName1)).build();
 146     InstanceIdentifier<Subnets> subnetsIdentifier = InstanceIdentifier.builder(TransportZones.class)
 147             .child(TransportZone.class, new TransportZoneKey(transportZone1)).child(Subnets.class,
 148                     new SubnetsKey(ipPrefixTest)).build();
 149     InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces
 150             .state.Interface> interfaceIdentifier = ItmUtils.buildStateInterfaceId(tunnelInterfaceName);
 151     InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces
 152             .Interface> interfaceIdentifierNew = ItmUtils.buildId(tunnelInterfaceName);
 153
 154     @Mock DataBroker dataBroker;
 155     @Mock ListenerRegistration<DataChangeListener> dataChangeListenerRegistration;
 156     @Mock ReadOnlyTransaction mockReadTx;
 157     @Mock WriteTransaction mockWriteTx;
 158     @Mock Map<String, Map<SubnetObject, List<Vteps>>> tZones;
 159
 160     Optional<TransportZone> optionalTransportZone;
 161     Optional<TransportZones> optionalTransportZones;
 162     Optional<TunnelMonitorInterval> optionalTunnelMonitorInterval;
 163     Optional<TunnelMonitorParams> optionalTunnelMonitorParams;
 164     Optional<Vteps> optionalVteps;
 165     Optional<Subnets> optionalSubnets;
 166     Optional<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state
 167             .Interface> ifStateOptional;
 168     Optional<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface>
 169             ifStateOptionalNew;
 170
 171     TepCommandHelper tepCommandHelper ;
 172
 173     @Before
 174     public void setUp() throws Exception {
 175         when(dataBroker.registerDataChangeListener(
 176                 any(LogicalDatastoreType.class),
 177                 any(InstanceIdentifier.class),
 178                 any(DataChangeListener.class),
 179                 any(AsyncDataBroker.DataChangeScope.class)))
 180                 .thenReturn(dataChangeListenerRegistration);
 181         setupMocks();
 182
 183         optionalTransportZone = Optional.of(transportZone);
 184         optionalTransportZones = Optional.of(transportZones);
 185         optionalTunnelMonitorInterval = Optional.of(tunnelMonitorInterval);
 186         optionalTunnelMonitorParams = Optional.of(tunnelMonitorParams);
 187         optionalVteps = Optional.of(vteps);
 188         optionalSubnets = Optional.of(subnetsTest);
 189         ifStateOptional = Optional.of(interfaceTest);
 190         ifStateOptionalNew = Optional.of(interfaceTestNew);
 191
 192         doReturn(Futures.immediateCheckedFuture(optionalTransportZone)).when(mockReadTx).read(LogicalDatastoreType
 193                 .CONFIGURATION,transportZoneIdentifier);
 194         doReturn(Futures.immediateCheckedFuture(optionalTransportZones)).when(mockReadTx).read(LogicalDatastoreType
 195                 .CONFIGURATION,transportZonesIdentifier);
 196         doReturn(Futures.immediateCheckedFuture(optionalTunnelMonitorInterval)).when(mockReadTx).read
 197                 (LogicalDatastoreType.CONFIGURATION,tunnelMonitorIntervalIdentifier);
 198         doReturn(Futures.immediateCheckedFuture(optionalTunnelMonitorParams)).when(mockReadTx).read
 199                 (LogicalDatastoreType.CONFIGURATION,tunnelMonitorParamsIdentifier);
 200         doReturn(Futures.immediateCheckedFuture(optionalVteps)).when(mockReadTx).read(LogicalDatastoreType
 201                 .CONFIGURATION,vtepsIdentifier);
 202         doReturn(Futures.immediateCheckedFuture(optionalSubnets)).when(mockReadTx).read(LogicalDatastoreType
 203                 .CONFIGURATION,subnetsIdentifier);
 204         doReturn(Futures.immediateCheckedFuture(ifStateOptional)).when(mockReadTx).read(LogicalDatastoreType
 205                 .OPERATIONAL,interfaceIdentifier);
 206         doReturn(Futures.immediateCheckedFuture(ifStateOptionalNew)).when(mockReadTx).read(LogicalDatastoreType
 207                 .CONFIGURATION,interfaceIdentifierNew);
 208
 209         tepCommandHelper = new TepCommandHelper(dataBroker);
 210
 211     }
 212
 213     @After
 214     public void cleanUp() {
 215     }
 216
 217     private void setupMocks() {
 218
 219         System.setOut(new PrintStream(outContent));
 220         instanceIdentifierList.add(transportZoneIdentifier);
 221         instanceIdentifierList.add(vtepsIdentifier);
 222         instanceIdentifierList.add(subnetsIdentifier);
 223         deviceVteps = new DeviceVtepsBuilder().setIpAddress(ipAddress1).setKey(new DeviceVtepsKey(ipAddress1,sourceDevice))
 224                 .setNodeId(sourceDevice).setTopologyId(destinationDevice).build();
 225         vteps = new VtepsBuilder().setPortname(portName1).setDpnId(dpId2).setIpAddress(ipAddress1).setKey(new
 226                 VtepsKey(dpId2,portName1)).build();
 227         vtepsNew = new VtepsBuilder().setPortname(portName1).setDpnId(dpId1).setIpAddress(ipAddress1).setKey(new
 228                 VtepsKey(dpId1,portName1)).build();
 229         vtepsTest = new VtepsBuilder().build();
 230         deviceVtepsList.add(deviceVteps);
 231         vtepsList.add(vteps);
 232         subnetsTest = new SubnetsBuilder().setGatewayIp(gtwyIp1).setVlanId(vlanId).setKey(new SubnetsKey(ipPrefixTest))
 233                 .setDeviceVteps(deviceVtepsList).setVteps(vtepsList).build();
 234         subnetsList.add(subnetsTest);
 235         transportZone = new TransportZoneBuilder().setZoneName(transportZone1).setTunnelType(tunnelType1).setKey(new
 236                 TransportZoneKey(transportZone1)).setSubnets(subnetsList).build();
 237         transportZoneNew = new TransportZoneBuilder().setZoneName(transportZone1).setTunnelType(tunnelType2).setKey(new
 238                 TransportZoneKey(transportZone1)).setSubnets(subnetsList).build();
 239         transportZoneList.add(transportZone);
 240         transportZones = new TransportZonesBuilder().setTransportZone(transportZoneList).build();
 241         transportZonesNew = new TransportZonesBuilder().setTransportZone(transportZoneListNew).build();
 242         tunnelMonitorInterval = new TunnelMonitorIntervalBuilder().setInterval(10000).build();
 243         tunnelMonitorParams = new TunnelMonitorParamsBuilder().setEnabled(true).build();
 244         internalTunnelTest = new InternalTunnelBuilder().setSourceDPN(dpId1).setDestinationDPN(dpId2)
 245                 .setTunnelInterfaceName(tunnelInterfaceName).setKey(new InternalTunnelKey(dpId1,dpId2,tunnelType1))
 246                 .setTransportType(tunnelType1).build();
 247         internalTunnelList.add(internalTunnelTest);
 248         tunnelList = new TunnelListBuilder().setInternalTunnel(internalTunnelList).build();
 249         tunnelListTest = new TunnelListBuilder().build();
 250         lowerLayerIfList.add(dpId1.toString());
 251         interfaceTest = new InterfaceBuilder().setOperStatus(Interface.OperStatus.Up).setAdminStatus
 252                 (org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.AdminStatus.Up)
 253                 .setPhysAddress(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.PhysAddress.getDefaultInstance("AA:AA:AA:AA:AA:AA"))
 254                 .setIfIndex(100).setLowerLayerIf(lowerLayerIfList).setType(L2vlan.class).build();
 255         interfaceTestNew = ItmUtils.buildTunnelInterface(dpId1, tunnelInterfaceName, destinationDevice, enabled,
 256                 TunnelTypeVxlan.class, ipAddress1, ipAddress2, gtwyIp1, vlanId, true, enabled,monitorProtocol, interval);
 257         interfaceTestNewCase = ItmUtils.buildTunnelInterface(dpId1, tunnelInterfaceName, destinationDevice, enabled,
 258                 TunnelTypeGre.class, ipAddress1, ipAddress2, gtwyIp1, vlanId, true, enabled, monitorProtocol, interval);
 259         doReturn(mockReadTx).when(dataBroker).newReadOnlyTransaction();
 260         doReturn(mockWriteTx).when(dataBroker).newWriteOnlyTransaction();
 261         doReturn(Futures.immediateCheckedFuture(null)).when(mockWriteTx).submit();
 262     }
 263
 264     @Test
 265     public void testCreateLocalCacheTzonesEmpty(){
 266
 267         tepCommandHelper.createLocalCache(dpId1,portName1,vlanId,tepIp1,subnetMask,gwyIp1,transportZone1);
 268
 269         verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,transportZoneIdentifier);
 270
 271     }
 272
 273     @Test
 274     public void testCreateLocalCacheWithoutcheckExistingSubnet(){
 275
 276         IpAddress gatewayIpObj = new IpAddress("0.0.0.0".toCharArray());
 277         IpPrefix subnetMaskObj = new IpPrefix(subnetMask.toCharArray());
 278         SubnetsKey subnetsKey = new SubnetsKey(subnetMaskObj);
 279         SubnetObject subObCli = new SubnetObject(gatewayIpObj, subnetsKey, subnetMaskObj, vlanId);
 280         Map<SubnetObject, List<Vteps>> subVtepMapTemp = new HashMap<SubnetObject, List<Vteps>>();
 281         subVtepMapTemp.put(subObCli, vtepsList);
 282         transportZoneNew = new TransportZoneBuilder().setZoneName(transportZone1).setTunnelType(tunnelType2).build();
 283
 284         Optional<TransportZone> optionalTransportZone = Optional.of(transportZoneNew);
 285
 286         doReturn(Futures.immediateCheckedFuture(optionalTransportZone)).when(mockReadTx).read(LogicalDatastoreType
 287                 .CONFIGURATION,transportZoneIdentifier);
 288         doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(LogicalDatastoreType
 289                 .CONFIGURATION,transportZonesIdentifier);
 290
 291         tepCommandHelper.createLocalCache(dpId1,portName1,vlanId,tepIp1,subnetMask,gwyIp1,transportZone1);
 292         tepCommandHelper.createLocalCache(dpId2,portName1,vlanId, tepIp1,subnetMask,gwyIp1, transportZone1);
 293
 294         verify(mockReadTx, times(2)).read(LogicalDatastoreType.CONFIGURATION,transportZoneIdentifier);
 295
 296     }
 297
 298     @Test
 299     public void testCreateLocalCacheWithcheckExistingSubnet(){
 300
 301         transportZoneNew = new TransportZoneBuilder().setZoneName(transportZone1).setTunnelType(tunnelType2).build();
 302
 303         Optional<TransportZone> optionalTransportZone = Optional.of(transportZoneNew);
 304
 305         doReturn(Futures.immediateCheckedFuture(optionalTransportZone)).when(mockReadTx).read(LogicalDatastoreType
 306                 .CONFIGURATION,transportZoneIdentifier);
 307         doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(LogicalDatastoreType
 308                 .CONFIGURATION,transportZonesIdentifier);
 309
 310         tepCommandHelper.createLocalCache(dpId1,portName1,vlanId,tepIp1,subnetMask,gwyIp1,transportZone1);
 311         tepCommandHelper.createLocalCache(dpId2,portName1,vlanId, tepIp1,subnetMask,gwyIp2, transportZone1);
 312
 313         verify(mockReadTx, times(2)).read(LogicalDatastoreType.CONFIGURATION,transportZoneIdentifier);
 314
 315     }
 316
 317     @Test
 318     public void testCreateLocalCacheInvalidIp(){
 319
 320         tepCommandHelper.createLocalCache(dpId1,portName1,vlanId,tepIp3,subnetMask,gwyIp1,transportZone1);
 321
 322         assertEquals("Invalid IpAddress. Expected: 1.0.0.0 to 254.255.255.255" + newline,outContent.toString());
 323
 324     }
 325
 326     @Test
 327     public void testCreateLocalCacheGtwyIpNull(){
 328
 329         tepCommandHelper.createLocalCache(dpId1,portName1,vlanId,tepIp1,subnetMask,null,transportZone1);
 330
 331         LOG.debug("gateway is null");
 332
 333     }
 334
 335     @Test
 336     public void testCreateLocalCacheInvalidSubnetMask(){
 337
 338         tepCommandHelper.createLocalCache(dpId1,portName1,vlanId,tepIp1,tepIp2,gwyIp1,transportZone1);
 339
 340         String newline = System.getProperty("line.separator");
 341         assertEquals("Invalid Subnet Mask. Expected: 0.0.0.0/0 to 255.255.255.255/32" + newline,outContent.toString());
 342
 343     }
 344
 345     @Test
 346     public void testCreateLocalCacheMismatchIpwithSubnet(){
 347
 348         tepCommandHelper.createLocalCache(dpId1,portName1,vlanId,tepIp4,subnetMask,gwyIp1,transportZone1);
 349
 350         assertEquals("IpAddress and gateWayIp should belong to the subnet provided" + newline,outContent.toString());
 351
 352     }
 353
 354     @Test
 355     public void testConfigureTunnelType(){
 356
 357         doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(LogicalDatastoreType
 358                 .CONFIGURATION,transportZoneIdentifier);
 359
 360         tepCommandHelper.configureTunnelType(transportZone1,"VXLAN");
 361
 362         verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,transportZoneIdentifier);
 363         verify(mockWriteTx).put(LogicalDatastoreType.CONFIGURATION,transportZonesIdentifier,transportZones,true);
 364
 365     }
 366
 367     @Test
 368     public void testConfigureTunnelMonitorInterval(){
 369
 370         TunnelMonitorInterval tunnelMonitor = new TunnelMonitorIntervalBuilder().setInterval(interval).build();
 371
 372         tepCommandHelper.configureTunnelMonitorInterval(interval);
 373
 374         verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,tunnelMonitorIntervalIdentifier);
 375         verify(mockWriteTx).merge(LogicalDatastoreType.CONFIGURATION,tunnelMonitorIntervalIdentifier,tunnelMonitor,true);
 376
 377     }
 378
 379     @Test
 380     public void testConfigureTunnelMonitorParams(){
 381
 382         TunnelMonitorParams tunnelMonitor = new TunnelMonitorParamsBuilder().setEnabled(enabled).setMonitorProtocol(monitorProtocol).build();
 383
 384         tepCommandHelper.configureTunnelMonitorParams(enabled, "BFD");
 385
 386         verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,tunnelMonitorParamsIdentifier);
 387         verify(mockWriteTx).merge(LogicalDatastoreType.CONFIGURATION,tunnelMonitorParamsIdentifier,tunnelMonitor,true);
 388
 389     }
 390
 391     @Test
 392     public void testDeleteVtep(){
 393
 394         tepCommandHelper.deleteVtep(dpId1,portName1,vlanId,tepIp1,subnetMask,gwyIp1,transportZone1);
 395
 396         verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,vtepsIdentifier);
 397         verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,subnetsIdentifier);
 398
 399     }
 400
 401     @Test
 402     public void testDeleteVtepInvalidIp(){
 403
 404         tepCommandHelper.deleteVtep(dpId1,portName1,vlanId,tepIp3,subnetMask,gwyIp1,transportZone1);
 405
 406         String newline = System.getProperty("line.separator");
 407         assertEquals("Invalid IpAddress. Expected: 1.0.0.0 to 254.255.255.255" + newline,outContent.toString());
 408
 409     }
 410
 411     @Test
 412     public void testDeleteVtepInvalidSubnetMask(){
 413
 414         tepCommandHelper.deleteVtep(dpId1,portName1,vlanId,tepIp1,tepIp1,gwyIp1,transportZone1);
 415
 416         assertEquals("Invalid Subnet Mask. Expected: 0.0.0.0/0 to 255.255.255.255/32" + newline,outContent.toString());
 417
 418     }
 419
 420     @Test
 421     public void testDeleteVtepGatewayIpNull(){
 422
 423         tepCommandHelper.deleteVtep(dpId1,portName1,vlanId,tepIp1,subnetMask,null,transportZone1);
 424
 425         LOG.debug("gateway is null in deleteVtep");
 426
 427     }
 428
 429     @Test
 430     public void testDeleteVtepIpSubnetMismatch(){
 431
 432         tepCommandHelper.deleteVtep(dpId1,portName1,vlanId,tepIp4,subnetMask,gwyIp1,transportZone1);
 433
 434         assertEquals("IpAddress and gateWayIp should belong to the subnet provided" + newline,outContent.toString());
 435
 436     }
 437
 438     @Test
 439     public void testBuildTepsTunnelTypeVxlan(){
 440
 441         tepCommandHelper.createLocalCache(dpId1,portName1,vlanId,tepIp1,subnetMask,gwyIp1,transportZone1);
 442         tepCommandHelper.buildTeps();
 443
 444         verify(mockReadTx, times(2)).read(LogicalDatastoreType.CONFIGURATION,transportZoneIdentifier);
 445         verify(mockWriteTx).merge(LogicalDatastoreType.CONFIGURATION,transportZonesIdentifier,transportZonesNew,true);
 446
 447     }
 448
 449     @Test
 450     public void testBuildTepsTunnelTypeGre(){
 451
 452         optionalTransportZone = Optional.of(transportZoneNew);
 453
 454         doReturn(Futures.immediateCheckedFuture(optionalTransportZone)).when(mockReadTx).read(LogicalDatastoreType
 455                 .CONFIGURATION,transportZoneIdentifier);
 456
 457         tepCommandHelper.createLocalCache(dpId1,portName1,vlanId,tepIp1,subnetMask,gwyIp1,transportZone1);
 458         tepCommandHelper.buildTeps();
 459
 460         verify(mockReadTx, times(2)).read(LogicalDatastoreType.CONFIGURATION,transportZoneIdentifier);
 461         verify(mockWriteTx).merge(LogicalDatastoreType.CONFIGURATION,transportZonesIdentifier,transportZonesNew,true);
 462
 463     }
 464
 465
 466     @Test
 467     public void testBuildTepsTransportZoneAbsent(){
 468
 469         optionalTransportZone = Optional.absent();
 470
 471         doReturn(Futures.immediateCheckedFuture(optionalTransportZone)).when(mockReadTx).read(LogicalDatastoreType
 472                 .CONFIGURATION,transportZoneIdentifier);
 473
 474         tepCommandHelper.createLocalCache(dpId1,portName1,vlanId,tepIp1,subnetMask,gwyIp1,transportZone1);
 475         tepCommandHelper.buildTeps();
 476
 477         verify(mockReadTx, times(2)).read(LogicalDatastoreType.CONFIGURATION,transportZoneIdentifier);
 478         verify(mockWriteTx).merge(LogicalDatastoreType.CONFIGURATION,transportZonesIdentifier,transportZonesNew,true);
 479
 480     }
 481
 482     @Test
 483     public void testShowTepsWithTransportZone(){
 484
 485         tepCommandHelper.showTeps(enabled,interval);
 486
 487         verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,transportZonesIdentifier);
 488
 489     }
 490
 491     @Test
 492     public void testShowTepsWithoutTransportZone(){
 493
 494         optionalTransportZones = Optional.of(transportZonesNew);
 495
 496         doReturn(Futures.immediateCheckedFuture(optionalTransportZones)).when(mockReadTx).read(LogicalDatastoreType
 497                 .CONFIGURATION,transportZonesIdentifier);
 498
 499         tepCommandHelper.showTeps(enabled,interval);
 500
 501         verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,transportZonesIdentifier);
 502         assertEquals("No teps configured" + newline,outContent.toString());
 503
 504     }
 505
 506     @Test
 507     public void testDeleteOnCommit(){
 508
 509         transportZoneList.add(transportZone);
 510         transportZoneList.add(transportZoneNew);
 511         transportZones = new TransportZonesBuilder().setTransportZone(transportZoneList).build();
 512         optionalTransportZones = Optional.of(transportZones);
 513
 514         doReturn(Futures.immediateCheckedFuture(optionalTransportZones)).when(mockReadTx).read(LogicalDatastoreType
 515                 .CONFIGURATION,transportZonesIdentifier);
 516
 517         tepCommandHelper.deleteVtep(dpId1,portName1,vlanId,tepIp1,subnetMask,gwyIp1,transportZone1);
 518         tepCommandHelper.deleteOnCommit();
 519
 520         verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,transportZonesIdentifier);
 521         verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,vtepsIdentifier);
 522         verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,subnetsIdentifier);
 523         verify(mockWriteTx).delete(LogicalDatastoreType.CONFIGURATION,vtepsIdentifierNew);
 524         verify(mockWriteTx).delete(LogicalDatastoreType.CONFIGURATION,subnetsIdentifier);
 525         verify(mockWriteTx).delete(LogicalDatastoreType.CONFIGURATION,transportZoneIdentifier);
 526
 527     }
 528
 529     @Test
 530     public void testShowStateTunnelTypeVxlan(){
 531
 532         tepCommandHelper.showState(tunnelList,enabled);
 533
 534         verify(mockReadTx).read(LogicalDatastoreType.OPERATIONAL,interfaceIdentifier);
 535         verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,interfaceIdentifierNew);
 536
 537     }
 538
 539     @Test
 540     public void testShowStateTunnelTypeGre(){
 541
 542         Optional<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface>
 543                 ifStateOptionalNew = Optional.of(interfaceTestNewCase);
 544
 545         doReturn(Futures.immediateCheckedFuture(ifStateOptionalNew)).when(mockReadTx).read(LogicalDatastoreType
 546                 .CONFIGURATION,interfaceIdentifierNew);
 547
 548         tepCommandHelper.showState(tunnelList,enabled);
 549
 550         verify(mockReadTx).read(LogicalDatastoreType.OPERATIONAL,interfaceIdentifier);
 551         verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,interfaceIdentifierNew);
 552
 553     }
 554
 555     @Test
 556     public void testShowStateTunnelAbsent(){
 557
 558         tepCommandHelper.showState(tunnelListTest, enabled);
 559
 560         assertEquals("No Internal Tunnels Exist" + newline,outContent.toString());
 561
 562     }
 563
 564     @Test
 565     public void testGetTransportZone(){
 566
 567         tepCommandHelper.getTransportZone(transportZone1);
 568
 569         verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,transportZoneIdentifier);
 570     }
 571
 572     @Test
 573     public void testIsInCache(){
 574
 575         tepCommandHelper.createLocalCache(dpId1,portName1,vlanId,tepIp1,subnetMask,gwyIp1,transportZone1);
 576         tepCommandHelper.isInCache(dpId1,portName1,vlanId,tepIp1,subnetMask,gwyIp1,transportZone1);
 577
 578         verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,transportZoneIdentifier);
 579
 580     }
 581
 582     @Test
 583     public void testValidateForDuplicates(){
 584
 585         tepCommandHelper.createLocalCache(dpId1,portName1,vlanId,tepIp1,subnetMask,gwyIp1,transportZone1);
 586         tepCommandHelper.validateForDuplicates(vtepsTest,transportZone1);
 587
 588         verify(mockReadTx, times(2)).read(LogicalDatastoreType.CONFIGURATION,transportZonesIdentifier);
 589
 590     }
 591
 592     @Test
 593     public void testCheckTepPerTzPerDpn(){
 594
 595         tepCommandHelper.createLocalCache(dpId1,portName1,vlanId,tepIp1,subnetMask,gwyIp1,transportZone1);
 596         tepCommandHelper.checkTepPerTzPerDpn(transportZone1,dpId2);
 597
 598         verify(mockReadTx, times(2)).read(LogicalDatastoreType.CONFIGURATION,transportZoneIdentifier);
 599
 600     }
 601
 602 }