diff --git a/apps/vpls/src/test/java/org/onosproject/vpls/VplsNeighbourHandlerTest.java b/apps/vpls/src/test/java/org/onosproject/vpls/VplsNeighbourHandlerTest.java
index 90e3415..66edd13 100644
--- a/apps/vpls/src/test/java/org/onosproject/vpls/VplsNeighbourHandlerTest.java
+++ b/apps/vpls/src/test/java/org/onosproject/vpls/VplsNeighbourHandlerTest.java
@@ -19,6 +19,7 @@
 import com.google.common.collect.HashMultimap;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.ImmutableSetMultimap;
+import com.google.common.collect.Maps;
 import com.google.common.collect.SetMultimap;
 import com.google.common.collect.Sets;
 import org.junit.After;
@@ -41,6 +42,7 @@
 import org.onosproject.net.ConnectPoint;
 import org.onosproject.net.DefaultHost;
 import org.onosproject.net.DeviceId;
+import org.onosproject.net.EncapsulationType;
 import org.onosproject.net.Host;
 import org.onosproject.net.HostId;
 import org.onosproject.net.HostLocation;
@@ -48,9 +50,9 @@
 import org.onosproject.net.host.HostService;
 import org.onosproject.net.host.HostServiceAdapter;
 import org.onosproject.net.provider.ProviderId;
-import org.onosproject.vpls.config.VplsConfigurationService;
 
 import java.util.Collection;
+import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;
 import java.util.stream.Collectors;
