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