TestStubs for Elan-Evpn Junit

Teststubs are written  for InterfaceManager and ITM
Right now these stubs contains testcode mainly required by Elan. These can
be expanded as we write more testcases.

Added addInterfaceInfo and addTunnelInterfaceInfo methods.

Elan Junit Testcases are written and raised as seperate review in netvirt
https://git.opendaylight.org/gerrit/#/c/62894/

Change-Id: I873999721e135c3cc968ef0d1aa239d794d12cb3
Signed-off-by: Riyazahmed D Talikoti <riyazahmed.d.talikoti@ericsson.com>

diff --git a/commons/testutils/pom.xml b/commons/testutils/pom.xml
index 0f53d10d0131b954e36885186f87e63075193468..c63078ddc1ed42e0044a777326371ea45dc5c248 100644 (file)
--- a/commons/testutils/pom.xml
+++ b/commons/testutils/pom.xml
@@ -88,5 +88,15 @@ and is available at http://www.eclipse.org/legal/epl-v10.html
       <type>test-jar</type>
       <scope>compile</scope>
     </dependency>
+    <dependency>
+      <groupId>org.opendaylight.genius</groupId>
+      <artifactId>idmanager-api</artifactId>
+      <version>${project.version}</version>
+    </dependency>
+    <dependency>
+      <groupId>org.opendaylight.genius</groupId>
+      <artifactId>itm-api</artifactId>
+      <version>${project.version}</version>
+    </dependency>
   </dependencies>
 </project>

diff --git a/commons/testutils/src/main/java/org/opendaylight/genius/testutils/TestInterfaceManager.java b/commons/testutils/src/main/java/org/opendaylight/genius/testutils/TestInterfaceManager.java
index 0d3a8d30566556b50328267389905725f7d82314..a67afac72c90389b2ad6c39da4b6da79a333d970 100644 (file)
--- a/commons/testutils/src/main/java/org/opendaylight/genius/testutils/TestInterfaceManager.java
+++ b/commons/testutils/src/main/java/org/opendaylight/genius/testutils/TestInterfaceManager.java
@@ -9,11 +9,20 @@ package org.opendaylight.genius.testutils;
 
 import static org.opendaylight.yangtools.testutils.mockito.MoreAnswers.realOrException;
 
+import java.math.BigInteger;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
+
 import org.mockito.Mockito;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
 import org.opendaylight.genius.interfacemanager.globals.InterfaceInfo;
 import org.opendaylight.genius.interfacemanager.interfaces.IInterfaceManager;