@@ -61,81 +63,88 @@
  * Tests the the {@link VplsNeighbourHandler} class.
  */
 public class VplsNeighbourHandlerTest {
-    private final ConnectPoint of1p1 =
-            new ConnectPoint(DeviceId.deviceId("of:1"),
-                             PortNumber.portNumber(1));
-    private final ConnectPoint of4p1 =
-            new ConnectPoint(DeviceId.deviceId("of:4"),
-                             PortNumber.portNumber(1));
-    private final ConnectPoint of3p1 =
-            new ConnectPoint(DeviceId.deviceId("of:3"),
-                             PortNumber.portNumber(1));
-    private final ConnectPoint of4p2 =
-            new ConnectPoint(DeviceId.deviceId("of:4"),
-                             PortNumber.portNumber(2));
-    private final ConnectPoint of2p1 =
-            new ConnectPoint(DeviceId.deviceId("of:2"),
-                             PortNumber.portNumber(1));
 
-    private final VlanId vlan100 = VlanId.vlanId("100");
-    private final VlanId vlan200 = VlanId.vlanId("200");
-    private final VlanId vlan300 = VlanId.vlanId("300");
+    private static final String IFACES_NOT_EXPECTED =
+            "The interfaces reached by the packet are not equal to the " +
+                    "interfaces expected";
 
-    private final Interface v100h1 =
-            new Interface("v100h1", of1p1, null, null, vlan100);
-    private final Interface v100h2 =
-            new Interface("v100h2", of4p1, null, null, vlan100);
-    private final Interface v200h1 =
-            new Interface("v200h1", of4p2, null, null, vlan200);
-    private final Interface v300h1 =
-            new Interface("v300h1", of3p1, null, null, vlan300);
-    private final Interface v200h2 =
-            new Interface("v200h2", of2p1, null, null, vlan200);
+    private static final DeviceId DID1 = getDeviceId(1);
+    private static final DeviceId DID2 = getDeviceId(2);
+    private static final DeviceId DID3 = getDeviceId(3);
+    private static final DeviceId DID4 = getDeviceId(4);
 
-    private final MacAddress mac1 = MacAddress.valueOf("00:00:00:00:00:01");
-    private final MacAddress mac2 = MacAddress.valueOf("00:00:00:00:00:02");
-    private final MacAddress mac3 = MacAddress.valueOf("00:00:00:00:00:03");
-    private final MacAddress mac4 = MacAddress.valueOf("00:00:00:00:00:04");
-    private final MacAddress mac5 = MacAddress.valueOf("00:00:00:00:00:05");
+    private static final PortNumber P1 = PortNumber.portNumber(1);
+    private static final PortNumber P2 = PortNumber.portNumber(2);
 
-    private final ProviderId pid = new ProviderId("of", "foo");
+    private static final ConnectPoint OF1P1 = new ConnectPoint(DID1, P1);
+    private static final ConnectPoint OF2P1 = new ConnectPoint(DID2, P1);
+    private static final ConnectPoint OF3P1 = new ConnectPoint(DID3, P1);
+    private static final ConnectPoint OF4P1 = new ConnectPoint(DID4, P1);
+    private static final ConnectPoint OF4P2 = new ConnectPoint(DID4, P2);
 
-    private final Host v100host1 = makeHost(mac1, vlan100, of1p1);
-    private final Host v100host2 = makeHost(mac2, vlan100, of4p1);
-    private final Host v200host1 = makeHost(mac3, vlan200, of4p2);
-    private final Host v300host1 = makeHost(mac4, vlan300, of3p1);
-    private final Host v200host2 = makeHost(mac5, vlan200, of2p1);
+    private static final String VPLS1 = "vpls1";
+    private static final String VPLS2 = "vpls2";
 
-    private final Set<Host> availableHosts = ImmutableSet.of(v100host1,
-                                                             v100host2,
-                                                             v200host1,
-                                                             v300host1,
-                                                             v200host2);
+    private static final VlanId VLAN100 = VlanId.vlanId("100");
+    private static final VlanId VLAN200 = VlanId.vlanId("200");
+    private static final VlanId VLAN300 = VlanId.vlanId("300");
 
-    private final Set<Interface> avaliableInterfaces =
-            ImmutableSet.of(v100h1, v100h2, v200h1, v200h2, v300h1);
+    private static final Interface V100H1 =
+            new Interface("v100h1", OF1P1, null, null, VLAN100);
+    private static final Interface V100H2 =
+            new Interface("v100h2", OF4P1, null, null, VLAN100);
+    private static final Interface V200H1 =
+            new Interface("v200h1", OF4P2, null, null, VLAN200);
+    private static final Interface V200H2 =
+            new Interface("v200h2", OF2P1, null, null, VLAN200);
+    private static final Interface V300H1 =
+            new Interface("v300h1", OF3P1, null, null, VLAN300);
+
+    private static final MacAddress MAC1 = MacAddress.valueOf("00:00:00:00:00:01");
+    private static final MacAddress MAC2 = MacAddress.valueOf("00:00:00:00:00:02");
+    private static final MacAddress MAC3 = MacAddress.valueOf("00:00:00:00:00:03");
+    private static final MacAddress MAC4 = MacAddress.valueOf("00:00:00:00:00:04");
+    private static final MacAddress MAC5 = MacAddress.valueOf("00:00:00:00:00:05");
+
+    private static final ProviderId PID = new ProviderId("of", "foo");
+
+    private final Host v100Host1 = makeHost(MAC1, VLAN100, OF1P1);
+    private final Host v100Host2 = makeHost(MAC2, VLAN100, OF4P1);
+    private final Host v200Host1 = makeHost(MAC3, VLAN200, OF4P2);
+    private final Host v200Host2 = makeHost(MAC5, VLAN200, OF2P1);
+    private final Host v300Host1 = makeHost(MAC4, VLAN300, OF3P1);
+
+    private final Set<Host> availableHosts = ImmutableSet.of(v100Host1,
+                                                             v100Host2,
+                                                             v200Host1,
+                                                             v300Host1,
+                                                             v200Host2);
+
+    private final Set<Interface> availableInterfaces =
+            ImmutableSet.of(V100H1, V100H2, V200H1, V200H2, V300H1);
 
     private VplsNeighbourHandler vplsNeighbourHandler;
 
     private HostService hostService;
 
     /**
-     * Sets up 2 VPLS which contain 2 networks and 5 hosts.
-     * net1 contains 3 hosts: v100h1, v200h1 and v300h1
-     * net2 contains 2 hosts: v100h2, v200h2
+     * Sets up 2 VPLS.
+     * VPLS 1 contains 3 hosts: v100h1, v200h1 and v300h1
+     * VPLS 2 contains 2 hosts: v100h2, v200h2
      */
     @Before
     public void setUp() {
         vplsNeighbourHandler = new VplsNeighbourHandler();
-        SetMultimap<String, Interface> vplsNetworks =
+        SetMultimap<String, Interface> ifacesByVpls =
                 HashMultimap.create();
-        vplsNetworks.put("net1", v100h1);
-        vplsNetworks.put("net1", v200h1);
-        vplsNetworks.put("net1", v300h1);
-        vplsNetworks.put("net2", v100h2);
-        vplsNetworks.put("net2", v200h2);
+        ifacesByVpls.put(VPLS1, V100H1);
+        ifacesByVpls.put(VPLS1, V200H1);
+        ifacesByVpls.put(VPLS1, V300H1);
+        ifacesByVpls.put(VPLS2, V100H2);
+        ifacesByVpls.put(VPLS2, V200H2);
+        HashMap<String, EncapsulationType> encap = Maps.newHashMap();
         vplsNeighbourHandler.vplsConfigService =
-                new TestVplsConfigService(vplsNetworks);
+                new TestVplsConfigService(ifacesByVpls, encap);
         vplsNeighbourHandler.interfaceService =
                 new TestInterfaceService();
         vplsNeighbourHandler.neighbourService =
@@ -150,133 +159,133 @@
     }
 
     /**
-     * Sends request messages to all hosts in VPLS net1.
-     * Request messages should be received from other hosts in net1.
+     * Sends request messages to all hosts in VPLS 1.
+     * Request messages should be received from other hosts in VPLS 1.
      */
     @Test
-    public void testNet1RequestMessage() {
-        // Request from v100h1 (net1)
-        // Should be received by v200h1 and v300h1
+    public void vpls1RequestMessage() {
+        // Request messages from v100h1 (VPLS 1) should be received by v200h1 and v300h1
         TestMessageContext requestMessage =
-                makeBroadcastRequestContext(v100host1);
-        Set<Interface> expectInterfaces = ImmutableSet.of(v200h1, v300h1);
+                makeBroadcastRequestContext(v100Host1);
+        Set<Interface> expectInterfaces = ImmutableSet.of(V200H1, V300H1);
         vplsNeighbourHandler.handleRequest(requestMessage);
-        assertEquals(expectInterfaces, requestMessage.forwardResults);
+        assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, requestMessage.forwardResults);
 
-        // Request from v200h1 (net1)
-        // Should be received by v100h1 and v300h1
-        requestMessage = makeBroadcastRequestContext(v200host1);
-        expectInterfaces = ImmutableSet.of(v100h1, v300h1);
+        // Request messages from v200h1 (VPLS 1) should be received by v100h1 and v300h1
+        requestMessage = makeBroadcastRequestContext(v200Host1);
+        expectInterfaces = ImmutableSet.of(V100H1, V300H1);
         vplsNeighbourHandler.handleRequest(requestMessage);
-        assertEquals(expectInterfaces, requestMessage.forwardResults);
+        assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, requestMessage.forwardResults);
 
-        // Request from v300h1 (net1)
-        // Should be received by v100h1 and v200h1
-        requestMessage = makeBroadcastRequestContext(v300host1);
-        expectInterfaces = ImmutableSet.of(v100h1, v200h1);
+        // Request from v300h1 (VPLS 1) should be received by v100h1 and v200h1
+        requestMessage = makeBroadcastRequestContext(v300Host1);
+        expectInterfaces = ImmutableSet.of(V100H1, V200H1);
         vplsNeighbourHandler.handleRequest(requestMessage);
-        assertEquals(expectInterfaces, requestMessage.forwardResults);
+        assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, requestMessage.forwardResults);
     }
 
     /**
-     * Sends request messages to all hosts in VPLS net2.
-     * Request messages should be received from other hosts in net2.
+     * Sends request messages to all hosts in VPLS 2.
+     * Request messages should be received from other hosts in VPLS 2.
      */
     @Test
