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