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 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             .create(TransportZones.class).child(TransportZone.class, new TransportZoneKey(transportZone1));
 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 ReadTransaction 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(FluentFutures.immediateFluentFuture(optionalTransportZone)).when(mockReadTx).read(LogicalDatastoreType
 169                 .CONFIGURATION,transportZoneIdentifier);
 170         doReturn(FluentFutures.immediateFluentFuture(optionalTransportZones)).when(mockReadTx).read(LogicalDatastoreType
 171                 .CONFIGURATION,transportZonesIdentifier);
 172         doReturn(FluentFutures.immediateFluentFuture(optionalTunnelMonitorInterval)).when(mockReadTx)
 173                 .read(LogicalDatastoreType.CONFIGURATION,tunnelMonitorIntervalIdentifier);
 174         doReturn(FluentFutures.immediateFluentFuture(optionalTunnelMonitorParams)).when(mockReadTx)
 175                 .read(LogicalDatastoreType.CONFIGURATION,tunnelMonitorParamsIdentifier);
 176         doReturn(FluentFutures.immediateFluentFuture(optionalVteps)).when(mockReadTx)
 177                 .read(LogicalDatastoreType.CONFIGURATION,vtepsIdentifier);
 178         lenient().doReturn(FluentFutures.immediateFluentFuture(ifStateOptional)).when(mockReadTx)
 179                 .read(LogicalDatastoreType.OPERATIONAL,interfaceIdentifier);
 180         lenient().doReturn(FluentFutures.immediateFluentFuture(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(FluentFutures.immediateNullFluentFuture()).when(mockWriteTx).commit();
 235         doReturn(FluentFuture.from(FluentFutures.immediateFluentFuture(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(FluentFutures.immediateFluentFuture(Optional.of(transportZoneNew))).when(mockReadTx).read(
 258                 LogicalDatastoreType.CONFIGURATION,transportZoneIdentifier);
 259         lenient().doReturn(FluentFutures.immediateFluentFuture(Optional.empty()))
 260                 .when(mockReadTx).read(LogicalDatastoreType.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(FluentFutures.immediateFluentFuture(optionalTransportZone)).when(mockReadTx).read(LogicalDatastoreType
 282                 .CONFIGURATION,transportZoneIdentifier);
 283         lenient().doReturn(FluentFutures.immediateFluentFuture(Optional.empty()))
 284                 .when(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,transportZonesIdentifier);
 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     @SuppressWarnings("checkstyle:IllegalCatch")
 297     @Test
 298     public void testCreateLocalCacheGtwyIpNull() {
 299
 300         try {
 301             tepCommandHelper.createLocalCache(dpId1,tepIp1,transportZone1);
 302         } catch (TepException e) {
 303             LOG.error(e.getMessage());
 304         }
 305         LOG.debug("gateway is null");
 306     }
 307
 308     @Test
 309     public void testConfigureTunnelType() throws ExecutionException, InterruptedException {
 310         doReturn(FluentFutures.immediateFluentFuture(Optional.empty())).when(mockReadTx).read(LogicalDatastoreType
 311                 .CONFIGURATION,transportZoneIdentifier);
 312
 313         tepCommandHelper.configureTunnelType(transportZone1, "VXLAN");
 314
 315         verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION, transportZoneIdentifier);
 316
 317         final List<TransportZone> newList = new ArrayList<>(transportZoneList);
 318         newList.add(new TransportZoneBuilder().withKey(new TransportZoneKey(transportZone1))
 319             .setTunnelType(TunnelTypeVxlan.class).build());
 320
 321         verify(mockWriteTx).put(LogicalDatastoreType.CONFIGURATION, transportZonesIdentifier,
 322             new TransportZonesBuilder().setTransportZone(newList).build());
 323     }
 324
 325     @Test
 326     public void testConfigureTunnelMonitorInterval() {
 327
 328         TunnelMonitorInterval tunnelMonitor = new TunnelMonitorIntervalBuilder().setInterval(interval).build();
 329
 330         tepCommandHelper.configureTunnelMonitorInterval(interval);
 331
 332         verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,tunnelMonitorIntervalIdentifier);
 333         verify(mockWriteTx).merge(LogicalDatastoreType.CONFIGURATION,tunnelMonitorIntervalIdentifier,
 334                 tunnelMonitor,true);
 335     }
 336
 337     @Test
 338     public void testConfigureTunnelMonitorParams() {
 339
 340         TunnelMonitorParams tunnelMonitor = new TunnelMonitorParamsBuilder().setEnabled(enabled)
 341                 .setMonitorProtocol(monitorProtocol).build();
 342
 343         tepCommandHelper.configureTunnelMonitorParams(enabled, "BFD");
 344
 345         verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,tunnelMonitorParamsIdentifier);
 346         verify(mockWriteTx).merge(LogicalDatastoreType.CONFIGURATION,tunnelMonitorParamsIdentifier,
 347                 tunnelMonitor);
 348     }
 349
 350     @SuppressWarnings("checkstyle:IllegalCatch")
 351     @Test
 352     public void testDeleteVtep() {
 353
 354         try {
 355             tepCommandHelper.deleteVtep(dpId1, tepIp1, transportZone1);
 356         } catch (Exception e) {
 357             LOG.error(e.getMessage());
 358         }
 359
 360         verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,vtepsIdentifier);
 361     }
 362
 363     @SuppressWarnings("checkstyle:IllegalCatch")
 364     @Test
 365     public void testDeleteVtepGatewayIpNull() {
 366
 367         try {
 368             tepCommandHelper.deleteVtep(dpId1, tepIp1, transportZone1);
 369         }  catch (Exception e) {
 370             LOG.error(e.getMessage());
 371         }
 372
 373         LOG.debug("gateway is null in deleteVtep");
 374
 375     }
 376
 377     @SuppressWarnings("checkstyle:IllegalCatch")
 378     @Test
 379     public void testBuildTepsTunnelTypeVxlan() {
 380
 381         try {
 382             tepCommandHelper.createLocalCache(dpId1,tepIp1,transportZone1);
 383         } catch (TepException e) {
 384             LOG.error(e.getMessage());
 385         }
 386         tepCommandHelper.buildTeps();
 387
 388         verify(mockReadTx, times(2)).read(LogicalDatastoreType.CONFIGURATION,transportZoneIdentifier);
 389         verify(mockWriteTx).merge(LogicalDatastoreType.CONFIGURATION,transportZonesIdentifier,transportZonesNew,true);
 390
 391     }
 392
 393     @Test
 394     public void testBuildTepsTunnelTypeGre() {
 395
 396         doReturn(FluentFutures.immediateFluentFuture(Optional.of(transportZoneNew))).when(mockReadTx).read(
 397                 LogicalDatastoreType.CONFIGURATION, transportZoneIdentifier);
 398
 399         try {
 400             tepCommandHelper.createLocalCache(dpId1,tepIp1,transportZone1);
 401         } catch (TepException e) {
 402             LOG.error(e.getMessage());
 403         }
 404         tepCommandHelper.buildTeps();
 405
 406         verify(mockReadTx, times(2)).read(LogicalDatastoreType.CONFIGURATION,transportZoneIdentifier);
 407         verify(mockWriteTx).merge(LogicalDatastoreType.CONFIGURATION,transportZonesIdentifier,transportZonesNew,true);
 408
 409     }
 410
 411
 412     @Test
 413     public void testBuildTepsTransportZoneAbsent() throws TepException {
 414
 415         doReturn(FluentFutures.immediateFluentFuture(Optional.empty())).when(mockReadTx).read(LogicalDatastoreType
 416                 .CONFIGURATION,transportZoneIdentifier);
 417
 418         tepCommandHelper.createLocalCache(dpId1,tepIp1,transportZone1);
 419         tepCommandHelper.buildTeps();
 420
 421         verify(mockReadTx, times(2)).read(LogicalDatastoreType.CONFIGURATION,transportZoneIdentifier);
 422         verify(mockWriteTx).merge(LogicalDatastoreType.CONFIGURATION,transportZonesIdentifier,transportZonesNew,true);
 423
 424     }
 425
 426     @Test
 427     public void testShowTepsWithTransportZone() {
 428
 429         try {
 430             tepCommandHelper.showTeps(enabled, interval);
 431         } catch (TepException e) {
 432             LOG.error(e.getMessage());
 433         }
 434
 435         verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,transportZonesIdentifier);
 436
 437     }
 438
 439     @Test
 440     public void testShowTepsWithoutTransportZone() {
 441
 442         optionalTransportZones = Optional.of(transportZonesNew);
 443
 444         doReturn(FluentFutures.immediateFluentFuture(optionalTransportZones)).when(mockReadTx).read(LogicalDatastoreType
 445                 .CONFIGURATION,transportZonesIdentifier);
 446
 447         String output = null;
 448         try {
 449             tepCommandHelper.showTeps(enabled, interval);
 450         } catch (TepException e) {
 451             output = e.getMessage();
 452         }
 453
 454         verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,transportZonesIdentifier);
 455         assertEquals("No teps configured",output);
 456
 457     }
 458
 459     @Test
 460     public void testDeleteOnCommit() {
 461
 462         transportZoneList.add(transportZone);
 463         transportZoneList.add(transportZoneNew);
 464         transportZones = new TransportZonesBuilder().setTransportZone(transportZoneList).build();
 465         optionalTransportZones = Optional.of(transportZones);
 466
 467         doReturn(FluentFutures.immediateFluentFuture(optionalTransportZones)).when(mockReadTx).read(LogicalDatastoreType
 468                 .CONFIGURATION,transportZonesIdentifier);
 469
 470         try {
 471             tepCommandHelper.deleteVtep(dpId1, tepIp1, transportZone1);
 472         } catch (TepException e) {
 473             LOG.error(e.getMessage());
 474         }
 475         tepCommandHelper.deleteOnCommit();
 476
 477         verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,vtepsIdentifier);
 478     }
 479
 480     @Test
 481     public void testGetTransportZone() {
 482
 483         tepCommandHelper.getTransportZone(transportZone1);
 484
 485         verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,transportZoneIdentifier);
 486     }
 487
 488     @Test
 489     public void testIsInCache() {
 490
 491         try {
 492             tepCommandHelper.createLocalCache(dpId1, tepIp1, transportZone1);
 493             tepCommandHelper.isInCache(dpId1, tepIp1 ,transportZone1);
 494         } catch (TepException e) {
 495             LOG.error(e.getMessage());
 496         }
 497         verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,transportZoneIdentifier);
 498     }
 499
 500     @Test
 501     public void testCheckTepPerTzPerDpn() {
 502
 503         try {
 504             tepCommandHelper.createLocalCache(dpId1,tepIp1,transportZone1);
 505         } catch (TepException e) {
 506             LOG.error(e.getMessage());
 507         }
 508         tepCommandHelper.checkTepPerTzPerDpn(transportZone1,dpId2);
 509
 510         verify(mockReadTx, times(2)).read(LogicalDatastoreType.CONFIGURATION,transportZoneIdentifier);
 511
 512     }
 513
 514 }