-    public void testNet2RequestMessage() {
-        // Request from v100h2
-        // Should be received by v200h2
+    public void vpls2RequestMessage() {
+        // Request messages from v100h2 (VPLS 2) should be received by v200h2
         TestMessageContext requestMessage =
-                makeBroadcastRequestContext(v100host2);
-        Set<Interface> expectInterfaces = ImmutableSet.of(v200h2);
+                makeBroadcastRequestContext(v100Host2);
+        Set<Interface> expectInterfaces = ImmutableSet.of(V200H2);
         vplsNeighbourHandler.handleRequest(requestMessage);
-        assertEquals(expectInterfaces, requestMessage.forwardResults);
+        assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, requestMessage.forwardResults);
 
-        // Request from v200h2
-        // Should be received by v100h2
-        requestMessage = makeBroadcastRequestContext(v200host2);
-        expectInterfaces = ImmutableSet.of(v100h2);
+        // Request messages from v200h2 (VPLS 2) should be received by v100h2
+        requestMessage = makeBroadcastRequestContext(v200Host2);
+        expectInterfaces = ImmutableSet.of(V100H2);
         vplsNeighbourHandler.handleRequest(requestMessage);
-        assertEquals(expectInterfaces, requestMessage.forwardResults);
+        assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, requestMessage.forwardResults);
     }
 
     /**
-     * Sends reply messages to hosts in VPLS net1.
+     * Sends reply messages to hosts in VPLS 1.
      * Reply messages should be received by the host with MAC address equal to
      * the dstMac of the message context.
      */
     @Test
