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