HONEYCOMB-75 - Lisp implemetation

Rebased on final minimal distro

Change-Id: Ib71fc59e62dda4633f4f79c5c7417a4aaf02a177
Signed-off-by: Jan Srnicek <jsrnicek@cisco.com>
Signed-off-by: Florin Coras <fcoras@cisco.com>
Signed-off-by: Maros Marsalek <mmarsale@cisco.com>

9 files changed, 1224 insertions, 0 deletions

diff --git a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/context/util/EidMappingContextTest.java b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/context/util/EidMappingContextTest.java
new file mode 100644
index 000000000..710477a70
--- /dev/null
+++ b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/context/util/EidMappingContextTest.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2016 Cisco and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.fd.honeycomb.lisp.context.util;
+
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.when;
+
+import com.google.common.base.Optional;
+import io.fd.honeycomb.translate.MappingContext;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.eid.mapping.context.rev160801.contexts.eid.mapping.context.mappings.MappingBuilder;
+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.lisp.address.types.rev151105.lisp.address.address.Ipv4;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv4Builder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.MappingId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.local.mappings.local.mapping.Eid;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.local.mappings.local.mapping.EidBuilder;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class EidMappingContextTest {
+
+    private EidMappingContext eidMappingContext;
+
+    @Mock
+    private MappingContext mappingContext;
+
+    @Before
+    public void init() {
+        MockitoAnnotations.initMocks(this);
+        eidMappingContext = new EidMappingContext("eid-eidMappingContext");
+    }
+
+    @Test
+    public void testStoreAndGet() {
+        Eid eid =
+                new EidBuilder().setAddress(new Ipv4Builder().setIpv4(new Ipv4Address("192.168.2.1")).build()).build();
+        MappingId id = new MappingId("first");
+
+        eidMappingContext.addEid(id, eid, mappingContext);
+        when(mappingContext.read(Mockito.any(InstanceIdentifier.class)))
+                .thenReturn(Optional.of(
+                        new MappingBuilder().setId(id).setEid(copyEid(eid)).build()
+                ));
+
+        Eid sameEid =
+                new EidBuilder().setAddress(new Ipv4Builder().setIpv4(new Ipv4Address("192.168.2.1")).build()).build();
+        MappingId sameId = new MappingId("first");
+
+        assertTrue(eidMappingContext.containsEid(sameId, mappingContext));
+
+        org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.eid.mapping.context.rev160801.contexts.eid.mapping.context.mappings.mapping.Eid
+                loadedEid = eidMappingContext.getEid(sameId, mappingContext);
+
+        assertEquals("192.168.2.1", ((Ipv4) (loadedEid.getAddress())).getIpv4().getValue());
+    }
+
+    private org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.eid.mapping.context.rev160801.contexts.eid.mapping.context.mappings.mapping.Eid copyEid(
+            Eid eid) {
+        return new org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.eid.mapping.context.rev160801.contexts.eid.mapping.context.mappings.mapping.EidBuilder()
+                .setAddress(eid.getAddress())
+                .setAddressType(eid.getAddressType())
+                .setVirtualNetworkId(eid.getVirtualNetworkId())
+                .build();
+    }
+}
diff --git a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/util/EidConverterTest.java b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/util/EidConverterTest.java
new file mode 100755
index 000000000..15087ef24
--- /dev/null
+++ b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/util/EidConverterTest.java
@@ -0,0 +1,49 @@
+package io.fd.honeycomb.lisp.translate.util;
+
+import static io.fd.honeycomb.lisp.translate.read.dump.executor.params.MappingsDumpParams.EidType.IPV4;
+import static io.fd.honeycomb.lisp.translate.read.dump.executor.params.MappingsDumpParams.EidType.IPV6;
+import static io.fd.honeycomb.lisp.translate.read.dump.executor.params.MappingsDumpParams.EidType.MAC;
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+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.inet.types.rev130715.Ipv6Address;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv4Builder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv6Builder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.MacBuilder;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
+
+public class EidConverterTest {
+
+    @Test
+    public void testGetEidType() {
+        assertEquals(IPV4, EidConverter
+                .getEidType(
+                        new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.remote.mappings.remote.mapping.EidBuilder()
+                                .setAddress(
+                                        new Ipv4Builder().setIpv4(
+                                                new Ipv4Address("192.168.2.1"))
+                                                .build())
+                                .build()));
+
+        assertEquals(IPV6, EidConverter
+                .getEidType(
+                        new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.remote.mappings.remote.mapping.EidBuilder()
+                                .setAddress(
+                                        new Ipv6Builder().setIpv6(
+                                                new Ipv6Address("2001:0db8:0a0b:12f0:0000:0000:0000:0001"))
+                                                .build())
+                                .build()));
+
+        assertEquals(MAC, EidConverter
+                .getEidType(
+                        new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.remote.mappings.remote.mapping.EidBuilder()
+                                .setAddress(
+                                        new MacBuilder().setMac(
+                                                new MacAddress("aa:bb:cc:dd:ee:ff"))
+                                                .build())
+                                .build()));
+
+        //TODO  testing of other types when they are implemented
+    }
+}
diff --git a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/write/InterfaceCustomizerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/write/InterfaceCustomizerTest.java
new file mode 100755
index 000000000..6dccdfeab
--- /dev/null
+++ b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/write/InterfaceCustomizerTest.java
@@ -0,0 +1,198 @@
+/*
+ * Copyright (c) 2015 Cisco and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.fd.honeycomb.lisp.translate.write;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.google.common.base.Optional;
+import io.fd.honeycomb.translate.MappingContext;
+import io.fd.honeycomb.translate.v3po.util.NamingContext;
+import io.fd.honeycomb.translate.v3po.util.TranslateUtils;
+import io.fd.honeycomb.translate.write.WriteContext;
+import io.fd.honeycomb.translate.write.WriteFailedException;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.naming.context.rev160513.contexts.naming.context.mappings.MappingBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.Lisp;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.locator.sets.grouping.LocatorSets;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.locator.sets.grouping.locator.sets.LocatorSet;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.locator.sets.grouping.locator.sets.LocatorSetKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.locator.sets.grouping.locator.sets.locator.set.Interface;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.locator.sets.grouping.locator.sets.locator.set.InterfaceBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.locator.sets.grouping.locator.sets.locator.set.InterfaceKey;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.openvpp.jvpp.core.dto.LispAddDelLocator;
+import org.openvpp.jvpp.core.dto.LispAddDelLocatorReply;
+import org.openvpp.jvpp.core.future.FutureJVppCore;
+
+
+public class InterfaceCustomizerTest {
+
+    @Mock
+    private FutureJVppCore fakeJvpp;
+
+    @Mock
+    private WriteContext writeContext;
+
+    @Mock
+    private MappingContext mappingContext;
+
+    @Captor
+    private ArgumentCaptor<LispAddDelLocator> intfCaptor;
+
+    private NamingContext namingContext;
+    private InstanceIdentifier<Interface> id;
+    private CompletableFuture<LispAddDelLocatorReply> completeFuture;
+    private LispAddDelLocatorReply fakeReply;
+    private Interface intf;
+    private InterfaceCustomizer customizer;
+
+    @Before
+    public void init() {
+        MockitoAnnotations.initMocks(this);
+
+        id = InstanceIdentifier.builder(Lisp.class)
+                .child(LocatorSets.class)
+                .child(LocatorSet.class, new LocatorSetKey("Locator"))
+                .child(Interface.class, new InterfaceKey("Interface"))
+                .build();
+
+        intf = new InterfaceBuilder()
+                .setPriority((short) 1)
+                .setWeight((short) 2)
+                .build();
+
+        namingContext = new NamingContext("PREFIX", "INSTANCE");
+
+        customizer = new InterfaceCustomizer(fakeJvpp, namingContext);
+
+        fakeReply = new LispAddDelLocatorReply();
+
+        completeFuture = new CompletableFuture<>();
+        completeFuture.complete(fakeReply);
+
+        when(writeContext.getMappingContext()).thenReturn(mappingContext);
+        when(mappingContext.read(Mockito.any()))
+                .thenReturn(Optional.of((DataObject) new MappingBuilder().setIndex(5).setName("interface").build()));
+        when(fakeJvpp.lispAddDelLocator(any(LispAddDelLocator.class))).thenReturn(completeFuture);
+
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void testWriteCurrentAttributesNullData() throws WriteFailedException {
+        new InterfaceCustomizer(mock(FutureJVppCore.class), new NamingContext("PREFIX", "INSTANCE"))
+                .writeCurrentAttributes(null, null, null);
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void testWriteCurrentAttributesNullPriority() throws WriteFailedException {
+        Interface intf = mock(Interface.class);
+        when(intf.getWeight()).thenReturn((short) 1);
+        when(intf.getPriority()).thenReturn(null);
+
+        new InterfaceCustomizer(mock(FutureJVppCore.class), new NamingContext("PREFIX", "INSTANCE"))
+                .writeCurrentAttributes(null, intf, null);
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void testWriteCurrentAttributesNullWeight() throws WriteFailedException {
+        Interface intf = mock(Interface.class);
+        when(intf.getWeight()).thenReturn(null);
+        when(intf.getPriority()).thenReturn((short) 1);
+
+        new InterfaceCustomizer(mock(FutureJVppCore.class), new NamingContext("PREFIX", "INSTANCE"))
+                .writeCurrentAttributes(null, intf, null);
+    }
+
+    @Test
+    public void testWriteCurrentAttributes() throws InterruptedException, ExecutionException, WriteFailedException {
+        customizer.writeCurrentAttributes(id, intf, writeContext);
+
+        verify(fakeJvpp, times(1)).lispAddDelLocator(intfCaptor.capture());
+
+        LispAddDelLocator request = intfCaptor.getValue();
+
+        assertNotNull(request);
+        assertEquals(1, request.isAdd);
+        assertEquals(2, request.weight);
+        assertEquals(1, request.priority);
+        assertEquals(5, request.swIfIndex);
+        assertEquals("Locator", TranslateUtils.toString(request.locatorSetName));
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void testUpdateCurrentAttributes() throws WriteFailedException {
+        new InterfaceCustomizer(fakeJvpp, namingContext)
+                .updateCurrentAttributes(null, null, null, null);
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void testDeleteCurrentAttributesNullData() throws WriteFailedException {
+        new InterfaceCustomizer(fakeJvpp, namingContext)
+                .deleteCurrentAttributes(null, null, null);
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void testDeleteCurrentAttributesNullPriority() throws WriteFailedException {
+        Interface interf = mock(Interface.class);
+        when(interf.getWeight()).thenReturn((short) 1);
+        when(interf.getPriority()).thenReturn(null);
+
+        new InterfaceCustomizer(mock(FutureJVppCore.class), new NamingContext("PREFIX", "INSTANCE"))
+                .deleteCurrentAttributes(null, interf, null);
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void testDeleteCurrentAttributesNullWeight() throws WriteFailedException {
+        Interface interf = mock(Interface.class);
+        when(interf.getWeight()).thenReturn(null);
+        when(interf.getPriority()).thenReturn((short) 1);
+
+        new InterfaceCustomizer(mock(FutureJVppCore.class), new NamingContext("PREFIX", "INSTANCE"))
+                .deleteCurrentAttributes(null, interf, null);
+    }
+
+    @Test
+    public void testDeleteCurrentAttributes() throws InterruptedException, ExecutionException, WriteFailedException {
+        customizer.deleteCurrentAttributes(id, intf, writeContext);
+
+        verify(fakeJvpp, times(1)).lispAddDelLocator(intfCaptor.capture());
+
+        LispAddDelLocator request = intfCaptor.getValue();
+
+        assertNotNull(request);
+        assertEquals(0, request.isAdd);
+        assertEquals(2, request.weight);
+        assertEquals(1, request.priority);
+        assertEquals(5, request.swIfIndex);
+        assertEquals("Locator", TranslateUtils.toString(request.locatorSetName));
+    }
+}
diff --git a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/write/LispCustomizerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/write/LispCustomizerTest.java
new file mode 100755
index 000000000..aaa73303c
--- /dev/null
+++ b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/write/LispCustomizerTest.java
@@ -0,0 +1,128 @@
+/*
+ * Copyright (c) 2015 Cisco and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.fd.honeycomb.lisp.translate.write;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import io.fd.honeycomb.translate.write.WriteFailedException;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.Lisp;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.LispBuilder;
+import org.openvpp.jvpp.core.dto.LispEnableDisable;
+import org.openvpp.jvpp.core.dto.LispEnableDisableReply;
+import org.openvpp.jvpp.core.future.FutureJVppCore;
+
+
+public class LispCustomizerTest {
+
+    @Test(expected = NullPointerException.class)
+    public void testWriteCurrentAttributesNullData() throws WriteFailedException {
+        new LispCustomizer(mock(FutureJVppCore.class)).writeCurrentAttributes(null, null, null);
+    }
+
+    @Test
+    public void testWriteCurrentAttributes() throws InterruptedException, ExecutionException, WriteFailedException {
+        FutureJVppCore fakeJvpp = mock(FutureJVppCore.class);
+        Lisp intf = new LispBuilder().setEnable(true).build();
+
+        ArgumentCaptor<LispEnableDisable> mappingCaptor = ArgumentCaptor.forClass(LispEnableDisable.class);
+
+        LispEnableDisableReply fakeReply = new LispEnableDisableReply();
+
+        CompletableFuture<LispEnableDisableReply> completeFuture = new CompletableFuture<>();
+        completeFuture.complete(fakeReply);
+
+        when(fakeJvpp.lispEnableDisable(any(LispEnableDisable.class))).thenReturn(completeFuture);
+
+        new LispCustomizer(fakeJvpp).writeCurrentAttributes(null, intf, null);
+
+        verify(fakeJvpp, times(1)).lispEnableDisable(mappingCaptor.capture());
+
+        LispEnableDisable request = mappingCaptor.getValue();
+
+        assertNotNull(request);
+        assertEquals(1, request.isEn);
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void testUpdateCurrentAttributesNullData() throws WriteFailedException {
+        new LispCustomizer(mock(FutureJVppCore.class)).updateCurrentAttributes(null, null, null, null);
+    }
+
+    @Test
+    public void testUpdateCurrentAttributes() throws WriteFailedException, InterruptedException, ExecutionException {
+        FutureJVppCore fakeJvpp = mock(FutureJVppCore.class);
+        Lisp lisp = new LispBuilder().setEnable(true).build();
+
+        ArgumentCaptor<LispEnableDisable> lispCaptor = ArgumentCaptor.forClass(LispEnableDisable.class);
+
+        LispEnableDisableReply fakeReply = new LispEnableDisableReply();
+
+        CompletableFuture<LispEnableDisableReply> completeFuture = new CompletableFuture<>();
+        completeFuture.complete(fakeReply);
+
+        when(fakeJvpp.lispEnableDisable(any(LispEnableDisable.class))).thenReturn(completeFuture);
+
+        new LispCustomizer(fakeJvpp).updateCurrentAttributes(null, null, lisp, null);
+
+        verify(fakeJvpp, times(1)).lispEnableDisable(lispCaptor.capture());
+
+        LispEnableDisable request = lispCaptor.getValue();
+
+        assertNotNull(request);
+        assertEquals(1, request.isEn);
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void testDeleteCurrentAttributesNullData() throws WriteFailedException {
+        new LispCustomizer(mock(FutureJVppCore.class)).deleteCurrentAttributes(null, null, null);
+    }
+
+    @Test
+    public void testDeleteCurrentAttributes() throws WriteFailedException, InterruptedException, ExecutionException {
+        FutureJVppCore fakeJvpp = mock(FutureJVppCore.class);
+        Lisp lisp = new LispBuilder().setEnable(true).build();
+
+        ArgumentCaptor<LispEnableDisable> lispCaptor = ArgumentCaptor.forClass(LispEnableDisable.class);
+
+        LispEnableDisableReply fakeReply = new LispEnableDisableReply();
+
+        CompletableFuture<LispEnableDisableReply> completeFuture = new CompletableFuture<>();
+        completeFuture.complete(fakeReply);
+
+        when(fakeJvpp.lispEnableDisable(any(LispEnableDisable.class))).thenReturn(completeFuture);
+
+        new LispCustomizer(fakeJvpp).deleteCurrentAttributes(null, lisp, null);
+
+        verify(fakeJvpp, times(1)).lispEnableDisable(lispCaptor.capture());
+
+        LispEnableDisable request = lispCaptor.getValue();
+
+        assertNotNull(request);
+        assertEquals(0, request.isEn);
+    }
+
+}
diff --git a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/write/LocalMappingCustomizerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/write/LocalMappingCustomizerTest.java
new file mode 100755
index 000000000..2b28ce6b9
--- /dev/null
+++ b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/write/LocalMappingCustomizerTest.java
@@ -0,0 +1,189 @@
+/*
+ * Copyright (c) 2015 Cisco and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.fd.honeycomb.lisp.translate.write;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import io.fd.honeycomb.lisp.context.util.EidMappingContext;
+import io.fd.honeycomb.translate.MappingContext;
+import io.fd.honeycomb.translate.v3po.util.TranslateUtils;
+import io.fd.honeycomb.translate.write.WriteContext;
+import io.fd.honeycomb.translate.write.WriteFailedException;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+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.lisp.address.types.rev151105.lisp.address.address.Ipv4Builder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.Lisp;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.MappingId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.EidTable;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.VniTable;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.VniTableKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.LocalMappings;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.local.mappings.LocalMapping;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.local.mappings.LocalMappingBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.local.mappings.LocalMappingKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.local.mappings.local.mapping.Eid;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.local.mappings.local.mapping.EidBuilder;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.openvpp.jvpp.core.dto.LispAddDelLocalEid;
+import org.openvpp.jvpp.core.dto.LispAddDelLocalEidReply;
+import org.openvpp.jvpp.core.future.FutureJVppCore;
+
+
+public class LocalMappingCustomizerTest {
+
+    @Mock
+    private FutureJVppCore fakeJvpp;
+
+    @Captor
+    private ArgumentCaptor<LispAddDelLocalEid> mappingCaptor;
+
+    private MappingId mappingId;
+    private InstanceIdentifier<LocalMapping> id;
+    private LocalMapping mapping;
+    private LispAddDelLocalEidReply fakeReply;
+    private CompletableFuture<LispAddDelLocalEidReply> completeFuture;
+    private LocalMappingCustomizer customizer;
+    private EidMappingContext localMappingContext;
+    private WriteContext writeContext;
+    private MappingContext mappingCtx;
+
+    @Before
+    public void init() {
+        MockitoAnnotations.initMocks(this);
+
+        final Eid
+                eid = new EidBuilder().setAddress(
+                new Ipv4Builder().setIpv4(
+                        new Ipv4Address("192.168.2.1"))
+                        .build())
+                .build();
+
+
+        mappingId = new MappingId("REMOTE");
+        final LocalMappingKey key = new LocalMappingKey(mappingId);
+        localMappingContext = new EidMappingContext("local");
+        mappingCtx = mock(MappingContext.class);
+        writeContext = mock(WriteContext.class);
+
+        mapping = new LocalMappingBuilder()
+                .setEid(eid)
+                .setLocatorSet("Locator")
+                .build();
+
+        id = InstanceIdentifier.builder(Lisp.class)
+                .child(EidTable.class)
+                .child(VniTable.class, new VniTableKey(25L))
+                .child(LocalMappings.class)
+                .child(LocalMapping.class, new LocalMappingKey(new MappingId("local")))
+                .build();
+
+        fakeReply = new LispAddDelLocalEidReply();
+        completeFuture = new CompletableFuture<>();
+        completeFuture.complete(fakeReply);
+        customizer = new LocalMappingCustomizer(fakeJvpp, localMappingContext);
+
+        when(fakeJvpp.lispAddDelLocalEid(any(LispAddDelLocalEid.class))).thenReturn(completeFuture);
+        when(writeContext.getMappingContext()).thenReturn(mappingCtx);
+        when(mappingCtx.read(Mockito.any())).thenReturn(com.google.common.base.Optional
+                .of(new LocalMappingBuilder().setKey(key).setId(mappingId).setEid(eid).build()));
+    }
+
+
+    @Test(expected = NullPointerException.class)
+    public void testWriteCurrentAttributesNullData() throws WriteFailedException {
+        customizer.writeCurrentAttributes(null, null, writeContext);
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void testWriteCurrentAttributesNullEid() throws WriteFailedException {
+
+        LocalMapping mapping = mock(LocalMapping.class);
+        when(mapping.getEid()).thenReturn(null);
+        when(mapping.getLocatorSet()).thenReturn("Locator");
+
+        new LocalMappingCustomizer(mock(FutureJVppCore.class), localMappingContext)
+                .writeCurrentAttributes(null, mapping, writeContext);
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void testWriteCurrentAttributesNullLocator() throws WriteFailedException {
+
+        LocalMapping mapping = mock(LocalMapping.class);
+        when(mapping.getEid()).thenReturn(mock(Eid.class));
+        when(mapping.getLocatorSet()).thenReturn(null);
+
+        customizer.writeCurrentAttributes(null, mapping, writeContext);
+    }
+
+
+    @Test
+    public void testWriteCurrentAttributes() throws WriteFailedException, InterruptedException, ExecutionException {
+        //to simulate no mapping
+        when(mappingCtx.read(Mockito.any())).thenReturn(com.google.common.base.Optional.absent());
+
+        customizer.writeCurrentAttributes(id, mapping, writeContext);
+
+        verify(fakeJvpp, times(1)).lispAddDelLocalEid(mappingCaptor.capture());
+
+        LispAddDelLocalEid request = mappingCaptor.getValue();
+
+        assertNotNull(request);
+        assertEquals("Locator", new String(request.locatorSetName));
+        assertEquals("1.2.168.192", TranslateUtils.arrayToIpv4AddressNoZone(request.eid).getValue());
+        assertEquals(0, request.eidType);
+        assertEquals(1, request.isAdd);
+        assertEquals(25, request.vni);
+        assertEquals("Locator", TranslateUtils.toString(request.locatorSetName));
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void testUpdateCurrentAttributes() throws WriteFailedException {
+        new LocalMappingCustomizer(mock(FutureJVppCore.class), localMappingContext)
+                .updateCurrentAttributes(null, null, null, writeContext);
+    }
+
+    @Test
+    public void testDeleteCurrentAttributes() throws WriteFailedException, InterruptedException, ExecutionException {
+        customizer.deleteCurrentAttributes(id, mapping, writeContext);
+
+        verify(fakeJvpp, times(1)).lispAddDelLocalEid(mappingCaptor.capture());
+
+        LispAddDelLocalEid request = mappingCaptor.getValue();
+
+        assertNotNull(request);
+        assertEquals("Locator", new String(request.locatorSetName));
+        assertEquals("1.2.168.192", TranslateUtils.arrayToIpv4AddressNoZone(request.eid).getValue());
+        assertEquals(0, request.eidType);
+        assertEquals(0, request.isAdd);
+        assertEquals(25, request.vni);
+        assertEquals("Locator", TranslateUtils.toString(request.locatorSetName));
+    }
+}
diff --git a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/write/LocatorSetCustomizerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/write/LocatorSetCustomizerTest.java
new file mode 100755
index 000000000..e7fb88ae5
--- /dev/null
+++ b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/write/LocatorSetCustomizerTest.java
@@ -0,0 +1,157 @@
+/*
+ * Copyright (c) 2015 Cisco and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.fd.honeycomb.lisp.translate.write;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import com.google.common.collect.ImmutableList;
+import io.fd.honeycomb.translate.MappingContext;
+import io.fd.honeycomb.translate.ModificationCache;
+import io.fd.honeycomb.translate.v3po.util.NamingContext;
+import io.fd.honeycomb.translate.write.WriteContext;
+import io.fd.honeycomb.translate.write.WriteFailedException;
+import java.nio.charset.StandardCharsets;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.locator.sets.grouping.locator.sets.LocatorSet;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.locator.sets.grouping.locator.sets.LocatorSetBuilder;
+import org.openvpp.jvpp.core.dto.LispAddDelLocatorSet;
+import org.openvpp.jvpp.core.dto.LispAddDelLocatorSetReply;
+import org.openvpp.jvpp.core.dto.LispLocatorSetDetails;
+import org.openvpp.jvpp.core.dto.LispLocatorSetDetailsReplyDump;
+import org.openvpp.jvpp.core.future.FutureJVppCore;
+
+
+public class LocatorSetCustomizerTest {
+
+    private FutureJVppCore fakeJvpp;
+    private NamingContext locatorSetContext;
+    private MappingContext mappingContext;
+    private ModificationCache cache;
+    private WriteContext context;
+
+    @Before
+    public void init() {
+        fakeJvpp = mock(FutureJVppCore.class);
+        locatorSetContext = new NamingContext("locator-set", "instance");
+        context = mock(WriteContext.class);
+        mappingContext = mock(MappingContext.class);
+        cache = new ModificationCache();
+        when(context.getMappingContext()).thenReturn(mappingContext);
+        when(context.getModificationCache()).thenReturn(cache);
+    }
+
+
+    @Test(expected = NullPointerException.class)
+    public void testWriteCurrentAttributesNullData() throws WriteFailedException {
+        new LocatorSetCustomizer(fakeJvpp, locatorSetContext).writeCurrentAttributes(null, null, null);
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void testWriteCurrentAttributesBadData() throws WriteFailedException {
+        new LocatorSetCustomizer(fakeJvpp, locatorSetContext)
+                .writeCurrentAttributes(null, mock(LocatorSet.class), null);
+    }
+
+    @Test
+    public void testWriteCurrentAttributes() throws WriteFailedException, InterruptedException, ExecutionException {
+
+        LocatorSet locatorSet = new LocatorSetBuilder()
+                .setName("Locator")
+                .build();
+
+        ArgumentCaptor<LispAddDelLocatorSet> locatorSetCaptor = ArgumentCaptor.forClass(LispAddDelLocatorSet.class);
+
+        LispAddDelLocatorSetReply fakeReply = new LispAddDelLocatorSetReply();
+
+        CompletableFuture<LispAddDelLocatorSetReply> completeFuture = new CompletableFuture<>();
+        completeFuture.complete(fakeReply);
+
+        when(fakeJvpp.lispAddDelLocatorSet(any(LispAddDelLocatorSet.class))).thenReturn(completeFuture);
+
+        final LispLocatorSetDetailsReplyDump reply = new LispLocatorSetDetailsReplyDump();
+        LispLocatorSetDetails details = new LispLocatorSetDetails();
+        details.locatorSetName = "Locator".getBytes(StandardCharsets.UTF_8);
+        reply.lispLocatorSetDetails = ImmutableList.of(details);
+
+        cache.put(io.fd.honeycomb.lisp.translate.read.LocatorSetCustomizer.LOCATOR_SETS_CACHE_ID, reply);
+
+        new LocatorSetCustomizer(fakeJvpp, locatorSetContext).writeCurrentAttributes(null, locatorSet, context);
+
+        verify(fakeJvpp, times(1)).lispAddDelLocatorSet(locatorSetCaptor.capture());
+
+        LispAddDelLocatorSet request = locatorSetCaptor.getValue();
+
+        assertNotNull(request);
+        assertEquals("Locator", new String(request.locatorSetName));
+        assertEquals(1, request.isAdd);
+
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void testUpdateCurrentAttributes() throws WriteFailedException {
+        new LocatorSetCustomizer(fakeJvpp, locatorSetContext).updateCurrentAttributes(null, null, null, null);
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void testDeleteCurrentAttributesNullData() throws WriteFailedException {
+        new LocatorSetCustomizer(fakeJvpp, locatorSetContext).deleteCurrentAttributes(null, null, null);
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void testDeleteCurrentAttributesBadData() throws WriteFailedException {
+        new LocatorSetCustomizer(fakeJvpp, locatorSetContext)
+                .deleteCurrentAttributes(null, mock(LocatorSet.class), null);
+    }
+
+    @Test
+    public void testDeleteCurrentAttributes() throws InterruptedException, ExecutionException, WriteFailedException {
+
+        LocatorSet locatorSet = new LocatorSetBuilder()
+                .setName("Locator")
+                .build();
+
+        ArgumentCaptor<LispAddDelLocatorSet> locatorSetCaptor = ArgumentCaptor.forClass(LispAddDelLocatorSet.class);
+
+        LispAddDelLocatorSetReply fakeReply = new LispAddDelLocatorSetReply();
+
+        CompletableFuture<LispAddDelLocatorSetReply> completeFuture = new CompletableFuture<>();
+        completeFuture.complete(fakeReply);
+
+        when(fakeJvpp.lispAddDelLocatorSet(any(LispAddDelLocatorSet.class))).thenReturn(completeFuture);
+
+        new LocatorSetCustomizer(fakeJvpp, locatorSetContext).deleteCurrentAttributes(null, locatorSet, context);
+
+        verify(fakeJvpp, times(1)).lispAddDelLocatorSet(locatorSetCaptor.capture());
+
+        LispAddDelLocatorSet request = locatorSetCaptor.getValue();
+
+        assertNotNull(request);
+        assertEquals("Locator", new String(request.locatorSetName));
+        assertEquals(0, request.isAdd);
+
+    }
+}
diff --git a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/write/MapResolverCustomizerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/write/MapResolverCustomizerTest.java
new file mode 100755
index 000000000..63be37a23
--- /dev/null
+++ b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/write/MapResolverCustomizerTest.java
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) 2015 Cisco and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.fd.honeycomb.lisp.translate.write;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import io.fd.honeycomb.translate.v3po.util.TranslateUtils;
+import io.fd.honeycomb.translate.write.WriteFailedException;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+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.params.xml.ns.yang.lisp.rev160520.map.resolvers.grouping.map.resolvers.MapResolver;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.map.resolvers.grouping.map.resolvers.MapResolverBuilder;
+import org.openvpp.jvpp.core.dto.LispAddDelMapResolver;
+import org.openvpp.jvpp.core.dto.LispAddDelMapResolverReply;
+import org.openvpp.jvpp.core.future.FutureJVppCore;
+
+
+public class MapResolverCustomizerTest {
+
+    @Test(expected = NullPointerException.class)
+    public void testWriteCurrentAttributesNullData() throws WriteFailedException {
+        new MapResolverCustomizer(mock(FutureJVppCore.class)).writeCurrentAttributes(null, null, null);
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void testWriteCurrentAttributesBadData() throws WriteFailedException {
+        new MapResolverCustomizer(mock(FutureJVppCore.class))
+                .writeCurrentAttributes(null, new MapResolverBuilder().build(), null);
+    }
+
+    @Test
+    public void testWriteCurrentAttributes() throws WriteFailedException, InterruptedException, ExecutionException {
+        FutureJVppCore fakeJvpp = mock(FutureJVppCore.class);
+
+        MapResolverCustomizer customizer = new MapResolverCustomizer(fakeJvpp);
+        Ipv4Address address = new Ipv4Address("192.168.2.1");
+        MapResolver resolver = new MapResolverBuilder().setIpAddress(new IpAddress(address)).build();
+
+        ArgumentCaptor<LispAddDelMapResolver> resolverCaptor = ArgumentCaptor.forClass(LispAddDelMapResolver.class);
+
+        LispAddDelMapResolverReply fakeReply = new LispAddDelMapResolverReply();
+
+        CompletableFuture<LispAddDelMapResolverReply> finalStage = new CompletableFuture<>();
+        finalStage.complete(fakeReply);
+
+        when(fakeJvpp.lispAddDelMapResolver(any(LispAddDelMapResolver.class))).thenReturn(finalStage);
+
+        customizer.writeCurrentAttributes(null, resolver, null);
+        verify(fakeJvpp, times(1)).lispAddDelMapResolver(resolverCaptor.capture());
+
+        LispAddDelMapResolver request = resolverCaptor.getValue();
+        assertEquals(1, request.isAdd);
+        assertEquals("1.2.168.192", TranslateUtils.arrayToIpv4AddressNoZone(request.ipAddress).getValue());
+    }
+
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void testUpdateCurrentAttributes() throws WriteFailedException {
+        new MapResolverCustomizer(mock(FutureJVppCore.class)).updateCurrentAttributes(null, null, null, null);
+    }
+
+    @Test
+    public void testDeleteCurrentAttributes() throws InterruptedException, ExecutionException, WriteFailedException {
+
+        FutureJVppCore fakeJvpp = mock(FutureJVppCore.class);
+
+        MapResolverCustomizer customizer = new MapResolverCustomizer(fakeJvpp);
+        Ipv4Address address = new Ipv4Address("192.168.2.1");
+        MapResolver resolver = new MapResolverBuilder().setIpAddress(new IpAddress(address)).build();
+
+        ArgumentCaptor<LispAddDelMapResolver> resolverCaptor = ArgumentCaptor.forClass(LispAddDelMapResolver.class);
+
+        LispAddDelMapResolverReply fakeReply = new LispAddDelMapResolverReply();
+
+        CompletableFuture<LispAddDelMapResolverReply> finalStage = new CompletableFuture<>();
+        finalStage.complete(fakeReply);
+
+        when(fakeJvpp.lispAddDelMapResolver(any(LispAddDelMapResolver.class))).thenReturn(finalStage);
+
+        customizer.deleteCurrentAttributes(null, resolver, null);
+        verify(fakeJvpp, times(1)).lispAddDelMapResolver(resolverCaptor.capture());
+
+        LispAddDelMapResolver request = resolverCaptor.getValue();
+        assertEquals(0, request.isAdd);
+        assertEquals("1.2.168.192", TranslateUtils.arrayToIpv4AddressNoZone(request.ipAddress).getValue());
+    }
+
+}
diff --git a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/write/PitrCfgCustomizerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/write/PitrCfgCustomizerTest.java
new file mode 100755
index 000000000..5f1ffb888
--- /dev/null
+++ b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/write/PitrCfgCustomizerTest.java
@@ -0,0 +1,132 @@
+/*
+ * Copyright (c) 2015 Cisco and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.fd.honeycomb.lisp.translate.write;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import io.fd.honeycomb.translate.write.WriteFailedException;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.pitr.cfg.grouping.PitrCfg;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.pitr.cfg.grouping.PitrCfgBuilder;
+import org.openvpp.jvpp.core.dto.LispPitrSetLocatorSet;
+import org.openvpp.jvpp.core.dto.LispPitrSetLocatorSetReply;
+import org.openvpp.jvpp.core.future.FutureJVppCore;
+
+
+public class PitrCfgCustomizerTest {
+
+    @Test(expected = NullPointerException.class)
+    public void testWriteCurrentAttributesNullData() throws WriteFailedException {
+        new PitrCfgCustomizer(mock(FutureJVppCore.class)).writeCurrentAttributes(null, null, null);
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void testWriteCurrentAttributesBadData() throws WriteFailedException {
+        new PitrCfgCustomizer(mock(FutureJVppCore.class)).writeCurrentAttributes(null, mock(PitrCfg.class), null);
+    }
+
+    @Test
+    public void testWriteCurrentAttributes() throws InterruptedException, ExecutionException, WriteFailedException {
+        FutureJVppCore fakeJvpp = mock(FutureJVppCore.class);
+
+        PitrCfgCustomizer customizer = new PitrCfgCustomizer(fakeJvpp);
+        PitrCfg cfg = new PitrCfgBuilder().setLocatorSet("Locator").build();
+
+        ArgumentCaptor<LispPitrSetLocatorSet> cfgCaptor = ArgumentCaptor.forClass(LispPitrSetLocatorSet.class);
+
+        LispPitrSetLocatorSetReply fakeReply = new LispPitrSetLocatorSetReply();
+
+        CompletableFuture<LispPitrSetLocatorSetReply> finalStage = new CompletableFuture<>();
+        finalStage.complete(fakeReply);
+
+        when(fakeJvpp.lispPitrSetLocatorSet(any(LispPitrSetLocatorSet.class))).thenReturn(finalStage);
+
+        customizer.writeCurrentAttributes(null, cfg, null);
+        verify(fakeJvpp, times(1)).lispPitrSetLocatorSet(cfgCaptor.capture());
+
+        LispPitrSetLocatorSet request = cfgCaptor.getValue();
+        assertEquals(1, request.isAdd);
+        assertEquals("Locator", new String(request.lsName));
+    }
+
+    @Test
+    public void testUpdateCurrentAttributes() throws WriteFailedException {
+        FutureJVppCore fakeJvpp = mock(FutureJVppCore.class);
+
+        PitrCfgCustomizer customizer = new PitrCfgCustomizer(fakeJvpp);
+        PitrCfg cfg = new PitrCfgBuilder().setLocatorSet("Locator").build();
+
+        ArgumentCaptor<LispPitrSetLocatorSet> cfgCaptor = ArgumentCaptor.forClass(LispPitrSetLocatorSet.class);
+
+        LispPitrSetLocatorSetReply fakeReply = new LispPitrSetLocatorSetReply();
+
+        CompletableFuture<LispPitrSetLocatorSetReply> finalStage = new CompletableFuture<>();
+        finalStage.complete(fakeReply);
+
+        when(fakeJvpp.lispPitrSetLocatorSet(any(LispPitrSetLocatorSet.class))).thenReturn(finalStage);
+
+        customizer.writeCurrentAttributes(null, cfg, null);
+        verify(fakeJvpp, times(1)).lispPitrSetLocatorSet(cfgCaptor.capture());
+
+        LispPitrSetLocatorSet request = cfgCaptor.getValue();
+        assertEquals(1, request.isAdd);
+        assertEquals("Locator", new String(request.lsName));
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void testDeleteCurrentAttributesNullData() throws WriteFailedException {
+        new PitrCfgCustomizer(mock(FutureJVppCore.class)).deleteCurrentAttributes(null, null, null);
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void testDeleteCurrentAttributesBadData() throws WriteFailedException {
+        new PitrCfgCustomizer(mock(FutureJVppCore.class)).deleteCurrentAttributes(null, mock(PitrCfg.class), null);
+    }
+
+    @Test
+    public void testDeleteCurrentAttributes() throws WriteFailedException, InterruptedException, ExecutionException {
+        FutureJVppCore fakeJvpp = mock(FutureJVppCore.class);
+
+        PitrCfgCustomizer customizer = new PitrCfgCustomizer(fakeJvpp);
+        PitrCfg cfg = new PitrCfgBuilder().setLocatorSet("Locator").build();
+
+        ArgumentCaptor<LispPitrSetLocatorSet> cfgCaptor = ArgumentCaptor.forClass(LispPitrSetLocatorSet.class);
+
+        LispPitrSetLocatorSetReply fakeReply = new LispPitrSetLocatorSetReply();
+
+        CompletableFuture<LispPitrSetLocatorSetReply> finalStage = new CompletableFuture<>();
+        finalStage.complete(fakeReply);
+
+        when(fakeJvpp.lispPitrSetLocatorSet(any(LispPitrSetLocatorSet.class))).thenReturn(finalStage);
+
+        customizer.deleteCurrentAttributes(null, cfg, null);
+        verify(fakeJvpp, times(1)).lispPitrSetLocatorSet(cfgCaptor.capture());
+
+        LispPitrSetLocatorSet request = cfgCaptor.getValue();
+        assertEquals(0, request.isAdd);
+        assertEquals("Locator", new String(request.lsName));
+    }
+
+}
diff --git a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/write/RemoteMappingCustomizerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/write/RemoteMappingCustomizerTest.java
new file mode 100755
index 000000000..7797db1f7
--- /dev/null
+++ b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/write/RemoteMappingCustomizerTest.java
@@ -0,0 +1,175 @@
+/*
+ * Copyright (c) 2015 Cisco and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.fd.honeycomb.lisp.translate.write;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import io.fd.honeycomb.lisp.context.util.EidMappingContext;
+import io.fd.honeycomb.translate.MappingContext;
+import io.fd.honeycomb.translate.v3po.util.TranslateUtils;
+import io.fd.honeycomb.translate.write.WriteContext;
+import io.fd.honeycomb.translate.write.WriteFailedException;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
+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.inet.types.rev130715.Ipv6Address;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv4Builder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.Lisp;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.MapReplyAction;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.MappingId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.EidTable;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.VniTable;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.VniTableKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.RemoteMappings;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.remote.mappings.RemoteMapping;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.remote.mappings.RemoteMappingBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.remote.mappings.RemoteMappingKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.remote.mappings.remote.mapping.Eid;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.remote.mappings.remote.mapping.EidBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.remote.mappings.remote.mapping.locator.list.NegativeMappingBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.remote.mappings.remote.mapping.locator.list.positive.mapping.rlocs.Locator;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.remote.mappings.remote.mapping.locator.list.positive.mapping.rlocs.LocatorBuilder;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.openvpp.jvpp.core.dto.LispAddDelRemoteMapping;
+import org.openvpp.jvpp.core.dto.LispAddDelRemoteMappingReply;
+import org.openvpp.jvpp.core.future.FutureJVppCore;
+
+
+public class RemoteMappingCustomizerTest {
+
+    @Mock
+    private FutureJVppCore fakeJvpp;
+
+    @Captor
+    private ArgumentCaptor<LispAddDelRemoteMapping> mappingCaptor;
+
+    private MappingId mappingId;
+    private RemoteMappingCustomizer customizer;
+    private RemoteMapping intf;
+    private LispAddDelRemoteMappingReply fakeReply;
+    private CompletableFuture<LispAddDelRemoteMappingReply> completeFuture;
+    private InstanceIdentifier<RemoteMapping> id;
+    private EidMappingContext remoteMappingContext;
+    private WriteContext writeContext;
+    private MappingContext mapping;
+
+
+    @Before
+    public void init() {
+        MockitoAnnotations.initMocks(this);
+
+        final Eid eid = new EidBuilder().setAddress(
+                new Ipv4Builder().setIpv4(
+                        new Ipv4Address("192.168.2.1"))
+                        .build())
+                .build();
+
+        mappingId = new MappingId("REMOTE");
+        final RemoteMappingKey key = new RemoteMappingKey(mappingId);
+        remoteMappingContext = new EidMappingContext("remote");
+        mapping = mock(MappingContext.class);
+        writeContext = mock(WriteContext.class);
+
+
+        intf = new RemoteMappingBuilder()
+                .setEid(
+                        eid)
+                .setLocatorList(new NegativeMappingBuilder().setMapReplyAction(MapReplyAction.Drop).build())
+                .build();
+
+        id = InstanceIdentifier.builder(Lisp.class).child(EidTable.class)
+                .child(VniTable.class, new VniTableKey(25L))
+                .child(RemoteMappings.class)
+                .child(RemoteMapping.class, key).build();
+
+        fakeReply = new LispAddDelRemoteMappingReply();
+        completeFuture = new CompletableFuture<>();
+        completeFuture.complete(fakeReply);
+        customizer = new RemoteMappingCustomizer(fakeJvpp, remoteMappingContext);
+
+        when(fakeJvpp.lispAddDelRemoteMapping(Mockito.any())).thenReturn(completeFuture);
+        when(writeContext.getMappingContext()).thenReturn(mapping);
+        when(mapping.read(Mockito.any())).thenReturn(com.google.common.base.Optional
+                .of(new RemoteMappingBuilder().setKey(key).setId(mappingId).setEid(eid).build()));
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void testWriteCurrentAttributesNullData() throws WriteFailedException {
+        customizer.writeCurrentAttributes(null, null, writeContext);
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void testWriteCurrentAttributesBadData() throws WriteFailedException {
+        customizer
+                .writeCurrentAttributes(null, mock(RemoteMapping.class), writeContext);
+    }
+
+    @Test
+    public void testWriteCurrentAttributes() throws WriteFailedException, InterruptedException, ExecutionException {
+        //to simulate no mapping
+        when(mapping.read(Mockito.any())).thenReturn(com.google.common.base.Optional.absent());
+
+        customizer.writeCurrentAttributes(id, intf, writeContext);
+
+        verify(fakeJvpp, times(1)).lispAddDelRemoteMapping(mappingCaptor.capture());
+
+        LispAddDelRemoteMapping request = mappingCaptor.getValue();
+
+        assertNotNull(request);
+        assertEquals(1, request.isAdd);
+        assertEquals("1.2.168.192", TranslateUtils.arrayToIpv4AddressNoZone(request.eid).getValue());
+        assertEquals(25, request.vni);
+    }
+
+    @Test(expected = UnsupportedOperationException.class)
+    public void testUpdateCurrentAttributes() throws WriteFailedException {
+        customizer.updateCurrentAttributes(null, null, null, writeContext);
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void testDeleteCurrentAttributesNullData() throws WriteFailedException {
+        customizer.deleteCurrentAttributes(null, null, writeContext);
+    }
+
+    @Test
+    public void testDeleteCurrentAttributes() throws WriteFailedException, InterruptedException, ExecutionException {
+        customizer.deleteCurrentAttributes(id, intf, writeContext);
+
+        verify(fakeJvpp, times(1)).lispAddDelRemoteMapping(mappingCaptor.capture());
+
+        LispAddDelRemoteMapping request = mappingCaptor.getValue();
+
+        assertNotNull(request);
+        assertEquals(0, request.isAdd);
+        assertEquals("1.2.168.192", TranslateUtils.arrayToIpv4AddressNoZone(request.eid).getValue());
+        assertEquals(25, request.vni);
+    }
+
+}