+import org.opendaylight.genius.testutils.interfacemanager.InterfaceHelper;
+import org.opendaylight.genius.testutils.interfacemanager.InterfaceStateHelper;
+import org.opendaylight.genius.testutils.interfacemanager.TunnelInterfaceDetails;
 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
 
 /**
@@ -23,26 +32,63 @@ import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.
  */
 public abstract class TestInterfaceManager implements IInterfaceManager {
 
-    // Implementation similar to e.g. the org.opendaylight.genius.mdsalutil.interfaces.testutils.TestIMdsalApiManager
+    private Map<String, InterfaceInfo> interfaceInfos;
+    private Map<String, Interface> interfaces;
+    private Map<String, Boolean> externalInterfaces;
+    private DataBroker dataBroker;
 
-    public static TestInterfaceManager newInstance() {
+    public static TestInterfaceManager newInstance(DataBroker dataBroker) {
         TestInterfaceManager testInterfaceManager = Mockito.mock(TestInterfaceManager.class, realOrException());
         testInterfaceManager.interfaceInfos = new ConcurrentHashMap<>();
         testInterfaceManager.interfaces = new ConcurrentHashMap<>();
+        testInterfaceManager.externalInterfaces = new ConcurrentHashMap<>();
+        testInterfaceManager.dataBroker = dataBroker;
         return testInterfaceManager;
     }
 
-    private Map<String, InterfaceInfo> interfaceInfos;
-    private Map<String, Interface> interfaces;
-
-    public void addInterfaceInfo(InterfaceInfo interfaceInfo) {
+    public void addInterfaceInfo(InterfaceInfo interfaceInfo)
+            throws TransactionCommitFailedException {
         interfaceInfos.put(interfaceInfo.getInterfaceName(), interfaceInfo);
+        ReadWriteTransaction tx = dataBroker.newReadWriteTransaction();
+
+        Interface iface = InterfaceHelper.buildVlanInterfaceFromInfo(interfaceInfo);
+        //Add the interface to config ds so that if the application reads from configds it finds it there
+        tx.put(LogicalDatastoreType.CONFIGURATION,
+                InterfaceHelper.buildIId(interfaceInfo.getInterfaceName()),
+                iface);
+
+        //Add the interface to oper ds so that if the application reads from configds it finds it there
+        tx.put(LogicalDatastoreType.OPERATIONAL,
+                InterfaceStateHelper.buildStateInterfaceIid(interfaceInfo.getInterfaceName()),
+                InterfaceStateHelper.buildStateFromInterfaceInfo(interfaceInfo));
+        tx.submit().checkedGet();
+        addInterface(iface);
     }
 
     public void addInterface(Interface iface) {
         interfaces.put(iface.getName(), iface);
     }
 
+    public void addTunnelInterface(TunnelInterfaceDetails tunnelInterfaceDetails)
+            throws TransactionCommitFailedException {
+        InterfaceInfo interfaceInfo = tunnelInterfaceDetails.getInterfaceInfo();
+        interfaceInfos.put(interfaceInfo.getInterfaceName(), interfaceInfo);
+
+        Interface iface = InterfaceHelper.buildVxlanTunnelInterfaceFromInfo(tunnelInterfaceDetails);
+
+        ReadWriteTransaction tx = dataBroker.newReadWriteTransaction();
+        tx.put(LogicalDatastoreType.CONFIGURATION,
+                InterfaceHelper.buildIId(interfaceInfo.getInterfaceName()),
+                iface);
+
+        tx.put(LogicalDatastoreType.OPERATIONAL,
+                InterfaceStateHelper.buildStateInterfaceIid(interfaceInfo.getInterfaceName()),
+                InterfaceStateHelper.buildStateFromInterfaceInfo(interfaceInfo));
+        tx.submit().checkedGet();
+        externalInterfaces.put(interfaceInfo.getInterfaceName(), true);
+        addInterface(iface);
+    }
+
     @Override
     public InterfaceInfo getInterfaceInfo(String interfaceName) {
         InterfaceInfo interfaceInfo = interfaceInfos.get(interfaceName);
@@ -58,6 +104,12 @@ public abstract class TestInterfaceManager implements IInterfaceManager {
         return getInterfaceInfo(interfaceName);
     }
 
+    @Override
+    public InterfaceInfo getInterfaceInfoFromOperationalDataStore(
+            String interfaceName, InterfaceInfo.InterfaceType interfaceType) {
+        return interfaceInfos.get(interfaceName);
+    }
+
     @Override
     public InterfaceInfo getInterfaceInfoFromOperationalDSCache(String interfaceName) {
         return getInterfaceInfo(interfaceName);
@@ -72,6 +124,21 @@ public abstract class TestInterfaceManager implements IInterfaceManager {
                     + interfaceName);
         }
         return iface;
+    }
 
+    @Override
+    public BigInteger getDpnForInterface(String interfaceName) {
+        return interfaceInfos.get(interfaceName).getDpId();
     }
+
+    @Override
+    public BigInteger getDpnForInterface(Interface intrface) {
+        return interfaceInfos.get(intrface.getName()).getDpId();
+    }
+
+    @Override
+    public boolean isExternalInterface(String interfaceName) {
+        return externalInterfaces.containsKey(interfaceName);
+    }
+
 }

diff --git a/commons/testutils/src/main/java/org/opendaylight/genius/testutils/interfacemanager/InterfaceHelper.java b/commons/testutils/src/main/java/org/opendaylight/genius/testutils/interfacemanager/InterfaceHelper.java
new file mode 100644 (file)
index 0000000..44de9ae
--- /dev/null
+++ b/commons/testutils/src/main/java/org/opendaylight/genius/testutils/interfacemanager/InterfaceHelper.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright © 2017 Ericsson India Global Services Pvt Ltd. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.genius.testutils.interfacemanager;
+
+import java.util.Collections;
+
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
+import org.opendaylight.genius.interfacemanager.globals.InterfaceInfo;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev140508.L2vlan;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev140508.Tunnel;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfTunnel;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.IfTunnelBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.ParentRefs;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.ParentRefsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.interfacemanager.rev160406.TunnelTypeVxlan;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public final class InterfaceHelper {
+
+    private static final String DEFAULT_GW = "0.0.0.0";
+
+    private InterfaceHelper() {
+    }
+
+    public static InstanceIdentifier<Interface> buildIId(String interfaceName) {
+        return InstanceIdentifier
+                .builder(Interfaces.class)
+                .child(Interface.class, new InterfaceKey(interfaceName))
+                .build();
+    }
+
+    public static Interface readInterfaceFromConfigDs(String interfaceName,
+                                                      DataBroker dataBroker) throws ReadFailedException {
+        return SingleTransactionDataBroker.syncReadOptional(
+                dataBroker,
+                LogicalDatastoreType.CONFIGURATION,
+                buildIId(interfaceName)).orNull();
+    }
+
+    public static Interface buildVlanInterfaceFromInfo(InterfaceInfo interfaceInfo) {
+        ParentRefs parentRefs = new ParentRefsBuilder()
+                .setDatapathNodeIdentifier(interfaceInfo.getDpId())
+                .setParentInterface(interfaceInfo.getInterfaceName())
+                .build();
+
+        return new InterfaceBuilder()
+                .setKey(new InterfaceKey(interfaceInfo.getInterfaceName()))
+                .setName(interfaceInfo.getInterfaceName())
+                .setDescription("Vlan interface")
+                .setEnabled(true)
+                .setType(L2vlan.class)
+                .addAugmentation(ParentRefs.class, parentRefs)
+                .build();
+    }
+
+    public static Interface buildVxlanTunnelInterfaceFromInfo(TunnelInterfaceDetails tunnelInterfaceDetails) {
+        InterfaceInfo interfaceInfo = tunnelInterfaceDetails.getInterfaceInfo();
+        ParentRefs parentRefs = new ParentRefsBuilder()
+                .setDatapathNodeIdentifier(interfaceInfo.getDpId())
+                .setParentInterface(interfaceInfo.getInterfaceName())
+                .build();
+
+        IfTunnel tunnel = new IfTunnelBuilder()
+                .setTunnelDestination(new IpAddress(new Ipv4Address(tunnelInterfaceDetails.getDstIp())))
+                .setTunnelGateway(new IpAddress(new Ipv4Address(DEFAULT_GW)))
+                .setTunnelSource(new IpAddress(new Ipv4Address(tunnelInterfaceDetails.getSrcIp())))
+                .setTunnelInterfaceType(TunnelTypeVxlan.class)
+                .setInternal(!tunnelInterfaceDetails.isExternal())
+                .setTunnelRemoteIpFlow(false)
+                .setTunnelOptions(Collections.emptyList())
+                .build();
+
+        return new InterfaceBuilder()
+                .setKey(new InterfaceKey(interfaceInfo.getInterfaceName()))
+                .setName(interfaceInfo.getInterfaceName())
+                .setDescription("Tunnel interface")
+                .setEnabled(true)
+                .setType(Tunnel.class)
+                .addAugmentation(ParentRefs.class, parentRefs)
+                .addAugmentation(IfTunnel.class, tunnel)
+                .build();
+    }
+}

diff --git a/commons/testutils/src/main/java/org/opendaylight/genius/testutils/interfacemanager/InterfaceStateHelper.java b/commons/testutils/src/main/java/org/opendaylight/genius/testutils/interfacemanager/InterfaceStateHelper.java
new file mode 100644 (file)
index 0000000..64a8b29
--- /dev/null
+++ b/commons/testutils/src/main/java/org/opendaylight/genius/testutils/interfacemanager/InterfaceStateHelper.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright © 2017 Ericsson India Global Services Pvt Ltd. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.genius.testutils.interfacemanager;
+
+import com.google.common.collect.Lists;
+import java.math.BigInteger;
+
+import org.opendaylight.genius.interfacemanager.globals.InterfaceInfo;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev140508.Other;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.InterfacesState;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.AdminStatus;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface.OperStatus;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.Interface;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.InterfaceBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.state.InterfaceKey;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.PhysAddress;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public final class InterfaceStateHelper {
+
+    private InterfaceStateHelper() {
+    }
+
+    public static InstanceIdentifier<Interface> buildStateInterfaceIid(String interfaceName) {
+        return InstanceIdentifier
+                .builder(InterfacesState.class)
+                .child(Interface.class, new InterfaceKey(interfaceName))
+                .build();
+    }
+
+    public static Interface buildStateFromInterfaceInfo(InterfaceInfo interfaceInfo) {
+        BigInteger dpId = interfaceInfo.getDpId();
+        int portno = interfaceInfo.getPortNo();
+        NodeConnectorId nodeConnectorId = new NodeConnectorId("openflow:" + dpId.toString() + ":" + portno);
+        return new InterfaceBuilder()
+                .setType(Other.class)
+                .setIfIndex(interfaceInfo.getInterfaceTag())
+                .setAdminStatus(AdminStatus.Up)
+                .setOperStatus(OperStatus.Up)
+                .setLowerLayerIf(Lists.newArrayList(nodeConnectorId.getValue()))
+                .setPhysAddress(new PhysAddress(interfaceInfo.getMacAddress()))
+                .setKey(new InterfaceKey(interfaceInfo.getInterfaceName()))
+                .build();
+    }
+}

diff --git a/commons/testutils/src/main/java/org/opendaylight/genius/testutils/interfacemanager/TunnelInterfaceDetails.java b/commons/testutils/src/main/java/org/opendaylight/genius/testutils/interfacemanager/TunnelInterfaceDetails.java
new file mode 100644 (file)
index 0000000..0e0de8a
--- /dev/null
+++ b/commons/testutils/src/main/java/org/opendaylight/genius/testutils/interfacemanager/TunnelInterfaceDetails.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright © 2017 Ericsson India Global Services Pvt Ltd. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.genius.testutils.interfacemanager;
+
+import org.opendaylight.genius.interfacemanager.globals.InterfaceInfo;
+
+public final class TunnelInterfaceDetails {
+
+    private final String srcIp;
+    private final String dstIp;
+    private final boolean external;
+    private final InterfaceInfo interfaceInfo;
+
+    public TunnelInterfaceDetails(String srcIp, String dstIp, boolean external, InterfaceInfo interfaceInfo) {
+        this.srcIp = srcIp;
+        this.dstIp = dstIp;
+        this.interfaceInfo = interfaceInfo;
+        this.external = external;
+    }
+
+    public String getSrcIp() {
+        return srcIp;
+    }
+
+    public String getDstIp() {
+        return dstIp;
+    }
+
+    public InterfaceInfo getInterfaceInfo() {
+        return interfaceInfo;
+    }
+
+    boolean isExternal() {
+        return external;
+    }
+}

diff --git a/commons/testutils/src/main/java/org/opendaylight/genius/testutils/itm/ItmRpcTestImpl.java b/commons/testutils/src/main/java/org/opendaylight/genius/testutils/itm/ItmRpcTestImpl.java
new file mode 100644 (file)
index 0000000..2a6032c
--- /dev/null
+++ b/commons/testutils/src/main/java/org/opendaylight/genius/testutils/itm/ItmRpcTestImpl.java
@@ -0,0 +1,167 @@
+/*
+ * Copyright © 2017 Ericsson India Global Services Pvt Ltd. and others.  All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.genius.testutils.itm;
+
+import com.google.common.collect.Lists;
+import java.math.BigInteger;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.Future;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddExternalTunnelEndpointInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddL2GwDeviceInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.AddL2GwMlagDeviceInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.BuildExternalTunnelFromDpnsInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.CreateTerminatingServiceActionsInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.DeleteL2GwDeviceInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.DeleteL2GwMlagDeviceInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetDpnEndpointIpsInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetDpnEndpointIpsOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetDpnEndpointIpsOutputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetExternalTunnelInterfaceNameInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetExternalTunnelInterfaceNameOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetExternalTunnelInterfaceNameOutputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetInternalOrExternalInterfaceNameInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetInternalOrExternalInterfaceNameOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetTunnelInterfaceNameInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetTunnelInterfaceNameOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.GetTunnelInterfaceNameOutputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.IsDcgwPresentInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.IsDcgwPresentOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.IsDcgwPresentOutputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.IsTunnelInternalOrExternalInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.IsTunnelInternalOrExternalOutput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.ItmRpcService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveExternalTunnelEndpointInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveExternalTunnelFromDpnsInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.genius.itm.rpcs.rev160406.RemoveTerminatingServiceActionsInput;
+import org.opendaylight.yangtools.yang.common.RpcResult;
+import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
+
+public final class ItmRpcTestImpl implements ItmRpcService {
+
+    private final Map<BigInteger, IpAddress> tepIps = new ConcurrentHashMap<>();
+    private final Map<BigInteger, Map<String, String>> interfaceNames = new ConcurrentHashMap<>();
+    private final Map<BigInteger, Map<String, String>> externalInterfaceNames = new ConcurrentHashMap<>();
+
+    public synchronized void addDpn(BigInteger dpnId, String tepIp) {
+        tepIps.put(dpnId, new IpAddress(new Ipv4Address(tepIp)));
+    }
+
+    public synchronized void addInterface(BigInteger dpnId, String dstTep, String interfaceName) {
+        interfaceNames.putIfAbsent(dpnId, new ConcurrentHashMap<>());
+        interfaceNames.get(dpnId).put(dstTep, interfaceName);
+    }
+
+    public synchronized void addExternalInterface(BigInteger dpnId, String dstTep, String interfaceName) {
+        dstTep = new IpAddress(new Ipv4Address(dstTep)).toString();
+        externalInterfaceNames.putIfAbsent(dpnId, new ConcurrentHashMap<>());
+        externalInterfaceNames.get(dpnId).put(dstTep, interfaceName);
+    }
+
+    @Override
+    public synchronized Future<RpcResult<Void>> buildExternalTunnelFromDpns(BuildExternalTunnelFromDpnsInput input) {
+        return RpcResultBuilder.<Void>success().buildFuture();
+    }
+
+    @Override
+    public synchronized Future<RpcResult<Void>> removeExternalTunnelEndpoint(RemoveExternalTunnelEndpointInput input) {
+        return RpcResultBuilder.<Void>success().buildFuture();
+    }
+
+    @Override
+    public synchronized Future<RpcResult<Void>> addL2GwMlagDevice(AddL2GwMlagDeviceInput input) {
+        return RpcResultBuilder.<Void>success().buildFuture();
+    }
+
+    @Override
+    public synchronized Future<RpcResult<Void>> removeExternalTunnelFromDpns(RemoveExternalTunnelFromDpnsInput input) {
+        return RpcResultBuilder.<Void>success().buildFuture();
+    }
+
+    @Override
+    public synchronized Future<RpcResult<Void>> deleteL2GwDevice(DeleteL2GwDeviceInput input) {
+        return RpcResultBuilder.<Void>success().buildFuture();
+    }
+
+    @Override
+    public synchronized Future<RpcResult<Void>> addL2GwDevice(AddL2GwDeviceInput input) {
+        return RpcResultBuilder.<Void>success().buildFuture();
+    }
+
+    @Override
+    public synchronized Future<RpcResult<IsTunnelInternalOrExternalOutput>> isTunnelInternalOrExternal(
+            IsTunnelInternalOrExternalInput input) {
+        IsTunnelInternalOrExternalOutput output = null;
+        return RpcResultBuilder.success(output).buildFuture();
+    }
+
+    @Override
+    public synchronized Future<RpcResult<GetTunnelInterfaceNameOutput>> getTunnelInterfaceName(
+            GetTunnelInterfaceNameInput input) {
+        String interfaceName = interfaceNames.get(input.getSourceDpid())
+                .get(new String(tepIps.get(input.getDestinationDpid()).getValue()));
+        GetTunnelInterfaceNameOutput output =
+                new GetTunnelInterfaceNameOutputBuilder().setInterfaceName(interfaceName).build();
+        return RpcResultBuilder.success(output).buildFuture();
+    }
+
+    @Override
+    public synchronized Future<RpcResult<IsDcgwPresentOutput>> isDcgwPresent(IsDcgwPresentInput input) {
+        IsDcgwPresentOutput output = new IsDcgwPresentOutputBuilder().setRetVal(0L).build();
+        return RpcResultBuilder.success(output).buildFuture();
+    }
+
+    @Override
+    public synchronized Future<RpcResult<GetExternalTunnelInterfaceNameOutput>> getExternalTunnelInterfaceName(
+            GetExternalTunnelInterfaceNameInput input) {
+        String interfaceName = externalInterfaceNames.get(new BigInteger(input.getSourceNode(), 10))
+                .get(input.getDestinationNode());
+        GetExternalTunnelInterfaceNameOutput output = new GetExternalTunnelInterfaceNameOutputBuilder()
+                .setInterfaceName(interfaceName)
+                .build();
+        return RpcResultBuilder.success(output).buildFuture();
+    }
+
+    @Override
+    public synchronized Future<RpcResult<Void>> createTerminatingServiceActions(
+            CreateTerminatingServiceActionsInput input) {
+        return RpcResultBuilder.<Void>success().buildFuture();
+    }
+
+    @Override
+    public synchronized Future<RpcResult<GetDpnEndpointIpsOutput>> getDpnEndpointIps(GetDpnEndpointIpsInput input) {
+        GetDpnEndpointIpsOutput output = new GetDpnEndpointIpsOutputBuilder()
+                .setNexthopipList(Lists.newArrayList(tepIps.get(input.getSourceDpid()))).build();
+        return RpcResultBuilder.success(output).buildFuture();
+    }
+
+    @Override
+    public synchronized Future<RpcResult<Void>> deleteL2GwMlagDevice(DeleteL2GwMlagDeviceInput input) {
+        return RpcResultBuilder.<Void>success().buildFuture();
+    }
+
+    @Override
+    public synchronized Future<RpcResult<GetInternalOrExternalInterfaceNameOutput>> getInternalOrExternalInterfaceName(
+            GetInternalOrExternalInterfaceNameInput input) {
+        GetInternalOrExternalInterfaceNameOutput output = null;
+        return RpcResultBuilder.success(output).buildFuture();
+    }
+
+    @Override
+    public synchronized Future<RpcResult<Void>> removeTerminatingServiceActions(
+            RemoveTerminatingServiceActionsInput input) {
+        return RpcResultBuilder.<Void>success().buildFuture();
+    }
+
+    @Override
+    public synchronized Future<RpcResult<Void>> addExternalTunnelEndpoint(AddExternalTunnelEndpointInput input) {
+        return RpcResultBuilder.<Void>success().buildFuture();
+    }
+}