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