-    public void testNet1ReplyMessage() {
-        // Response from v100h1 (net1) to v200h1 (net1)
-        // Should be received by v200h1
+    public void vpls1ReplyMessage() {
+        // Reply messages from v100h1 (VPLS 1) should be received by v200h1
         TestMessageContext replyMessage =
-                makeReplyContext(v100host1, v200host1);
-        Set<Interface> expectInterfaces = ImmutableSet.of(v200h1);
+                makeReplyContext(v100Host1, v200Host1);
+        Set<Interface> expectInterfaces = ImmutableSet.of(V200H1);
         vplsNeighbourHandler.handleReply(replyMessage, hostService);
-        assertEquals(expectInterfaces, replyMessage.forwardResults);
+        assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, replyMessage.forwardResults);
 
-        // Response from v200h1 (net1) to v300h1 (net1)
-        // Should be received by v300h1
-        replyMessage = makeReplyContext(v200host1, v300host1);
-        expectInterfaces = ImmutableSet.of(v300h1);
+        // Reply messages from v200h1 (VPLS 1) should be received by v300h1
+        replyMessage = makeReplyContext(v200Host1, v300Host1);
+        expectInterfaces = ImmutableSet.of(V300H1);
         vplsNeighbourHandler.handleReply(replyMessage, hostService);
-        assertEquals(expectInterfaces, replyMessage.forwardResults);
+        assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, replyMessage.forwardResults);
 
-        // Response from v300h1 (net1) to v100h1 (net1)
-        // Should be received by v100h1
-        replyMessage = makeReplyContext(v300host1, v100host1);
-        expectInterfaces = ImmutableSet.of(v100h1);
+        // Reply messages from v300h1 (VPLS 1) should be received by v100h1
+        replyMessage = makeReplyContext(v300Host1, v100Host1);
+        expectInterfaces = ImmutableSet.of(V100H1);
         vplsNeighbourHandler.handleReply(replyMessage, hostService);
