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