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
   9 package org.opendaylight.genius.itm.impl;
  10
  11 import static org.mockito.Matchers.any;
  12 import static org.mockito.Mockito.doReturn;
  13 import static org.mockito.Mockito.verify;
  14 import static org.mockito.Mockito.when;
  15
  16 import com.google.common.base.Optional;
  17 import com.google.common.util.concurrent.Futures;
  18 import java.math.BigInteger;
  19 import java.util.ArrayList;
  20 import java.util.Collections;
  21 import java.util.List;
  22 import java.util.concurrent.Future;
  23 import org.junit.After;
  24 import org.junit.Before;
  25 import org.junit.Ignore;
  26 import org.junit.Test;
  27 import org.junit.runner.RunWith;
  28 import org.mockito.Mock;
  29 import org.mockito.runners.MockitoJUnitRunner;
  30 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  31 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  32 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  33 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  34 import org.opendaylight.genius.itm.globals.ITMConstants;
  35 import org.opendaylight.genius.itm.rpc.ItmManagerRpcService;
  36 import org.opendaylight.genius.mdsalutil.interfaces.IMdsalApiManager;
  37 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
  38 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddressBuilder;
  39 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix;
  40 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefixBuilder;
  41 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInput;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdInputBuilder;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdOutput;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.AllocateIdOutputBuilder;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.IdManagerService;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.idmanager.rev160406.ReleaseIdInput;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelMonitoringTypeBase;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeBase;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeMplsOverGre;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeVxlan;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.config.rev160406.ItmConfig;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.DpnEndpoints;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.DpnEndpointsBuilder;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.ExternalTunnelList;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.TunnelList;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.DPNTEPsInfo;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.DPNTEPsInfoBuilder;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.DPNTEPsInfoKey;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.dpn.teps.info.TunnelEndPoints;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.dpn.teps.info.TunnelEndPointsBuilder;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.dpn.endpoints.dpn.teps.info.TunnelEndPointsKey;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.external.tunnel.list.ExternalTunnel;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.external.tunnel.list.ExternalTunnelBuilder;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.external.tunnel.list.ExternalTunnelKey;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnel.list.InternalTunnel;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnel.list.InternalTunnelBuilder;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.op.rev160406.tunnel.list.InternalTunnelKey;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.TransportZones;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.TransportZonesBuilder;
  71 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZone;
  72 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZoneBuilder;
  73 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.TransportZoneKey;
  74 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.Subnets;
  75 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.SubnetsBuilder;
  76 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.SubnetsKey;
  77 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.subnets.DeviceVteps;
  78 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.subnets.DeviceVtepsBuilder;
  79 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rev160406.transport.zones.transport.zone.subnets.DeviceVtepsKey;
  80 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddExternalTunnelEndpointInput;
  81 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddExternalTunnelEndpointInputBuilder;
  82 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddL2GwDeviceInput;
  83 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddL2GwDeviceInputBuilder;
  84 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddL2GwMlagDeviceInput;
  85 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddL2GwMlagDeviceInputBuilder;
  86 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.BuildExternalTunnelFromDpnsInput;
  87 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.BuildExternalTunnelFromDpnsInputBuilder;
  88 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.DeleteL2GwDeviceInput;
  89 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.DeleteL2GwDeviceInputBuilder;
  90 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.DeleteL2GwMlagDeviceInput;
  91 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.DeleteL2GwMlagDeviceInputBuilder;
  92 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetExternalTunnelInterfaceNameInput;
  93 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetExternalTunnelInterfaceNameInputBuilder;
  94 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetInternalOrExternalInterfaceNameInput;
  95 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetInternalOrExternalInterfaceNameInputBuilder;
  96 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetTunnelInterfaceNameInput;
  97 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetTunnelInterfaceNameInputBuilder;
  98 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveExternalTunnelEndpointInput;
  99 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveExternalTunnelEndpointInputBuilder;
 100 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveExternalTunnelFromDpnsInput;
 101 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveExternalTunnelFromDpnsInputBuilder;
 102 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveTerminatingServiceActionsInput;
 103 import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveTerminatingServiceActionsInputBuilder;
 104 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 105 import org.opendaylight.yangtools.yang.common.RpcResult;
 106 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
 107
 108 @RunWith(MockitoJUnitRunner.class)
 109 public class ItmManagerRpcServiceTest {
 110
 111     int vlanId = 100 ;
 112     String portName1 = "phy0";
 113     String sourceDevice = "abc";
 114     String destinationDevice = "xyz";
 115     String tepIp1 = "192.168.56.101";
 116     String gwyIp1 = "0.0.0.0";
 117     String subnetIp = "10.1.1.24";
 118     String tunnelInterfaceName =  "1:phy0:100" ;
 119     String transportZone1 = "TZA" ;
 120     String trunkInterfaceName = null;
 121     IpAddress ipAddress1 = IpAddressBuilder.getDefaultInstance(tepIp1);
 122     IpAddress gtwyIp1 = IpAddressBuilder.getDefaultInstance(gwyIp1);
 123     IpPrefix ipPrefixTest = IpPrefixBuilder.getDefaultInstance(subnetIp + "/24");
 124     BigInteger dpId1 = BigInteger.valueOf(1);
 125     BigInteger dpId2 = BigInteger.valueOf(2);
 126     ExternalTunnel externalTunnel = null;
 127     ExternalTunnel externalTunnelNew = null;
 128     InternalTunnel internalTunnel = null;
 129     DpnEndpoints dpnEndpoints = null;
 130     DPNTEPsInfo dpntePsInfoVxlan = null;
 131     TunnelEndPoints tunnelEndPointsVxlan = null;
 132     AllocateIdInput getIdInput1 = null;
 133     Interface iface = null;
 134     Subnets subnetsTest = null;
 135     TransportZones transportZones = null;
 136     TransportZone transportZone = null;
 137     DeviceVteps deviceVteps = null;
 138     List<DPNTEPsInfo> cfgdDpnListVxlan = new ArrayList<>() ;
 139     List<TunnelEndPoints> tunnelEndPointsListVxlan = new ArrayList<>();
 140     List<TransportZone> transportZoneList = new ArrayList<>() ;
 141     List<Subnets> subnetsList = new ArrayList<>() ;
 142     List<DeviceVteps> deviceVtepsList = new ArrayList<>();
 143     List<String> stringList = new ArrayList<>();
 144     List<BigInteger> dpId1List = new ArrayList<>();
 145     DeviceVtepsKey deviceVtepKey = new DeviceVtepsKey(ipAddress1, sourceDevice);
 146     AddExternalTunnelEndpointInput addExternalTunnelEndpointInput = null;
 147     GetInternalOrExternalInterfaceNameInput getInternalOrExternalInterfaceNameInput = null;
 148     BuildExternalTunnelFromDpnsInput buildExternalTunnelFromDpnsInput = null;
 149     RemoveExternalTunnelFromDpnsInput removeExternalTunnelFromDpnsInput = null;
 150     RemoveExternalTunnelEndpointInput removeExternalTunnelEndpointInput = null;
 151     RemoveTerminatingServiceActionsInput removeTerminatingServiceActionsInput = null;
 152     GetExternalTunnelInterfaceNameInput getExternalTunnelInterfaceNameInput = null;
 153     AddL2GwDeviceInput addL2GwDeviceInput = null;
 154     DeleteL2GwDeviceInput deleteL2GwDeviceInput = null;
 155     AddL2GwMlagDeviceInput addL2GwMlagDeviceInput = null;
 156     DeleteL2GwMlagDeviceInput deleteL2GwMlagDeviceInput = null;
 157     GetTunnelInterfaceNameInput getTunnelInterfaceNameInput = null;
 158     java.lang.Class<? extends TunnelTypeBase> tunnelType1 = TunnelTypeVxlan.class;
 159     AllocateIdOutput expectedId1 = new AllocateIdOutputBuilder().setIdValue(Long.valueOf("100")).build();
 160     Future<RpcResult<AllocateIdOutput>> idOutputOptional1 ;
 161     Class<? extends TunnelMonitoringTypeBase> monitorProtocol = ITMConstants.DEFAULT_MONITOR_PROTOCOL;
 162
 163     InstanceIdentifier<ExternalTunnel> externalTunnelIdentifier = InstanceIdentifier.create(ExternalTunnelList.class)
 164             .child(ExternalTunnel.class, new ExternalTunnelKey(String.valueOf(ipAddress1), dpId1.toString(),
 165                     TunnelTypeMplsOverGre.class));
 166     InstanceIdentifier<ExternalTunnel> externalTunnelIdentifierNew = InstanceIdentifier.create(ExternalTunnelList.class)
 167             .child(ExternalTunnel.class, new ExternalTunnelKey(String.valueOf(ipAddress1), 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(Subnets.class, new SubnetsKey(ipPrefixTest)).child(DeviceVteps.class, deviceVtepKey).build();
 182
 183
 184     @Mock DataBroker dataBroker;
 185     @Mock ReadOnlyTransaction mockReadTx;
 186     @Mock WriteTransaction mockWriteTx;
 187     @Mock IdManagerService idManagerService;
 188     @Mock IMdsalApiManager mdsalApiManager;
 189     @Mock ItmConfig itmConfig;
 190
 191     ItmManagerRpcService itmManagerRpcService ;
 192
 193     Optional<ExternalTunnel> externalTunnelOptional ;
 194     Optional<InternalTunnel> internalTunnelOptional;
 195     Optional<DpnEndpoints> dpnEndpointsOptional ;
 196     Optional<TransportZones> transportZonesOptional ;
 197
 198     @Before
 199     public void setUp() {
 200         setupMocks();
 201
 202         externalTunnelOptional = Optional.of(externalTunnel);
 203         internalTunnelOptional = Optional.of(internalTunnel);
 204         dpnEndpointsOptional = Optional.of(dpnEndpoints);
 205         transportZonesOptional = Optional.of(transportZones);
 206
 207         doReturn(Futures.immediateCheckedFuture(externalTunnelOptional)).when(mockReadTx).read(LogicalDatastoreType
 208                 .CONFIGURATION,externalTunnelIdentifier);
 209         doReturn(Futures.immediateCheckedFuture(externalTunnelOptional)).when(mockReadTx).read(LogicalDatastoreType
 210                 .CONFIGURATION,externalTunnelIdentifier1);
 211         doReturn(Futures.immediateCheckedFuture(internalTunnelOptional)).when(mockReadTx).read(LogicalDatastoreType
 212                 .CONFIGURATION,internalTunnelIdentifier);
 213         doReturn(Futures.immediateCheckedFuture(internalTunnelOptional)).when(mockReadTx).read(LogicalDatastoreType
 214                 .CONFIGURATION,internalTunnelIdentifierNew);
 215         doReturn(Futures.immediateCheckedFuture(dpnEndpointsOptional)).when(mockReadTx).read(LogicalDatastoreType
 216                 .CONFIGURATION,dpnEndpointsIdentifier);
 217         doReturn(Futures.immediateCheckedFuture(transportZonesOptional)).when(mockReadTx).read(LogicalDatastoreType
 218                 .CONFIGURATION,transportZonesIdentifier);
 219
 220         itmManagerRpcService = new ItmManagerRpcService(dataBroker,idManagerService, mdsalApiManager, itmConfig);
 221     }
 222
 223     @After
 224     public void cleanUp() {
 225     }
 226
 227     private void setupMocks() {
 228
 229         deviceVteps = new DeviceVtepsBuilder().setIpAddress(ipAddress1).setKey(new DeviceVtepsKey(ipAddress1,"abc"))
 230                 .setNodeId(sourceDevice).setTopologyId(destinationDevice).build();
 231         deviceVtepsList.add(deviceVteps);
 232         stringList.add(sourceDevice);
 233         dpId1List.add(dpId1);
 234         stringList.add("def");
 235         idOutputOptional1 = RpcResultBuilder.success(expectedId1).buildFuture();
 236         getIdInput1 = new AllocateIdInputBuilder()
 237                 .setPoolName(ITMConstants.ITM_IDPOOL_NAME)
 238                 .setIdKey("1:phy0:100:192.168.56.101:192.168.56.101:VXLAN").build();
 239         doReturn(idOutputOptional1).when(idManagerService).allocateId(getIdInput1);
 240         when(idManagerService.releaseId(any(ReleaseIdInput.class))).thenReturn(Futures.immediateFuture(RpcResultBuilder
 241                 .<Void>success().build()));
 242         trunkInterfaceName = ItmUtils.getTrunkInterfaceName(idManagerService, tunnelInterfaceName, ipAddress1
 243                 .getIpv4Address().getValue(), ipAddress1.getIpv4Address().getValue(), tunnelType1.getName());
 244         interfaceIdentifier = ItmUtils.buildId(trunkInterfaceName);
 245         tunnelEndPointsVxlan = new TunnelEndPointsBuilder().setVLANID(vlanId).setPortname(portName1)
 246                 .setIpAddress(ipAddress1).setGwIpAddress(gtwyIp1).setInterfaceName(tunnelInterfaceName)
 247                 .setTzMembership(ItmUtils.createTransportZoneMembership(transportZone1)).setTunnelType(tunnelType1)
 248                 .setSubnetMask(ipPrefixTest)
 249                 .setKey(new TunnelEndPointsKey(ipAddress1,portName1,tunnelType1,vlanId)).build();
 250         tunnelEndPointsListVxlan.add(tunnelEndPointsVxlan);
 251         dpntePsInfoVxlan = new DPNTEPsInfoBuilder().setDPNID(dpId1).setKey(new DPNTEPsInfoKey(dpId1)).setUp(true)
 252                 .setTunnelEndPoints(tunnelEndPointsListVxlan).build();
 253         cfgdDpnListVxlan.add(dpntePsInfoVxlan);
 254         dpnEndpoints = new DpnEndpointsBuilder().setDPNTEPsInfo(cfgdDpnListVxlan).build();
 255         externalTunnel = new ExternalTunnelBuilder().setSourceDevice(sourceDevice)
 256                 .setDestinationDevice(destinationDevice).setTransportType(tunnelType1)
 257                 .setTunnelInterfaceName(tunnelInterfaceName)
 258                 .setKey(new ExternalTunnelKey(destinationDevice,sourceDevice,tunnelType1)).build();
 259         internalTunnel = new InternalTunnelBuilder()
 260                 .setTunnelInterfaceNames(Collections.singletonList(tunnelInterfaceName)).setDestinationDPN(dpId2)
 261                 .setSourceDPN(dpId1).setTransportType(tunnelType1)
 262                 .setKey(new InternalTunnelKey(dpId2, dpId1, tunnelType1)).build();
 263         getInternalOrExternalInterfaceNameInput = new GetInternalOrExternalInterfaceNameInputBuilder()
 264                 .setDestinationIp(ipAddress1).setSourceDpid(dpId1).setTunnelType(tunnelType1).build();
 265         addExternalTunnelEndpointInput = new AddExternalTunnelEndpointInputBuilder().setTunnelType(tunnelType1)
 266                 .setDestinationIp(ipAddress1).build();
 267         addL2GwDeviceInput = new AddL2GwDeviceInputBuilder().setIpAddress(ipAddress1).setNodeId(sourceDevice)
 268                 .setTopologyId(destinationDevice).build();
 269         deleteL2GwDeviceInput = new DeleteL2GwDeviceInputBuilder().setIpAddress(ipAddress1).setNodeId(sourceDevice)
 270                 .setTopologyId(destinationDevice).build();
 271         addL2GwMlagDeviceInput = new AddL2GwMlagDeviceInputBuilder().setIpAddress(ipAddress1).setNodeId(stringList)
 272                 .setTopologyId(destinationDevice).build();
 273         deleteL2GwMlagDeviceInput = new DeleteL2GwMlagDeviceInputBuilder().setIpAddress(ipAddress1)
 274                 .setNodeId(stringList).setTopologyId(destinationDevice).build();
 275         buildExternalTunnelFromDpnsInput = new BuildExternalTunnelFromDpnsInputBuilder().setTunnelType(tunnelType1)
 276                 .setDestinationIp(ipAddress1).setDpnId(dpId1List).build();
 277         removeExternalTunnelFromDpnsInput = new RemoveExternalTunnelFromDpnsInputBuilder().setTunnelType(tunnelType1)
 278                 .setDestinationIp(ipAddress1).setDpnId(dpId1List).build();
 279         removeExternalTunnelEndpointInput = new RemoveExternalTunnelEndpointInputBuilder().setTunnelType(tunnelType1)
 280                 .setDestinationIp(ipAddress1).build();
 281         removeTerminatingServiceActionsInput = new RemoveTerminatingServiceActionsInputBuilder().setServiceId(vlanId)
 282                 .setDpnId(dpId1).build();
 283         getTunnelInterfaceNameInput = new GetTunnelInterfaceNameInputBuilder().setTunnelType(tunnelType1)
 284                 .setSourceDpid(dpId1).setDestinationDpid(dpId2).build();
 285         getExternalTunnelInterfaceNameInput = new GetExternalTunnelInterfaceNameInputBuilder()
 286                 .setTunnelType(tunnelType1).setDestinationNode(destinationDevice).setSourceNode(sourceDevice).build();
 287         iface = ItmUtils.buildTunnelInterface(dpId1,trunkInterfaceName, String.format("%s %s",
 288                 ItmUtils.convertTunnelTypetoString(tunnelType1), "Trunk Interface"),true,tunnelType1,
 289                 tunnelEndPointsVxlan.getIpAddress(),ipAddress1,gtwyIp1,tunnelEndPointsVxlan.getVLANID(), false, false,
 290                 monitorProtocol,null, false, null);
 291         subnetsTest = new SubnetsBuilder().setGatewayIp(gtwyIp1).setVlanId(vlanId).setKey(new SubnetsKey(ipPrefixTest))
 292                 .setDeviceVteps(deviceVtepsList).build();
 293         subnetsList.add(subnetsTest);
 294         transportZone = new TransportZoneBuilder().setZoneName(transportZone1)
 295                 .setTunnelType(tunnelType1).setKey(new TransportZoneKey(transportZone1))
 296                 .setSubnets(subnetsList).build();
 297         transportZoneList.add(transportZone);
 298         transportZones = new TransportZonesBuilder().setTransportZone(transportZoneList).build();
 299         doReturn(mockReadTx).when(dataBroker).newReadOnlyTransaction();
 300         doReturn(mockWriteTx).when(dataBroker).newWriteOnlyTransaction();
 301         doReturn(Futures.immediateCheckedFuture(null)).when(mockWriteTx).submit();
 302     }
 303
 304     @Test
 305     public void testGetInternalOrExternalInterfaceNameExtTunnelPresent() {
 306
 307         itmManagerRpcService.getInternalOrExternalInterfaceName(getInternalOrExternalInterfaceNameInput);
 308
 309         verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,externalTunnelIdentifier);
 310     }
 311
 312     @Ignore
 313     @Test
 314     public void testGetInternalOrExternalInterfaceNameExtTunnelAbsent() {
 315
 316         doReturn(Futures.immediateCheckedFuture(Optional.absent())).when(mockReadTx).read(LogicalDatastoreType
 317                 .CONFIGURATION,externalTunnelIdentifier);
 318
 319         itmManagerRpcService.getInternalOrExternalInterfaceName(getInternalOrExternalInterfaceNameInput);
 320
 321         verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,externalTunnelIdentifier);
 322         verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,internalTunnelIdentifierNew);
 323
 324     }
 325
 326     @Ignore
 327     @Test
 328     public void testAddExternalTunnelEndpoint() {
 329
 330         externalTunnelNew = ItmUtils.buildExternalTunnel(dpId1.toString(), ipAddress1.toString(),
 331                 tunnelType1, trunkInterfaceName);
 332
 333         itmManagerRpcService.addExternalTunnelEndpoint(addExternalTunnelEndpointInput);
 334
 335         verify(mockWriteTx).merge(LogicalDatastoreType.CONFIGURATION, interfaceIdentifier, iface, true);
 336         verify(mockWriteTx).merge(LogicalDatastoreType.CONFIGURATION, externalTunnelIdentifierNew,
 337                 externalTunnelNew,true);
 338     }
 339
 340     @Test
 341     public void testAddL2GwDevice() {
 342
 343         itmManagerRpcService.addL2GwDevice(addL2GwDeviceInput);
 344
 345         verify(mockWriteTx).put(LogicalDatastoreType.CONFIGURATION, deviceVtepsIdentifier, deviceVteps, true);
 346     }
 347
 348     @Test
 349     public void testAddL2GwMlagDevice() {
 350
 351         itmManagerRpcService.addL2GwMlagDevice(addL2GwMlagDeviceInput);
 352
 353         verify(mockWriteTx).put(LogicalDatastoreType.CONFIGURATION, deviceVtepsIdentifier, deviceVteps, true);
 354     }
 355
 356     @Test
 357     public void testDeleteL2GwDevice() {
 358
 359         itmManagerRpcService.deleteL2GwDevice(deleteL2GwDeviceInput);
 360
 361         verify(mockWriteTx).delete(LogicalDatastoreType.CONFIGURATION,deviceVtepsIdentifier);
 362     }
 363
 364     @Test
 365     public void testDeleteL2GwMlagDevice() {
 366
 367         itmManagerRpcService.deleteL2GwMlagDevice(deleteL2GwMlagDeviceInput);
 368
 369         verify(mockWriteTx).delete(LogicalDatastoreType.CONFIGURATION,deviceVtepsIdentifier);
 370     }
 371
 372     @Ignore
 373     @Test
 374     public void testBuildExternalTunnelFromDpns() {
 375
 376         externalTunnelNew = ItmUtils.buildExternalTunnel(dpId1.toString(), ipAddress1.toString(),
 377                 tunnelType1, trunkInterfaceName);
 378
 379         itmManagerRpcService.buildExternalTunnelFromDpns(buildExternalTunnelFromDpnsInput);
 380
 381         verify(mockWriteTx).merge(LogicalDatastoreType.CONFIGURATION,interfaceIdentifier,iface,true);
 382         verify(mockWriteTx).merge(LogicalDatastoreType.CONFIGURATION,externalTunnelIdentifierNew,
 383                 externalTunnelNew,true);
 384     }
 385
 386     @Ignore
 387     @Test
 388     public void testRemoveExternalTunnelFromDpns() {
 389
 390         itmManagerRpcService.removeExternalTunnelFromDpns(removeExternalTunnelFromDpnsInput);
 391
 392         verify(mockWriteTx).delete(LogicalDatastoreType.CONFIGURATION,interfaceIdentifier);
 393         verify(mockWriteTx).delete(LogicalDatastoreType.CONFIGURATION,externalTunnelIdentifierNew);
 394     }
 395
 396     @Ignore
 397     @Test
 398     public void testRemoveExternalTunnelEndpoint() {
 399
 400         itmManagerRpcService.removeExternalTunnelEndpoint(removeExternalTunnelEndpointInput);
 401
 402         verify(mockWriteTx).delete(LogicalDatastoreType.CONFIGURATION,interfaceIdentifier);
 403         verify(mockWriteTx).delete(LogicalDatastoreType.CONFIGURATION,externalTunnelIdentifierNew);
 404     }
 405
 406     @Test
 407     public void testGetTunnelInterfaceName() {
 408
 409         itmManagerRpcService.getTunnelInterfaceName(getTunnelInterfaceNameInput);
 410
 411         verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,internalTunnelIdentifier);
 412     }
 413
 414     @Test
 415     public void testGetExternalTunnelInterfaceName() {
 416
 417         itmManagerRpcService.getExternalTunnelInterfaceName(getExternalTunnelInterfaceNameInput);
 418
 419         verify(mockReadTx).read(LogicalDatastoreType.CONFIGURATION,externalTunnelIdentifier1);
 420     }
 421 }