-        assertEquals(expectInterfaces, replyMessage.forwardResults);
+        assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, replyMessage.forwardResults);
     }
 
     /**
-     * Sends reply messages to hosts in VPLS net2.
+     * Sends reply messages to hosts in VPLS 2.
      * Reply messages should be received by the host with MAC address equal to
      * the dstMac of the message context.
      */
     @Test
-    public void testNet2ReplyMessage() {
-        // Response from v100h2 (net2) to v200h2 (net2)
-        // Should be received by v200h2
+    public void vpls2ReplyMessage() {
+        // Reply messages from v100h2 (VPLS 2) should be received by v200h2
         TestMessageContext replyMessage =
-                makeReplyContext(v100host2, v200host2);
-        Set<Interface> expectInterfaces = ImmutableSet.of(v200h2);
+                makeReplyContext(v100Host2, v200Host2);
+        Set<Interface> expectInterfaces = ImmutableSet.of(V200H2);
         vplsNeighbourHandler.handleReply(replyMessage, hostService);
-        assertEquals(expectInterfaces, replyMessage.forwardResults);
+        assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, replyMessage.forwardResults);
 
-        // Response from v200h2 (net2) to v100h2 (net2)
-        // Should be received by v100h2
-        replyMessage = makeReplyContext(v200host2, v100host2);
-        expectInterfaces = ImmutableSet.of(v100h2);
+        // Reply messages from v200h2 (VPLS 2) should be received by v100h2
+        replyMessage = makeReplyContext(v200Host2, v100Host2);
+        expectInterfaces = ImmutableSet.of(V100H2);
         vplsNeighbourHandler.handleReply(replyMessage, hostService);
-        assertEquals(expectInterfaces, replyMessage.forwardResults);
+        assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, replyMessage.forwardResults);
     }
 
     /**
      * Sends wrong reply messages to hosts.
      * The source and the destination MAC addresses are not set on any host of the VPLS.
-     * The reply messages won't be received by any hosts.
+     * The reply messages will not be received by any hosts.
      */
     @Test
