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