itm/itm-impl/src/test/java/org/opendaylight/genius/itm/impl/ItmManagerRpcServiceTest.java

   1 /*
   2  * Copyright (c) 2016 Ericsson India Global Services Pvt Ltd. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.genius.itm.impl;
   9
  10 import static org.mockito.Mockito.doReturn;
  11 import static org.mockito.Mockito.lenient;
  12 import static org.mockito.Mockito.verify;
  13
  14 import java.util.ArrayList;
  15 import java.util.Collections;
  16 import java.util.List;
  17 import java.util.Optional;
  18 import org.junit.After;
  19 import org.junit.Before;
  20 import org.junit.Ignore;
  21 import org.junit.Test;
  22 import org.junit.runner.RunWith;
  23 import org.mockito.Mock;
  24 import org.mockito.junit.MockitoJUnitRunner;
  25 import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
  26 import org.opendaylight.genius.interfacemanager.interfaces.InterfaceManagerService;
  27 import org.opendaylight.genius.itm.cache.DPNTEPsInfoCache;
  28 import org.opendaylight.genius.itm.cache.DpnTepStateCache;
  29 import org.opendaylight.genius.itm.cache.OfDpnTepConfigCache;
  30 import org.opendaylight.genius.itm.cache.OfTepStateCache;
  31 import org.opendaylight.genius.itm.cache.OvsBridgeRefEntryCache;
  32 import org.opendaylight.genius.itm.cache.TunnelStateCache;
  33 import org.opendaylight.genius.itm.cache.UnprocessedNodeConnectorCache;
  34 import org.opendaylight.genius.itm.cache.UnprocessedNodeConnectorEndPointCache;
  35 import org.opendaylight.genius.itm.cache.UnprocessedOFNodeConnectorCache;
  36 import org.opendaylight.genius.itm.globals.ITMConstants;
  37 import org.opendaylight.genius.itm.itmdirecttunnels.renderer.ovs.utilities.DirectTunnelUtils;
  38 import org.opendaylight.genius.itm.rpc.ItmManagerRpcService;
  39 import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
  40 import org.opendaylight.genius.utils.clustering.EntityOwnershipUtils;
  41 import org.opendaylight.infrautils.caches.baseimpl.internal.CacheManagersRegistryImpl;
  42 import org.opendaylight.infrautils.caches.guava.internal.GuavaCacheProvider;
  43 import org.opendaylight.infrautils.jobcoordinator.JobCoordinator;
  44 import org.opendaylight.mdsal.binding.api.DataBroker;
  45 import org.opendaylight.mdsal.binding.api.ReadTransaction;
  46 import org.opendaylight.mdsal.binding.api.WriteTransaction;
  47 import org.opendaylight.mdsal.binding.util.TypedReadWriteTransaction;
  48 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  49 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
  50 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddressBuilder;
  51 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix;
  52 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefixBuilder;
  53 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelMonitoringTypeBase;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeBase;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeMplsOverGre;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeVxlan;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.ItmConfig;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.DpnEndpoints;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.DpnEndpointsBuilder;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.ExternalTunnelList;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TunnelList;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.DPNTEPsInfo;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.DPNTEPsInfoBuilder;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.DPNTEPsInfoKey;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.dpn.teps.info.TunnelEndPoints;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.dpn.teps.info.TunnelEndPointsBuilder;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.dpn.teps.info.TunnelEndPointsKey;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.external.tunnel.list.ExternalTunnel;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.external.tunnel.list.ExternalTunnelBuilder;
  71 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.external.tunnel.list.ExternalTunnelKey;
  72 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnel.list.InternalTunnel;
  73 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnel.list.InternalTunnelBuilder;
  74 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnel.list.InternalTunnelKey;
  75 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.TransportZones;
  76 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.TransportZonesBuilder;
  77 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZone;
  78 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZoneBuilder;
  79 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZoneKey;
  80 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.DeviceVteps;
  81 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.DeviceVtepsBuilder;
  82 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.DeviceVtepsKey;
  83 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddExternalTunnelEndpointInput;
  84 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddExternalTunnelEndpointInputBuilder;
  85 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddL2GwDeviceInput;
  86 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddL2GwDeviceInputBuilder;
  87 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddL2GwMlagDeviceInput;
  88 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddL2GwMlagDeviceInputBuilder;
  89 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.BuildExternalTunnelFromDpnsInput;
  90 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.BuildExternalTunnelFromDpnsInputBuilder;
  91 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.DeleteL2GwDeviceInput;
  92 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.DeleteL2GwDeviceInputBuilder;
  93 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.DeleteL2GwMlagDeviceInput;
  94 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.DeleteL2GwMlagDeviceInputBuilder;
  95 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetExternalTunnelInterfaceNameInput;
  96 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetExternalTunnelInterfaceNameInputBuilder;
  97 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetInternalOrExternalInterfaceNameInput;
  98 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetInternalOrExternalInterfaceNameInputBuilder;
  99 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetTunnelInterfaceNameInput;
 100 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetTunnelInterfaceNameInputBuilder;
 101 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveExternalTunnelEndpointInput;
 102 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveExternalTunnelEndpointInputBuilder;
 103 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveExternalTunnelFromDpnsInput;
 104 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveExternalTunnelFromDpnsInputBuilder;
 105 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveTerminatingServiceActionsInput;
 106 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveTerminatingServiceActionsInputBuilder;
 107 import org.opendaylight.yangtools.util.concurrent.FluentFutures;
 108 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 109 import org.opendaylight.yangtools.yang.common.Uint16;
 110 import org.opendaylight.yangtools.yang.common.Uint64;
 111
 112 @RunWith(MockitoJUnitRunner.class)
 113 public class ItmManagerRpcServiceTest {
 114
 115     Uint16 vlanId = Uint16.valueOf(100);
 116     String portName1 = "phy0";
 117     String sourceDevice = "abc";
 118     String destinationDevice = "xyz";
 119     String tepIp1 = "192.168.56.101";
 120     String gwyIp1 = "0.0.0.0";
 121     String subnetIp = "10.1.1.24";
 122     String tunnelInterfaceName =  "1:phy0:100" ;
 123     String transportZone1 = "TZA" ;
 124     String trunkInterfaceName = null;
 125     IpAddress ipAddress1 = IpAddressBuilder.getDefaultInstance(tepIp1);
 126     IpAddress gtwyIp1 = IpAddressBuilder.getDefaultInstance(gwyIp1);
 127     IpPrefix ipPrefixTest = IpPrefixBuilder.getDefaultInstance(subnetIp + "/24");
 128     Uint64 dpId1 = Uint64.ONE;
 129     Uint64 dpId2 = Uint64.valueOf(2);
 130     ExternalTunnel externalTunnel = null;
 131     ExternalTunnel externalTunnelNew = null;
 132     InternalTunnel internalTunnel = null;
 133     DpnEndpoints dpnEndpoints = null;
 134     DPNTEPsInfo dpntePsInfoVxlan = null;
 135     TunnelEndPoints tunnelEndPointsVxlan = null;
 136     Interface iface = null;
 137     TransportZones transportZones = null;
 138     TransportZone transportZone = null;
 139     DeviceVteps deviceVteps = null;
 140     List<DPNTEPsInfo> cfgdDpnListVxlan = new ArrayList<>() ;
 141     List<TunnelEndPoints> tunnelEndPointsListVxlan = new ArrayList<>();
 142     List<TransportZone> transportZoneList = new ArrayList<>() ;
 143     List<DeviceVteps> deviceVtepsList = new ArrayList<>();
 144     List<String> stringList = new ArrayList<>();
 145     List<Uint64> dpId1List = new ArrayList<>();
 146     DeviceVtepsKey deviceVtepKey = new DeviceVtepsKey(ipAddress1, sourceDevice);
 147     AddExternalTunnelEndpointInput addExternalTunnelEndpointInput = null;
 148     GetInternalOrExternalInterfaceNameInput getInternalOrExternalInterfaceNameInput = null;
 149     BuildExternalTunnelFromDpnsInput buildExternalTunnelFromDpnsInput = null;
 150     RemoveExternalTunnelFromDpnsInput removeExternalTunnelFromDpnsInput = null;
 151     RemoveExternalTunnelEndpointInput removeExternalTunnelEndpointInput = null;
 152     RemoveTerminatingServiceActionsInput removeTerminatingServiceActionsInput = null;
 153     GetExternalTunnelInterfaceNameInput getExternalTunnelInterfaceNameInput = null;
 154     AddL2GwDeviceInput addL2GwDeviceInput = null;
 155     DeleteL2GwDeviceInput deleteL2GwDeviceInput = null;
 156     AddL2GwMlagDeviceInput addL2GwMlagDeviceInput = null;
 157     DeleteL2GwMlagDeviceInput deleteL2GwMlagDeviceInput = null;
 158     GetTunnelInterfaceNameInput getTunnelInterfaceNameInput = null;
 159     java.lang.Class<? extends TunnelTypeBase> tunnelType1 = TunnelTypeVxlan.class;
 160     java.lang.Class<? extends TunnelTypeBase> tunnelType2 = TunnelTypeMplsOverGre.class;
 161     Class<? extends TunnelMonitoringTypeBase> monitorProtocol = ITMConstants.DEFAULT_MONITOR_PROTOCOL;
 162
 163     InstanceIdentifier<ExternalTunnel> externalTunnelIdentifier = InstanceIdentifier.create(ExternalTunnelList.class)
 164             .child(ExternalTunnel.class, new ExternalTunnelKey(ipAddress1.stringValue(), dpId1.toString(),
 165                     TunnelTypeMplsOverGre.class));
 166     InstanceIdentifier<ExternalTunnel> externalTunnelIdentifierNew = InstanceIdentifier.create(ExternalTunnelList.class)
 167             .child(ExternalTunnel.class, new ExternalTunnelKey(ipAddress1.stringValue(), dpId1.toString(),
 168                     tunnelType1));
 169     InstanceIdentifier<ExternalTunnel> externalTunnelIdentifier1 = InstanceIdentifier.create(ExternalTunnelList.class)
 170             .child(ExternalTunnel.class, new ExternalTunnelKey(destinationDevice, sourceDevice,
 171                     tunnelType1));
 172     InstanceIdentifier<InternalTunnel> internalTunnelIdentifier = InstanceIdentifier.create(TunnelList.class)
 173             .child(InternalTunnel.class, new InternalTunnelKey(dpId2, dpId1, tunnelType1));
 174     InstanceIdentifier<InternalTunnel> internalTunnelIdentifierNew = InstanceIdentifier.create(TunnelList.class)
 175             .child(InternalTunnel.class, new InternalTunnelKey(dpId1, dpId1, tunnelType1));
 176     InstanceIdentifier<DpnEndpoints> dpnEndpointsIdentifier = InstanceIdentifier.builder(DpnEndpoints.class).build();
 177     InstanceIdentifier<Interface> interfaceIdentifier = null;
 178     InstanceIdentifier<TransportZones> transportZonesIdentifier = InstanceIdentifier.create(TransportZones.class);
 179     InstanceIdentifier<DeviceVteps> deviceVtepsIdentifier = InstanceIdentifier.builder(TransportZones.class)
 180             .child(TransportZone.class, new TransportZoneKey(transportZone1))
 181             .child(DeviceVteps.class, deviceVtepKey).build();
 182
 183     @Mock DataBroker dataBroker;
 184     @Mock JobCoordinator jobCoordinator;
 185     @Mock ReadTransaction mockReadTx;
 186     @Mock WriteTransaction mockWriteTx;
 187     @Mock IMdsalApiManager mdsalApiManager;
 188     @Mock ItmConfig itmConfig;
 189     @Mock IInterfaceManager interfaceManager;
 190     @Mock InterfaceManagerService interfaceManagerService;
 191     @Mock EntityOwnershipUtils entityOwnershipUtils;
 192     @Mock TypedReadWriteTransaction mockTypedReadWriteTx;
 193
 194     ItmManagerRpcService itmManagerRpcService ;
 195     DirectTunnelUtils directTunnelUtils;
 196     UnprocessedNodeConnectorCache unprocessedNodeConnectorCache;
 197     UnprocessedNodeConnectorEndPointCache unprocessedNodeConnectorEndPointCache;
 198     UnprocessedOFNodeConnectorCache unprocessedOFNCCache;
 199
 200     Optional<ExternalTunnel> externalTunnelOptional ;
 201     Optional<InternalTunnel> internalTunnelOptional;
 202     Optional<DpnEndpoints> dpnEndpointsOptional ;
 203     Optional<TransportZones> transportZonesOptional ;
 204
 205     @Before
 206     public void setUp() {
 207         setupMocks();
 208
 209         externalTunnelOptional = Optional.of(externalTunnel);
 210         internalTunnelOptional = Optional.of(internalTunnel);
 211         dpnEndpointsOptional = Optional.of(dpnEndpoints);
 212         transportZonesOptional = Optional.of(transportZones);
 213
 214         doReturn(FluentFutures.immediateFluentFuture(externalTunnelOptional)).when(mockReadTx).read(LogicalDatastoreType
 215                 .CONFIGURATION,externalTunnelIdentifier);
 216         doReturn(FluentFutures.immediateFluentFuture(externalTunnelOptional)).when(mockReadTx).read(LogicalDatastoreType
 217                 .CONFIGURATION,externalTunnelIdentifier1);
 218         doReturn(FluentFutures.immediateFluentFuture(internalTunnelOptional)).when(mockReadTx).read(LogicalDatastoreType
 219                 .CONFIGURATION,internalTunnelIdentifier);
 220         lenient().doReturn(FluentFutures.immediateFluentFuture(internalTunnelOptional)).when(mockReadTx).read(
 221                 LogicalDatastoreType.CONFIGURATION,internalTunnelIdentifierNew);
 222         lenient().doReturn(FluentFutures.immediateFluentFuture(dpnEndpointsOptional)).when(mockReadTx).read(
 223                 LogicalDatastoreType.CONFIGURATION,dpnEndpointsIdentifier);
 224         doReturn(FluentFutures.immediateFluentFuture(transportZonesOptional)).when(mockReadTx).read(LogicalDatastoreType
 225                 .CONFIGURATION,transportZonesIdentifier);
 226
 227         DPNTEPsInfoCache dpntePsInfoCache =
 228             new DPNTEPsInfoCache(dataBroker, new GuavaCacheProvider(new CacheManagersRegistryImpl()),
 229             directTunnelUtils, jobCoordinator, unprocessedNodeConnectorEndPointCache);
 230         DpnTepStateCache dpnTepStateCache =
 231             new DpnTepStateCache(dataBroker, jobCoordinator, new GuavaCacheProvider(new CacheManagersRegistryImpl()),
 232             directTunnelUtils, dpntePsInfoCache, unprocessedNodeConnectorCache, unprocessedNodeConnectorEndPointCache);
 233         TunnelStateCache tunnelStateCache =
 234                 new TunnelStateCache(dataBroker, new GuavaCacheProvider(new CacheManagersRegistryImpl()));
 235         OvsBridgeRefEntryCache ovsBridgeRefEntryCache =
 236             new OvsBridgeRefEntryCache(dataBroker, new GuavaCacheProvider(new CacheManagersRegistryImpl()));
 237         OfDpnTepConfigCache ofDpnTepConfigCache = new OfDpnTepConfigCache(dataBroker, jobCoordinator,
 238                 new GuavaCacheProvider(new CacheManagersRegistryImpl()), directTunnelUtils, unprocessedOFNCCache);
 239
 240         OfTepStateCache ofTepStateCache = new OfTepStateCache(dataBroker, new GuavaCacheProvider(
 241                 new CacheManagersRegistryImpl()), interfaceManager, directTunnelUtils);
 242
 243         itmManagerRpcService = new ItmManagerRpcService(dataBroker, mdsalApiManager, itmConfig,
 244             dpntePsInfoCache, interfaceManager, dpnTepStateCache, tunnelStateCache, interfaceManagerService,
 245             ovsBridgeRefEntryCache, directTunnelUtils, ofDpnTepConfigCache, ofTepStateCache);
 246     }
 247
 248     @After
 249     public void cleanUp() {
 250     }
 251
 252     private void setupMocks() {
 253         deviceVteps = new DeviceVtepsBuilder().setIpAddress(ipAddress1).withKey(new DeviceVtepsKey(ipAddress1,"abc"))
 254                 .setNodeId(sourceDevice).setTopologyId(destinationDevice).build();
 255         deviceVtepsList.add(deviceVteps);
 256         stringList.add(sourceDevice);
 257         dpId1List.add(dpId1);
 258         stringList.add("def");
 259         trunkInterfaceName = ItmUtils.getTrunkInterfaceName(tunnelInterfaceName, ipAddress1.stringValue(),
 260             ipAddress1.stringValue(), tunnelType1.getName());
 261         interfaceIdentifier = ItmUtils.buildId(trunkInterfaceName);
 262         tunnelEndPointsVxlan = new TunnelEndPointsBuilder()
 263                 .setIpAddress(ipAddress1).setInterfaceName(tunnelInterfaceName)
 264                 .setTzMembership(ItmUtils.createTransportZoneMembership(transportZone1)).setTunnelType(tunnelType1)
 265                 .withKey(new TunnelEndPointsKey(ipAddress1,tunnelType1)).build();
 266         tunnelEndPointsListVxlan.add(tunnelEndPointsVxlan);
 267         dpntePsInfoVxlan = new DPNTEPsInfoBuilder().setDPNID(dpId1).withKey(new DPNTEPsInfoKey(dpId1)).setUp(true)
 268                 .setTunnelEndPoints(tunnelEndPointsListVxlan).build();
 269         cfgdDpnListVxlan.add(dpntePsInfoVxlan);
 270         dpnEndpoints = new DpnEndpointsBuilder().setDPNTEPsInfo(cfgdDpnListVxlan).build();
 271         externalTunnel = new ExternalTunnelBuilder().setSourceDevice(sourceDevice)
 272                 .setDestinationDevice(destinationDevice).setTransportType(tunnelType1)
 273                 .setTunnelInterfaceName(tunnelInterfaceName)
 274                 .withKey(new ExternalTunnelKey(destinationDevice,sourceDevice,tunnelType1)).build();
 275         internalTunnel = new InternalTunnelBuilder()
 276                 .setTunnelInterfaceNames(Collections.singletonList(tunnelInterfaceName)).setDestinationDPN(dpId2)
 277                 .setSourceDPN(dpId1).setTransportType(tunnelType1)
 278                 .withKey(new InternalTunnelKey(dpId2, dpId1, tunnelType1)).build();
 279         getInternalOrExternalInterfaceNameInput = new GetInternalOrExternalInterfaceNameInputBuilder()
 280                 .setDestinationIp(ipAddress1).setSourceDpid(dpId1).setTunnelType(tunnelType2).build();
 281         addExternalTunnelEndpointInput = new AddExternalTunnelEndpointInputBuilder().setTunnelType(tunnelType1)
 282                 .setDestinationIp(ipAddress1).build();
 283         addL2GwDeviceInput = new AddL2GwDeviceInputBuilder().setIpAddress(ipAddress1).setNodeId(sourceDevice)
 284                 .setTopologyId(destinationDevice).build();
 285         deleteL2GwDeviceInput = new DeleteL2GwDeviceInputBuilder().setIpAddress(ipAddress1).setNodeId(sourceDevice)
 286                 .setTopologyId(destinationDevice).build();
 287         addL2GwMlagDeviceInput = new AddL2GwMlagDeviceInputBuilder().setIpAddress(ipAddress1).setNodeId(stringList)
 288                 .setTopologyId(destinationDevice).build();
 289         deleteL2GwMlagDeviceInput = new DeleteL2GwMlagDeviceInputBuilder().setIpAddress(ipAddress1)
 290                 .setNodeId(stringList).setTopologyId(destinationDevice).build();
 291         buildExternalTunnelFromDpnsInput = new BuildExternalTunnelFromDpnsInputBuilder().setTunnelType(tunnelType1)
 292                 .setDestinationIp(ipAddress1).setDpnId(dpId1List).build();
 293         removeExternalTunnelFromDpnsInput = new RemoveExternalTunnelFromDpnsInputBuilder().setTunnelType(tunnelType1)
 294                 .setDestinationIp(ipAddress1).setDpnId(dpId1List).build();
 295         removeExternalTunnelEndpointInput = new RemoveExternalTunnelEndpointInputBuilder().setTunnelType(tunnelType1)
 296                 .setDestinationIp(ipAddress1).build();
 297         removeTerminatingServiceActionsInput = new RemoveTerminatingServiceActionsInputBuilder().setServiceId(vlanId)
 298                 .setDpnId(dpId1).build();
 299         getTunnelInterfaceNameInput = new GetTunnelInterfaceNameInputBuilder().setTunnelType(tunnelType1)
 300                 .setSourceDpid(dpId1).setDestinationDpid(dpId2).build();
 301         getExternalTunnelInterfaceNameInput = new GetExternalTunnelInterfaceNameInputBuilder()
 302                 .setTunnelType(tunnelType1).setDestinationNode(destinationDevice).setSourceNode(sourceDevice).build();
 303         iface = ItmUtils.buildTunnelInterface(dpId1,trunkInterfaceName, String.format("%s %s",
 304                 ItmUtils.convertTunnelTypetoString(tunnelType1), "Trunk Interface"),true,tunnelType1,
 305                 tunnelEndPointsVxlan.getIpAddress(),ipAddress1, false, false,
 306                 monitorProtocol,null, false, null);
 307
 308         transportZone = new TransportZoneBuilder().setZoneName(transportZone1)
 309                 .setTunnelType(tunnelType1).withKey(new TransportZoneKey(transportZone1))
 310                 .build();
 311         transportZoneList.add(transportZone);
 312         transportZones = new TransportZonesBuilder().setTransportZone(transportZoneList).build();
 313         doReturn(mockReadTx).when(dataBroker).newReadOnlyTransaction();
 314         doReturn(mockWriteTx).when(dataBroker).newWriteOnlyTransaction();
 315         lenient().doReturn(FluentFutures.immediateNullFluentFuture()).when(mockWriteTx).commit();
 316     }
 317
 318     @Test
 319     public void testGetInternalOrExternalInterfaceNameExtTunnelPresent() {
 320         itmManagerRpcService.getInternalOrExternalInterfaceName(getInternalOrExternalInterfaceNameInput);
 321
 322         verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION, externalTunnelIdentifier);
 323     }
 324
 325     @Ignore
 326     @Test
 327     public void testGetInternalOrExternalInterfaceNameExtTunnelAbsent() {
 328         doReturn(FluentFutures.immediateFluentFuture(Optional.empty())).when(mockReadTx).read(LogicalDatastoreType
 329                 .CONFIGURATION,externalTunnelIdentifier);
 330
 331         itmManagerRpcService.getInternalOrExternalInterfaceName(getInternalOrExternalInterfaceNameInput);
 332
 333         verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION, externalTunnelIdentifier);
 334         verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION, internalTunnelIdentifierNew);
 335     }
 336
 337     @Ignore
 338     @Test
 339     public void testAddExternalTunnelEndpoint() {
 340         externalTunnelNew = ItmUtils.buildExternalTunnel(dpId1.toString(), ipAddress1.stringValue(),
 341                 tunnelType1, trunkInterfaceName);
 342
 343         itmManagerRpcService.addExternalTunnelEndpoint(addExternalTunnelEndpointInput);
 344
 345         verify(mockWriteTx).mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION, interfaceIdentifier, iface);
 346         verify(mockWriteTx).mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION, externalTunnelIdentifierNew,
 347                 externalTunnelNew);
 348     }
 349
 350     @Test
 351     public void testAddL2GwDevice() {
 352         itmManagerRpcService.addL2GwDevice(addL2GwDeviceInput);
 353
 354         verify(mockWriteTx).mergeParentStructurePut(LogicalDatastoreType.CONFIGURATION, deviceVtepsIdentifier,
 355                 deviceVteps);
 356     }
 357
 358     @Test
 359     public void testAddL2GwMlagDevice() {
 360         itmManagerRpcService.addL2GwMlagDevice(addL2GwMlagDeviceInput);
 361
 362         verify(mockWriteTx).mergeParentStructurePut(LogicalDatastoreType.CONFIGURATION, deviceVtepsIdentifier,
 363                 deviceVteps);
 364     }
 365
 366     @Test
 367     public void testDeleteL2GwDevice() {
 368         itmManagerRpcService.deleteL2GwDevice(deleteL2GwDeviceInput);
 369
 370         verify(mockWriteTx).delete(LogicalDatastoreType.CONFIGURATION,deviceVtepsIdentifier);
 371     }
 372
 373     @Test
 374     public void testDeleteL2GwMlagDevice() {
 375         itmManagerRpcService.deleteL2GwMlagDevice(deleteL2GwMlagDeviceInput);
 376
 377         verify(mockWriteTx).delete(LogicalDatastoreType.CONFIGURATION,deviceVtepsIdentifier);
 378     }
 379
 380     @Ignore
 381     @Test
 382     public void testBuildExternalTunnelFromDpns() {
 383         externalTunnelNew = ItmUtils.buildExternalTunnel(dpId1.toString(), ipAddress1.stringValue(),
 384                 tunnelType1, trunkInterfaceName);
 385
 386         itmManagerRpcService.buildExternalTunnelFromDpns(buildExternalTunnelFromDpnsInput);
 387
 388         verify(mockWriteTx).mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION,interfaceIdentifier,iface);
 389         verify(mockWriteTx).mergeParentStructureMerge(LogicalDatastoreType.CONFIGURATION,externalTunnelIdentifierNew,
 390                 externalTunnelNew);
 391     }
 392
 393     @Ignore
 394     @Test
 395     public void testRemoveExternalTunnelFromDpns() {
 396
 397         itmManagerRpcService.removeExternalTunnelFromDpns(removeExternalTunnelFromDpnsInput);
 398
 399         verify(mockWriteTx).delete(LogicalDatastoreType.CONFIGURATION,interfaceIdentifier);
 400         verify(mockWriteTx).delete(LogicalDatastoreType.CONFIGURATION,externalTunnelIdentifierNew);
 401     }
 402
 403     @Ignore
 404     @Test
 405     public void testRemoveExternalTunnelEndpoint() {
 406         itmManagerRpcService.removeExternalTunnelEndpoint(removeExternalTunnelEndpointInput);
 407
 408         verify(mockWriteTx).delete(LogicalDatastoreType.CONFIGURATION,interfaceIdentifier);
 409         verify(mockWriteTx).delete(LogicalDatastoreType.CONFIGURATION,externalTunnelIdentifierNew);
 410     }
 411
 412     @Test
 413     public void testGetTunnelInterfaceName() {
 414         itmManagerRpcService.getTunnelInterfaceName(getTunnelInterfaceNameInput);
 415
 416         verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,internalTunnelIdentifier);
 417     }
 418
 419     @Test
 420     public void testGetExternalTunnelInterfaceName() {
 421         itmManagerRpcService.getExternalTunnelInterfaceName(getExternalTunnelInterfaceNameInput);
 422
 423         verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,externalTunnelIdentifier1);
 424     }
 425 }