-    public void testWrongReplyMessage() {
-        // Response from v100h1 (net1) to v100h2 (net2)
-        // forward results should be empty
-        TestMessageContext replyMessage = makeReplyContext(v100host1, v100host2);
+    public void wrongReplyMessage() {
+        // Reply message from v100h1 (VPLS 1) to v100h2 (VPLS 2).
+        // Forward results should be empty
+        TestMessageContext replyMessage = makeReplyContext(v100Host1, v100Host2);
         Set<Interface> expectInterfaces = ImmutableSet.of();
         vplsNeighbourHandler.handleReply(replyMessage, hostService);
-        assertEquals(expectInterfaces, replyMessage.forwardResults);
+        assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, replyMessage.forwardResults);
 
-        // Response from v200h2 (net2) to v300h1 (net1)
-        // forward results should be empty
-        replyMessage = makeReplyContext(v200host2, v300host1);
+        // Reply message from v200h2 (VPLS 2) to v300h1 (VPLS 1).
+        // Forward results should be empty
+        replyMessage = makeReplyContext(v200Host2, v300Host1);
         expectInterfaces = ImmutableSet.of();
         vplsNeighbourHandler.handleReply(replyMessage, hostService);
-        assertEquals(expectInterfaces, replyMessage.forwardResults);
+        assertEquals(IFACES_NOT_EXPECTED, expectInterfaces, replyMessage.forwardResults);
+    }
+
+    /**
+     * Returns the device Id of the ith device.
+     *
+     * @param i the device to get the Id of
+     * @return the device Id
+     */
+    private static DeviceId getDeviceId(int i) {
+        return DeviceId.deviceId("" + i);
     }
 
     private Host makeHost(MacAddress mac, VlanId vlan, ConnectPoint cp) {
-        return new DefaultHost(pid,
+        return new DefaultHost(PID,
                                HostId.hostId(mac, vlan),
                                mac,
                                vlan,
@@ -336,6 +345,7 @@
             this.forwardResults = Sets.newHashSet();
 
         }
+
         @Override
         public ConnectPoint inPort() {
             return inPort;
@@ -407,21 +417,22 @@
         }
     }
 
-    private class TestVplsConfigService implements VplsConfigurationService {
+    private class TestVplsConfigService extends VplsConfigurationServiceAdapter {
 
-        private final SetMultimap<String, Interface> vplsNetworks;
+        private final SetMultimap<String, Interface> ifacesByVplsName;
 
-        public TestVplsConfigService(SetMultimap<String, Interface> networks) {
-            this.vplsNetworks = networks;
+        public TestVplsConfigService(SetMultimap<String, Interface> ifacesByVplsName,
+                                     HashMap<String, EncapsulationType> encapByVplsName) {
+            this.ifacesByVplsName = ifacesByVplsName;
         }
 
         @Override
-        public void addVpls(String name, Set<String> ifaceNames) {
-            if (!vplsNetworks.containsKey(name)) {
+        public void addVpls(String vplsName, Set<String> ifaceNames, String encap) {
+            if (!ifacesByVplsName.containsKey(vplsName)) {
                 ifaceNames.forEach(ifaceName -> {
-                    avaliableInterfaces.forEach(intf -> {
-                        if (intf.name().equals(ifaceName)) {
-                            vplsNetworks.put(name, intf);
+                    availableInterfaces.forEach(iface -> {
+                        if (iface.name().equals(ifaceName)) {
+                            ifacesByVplsName.put(vplsName, iface);
                         }
                     });
                 });
@@ -429,87 +440,77 @@
         }
 
         @Override
-        public void removeVpls(String name) {
-            if (vplsNetworks.containsKey(name)) {
-                vplsNetworks.removeAll(name);
+        public void removeVpls(String vplsName) {
+            if (ifacesByVplsName.containsKey(vplsName)) {
+                ifacesByVplsName.removeAll(vplsName);
             }
         }
 
         @Override
-        public void addInterfaceToVpls(String name, String ifaceName) {
-            avaliableInterfaces.forEach(intf -> {
+        public void addIface(String vplsName, String ifaceName) {
+            availableInterfaces.forEach(intf -> {
                 if (intf.name().equals(ifaceName)) {
-                    vplsNetworks.put(name, intf);
+                    ifacesByVplsName.put(vplsName, intf);
                 }
             });
         }
 
         @Override
-        public void removeInterfaceFromVpls(String ifaceName) {
+        public void removeIface(String ifaceName) {
             SetMultimap<String, Interface> toBeRemoved = HashMultimap.create();
-            vplsNetworks.entries().forEach(e -> {
+            ifacesByVplsName.entries().forEach(e -> {
                 if (e.getValue().name().equals(ifaceName)) {
                     toBeRemoved.put(e.getKey(), e.getValue());
                 }
             });
 
             toBeRemoved.entries()
-                    .forEach(e -> vplsNetworks.remove(e.getKey(),
-                                                      e.getValue()));
+                    .forEach(e -> ifacesByVplsName.remove(e.getKey(),
+                                                          e.getValue()));
         }
 
         @Override
-        public void cleanVpls() {
-            vplsNetworks.clear();
+        public void cleanVplsConfig() {
+            ifacesByVplsName.clear();
         }
 
         @Override
-        public Set<String> getVplsAffectedByApi() {
-            return null;
+        public Set<Interface> allIfaces() {
+            return ImmutableSet.copyOf(ifacesByVplsName.values());
         }
 
         @Override
-        public Set<Interface> getAllInterfaces() {
-            return ImmutableSet.copyOf(vplsNetworks.values());
-        }
-
-        @Override
-        public Set<Interface> getVplsInterfaces(String name) {
-            return vplsNetworks.get(name)
+        public Set<Interface> ifaces(String name) {
+            return ifacesByVplsName.get(name)
                     .stream()
                     .collect(Collectors.toSet());
         }
 
         @Override
-        public Set<String> getAllVpls() {
-            return vplsNetworks.keySet();
+        public Set<String> vplsNames() {
+            return ifacesByVplsName.keySet();
         }
 
         @Override
-        public Set<String> getOldVpls() {
-            return null;
+        public SetMultimap<String, Interface> ifacesByVplsName() {
+            return ImmutableSetMultimap.copyOf(ifacesByVplsName);
         }
 
         @Override
-        public SetMultimap<String, Interface> getVplsNetworks() {
-            return ImmutableSetMultimap.copyOf(vplsNetworks);
-        }
-
-        @Override
-        public SetMultimap<String, Interface> getVplsNetwork(VlanId vlan,
-                                                             ConnectPoint connectPoint) {
-            String vplsNetworkName =
-                    vplsNetworks.entries().stream()
+        public SetMultimap<String, Interface> ifacesByVplsName(VlanId vlan,
+                                                               ConnectPoint connectPoint) {
+            String vplsName =
+                    ifacesByVplsName.entries().stream()
                             .filter(e -> e.getValue().connectPoint().equals(connectPoint))
                             .filter(e -> e.getValue().vlan().equals(vlan))
                             .map(e -> e.getKey())
                             .findFirst()
                             .orElse(null);
             SetMultimap<String, Interface> result = HashMultimap.create();
-            if (vplsNetworkName != null &&
-                    vplsNetworks.containsKey(vplsNetworkName)) {
-                vplsNetworks.get(vplsNetworkName)
-                        .forEach(intf -> result.put(vplsNetworkName, intf));
+            if (vplsName != null &&
+                    ifacesByVplsName.containsKey(vplsName)) {
+                ifacesByVplsName.get(vplsName)
+                        .forEach(intf -> result.put(vplsName, intf));
                 return result;
             }
             return null;
@@ -654,13 +655,13 @@
 
         @Override
         public Set<Interface> getInterfaces() {
-            return avaliableInterfaces;
+            return availableInterfaces;
         }
 
         @Override
         public Interface getInterfaceByName(ConnectPoint connectPoint,
                                             String name) {
-            return avaliableInterfaces.stream()
+            return availableInterfaces.stream()
                     .filter(intf -> intf.name().equals(name))
                     .findFirst()
                     .orElse(null);
@@ -669,28 +670,28 @@
 
         @Override
         public Set<Interface> getInterfacesByPort(ConnectPoint port) {
-            return avaliableInterfaces.stream()
+            return availableInterfaces.stream()
                     .filter(intf -> intf.connectPoint().equals(port))
                     .collect(Collectors.toSet());
         }
 
         @Override
         public Set<Interface> getInterfacesByIp(IpAddress ip) {
-            return avaliableInterfaces.stream()
+            return availableInterfaces.stream()
                     .filter(intf -> intf.ipAddressesList().contains(ip))
                     .collect(Collectors.toSet());
         }
 
         @Override
         public Set<Interface> getInterfacesByVlan(VlanId vlan) {
-            return avaliableInterfaces.stream()
+            return availableInterfaces.stream()
                     .filter(intf -> intf.vlan().equals(vlan))
                     .collect(Collectors.toSet());
         }
 
         @Override
         public Interface getMatchingInterface(IpAddress ip) {
-            return avaliableInterfaces.stream()
+            return availableInterfaces.stream()
                     .filter(intf -> intf.ipAddressesList().contains(ip))
                     .findFirst()
                     .orElse(null);