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

   1 /*
   2  * Copyright (c) 2016, 2017 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.Mockito.doReturn;
  13 import static org.mockito.Mockito.lenient;
  14 import static org.mockito.Mockito.times;
  15 import static org.mockito.Mockito.verify;
  16
  17 import java.io.ByteArrayOutputStream;
  18 import java.io.PrintStream;
  19 import java.util.ArrayList;
  20 import java.util.Collections;
  21 import java.util.List;
  22 import java.util.Optional;
  23 import java.util.concurrent.ExecutionException;
  24 import org.junit.After;
  25 import org.junit.Before;
  26 import org.junit.Test;
  27 import org.junit.runner.RunWith;
  28 import org.mockito.Mock;
  29 import org.mockito.junit.MockitoJUnitRunner;
  30 import org.opendaylight.genius.itm.cache.UnprocessedTunnelsStateCache;
  31 import org.opendaylight.genius.itm.globals.ITMConstants;
  32 import org.opendaylight.genius.itm.impl.ItmUtils;
  33 import org.opendaylight.mdsal.binding.api.DataBroker;
  34 import org.opendaylight.mdsal.binding.api.ReadTransaction;
  35 import org.opendaylight.mdsal.binding.api.WriteTransaction;
  36 import org.opendaylight.mdsal.common.api.CommitInfo;
  37 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  38 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev170119.L2vlan;
  39 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
  40 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddressBuilder;
  41 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
  42 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.InterfaceBuilder;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelMonitoringTypeBase;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeBase;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeGre;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeVxlan;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.ItmConfig;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.TunnelMonitorInterval;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.TunnelMonitorIntervalBuilder;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.TunnelMonitorParams;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.TunnelMonitorParamsBuilder;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TunnelOperStatus;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnel.list.InternalTunnel;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnel.list.InternalTunnelBuilder;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnel.list.InternalTunnelKey;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.StateTunnelList;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnels_state.StateTunnelListBuilder;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.TransportZones;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.TransportZonesBuilder;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZone;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZoneBuilder;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZoneKey;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.DeviceVteps;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.DeviceVtepsBuilder;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.DeviceVtepsKey;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.Vteps;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.VtepsBuilder;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.VtepsKey;
  69 import org.opendaylight.yangtools.util.concurrent.FluentFutures;
  70 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  71 import org.opendaylight.yangtools.yang.common.Uint64;
  72 import org.slf4j.Logger;
  73 import org.slf4j.LoggerFactory;
  74
  75 @RunWith(MockitoJUnitRunner.class)
  76 public class TepCommandHelperTest {
  77
  78     private static final Logger LOG = LoggerFactory.getLogger(TepCommandHelper.class);
  79
  80     private final int interval = 1000;
  81     private final Boolean enabled = false ;
  82     private final Class<? extends TunnelMonitoringTypeBase> monitorProtocol = ITMConstants.DEFAULT_MONITOR_PROTOCOL;
  83     private final String tepIp1 = "192.168.56.30";
  84     private final String tepIp2 = "192.168.56.102";
  85     private final String tepIp3 = "168.56.102";
  86     private final String tepIp4 = "150.168.56.102";
  87     private final String gwyIp1 = "192.168.56.105";
  88     private final String subnetMask = "192.168.56.100/24";
  89     private final String tunnelInterfaceName =  "1:phy0:100" ;
  90     private final String sourceDevice = "hwvtep://192.168.101.30:6640/physicalswitch/s3";
  91     private final String destinationDevice = "hwvtep:1";
  92     private final String transportZone1 = "TZA" ;
  93     private final Uint64 dpId1 = Uint64.ONE;
  94     private final Uint64 dpId2 = Uint64.valueOf(2);
  95     private final IpAddress ipAddress1 = IpAddressBuilder.getDefaultInstance(tepIp1);
  96     private final IpAddress ipAddress2 = IpAddressBuilder.getDefaultInstance(tepIp2);
  97     private final ByteArrayOutputStream outContent = new ByteArrayOutputStream();
  98     private TransportZone transportZone = null;
  99     private TransportZone transportZoneNew = null;
 100     private TransportZones transportZones = null;
 101     private TransportZones transportZonesNew = null;
 102     private TunnelMonitorInterval tunnelMonitorInterval = null;
 103     private TunnelMonitorParams tunnelMonitorParams = null;
 104     private Vteps vteps = null;
 105     private Vteps vtepsTest = null;
 106     private TransportZone mergeTransportZone = null;
 107     private TransportZone mergeTransportZoneGre = null;
 108     private TransportZones mergeParentTransportZones = null;
 109     private TransportZones mergeParentTransportZonesGre = null;
 110     private Vteps mergeVteps = null;
 111     private final List<Vteps> mergeVtepsList = new ArrayList<>();
 112     private final List<TransportZone> mergeParentTransportZoneList = new ArrayList<>();
 113     private final List<TransportZone> mergeParentTransportZoneListGre = new ArrayList<>();
 114     private org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state
 115             .Interface interfaceTest = null;
 116     private org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface
 117             interfaceTestNew = null;
 118     private final List<DeviceVteps> deviceVtepsList = new ArrayList<>();
 119     private final List<Vteps> vtepsList = new ArrayList<>();
 120     private final List<TransportZone> transportZoneList = new ArrayList<>();
 121     private final List<TransportZone> transportZoneListNew = new ArrayList<>();
 122     private final List<InternalTunnel> internalTunnelList = new ArrayList<>();
 123     private final List<StateTunnelList> stateTunnelList = new ArrayList<>() ;
 124     private final List<String> lowerLayerIfList = new ArrayList<>();
 125     private final List<InstanceIdentifier> instanceIdentifierList = new ArrayList<>();
 126     private final java.lang.Class<? extends TunnelTypeBase> tunnelType1 = TunnelTypeVxlan.class;
 127     private final java.lang.Class<? extends TunnelTypeBase> tunnelType2 = TunnelTypeGre.class;
 128
 129     private final InstanceIdentifier<TransportZone> transportZoneIdentifier = InstanceIdentifier
 130             .create(TransportZones.class).child(TransportZone.class, new TransportZoneKey(transportZone1));
 131     private final InstanceIdentifier<TransportZones> transportZonesIdentifier =
 132             InstanceIdentifier.builder(TransportZones.class).build();
 133     private final InstanceIdentifier<TunnelMonitorInterval> tunnelMonitorIntervalIdentifier =
 134             InstanceIdentifier.builder(TunnelMonitorInterval.class).build();
 135     private final InstanceIdentifier<TunnelMonitorParams> tunnelMonitorParamsIdentifier =
 136             InstanceIdentifier.builder(TunnelMonitorParams.class).build();
 137     private final InstanceIdentifier<Vteps> vtepsIdentifier = InstanceIdentifier.builder(TransportZones.class)
 138                     .child(TransportZone.class, new TransportZoneKey(transportZone1))
 139                     .child(Vteps.class, new VtepsKey(dpId1)).build();
 140     private final InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces
 141             .rev140508.interfaces.state.Interface>
 142             interfaceIdentifier = ItmUtils.buildStateInterfaceId(tunnelInterfaceName);
 143     private final InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces
 144             .rev140508.interfaces.Interface>
 145             interfaceIdentifierNew = ItmUtils.buildId(tunnelInterfaceName);
 146
 147     @Mock
 148     private DataBroker dataBroker;
 149     @Mock
 150     private ItmConfig itmConfig;
 151     @Mock
 152     private ReadTransaction mockReadTx;
 153     @Mock
 154     private WriteTransaction mockWriteTx;
 155
 156     private Optional<TransportZones> optionalTransportZones;
 157
 158     private TepCommandHelper tepCommandHelper ;
 159     private UnprocessedTunnelsStateCache unprocessedTunnelsStateCache;
 160
 161     @Before
 162     public void setUp() {
 163         setupMocks();
 164
 165         Optional<TransportZone> optionalTransportZone = Optional.of(transportZone);
 166         optionalTransportZones = Optional.of(transportZones);
 167         Optional<TunnelMonitorInterval> optionalTunnelMonitorInterval = Optional.of(tunnelMonitorInterval);
 168         Optional<TunnelMonitorParams> optionalTunnelMonitorParams = Optional.of(tunnelMonitorParams);
 169         Optional<Vteps> optionalVteps = Optional.of(vteps);
 170         Optional<Interface> ifStateOptional = Optional.of(interfaceTest);
 171         Optional<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces
 172                 .Interface>
 173                 ifStateOptionalNew = Optional.of(interfaceTestNew);
 174
 175         doReturn(FluentFutures.immediateFluentFuture(optionalTransportZone)).when(mockReadTx).read(LogicalDatastoreType
 176                 .CONFIGURATION,transportZoneIdentifier);
 177         doReturn(FluentFutures.immediateFluentFuture(optionalTransportZones)).when(mockReadTx).read(LogicalDatastoreType
 178                 .CONFIGURATION,transportZonesIdentifier);
 179         doReturn(FluentFutures.immediateFluentFuture(optionalTunnelMonitorInterval)).when(mockReadTx)
 180                 .read(LogicalDatastoreType.CONFIGURATION,tunnelMonitorIntervalIdentifier);
 181         doReturn(FluentFutures.immediateFluentFuture(optionalTunnelMonitorParams)).when(mockReadTx)
 182                 .read(LogicalDatastoreType.CONFIGURATION,tunnelMonitorParamsIdentifier);
 183         doReturn(FluentFutures.immediateFluentFuture(optionalVteps)).when(mockReadTx)
 184                 .read(LogicalDatastoreType.CONFIGURATION,vtepsIdentifier);
 185         lenient().doReturn(FluentFutures.immediateFluentFuture(ifStateOptional)).when(mockReadTx)
 186                 .read(LogicalDatastoreType.OPERATIONAL,interfaceIdentifier);
 187         lenient().doReturn(FluentFutures.immediateFluentFuture(ifStateOptionalNew)).when(mockReadTx)
 188                 .read(LogicalDatastoreType.CONFIGURATION,interfaceIdentifierNew);
 189
 190         unprocessedTunnelsStateCache = new UnprocessedTunnelsStateCache();
 191         tepCommandHelper = new TepCommandHelper(dataBroker, itmConfig,
 192                 unprocessedTunnelsStateCache);
 193
 194     }
 195
 196     @After
 197     public void cleanUp() {
 198     }
 199
 200     private void setupMocks() {
 201
 202         System.setOut(new PrintStream(outContent));
 203         instanceIdentifierList.add(transportZoneIdentifier);
 204         instanceIdentifierList.add(vtepsIdentifier);
 205         DeviceVteps deviceVteps = new DeviceVtepsBuilder().setIpAddress(ipAddress1)
 206                 .withKey(new DeviceVtepsKey(ipAddress1, sourceDevice))
 207                 .setNodeId(sourceDevice).setTopologyId(destinationDevice).build();
 208         vteps = new VtepsBuilder().setDpnId(dpId2)
 209                 .setIpAddress(ipAddress1).withKey(new VtepsKey(dpId2)).build();
 210         vtepsTest = new VtepsBuilder().setDpnId(Uint64.TEN).build();
 211         deviceVtepsList.add(deviceVteps);
 212         vtepsList.add(vteps);
 213         transportZone = new TransportZoneBuilder().setZoneName(transportZone1).setTunnelType(tunnelType1).withKey(new
 214                 TransportZoneKey(transportZone1)).setDeviceVteps(deviceVtepsList).setVteps(vtepsList).build();
 215         transportZoneNew = new TransportZoneBuilder().setZoneName(transportZone1).setTunnelType(tunnelType2).withKey(new
 216                 TransportZoneKey(transportZone1)).setDeviceVteps(deviceVtepsList).setVteps(vtepsList).build();
 217         transportZoneList.add(transportZone);
 218         transportZones = new TransportZonesBuilder().setTransportZone(transportZoneList).build();
 219         transportZonesNew = new TransportZonesBuilder().setTransportZone(transportZoneListNew).build();
 220         mergeVteps = new VtepsBuilder().setDpnId(dpId2)
 221                 .setIpAddress(ipAddress1).withKey(new VtepsKey(dpId1)).build();
 222         mergeVtepsList.add(mergeVteps);
 223         mergeTransportZone =
 224                 new TransportZoneBuilder().withKey(new TransportZoneKey(transportZone1))
 225                         .setTunnelType(tunnelType1).setZoneName(transportZone1).setVteps(mergeVtepsList)
 226                         .build();
 227         mergeParentTransportZoneList.add(mergeTransportZone);
 228         mergeParentTransportZones = new TransportZonesBuilder().setTransportZone(mergeParentTransportZoneList).build();
 229         mergeTransportZoneGre =
 230                 new TransportZoneBuilder().withKey(new TransportZoneKey(transportZone1))
 231                         .setTunnelType(tunnelType2).setZoneName(transportZone1).setVteps(mergeVtepsList)
 232                         .build();
 233         mergeParentTransportZoneListGre.add(mergeTransportZoneGre);
 234         mergeParentTransportZonesGre = new TransportZonesBuilder().setTransportZone(mergeParentTransportZoneListGre)
 235                 .build();
 236         tunnelMonitorInterval = new TunnelMonitorIntervalBuilder().setInterval(10000).build();
 237         tunnelMonitorParams = new TunnelMonitorParamsBuilder().setEnabled(true).build();
 238         InternalTunnel internalTunnelTest = new InternalTunnelBuilder().setSourceDPN(dpId1).setDestinationDPN(dpId2)
 239                 .setTunnelInterfaceNames(Collections.singletonList(tunnelInterfaceName))
 240                 .withKey(new InternalTunnelKey(dpId1, dpId2, tunnelType1)).setTransportType(tunnelType1).build();
 241         internalTunnelList.add(internalTunnelTest);
 242         StateTunnelList stateTunnelListTest = new StateTunnelListBuilder().setTunnelInterfaceName(tunnelInterfaceName)
 243                 .setOperState(TunnelOperStatus.Up).build();
 244         stateTunnelList.add(stateTunnelListTest);
 245         lowerLayerIfList.add(dpId1.toString());
 246         interfaceTest = new InterfaceBuilder().setName("foo").setOperStatus(Interface.OperStatus.Up)
 247                 .setAdminStatus(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508
 248                         .interfaces.state.Interface.AdminStatus.Up)
 249                 .setPhysAddress(org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715
 250                         .PhysAddress.getDefaultInstance("AA:AA:AA:AA:AA:AA"))
 251                 .setIfIndex(100).setLowerLayerIf(lowerLayerIfList).setType(L2vlan.class).build();
 252         interfaceTestNew = ItmUtils.buildTunnelInterface(dpId1, tunnelInterfaceName, destinationDevice, enabled,
 253                 TunnelTypeVxlan.class, ipAddress1, ipAddress2, true, enabled,monitorProtocol,
 254                 interval, false, null);
 255         doReturn(mockReadTx).when(dataBroker).newReadOnlyTransaction();
 256         doReturn(mockWriteTx).when(dataBroker).newWriteOnlyTransaction();
 257         lenient().doReturn(FluentFutures.immediateNullFluentFuture()).when(mockWriteTx).commit();
 258         doReturn(CommitInfo.emptyFluentFuture()).when(mockWriteTx).commit();
 259     }
 260
 261     @Test
 262     public void testCreateLocalCacheTzonesEmpty() {
 263
 264         try {
 265             tepCommandHelper.createLocalCache(dpId1,tepIp1,transportZone1);
 266         } catch (TepException e) {
 267             LOG.error(e.getMessage());
 268         }
 269
 270         verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,transportZoneIdentifier);
 271
 272     }
 273
 274     @Test
 275     public void testCreateLocalCacheWithoutcheckExistingSubnet() {
 276
 277         transportZoneNew = new TransportZoneBuilder().setZoneName(transportZone1).setTunnelType(tunnelType2)
 278                 .setDeviceVteps(deviceVtepsList).setVteps(vtepsList).build();
 279
 280         doReturn(FluentFutures.immediateFluentFuture(Optional.of(transportZoneNew))).when(mockReadTx).read(
 281                 LogicalDatastoreType.CONFIGURATION,transportZoneIdentifier);
 282         lenient().doReturn(FluentFutures.immediateFluentFuture(Optional.empty()))
 283                 .when(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,transportZonesIdentifier);
 284
 285         try {
 286             tepCommandHelper.createLocalCache(dpId1,tepIp1,transportZone1);
 287             tepCommandHelper.createLocalCache(dpId2,tepIp1,transportZone1);
 288         } catch (TepException e) {
 289             LOG.error(e.getMessage());
 290         }
 291
 292         verify(mockReadTx, times(2)).read(LogicalDatastoreType.CONFIGURATION,transportZoneIdentifier);
 293
 294     }
 295
 296     @Test
 297     public void testCreateLocalCacheWithcheckExistingSubnet() {
 298
 299         transportZoneNew = new TransportZoneBuilder().setZoneName(transportZone1).setTunnelType(tunnelType2)
 300                 .setDeviceVteps(deviceVtepsList).setVteps(vtepsList).build();
 301
 302         Optional<TransportZone> optionalTransportZone = Optional.of(transportZoneNew);
 303
 304         doReturn(FluentFutures.immediateFluentFuture(optionalTransportZone)).when(mockReadTx).read(LogicalDatastoreType
 305                 .CONFIGURATION,transportZoneIdentifier);
 306         lenient().doReturn(FluentFutures.immediateFluentFuture(Optional.empty()))
 307                 .when(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,transportZonesIdentifier);
 308         try {
 309             tepCommandHelper.createLocalCache(dpId1,tepIp1,transportZone1);
 310             tepCommandHelper.createLocalCache(dpId2,tepIp1,transportZone1);
 311         } catch (TepException e) {
 312             LOG.error(e.getMessage());
 313         }
 314
 315         verify(mockReadTx, times(2)).read(LogicalDatastoreType.CONFIGURATION,transportZoneIdentifier);
 316
 317     }
 318
 319     @SuppressWarnings("checkstyle:IllegalCatch")
 320     @Test
 321     public void testCreateLocalCacheGtwyIpNull() {
 322
 323         try {
 324             tepCommandHelper.createLocalCache(dpId1,tepIp1,transportZone1);
 325         } catch (TepException e) {
 326             LOG.error(e.getMessage());
 327         }
 328         LOG.debug("gateway is null");
 329     }
 330
 331     @Test
 332     public void testConfigureTunnelType() throws ExecutionException, InterruptedException {
 333         doReturn(FluentFutures.immediateFluentFuture(Optional.empty())).when(mockReadTx).read(LogicalDatastoreType
 334                 .CONFIGURATION,transportZoneIdentifier);
 335
 336         tepCommandHelper.configureTunnelType(transportZone1, "VXLAN");
 337
 338         verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION, transportZoneIdentifier);
 339
 340         final List<TransportZone> newList = new ArrayList<>(transportZoneList);
 341         newList.add(new TransportZoneBuilder().withKey(new TransportZoneKey(transportZone1))
 342             .setTunnelType(TunnelTypeVxlan.class).build());
 343
 344         verify(mockWriteTx).put(LogicalDatastoreType.CONFIGURATION, transportZonesIdentifier,
 345             new TransportZonesBuilder().setTransportZone(newList).build());
 346     }
 347
 348     @Test
 349     public void testConfigureTunnelMonitorInterval() {
 350
 351         TunnelMonitorInterval tunnelMonitor = new TunnelMonitorIntervalBuilder().setInterval(interval).build();
 352
 353         tepCommandHelper.configureTunnelMonitorInterval(interval);
 354
 355         verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,tunnelMonitorIntervalIdentifier);
 356         verify(mockWriteTx).mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION,
 357                 tunnelMonitorIntervalIdentifier, tunnelMonitor);
 358     }
 359
 360     @Test
 361     public void testConfigureTunnelMonitorParams() {
 362
 363         TunnelMonitorParams tunnelMonitor = new TunnelMonitorParamsBuilder().setEnabled(enabled)
 364                 .setMonitorProtocol(monitorProtocol).build();
 365
 366         tepCommandHelper.configureTunnelMonitorParams(enabled, "BFD");
 367
 368         verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,tunnelMonitorParamsIdentifier);
 369         verify(mockWriteTx).merge(LogicalDatastoreType.CONFIGURATION,tunnelMonitorParamsIdentifier,
 370                 tunnelMonitor);
 371     }
 372
 373     @SuppressWarnings("checkstyle:IllegalCatch")
 374     @Test
 375     public void testDeleteVtep() {
 376
 377         try {
 378             tepCommandHelper.deleteVtep(dpId1, tepIp1, transportZone1);
 379         } catch (Exception e) {
 380             LOG.error(e.getMessage());
 381         }
 382
 383         verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,vtepsIdentifier);
 384     }
 385
 386     @SuppressWarnings("checkstyle:IllegalCatch")
 387     @Test
 388     public void testDeleteVtepGatewayIpNull() {
 389
 390         try {
 391             tepCommandHelper.deleteVtep(dpId1, tepIp1, transportZone1);
 392         }  catch (Exception e) {
 393             LOG.error(e.getMessage());
 394         }
 395
 396         LOG.debug("gateway is null in deleteVtep");
 397
 398     }
 399
 400     @SuppressWarnings("checkstyle:IllegalCatch")
 401     @Test
 402     public void testBuildTepsTunnelTypeVxlan() {
 403
 404         try {
 405             tepCommandHelper.createLocalCache(dpId1,tepIp1,transportZone1);
 406         } catch (TepException e) {
 407             LOG.error(e.getMessage());
 408         }
 409         tepCommandHelper.buildTeps();
 410
 411         verify(mockReadTx, times(2)).read(LogicalDatastoreType.CONFIGURATION,transportZoneIdentifier);
 412         verify(mockWriteTx).mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION,transportZonesIdentifier,
 413                 mergeParentTransportZones);
 414     }
 415
 416     @Test
 417     public void testBuildTepsTunnelTypeGre() {
 418
 419         doReturn(FluentFutures.immediateFluentFuture(Optional.of(transportZoneNew))).when(mockReadTx).read(
 420                 LogicalDatastoreType.CONFIGURATION, transportZoneIdentifier);
 421
 422         try {
 423             tepCommandHelper.createLocalCache(dpId1,tepIp1,transportZone1);
 424         } catch (TepException e) {
 425             LOG.error(e.getMessage());
 426         }
 427         tepCommandHelper.buildTeps();
 428
 429         verify(mockReadTx, times(2)).read(LogicalDatastoreType.CONFIGURATION,transportZoneIdentifier);
 430         verify(mockWriteTx).mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION,transportZonesIdentifier,
 431                 mergeParentTransportZonesGre);
 432
 433     }
 434
 435
 436     @Test
 437     public void testBuildTepsTransportZoneAbsent() throws TepException {
 438
 439         doReturn(FluentFutures.immediateFluentFuture(Optional.empty())).when(mockReadTx).read(LogicalDatastoreType
 440                 .CONFIGURATION,transportZoneIdentifier);
 441
 442         tepCommandHelper.createLocalCache(dpId1,tepIp1,transportZone1);
 443         tepCommandHelper.buildTeps();
 444
 445         verify(mockReadTx, times(2)).read(LogicalDatastoreType.CONFIGURATION,transportZoneIdentifier);
 446         verify(mockWriteTx).mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION,transportZonesIdentifier,
 447                 mergeParentTransportZones);
 448
 449     }
 450
 451     @Test
 452     public void testShowTepsWithTransportZone() {
 453
 454         try {
 455             tepCommandHelper.showTeps(enabled, interval);
 456         } catch (TepException e) {
 457             LOG.error(e.getMessage());
 458         }
 459
 460         verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,transportZonesIdentifier);
 461
 462     }
 463
 464     @Test
 465     public void testShowTepsWithoutTransportZone() {
 466
 467         optionalTransportZones = Optional.of(transportZonesNew);
 468
 469         doReturn(FluentFutures.immediateFluentFuture(optionalTransportZones)).when(mockReadTx).read(LogicalDatastoreType
 470                 .CONFIGURATION,transportZonesIdentifier);
 471
 472         String output = null;
 473         try {
 474             tepCommandHelper.showTeps(enabled, interval);
 475         } catch (TepException e) {
 476             output = e.getMessage();
 477         }
 478
 479         verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,transportZonesIdentifier);
 480         assertEquals("No teps configured",output);
 481
 482     }
 483
 484     @Test
 485     public void testDeleteOnCommit() {
 486
 487         transportZoneList.add(transportZone);
 488         transportZoneList.add(transportZoneNew);
 489         transportZones = new TransportZonesBuilder().setTransportZone(transportZoneList).build();
 490         optionalTransportZones = Optional.of(transportZones);
 491
 492         doReturn(FluentFutures.immediateFluentFuture(optionalTransportZones)).when(mockReadTx).read(LogicalDatastoreType
 493                 .CONFIGURATION,transportZonesIdentifier);
 494
 495         try {
 496             tepCommandHelper.deleteVtep(dpId1, tepIp1, transportZone1);
 497         } catch (TepException e) {
 498             LOG.error(e.getMessage());
 499         }
 500         tepCommandHelper.deleteOnCommit();
 501
 502         verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,vtepsIdentifier);
 503     }
 504
 505     @Test
 506     public void testGetTransportZone() {
 507
 508         tepCommandHelper.getTransportZone(transportZone1);
 509
 510         verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,transportZoneIdentifier);
 511     }
 512
 513     @Test
 514     public void testIsInCache() {
 515
 516         try {
 517             tepCommandHelper.createLocalCache(dpId1, tepIp1, transportZone1);
 518             tepCommandHelper.isInCache(dpId1, tepIp1 ,transportZone1);
 519         } catch (TepException e) {
 520             LOG.error(e.getMessage());
 521         }
 522         verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,transportZoneIdentifier);
 523     }
 524
 525     @Test
 526     public void testCheckTepPerTzPerDpn() {
 527
 528         try {
 529             tepCommandHelper.createLocalCache(dpId1,tepIp1,transportZone1);
 530         } catch (TepException e) {
 531             LOG.error(e.getMessage());
 532         }
 533         tepCommandHelper.checkTepPerTzPerDpn(transportZone1,dpId2);
 534
 535         verify(mockReadTx, times(2)).read(LogicalDatastoreType.CONFIGURATION,transportZoneIdentifier);
 536
 537     }
 538
 539 }