diff options
Diffstat (limited to 'lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp')
14 files changed, 1003 insertions, 12 deletions
diff --git a/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/translate/read/LispInitTest.java b/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/translate/read/LispInitTest.java new file mode 100644 index 000000000..0d2a4b645 --- /dev/null +++ b/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/translate/read/LispInitTest.java @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2017 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.hc2vpp.lisp.translate.read; + +import com.google.common.collect.ImmutableSet; +import io.fd.honeycomb.test.tools.annotations.InjectablesProcessor; +import io.fd.honeycomb.test.tools.annotations.SchemaContextProvider; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.$YangModuleInfoImpl; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.Lisp; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.LispState; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.lisp.feature.data.grouping.LispFeatureData; +import org.opendaylight.yangtools.sal.binding.generator.impl.ModuleInfoBackedContext; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public interface LispInitTest extends InjectablesProcessor { + + InstanceIdentifier<LispFeatureData> LISP_FTR_IID = InstanceIdentifier.create(Lisp.class) + .child(LispFeatureData.class); + + InstanceIdentifier<LispFeatureData> LISP_STATE_FTR_IID = InstanceIdentifier.create(LispState.class) + .child(LispFeatureData.class); + + @SchemaContextProvider + default ModuleInfoBackedContext schemaContext() { + return provideSchemaContextFor(ImmutableSet.of($YangModuleInfoImpl.getInstance(), + org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.$YangModuleInfoImpl + .getInstance())); + } +} diff --git a/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/translate/read/LocalMappingCustomizerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/translate/read/LocalMappingCustomizerTest.java index 812ba6eb6..43ec43bec 100644 --- a/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/translate/read/LocalMappingCustomizerTest.java +++ b/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/translate/read/LocalMappingCustomizerTest.java @@ -23,12 +23,16 @@ import static org.mockito.Matchers.any; import static org.mockito.Mockito.when; import com.google.common.collect.ImmutableList; +import io.fd.hc2vpp.common.test.read.ListReaderCustomizerTest; +import io.fd.hc2vpp.common.translate.util.NamingContext; import io.fd.hc2vpp.lisp.context.util.EidMappingContext; import io.fd.hc2vpp.lisp.translate.util.EidTranslator; import io.fd.honeycomb.translate.MappingContext; +import io.fd.honeycomb.translate.read.ReadFailedException; import io.fd.honeycomb.translate.spi.read.ReaderCustomizer; -import io.fd.hc2vpp.common.translate.util.NamingContext; -import io.fd.hc2vpp.common.test.read.ListReaderCustomizerTest; +import io.fd.vpp.jvpp.core.dto.LispEidTableDetails; +import io.fd.vpp.jvpp.core.dto.LispEidTableDetailsReplyDump; +import java.nio.charset.StandardCharsets; import java.util.List; import org.junit.Test; import org.mockito.Mock; @@ -36,6 +40,7 @@ import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.eid.mapping 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.rev170315.HmacKeyType; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.MappingId; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.dp.subtable.grouping.LocalMappings; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.dp.subtable.grouping.LocalMappingsBuilder; @@ -46,11 +51,9 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.eid.table.grouping.EidTable; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.eid.table.grouping.eid.table.VniTable; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.eid.table.grouping.eid.table.VniTableKey; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.eid.table.grouping.eid.table.vni.table.BridgeDomainSubtable; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.eid.table.grouping.eid.table.vni.table.VrfSubtable; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.hmac.key.grouping.HmacKey; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; -import io.fd.vpp.jvpp.core.dto.LispEidTableDetails; -import io.fd.vpp.jvpp.core.dto.LispEidTableDetailsReplyDump; public class LocalMappingCustomizerTest extends ListReaderCustomizerTest<LocalMapping, LocalMappingKey, LocalMappingBuilder> implements EidTranslator { @@ -82,7 +85,6 @@ public class LocalMappingCustomizerTest extends .child(LocalMappings.class) .child(LocalMapping.class, new LocalMappingKey(new MappingId("local-mapping"))); - defineDumpData(); defineMappings(); } @@ -99,6 +101,26 @@ public class LocalMappingCustomizerTest extends detail.locatorSetIndex = 1; detail.ttl = 7; detail.vni = 12; + detail.key = "abcdefgh".getBytes(StandardCharsets.UTF_8); + detail.keyId = 1; + + replyDump.lispEidTableDetails = ImmutableList.of(detail); + when(api.lispEidTableDump(any())).thenReturn(future(replyDump)); + } + + private void defineDumpDataNoHmacKey() { + LispEidTableDetailsReplyDump replyDump = new LispEidTableDetailsReplyDump(); + LispEidTableDetails detail = new LispEidTableDetails(); + detail.action = 0; + detail.authoritative = 1; + detail.context = 4; + detail.eid = new byte[]{-64, -88, 2, 1}; + detail.eidPrefixLen = 32; + detail.eidType = (byte) IPV4.getValue(); + detail.isLocal = 1; + detail.locatorSetIndex = 1; + detail.ttl = 7; + detail.vni = 12; replyDump.lispEidTableDetails = ImmutableList.of(detail); when(api.lispEidTableDump(any())).thenReturn(future(replyDump)); @@ -117,7 +139,23 @@ public class LocalMappingCustomizerTest extends } @Test + public void readCurrentAttributesNoHmacKey() throws ReadFailedException { + defineDumpDataNoHmacKey(); + + LocalMappingBuilder builder = new LocalMappingBuilder(); + getCustomizer().readCurrentAttributes(validIdentifier, builder, ctx); + + final LocalMapping mapping = builder.build(); + + assertNotNull(mapping); + assertEquals(true, compareAddresses(EID_ADDRESS, mapping.getEid().getAddress())); + assertEquals("loc-set", mapping.getLocatorSet()); + assertEquals(HmacKeyType.NoKey, mapping.getHmacKey().getKeyType()); + } + + @Test public void readCurrentAttributes() throws Exception { + defineDumpData(); LocalMappingBuilder builder = new LocalMappingBuilder(); getCustomizer().readCurrentAttributes(validIdentifier, builder, ctx); @@ -126,10 +164,15 @@ public class LocalMappingCustomizerTest extends assertNotNull(mapping); assertEquals(true, compareAddresses(EID_ADDRESS, mapping.getEid().getAddress())); assertEquals("loc-set", mapping.getLocatorSet()); + + final HmacKey hmacKey = mapping.getHmacKey(); + assertEquals("abcdefgh", hmacKey.getKey()); + assertEquals(HmacKeyType.Sha196Key, hmacKey.getKeyType()); } @Test public void getAllIds() throws Exception { + defineDumpData(); final List<LocalMappingKey> keys = getCustomizer().getAllIds(emptyIdentifier, ctx); assertEquals(1, keys.size()); diff --git a/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/translate/read/LocatorSetCustomizerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/translate/read/LocatorSetCustomizerTest.java index 744c57590..b6773d2b2 100644 --- a/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/translate/read/LocatorSetCustomizerTest.java +++ b/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/translate/read/LocatorSetCustomizerTest.java @@ -54,7 +54,7 @@ import static org.mockito.Mockito.when; @RunWith(HoneycombTestRunner.class) public class LocatorSetCustomizerTest extends InitializingListReaderCustomizerTest<LocatorSet, LocatorSetKey, LocatorSetBuilder> - implements InjectablesProcessor { + implements LispInitTest { private static final String LOC_1_PATH = "/lisp:lisp-state" + "/lisp:lisp-feature-data" + @@ -107,11 +107,6 @@ public class LocatorSetCustomizerTest assertEquals("loc-set", keys.get(0).getName()); } - @SchemaContextProvider - public ModuleInfoBackedContext schemaContext() { - return provideSchemaContextFor(ImmutableSet.of($YangModuleInfoImpl.getInstance())); - } - @Test public void testInit(@InjectTestData(resourcePath = "/locator-set.json", id = LOC_1_PATH) LocatorSet locatorSet) { final LocatorSetKey loc1Key = new LocatorSetKey("loc1"); diff --git a/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/translate/read/MapRegisterCustomizerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/translate/read/MapRegisterCustomizerTest.java new file mode 100644 index 000000000..9dc1913c5 --- /dev/null +++ b/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/translate/read/MapRegisterCustomizerTest.java @@ -0,0 +1,66 @@ +/* + * Copyright (c) 2017 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.hc2vpp.lisp.translate.read; + +import static org.junit.Assert.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.when; + +import io.fd.hc2vpp.common.test.read.InitializingReaderCustomizerTest; +import io.fd.honeycomb.translate.spi.read.ReaderCustomizer; +import io.fd.vpp.jvpp.core.dto.ShowLispMapRegisterStateReply; +import org.junit.Before; +import org.junit.Test; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.lisp.feature.data.grouping.LispFeatureDataBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.register.grouping.MapRegister; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.register.grouping.MapRegisterBuilder; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class MapRegisterCustomizerTest extends InitializingReaderCustomizerTest implements LispInitTest { + private static final InstanceIdentifier<MapRegister> STATE_IID = LISP_STATE_FTR_IID.child(MapRegister.class); + private static final InstanceIdentifier<MapRegister> CONFIG_IID = LISP_FTR_IID.child(MapRegister.class); + + public MapRegisterCustomizerTest() { + super(MapRegister.class, LispFeatureDataBuilder.class); + } + + @Override + @Before + public void setUp() throws Exception { + final ShowLispMapRegisterStateReply reply = new ShowLispMapRegisterStateReply(); + reply.isEnabled = 1; + when(api.showLispMapRegisterState(any())).thenReturn(future(reply)); + } + + @Test + public void testReadCurrentAttributes() throws Exception { + final MapRegisterBuilder builder = new MapRegisterBuilder(); + customizer.readCurrentAttributes(CONFIG_IID, builder, ctx); + assertTrue(builder.isEnabled()); + } + + @Test + public void testInit() { + final MapRegister data = new MapRegisterBuilder().setEnabled(true).build(); + invokeInitTest(STATE_IID, data, CONFIG_IID, data); + } + + @Override + protected ReaderCustomizer initCustomizer() { + return new MapRegisterCustomizer(api); + } +}
\ No newline at end of file diff --git a/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/translate/read/MapRequestModeCustomizerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/translate/read/MapRequestModeCustomizerTest.java new file mode 100644 index 000000000..85e6231f0 --- /dev/null +++ b/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/translate/read/MapRequestModeCustomizerTest.java @@ -0,0 +1,69 @@ +/* + * Copyright (c) 2017 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.hc2vpp.lisp.translate.read; + +import static org.junit.Assert.assertEquals; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.when; +import static org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.MapRequestMode.DestinationOnly; + +import io.fd.hc2vpp.common.test.read.InitializingReaderCustomizerTest; +import io.fd.honeycomb.test.tools.HoneycombTestRunner; +import io.fd.honeycomb.translate.spi.read.ReaderCustomizer; +import io.fd.vpp.jvpp.core.dto.ShowLispMapRequestModeReply; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.lisp.feature.data.grouping.LispFeatureDataBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.request.mode.grouping.MapRequestMode; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.request.mode.grouping.MapRequestModeBuilder; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class MapRequestModeCustomizerTest extends InitializingReaderCustomizerTest implements LispInitTest { + private static final InstanceIdentifier<MapRequestMode> STATE_IID = LISP_STATE_FTR_IID.child(MapRequestMode.class); + private static final InstanceIdentifier<MapRequestMode> CONFIG_IID = LISP_FTR_IID.child(MapRequestMode.class); + + public MapRequestModeCustomizerTest() { + super(MapRequestMode.class, LispFeatureDataBuilder.class); + } + + @Override + @Before + public void setUp() throws Exception { + final ShowLispMapRequestModeReply reply = new ShowLispMapRequestModeReply(); + reply.mode = ((byte) DestinationOnly.getIntValue()); + when(api.showLispMapRequestMode(any())).thenReturn(future(reply)); + } + + @Test + public void testReadCurrentAttributes() throws Exception { + final MapRequestModeBuilder builder = new MapRequestModeBuilder(); + customizer.readCurrentAttributes(CONFIG_IID, builder, ctx); + assertEquals(DestinationOnly, builder.getMode()); + } + + @Test + public void testInit() { + final MapRequestMode data = new MapRequestModeBuilder().setMode(DestinationOnly).build(); + invokeInitTest(STATE_IID, data, CONFIG_IID, data); + } + + @Override + protected ReaderCustomizer initCustomizer() { + return new MapRequestModeCustomizer(api); + } +}
\ No newline at end of file diff --git a/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/translate/read/MapServerCustomizerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/translate/read/MapServerCustomizerTest.java new file mode 100644 index 000000000..1af22931e --- /dev/null +++ b/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/translate/read/MapServerCustomizerTest.java @@ -0,0 +1,112 @@ +/* + * Copyright (c) 2017 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.hc2vpp.lisp.translate.read; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.containsInAnyOrder; +import static org.hamcrest.Matchers.hasSize; +import static org.junit.Assert.assertEquals; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.when; + +import io.fd.hc2vpp.common.test.read.InitializingListReaderCustomizerTest; +import io.fd.honeycomb.translate.spi.read.ReaderCustomizer; +import io.fd.vpp.jvpp.core.dto.LispMapServerDetails; +import io.fd.vpp.jvpp.core.dto.LispMapServerDetailsReplyDump; +import io.fd.vpp.jvpp.core.dto.LispMapServerDump; +import java.util.Arrays; +import java.util.List; +import org.junit.Before; +import org.junit.Test; +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.Ipv4AddressNoZone; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6AddressNoZone; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.servers.grouping.MapServers; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.servers.grouping.MapServersBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.servers.grouping.map.servers.MapServer; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.servers.grouping.map.servers.MapServerBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.servers.grouping.map.servers.MapServerKey; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class MapServerCustomizerTest + extends InitializingListReaderCustomizerTest<MapServer, MapServerKey, MapServerBuilder> + implements LispInitTest { + + private static final MapServerKey + SERVER_KEY = new MapServerKey(new IpAddress(new Ipv4Address("192.168.2.1"))); + private static final InstanceIdentifier<MapServer> STATE_IID = LISP_STATE_FTR_IID.child(MapServers.class) + .child(MapServer.class, SERVER_KEY); + private static final InstanceIdentifier<MapServer> CONFIG_IID = LISP_FTR_IID.child(MapServers.class) + .child(MapServer.class, SERVER_KEY); + + public MapServerCustomizerTest() { + super(MapServer.class, MapServersBuilder.class); + } + + @Override + @Before + public void setUp() throws Exception { + final LispMapServerDetailsReplyDump reply = new LispMapServerDetailsReplyDump(); + LispMapServerDetails server1 = new LispMapServerDetails(); + //192.168.2.2 + server1.ipAddress = new byte[]{-64, -88, 2, 1}; + server1.isIpv6 = 0; + + LispMapServerDetails server2 = new LispMapServerDetails(); + //192.168.2.2 + server2.ipAddress = new byte[]{-64, -88, 2, 2}; + server2.isIpv6 = 0; + + LispMapServerDetails server3 = new LispMapServerDetails(); + //2001:0db8:0a0b:12f0:0000:0000:0000:0001 + server3.ipAddress = new byte[]{32, 1, 13, -72, 10, 11, 18, -16, 0, 0, 0, 0, 0, 0, 0, 1}; + server3.isIpv6 = 1; + + reply.lispMapServerDetails = Arrays.asList(server1, server2, server3); + when(api.lispMapServerDump(any(LispMapServerDump.class))).thenReturn(future(reply)); + } + + @Test + public void testGetAllIds() throws Exception { + final List<MapServerKey> allIds = getCustomizer().getAllIds(STATE_IID, ctx); + assertThat(allIds, hasSize(3)); + assertThat(allIds, containsInAnyOrder( + new MapServerKey(new IpAddress(new Ipv4AddressNoZone("192.168.2.1"))), + new MapServerKey(new IpAddress(new Ipv4AddressNoZone("192.168.2.2"))), + new MapServerKey(new IpAddress(new Ipv6AddressNoZone("2001:db8:a0b:12f0::1"))))); + } + + @Test + public void testReadCurrentAttributes() throws Exception { + final MapServerBuilder builder = new MapServerBuilder(); + getCustomizer().readCurrentAttributes(STATE_IID, builder, ctx); + assertEquals("192.168.2.1", builder.getIpAddress().getIpv4Address().getValue()); + } + + @Test + public void testInit() { + final MapServer data = new MapServerBuilder().setIpAddress( + new IpAddress(new Ipv4Address("192.168.2.1"))).build(); + invokeInitTest(STATE_IID, data, CONFIG_IID, data); + } + + @Override + protected ReaderCustomizer<MapServer, MapServerBuilder> initCustomizer() { + return new MapServerCustomizer(api); + } +}
\ No newline at end of file diff --git a/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/translate/read/PetrCfgCustomizerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/translate/read/PetrCfgCustomizerTest.java new file mode 100644 index 000000000..107523292 --- /dev/null +++ b/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/translate/read/PetrCfgCustomizerTest.java @@ -0,0 +1,84 @@ +/* + * Copyright (c) 2017 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.hc2vpp.lisp.translate.read; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNull; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.when; + +import io.fd.hc2vpp.common.test.read.InitializingReaderCustomizerTest; +import io.fd.honeycomb.translate.spi.read.ReaderCustomizer; +import io.fd.vpp.jvpp.core.dto.ShowLispUsePetrReply; +import org.junit.Test; +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.rev170315.lisp.feature.data.grouping.LispFeatureDataBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.use.petr.cfg.grouping.PetrCfg; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.use.petr.cfg.grouping.PetrCfgBuilder; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class PetrCfgCustomizerTest extends InitializingReaderCustomizerTest implements LispInitTest { + private static final InstanceIdentifier<PetrCfg> STATE_IID = LISP_STATE_FTR_IID.child(PetrCfg.class); + private static final InstanceIdentifier<PetrCfg> CONFIG_IID = LISP_FTR_IID.child(PetrCfg.class); + + public PetrCfgCustomizerTest() { + super(PetrCfg.class, LispFeatureDataBuilder.class); + } + + private void mockEnabledReply() { + final ShowLispUsePetrReply reply = new ShowLispUsePetrReply(); + reply.address = new byte[]{-64, -88, 2, 1}; + reply.status = 1; + reply.isIp4 = 1; + when(api.showLispUsePetr(any())).thenReturn(future(reply)); + } + + private void mockDisabledReply() { + final ShowLispUsePetrReply reply = new ShowLispUsePetrReply(); + reply.status = 0; + when(api.showLispUsePetr(any())).thenReturn(future(reply)); + } + + @Test + public void readCurrentAttributesEnabled() throws Exception { + mockEnabledReply(); + final PetrCfgBuilder builder = new PetrCfgBuilder(); + getCustomizer().readCurrentAttributes(STATE_IID, builder, ctx); + assertEquals("192.168.2.1", builder.getPetrAddress().getIpv4Address().getValue()); + } + + @Test + public void readCurrentAttributesDisabled() throws Exception { + mockDisabledReply(); + final PetrCfgBuilder builder = new PetrCfgBuilder(); + getCustomizer().readCurrentAttributes(STATE_IID, builder, ctx); + assertNull(builder.getPetrAddress()); + } + + @Test + public void testInit() { + final PetrCfg data = new PetrCfgBuilder().setPetrAddress( + new IpAddress(new Ipv4Address("192.168.2.1"))).build(); + invokeInitTest(STATE_IID, data, CONFIG_IID, data); + } + + @Override + protected ReaderCustomizer initCustomizer() { + return new PetrCfgCustomizer(api); + } +}
\ No newline at end of file diff --git a/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/translate/read/RlocProbeCustomizerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/translate/read/RlocProbeCustomizerTest.java new file mode 100644 index 000000000..f5d235358 --- /dev/null +++ b/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/translate/read/RlocProbeCustomizerTest.java @@ -0,0 +1,67 @@ +/* + * Copyright (c) 2017 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.hc2vpp.lisp.translate.read; + +import static org.junit.Assert.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.when; + +import io.fd.hc2vpp.common.test.read.InitializingReaderCustomizerTest; +import io.fd.honeycomb.translate.spi.read.ReaderCustomizer; +import io.fd.vpp.jvpp.core.dto.ShowLispRlocProbeStateReply; +import org.junit.Before; +import org.junit.Test; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.lisp.feature.data.grouping.LispFeatureDataBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.rloc.probing.grouping.RlocProbe; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.rloc.probing.grouping.RlocProbeBuilder; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class RlocProbeCustomizerTest extends InitializingReaderCustomizerTest implements LispInitTest { + private static final InstanceIdentifier<RlocProbe> STATE_IID = LISP_STATE_FTR_IID.child(RlocProbe.class); + private static final InstanceIdentifier<RlocProbe> CONFIG_IID = LISP_FTR_IID.child(RlocProbe.class); + + public RlocProbeCustomizerTest() { + super(RlocProbe.class, LispFeatureDataBuilder.class); + } + + @Override + @Before + public void setUp() throws Exception { + final ShowLispRlocProbeStateReply reply = new ShowLispRlocProbeStateReply(); + reply.isEnabled = 1; + when(api.showLispRlocProbeState(any())).thenReturn(future(reply)); + } + + @Test + public void testInit() { + final RlocProbe data = new RlocProbeBuilder().setEnabled(true).build(); + invokeInitTest(STATE_IID, data, CONFIG_IID, data); + } + + @Test + public void testReadCurrentAttributes() throws Exception { + final RlocProbeBuilder builder = new RlocProbeBuilder(); + getCustomizer().readCurrentAttributes(CONFIG_IID, builder, ctx); + assertTrue(builder.isEnabled()); + } + + + @Override + protected ReaderCustomizer initCustomizer() { + return new RlocProbeCustomizer(api); + } +}
\ No newline at end of file diff --git a/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/translate/write/LocalMappingCustomizerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/translate/write/LocalMappingCustomizerTest.java index 6f4a623ed..8855f0564 100755 --- a/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/translate/write/LocalMappingCustomizerTest.java +++ b/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/translate/write/LocalMappingCustomizerTest.java @@ -18,6 +18,7 @@ package io.fd.hc2vpp.lisp.translate.write; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; import static org.mockito.Matchers.any; import static org.mockito.Matchers.eq; import static org.mockito.Mockito.mock; @@ -32,6 +33,8 @@ import io.fd.hc2vpp.lisp.context.util.EidMappingContext; import io.fd.honeycomb.translate.write.WriteFailedException; import io.fd.vpp.jvpp.core.dto.LispAddDelLocalEid; import io.fd.vpp.jvpp.core.dto.LispAddDelLocalEidReply; +import java.nio.charset.StandardCharsets; +import java.util.Arrays; import java.util.concurrent.ExecutionException; import org.junit.Test; import org.mockito.ArgumentCaptor; @@ -40,6 +43,7 @@ import org.mockito.Mock; 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.Ipv4Afi; 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.rev170315.HmacKeyType; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.Lisp; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.MappingId; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.dp.subtable.grouping.LocalMappings; @@ -52,6 +56,7 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.eid.table.grouping.eid.table.VniTable; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.eid.table.grouping.eid.table.VniTableKey; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.eid.table.grouping.eid.table.vni.table.VrfSubtable; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.hmac.key.grouping.HmacKeyBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.lisp.feature.data.grouping.LispFeatureData; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; @@ -64,6 +69,7 @@ public class LocalMappingCustomizerTest extends WriterCustomizerTest implements private InstanceIdentifier<LocalMapping> id; private LocalMapping mapping; + private LocalMapping mappingWithHmacKey; private LocalMappingCustomizer customizer; @Override @@ -82,6 +88,13 @@ public class LocalMappingCustomizerTest extends WriterCustomizerTest implements .setLocatorSet("Locator") .build(); + mappingWithHmacKey = new LocalMappingBuilder(mapping) + .setHmacKey(new HmacKeyBuilder() + .setKey("abcd") + .setKeyType(HmacKeyType.Sha256128Key) + .build()) + .build(); + id = InstanceIdentifier.builder(Lisp.class) .child(LispFeatureData.class) .child(EidTable.class) @@ -138,6 +151,25 @@ public class LocalMappingCustomizerTest extends WriterCustomizerTest implements assertEquals("Locator", toString(request.locatorSetName)); } + @Test + public void testWriteCurrentAttributesWithHmacKey() throws WriteFailedException { + customizer.writeCurrentAttributes(id, mappingWithHmacKey, writeContext); + + verify(api, times(1)).lispAddDelLocalEid(mappingCaptor.capture()); + + LispAddDelLocalEid request = mappingCaptor.getValue(); + + assertNotNull(request); + assertEquals("Locator", new String(request.locatorSetName)); + assertEquals("192.168.2.1", arrayToIpv4AddressNoZone(request.eid).getValue()); + assertEquals(0, request.eidType); + assertEquals(1, request.isAdd); + assertEquals(25, request.vni); + assertEquals("Locator", toString(request.locatorSetName)); + assertTrue(Arrays.equals("abcd".getBytes(StandardCharsets.UTF_8), request.key)); + assertEquals(HmacKeyType.Sha256128Key.getIntValue(), request.keyId); + } + @Test(expected = UnsupportedOperationException.class) public void testUpdateCurrentAttributes() throws WriteFailedException { customizer.updateCurrentAttributes(null, null, null, writeContext); @@ -160,4 +192,24 @@ public class LocalMappingCustomizerTest extends WriterCustomizerTest implements assertEquals(25, request.vni); assertEquals("Locator", toString(request.locatorSetName)); } + + @Test + public void testDeleteCurrentAttributesWithHmacKey() throws WriteFailedException, InterruptedException, ExecutionException { + when(eidMappingContext.containsEid(any(), eq(mappingContext))).thenReturn(true); + customizer.deleteCurrentAttributes(id, mappingWithHmacKey, writeContext); + + verify(api, times(1)).lispAddDelLocalEid(mappingCaptor.capture()); + + LispAddDelLocalEid request = mappingCaptor.getValue(); + + assertNotNull(request); + assertEquals("Locator", new String(request.locatorSetName)); + assertEquals("192.168.2.1", arrayToIpv4AddressNoZone(request.eid).getValue()); + assertEquals(0, request.eidType); + assertEquals(0, request.isAdd); + assertEquals(25, request.vni); + assertEquals("Locator", toString(request.locatorSetName)); + assertTrue(Arrays.equals("abcd".getBytes(StandardCharsets.UTF_8), request.key)); + assertEquals(HmacKeyType.Sha256128Key.getIntValue(), request.keyId); + } } diff --git a/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/translate/write/MapRegisterCustomizerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/translate/write/MapRegisterCustomizerTest.java new file mode 100644 index 000000000..0eb5d1148 --- /dev/null +++ b/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/translate/write/MapRegisterCustomizerTest.java @@ -0,0 +1,92 @@ +/* + * Copyright (c) 2017 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.hc2vpp.lisp.translate.write; + +import static org.junit.Assert.assertEquals; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import io.fd.hc2vpp.common.test.write.WriterCustomizerTest; +import io.fd.hc2vpp.common.translate.util.ByteDataTranslator; +import io.fd.vpp.jvpp.core.dto.LispMapRegisterEnableDisable; +import io.fd.vpp.jvpp.core.dto.LispMapRegisterEnableDisableReply; +import org.junit.Test; +import org.mockito.ArgumentCaptor; +import org.mockito.Captor; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.register.grouping.MapRegister; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.register.grouping.MapRegisterBuilder; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class MapRegisterCustomizerTest extends WriterCustomizerTest implements ByteDataTranslator { + + private static final InstanceIdentifier<MapRegister> ID = InstanceIdentifier.create(MapRegister.class); + private MapRegisterCustomizer customizer; + private MapRegister enabledRegister; + private MapRegister disabledRegister; + + @Captor + private ArgumentCaptor<LispMapRegisterEnableDisable> requestCaptor; + + @Override + protected void setUpTest() throws Exception { + customizer = new MapRegisterCustomizer(api); + + enabledRegister = new MapRegisterBuilder() + .setEnabled(true) + .build(); + + disabledRegister = new MapRegisterBuilder() + .setEnabled(false) + .build(); + + when(api.lispMapRegisterEnableDisable(any(LispMapRegisterEnableDisable.class))) + .thenReturn(future(new LispMapRegisterEnableDisableReply())); + } + + @Test + public void writeCurrentAttributes() throws Exception { + customizer.writeCurrentAttributes(ID, enabledRegister, writeContext); + verifyRequest(true); + } + + @Test + public void updateCurrentAttributesToDisabled() throws Exception { + customizer.updateCurrentAttributes(ID, enabledRegister, disabledRegister, writeContext); + verifyRequest(false); + } + + @Test + public void updateCurrentAttributesToEnabled() throws Exception { + customizer.updateCurrentAttributes(ID, disabledRegister, enabledRegister, writeContext); + verifyRequest(true); + } + + @Test + public void deleteCurrentAttributes() throws Exception { + customizer.deleteCurrentAttributes(ID, disabledRegister, writeContext); + verifyRequest(false); + } + + private void verifyRequest(final boolean enabled) { + verify(api, times(1)).lispMapRegisterEnableDisable(requestCaptor.capture()); + + final LispMapRegisterEnableDisable request = requestCaptor.getValue(); + assertEquals(booleanToByte(enabled), request.isEnabled); + } +}
\ No newline at end of file diff --git a/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/translate/write/MapRequestModeCustomizerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/translate/write/MapRequestModeCustomizerTest.java new file mode 100644 index 000000000..d66097ad2 --- /dev/null +++ b/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/translate/write/MapRequestModeCustomizerTest.java @@ -0,0 +1,83 @@ +/* + * Copyright (c) 2017 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.hc2vpp.lisp.translate.write; + +import static org.junit.Assert.assertEquals; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import static org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.MapRequestMode.DestinationOnly; +import static org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.MapRequestMode.SourceDestination; + +import io.fd.hc2vpp.common.test.write.WriterCustomizerTest; +import io.fd.vpp.jvpp.core.dto.LispMapRequestMode; +import io.fd.vpp.jvpp.core.dto.LispMapRequestModeReply; +import org.junit.Test; +import org.mockito.ArgumentCaptor; +import org.mockito.Captor; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.request.mode.grouping.MapRequestMode; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.request.mode.grouping.MapRequestModeBuilder; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class MapRequestModeCustomizerTest extends WriterCustomizerTest { + + private static final InstanceIdentifier<MapRequestMode> ID = InstanceIdentifier.create(MapRequestMode.class); + private MapRequestModeCustomizer customizer; + private MapRequestMode sourceDestinationMode; + private MapRequestMode destinationOnlyMode; + + @Captor + private ArgumentCaptor<LispMapRequestMode> requestCaptor; + + @Override + protected void setUpTest() throws Exception { + customizer = new MapRequestModeCustomizer(api); + sourceDestinationMode = new MapRequestModeBuilder() + .setMode(SourceDestination) + .build(); + destinationOnlyMode = new MapRequestModeBuilder() + .setMode(DestinationOnly) + .build(); + when(api.lispMapRequestMode(any(LispMapRequestMode.class))).thenReturn(future(new LispMapRequestModeReply())); + } + + @Test + public void writeCurrentAttributes() throws Exception { + customizer.writeCurrentAttributes(ID, sourceDestinationMode, writeContext); + verifyModeRequest(SourceDestination); + } + + @Test + public void updateCurrentAttributes() throws Exception { + customizer.updateCurrentAttributes(ID, sourceDestinationMode, destinationOnlyMode, writeContext); + verifyModeRequest(DestinationOnly); + } + + @Test + public void deleteCurrentAttributes() throws Exception { + verify(api, times(0)).lispMapRequestMode(any()); + } + + private void verifyModeRequest( + final org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.MapRequestMode mode) { + verify(api, times(1)).lispMapRequestMode(requestCaptor.capture()); + + final LispMapRequestMode request = requestCaptor.getValue(); + assertEquals(mode.getIntValue(), request.mode); + } +}
\ No newline at end of file diff --git a/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/translate/write/MapServerCustomizerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/translate/write/MapServerCustomizerTest.java new file mode 100644 index 000000000..b69a44e68 --- /dev/null +++ b/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/translate/write/MapServerCustomizerTest.java @@ -0,0 +1,98 @@ +/* + * Copyright (c) 2017 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.hc2vpp.lisp.translate.write; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import io.fd.hc2vpp.common.test.write.WriterCustomizerTest; +import io.fd.hc2vpp.common.translate.util.ByteDataTranslator; +import io.fd.honeycomb.translate.write.WriteFailedException; +import io.fd.vpp.jvpp.core.dto.LispAddDelMapServer; +import io.fd.vpp.jvpp.core.dto.LispAddDelMapServerReply; +import java.util.Arrays; +import org.junit.Test; +import org.mockito.ArgumentCaptor; +import org.mockito.Captor; +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.rev170315.map.servers.grouping.MapServers; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.servers.grouping.map.servers.MapServer; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.servers.grouping.map.servers.MapServerBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.map.servers.grouping.map.servers.MapServerKey; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class MapServerCustomizerTest extends WriterCustomizerTest implements ByteDataTranslator { + + private static final MapServerKey MAP_SERVER_KEY = new MapServerKey( + new IpAddress(new Ipv4Address("192.168.2.1"))); + private static final InstanceIdentifier<MapServer> ID = InstanceIdentifier.create(MapServers.class) + .child(MapServer.class, MAP_SERVER_KEY); + + private MapServerCustomizer customizer; + private MapServer data; + + @Captor + private ArgumentCaptor<LispAddDelMapServer> requestCaptor; + + @Override + protected void setUpTest() throws Exception { + customizer = new MapServerCustomizer(api); + data = new MapServerBuilder() + .setIpAddress(MAP_SERVER_KEY.getIpAddress()) + .build(); + when(api.lispAddDelMapServer(any())).thenReturn(future(new LispAddDelMapServerReply())); + } + + @Test + public void writeCurrentAttributes() throws Exception { + customizer.writeCurrentAttributes(ID, data, writeContext); + verifyRequest(true); + } + + + @Test + public void updateCurrentAttributes() throws Exception { + try { + customizer.updateCurrentAttributes(ID, data, data, writeContext); + } catch (WriteFailedException e) { + assertTrue(e instanceof WriteFailedException.UpdateFailedException); + assertTrue(e.getCause() instanceof UnsupportedOperationException); + verify(api, times(0)).lispAddDelMapServer(any()); + } + } + + @Test + public void deleteCurrentAttributes() throws Exception { + customizer.deleteCurrentAttributes(ID, data, writeContext); + verifyRequest(false); + } + + private void verifyRequest(final boolean add) { + verify(api, times(1)).lispAddDelMapServer(requestCaptor.capture()); + + final LispAddDelMapServer request = requestCaptor.getValue(); + + assertEquals(booleanToByte(add), request.isAdd); + assertEquals(0, request.isIpv6); + assertTrue(Arrays.equals(new byte[]{-64, -88, 2, 1}, request.ipAddress)); + } +}
\ No newline at end of file diff --git a/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/translate/write/PetrCfgCustomizerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/translate/write/PetrCfgCustomizerTest.java new file mode 100644 index 000000000..bd7475bb1 --- /dev/null +++ b/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/translate/write/PetrCfgCustomizerTest.java @@ -0,0 +1,99 @@ +/* + * Copyright (c) 2017 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.hc2vpp.lisp.translate.write; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import io.fd.hc2vpp.common.test.write.WriterCustomizerTest; +import io.fd.vpp.jvpp.core.dto.LispUsePetr; +import io.fd.vpp.jvpp.core.dto.LispUsePetrReply; +import java.util.Arrays; +import org.junit.Test; +import org.mockito.ArgumentCaptor; +import org.mockito.Captor; +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.rev170315.use.petr.cfg.grouping.PetrCfg; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.use.petr.cfg.grouping.PetrCfgBuilder; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class PetrCfgCustomizerTest extends WriterCustomizerTest { + + private static final InstanceIdentifier<PetrCfg> ID = InstanceIdentifier.create(PetrCfg.class); + + private PetrCfgCustomizer customizer; + private PetrCfg enabledCfg; + private PetrCfg disabledCfg; + + @Captor + private ArgumentCaptor<LispUsePetr> requestCaptor; + + @Override + public void setUpTest() throws Exception { + customizer = new PetrCfgCustomizer(api); + enabledCfg = new PetrCfgBuilder().setPetrAddress(new IpAddress(new Ipv4Address("192.168.2.1"))).build(); + disabledCfg = new PetrCfgBuilder().build(); + when(api.lispUsePetr(any(LispUsePetr.class))).thenReturn(future(new LispUsePetrReply())); + } + + @Test + public void testWriteCurrentAttributes() throws Exception { + customizer.writeCurrentAttributes(ID, enabledCfg, writeContext); + verifyEnabledInvoked(); + } + + @Test + public void testUpdateCurrentAttributesToEnabled() throws Exception { + customizer.updateCurrentAttributes(ID, disabledCfg, enabledCfg, writeContext); + verifyEnabledInvoked(); + } + + @Test + public void testUpdateCurrentAttributesToDisabled() throws Exception { + customizer.updateCurrentAttributes(ID, enabledCfg, disabledCfg, writeContext); + verifyDisabledInvoked(); + } + + @Test + public void testDeleteCurrentAttributes() throws Exception { + customizer.deleteCurrentAttributes(ID, disabledCfg, writeContext); + verifyDisabledInvoked(); + } + + private void verifyEnabledInvoked() { + verify(api, times(1)).lispUsePetr(requestCaptor.capture()); + + final LispUsePetr cfg = requestCaptor.getValue(); + assertEquals(1, cfg.isIp4); + assertTrue(Arrays.equals(new byte[]{-64, -88, 2, 1}, cfg.address)); + assertEquals(1, cfg.isAdd); + } + + private void verifyDisabledInvoked() { + verify(api, times(1)).lispUsePetr(requestCaptor.capture()); + + final LispUsePetr cfg = requestCaptor.getValue(); + assertNull(cfg.address); + assertEquals(0, cfg.isAdd); + } +}
\ No newline at end of file diff --git a/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/translate/write/RlocProbeCustomizerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/translate/write/RlocProbeCustomizerTest.java new file mode 100644 index 000000000..829853e66 --- /dev/null +++ b/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/translate/write/RlocProbeCustomizerTest.java @@ -0,0 +1,88 @@ +/* + * Copyright (c) 2017 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.hc2vpp.lisp.translate.write; + +import static org.junit.Assert.assertEquals; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import io.fd.hc2vpp.common.test.write.WriterCustomizerTest; +import io.fd.hc2vpp.common.translate.util.ByteDataTranslator; +import io.fd.vpp.jvpp.core.dto.LispRlocProbeEnableDisable; +import io.fd.vpp.jvpp.core.dto.LispRlocProbeEnableDisableReply; +import org.junit.Test; +import org.mockito.ArgumentCaptor; +import org.mockito.Captor; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.rloc.probing.grouping.RlocProbe; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.rloc.probing.grouping.RlocProbeBuilder; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class RlocProbeCustomizerTest extends WriterCustomizerTest implements ByteDataTranslator { + + private static final InstanceIdentifier<RlocProbe> ID = InstanceIdentifier.create(RlocProbe.class); + private RlocProbeCustomizer customizer; + private RlocProbe enabledProbe; + private RlocProbe disabledProbe; + + @Captor + private ArgumentCaptor<LispRlocProbeEnableDisable> requestCaptor; + + @Override + protected void setUpTest() throws Exception { + customizer = new RlocProbeCustomizer(api); + enabledProbe = rlocProbe(true); + disabledProbe = rlocProbe(false); + when(api.lispRlocProbeEnableDisable(any(LispRlocProbeEnableDisable.class))) + .thenReturn(future(new LispRlocProbeEnableDisableReply())); + } + + @Test + public void testWriteCurrentAttributes() throws Exception { + customizer.writeCurrentAttributes(ID, enabledProbe, writeContext); + verifyRequest(true); + } + + @Test + public void testUpdateCurrentAttributesToDisabled() throws Exception { + customizer.updateCurrentAttributes(ID, enabledProbe, disabledProbe, writeContext); + verifyRequest(false); + } + + @Test + public void testUpdateCurrentAttributesToEnabled() throws Exception { + customizer.updateCurrentAttributes(ID, disabledProbe, enabledProbe, writeContext); + verifyRequest(true); + } + + @Test + public void testDeleteCurrentAttributes() throws Exception { + customizer.deleteCurrentAttributes(ID, disabledProbe, writeContext); + verifyRequest(false); + } + + private static RlocProbe rlocProbe(final boolean enabled) { + return new RlocProbeBuilder().setEnabled(enabled).build(); + } + + private void verifyRequest(final boolean enabled) { + verify(api, times(1)).lispRlocProbeEnableDisable(requestCaptor.capture()); + final LispRlocProbeEnableDisable request = requestCaptor.getValue(); + assertEquals(booleanToByte(enabled), request.isEnabled); + } +}
\ No newline at end of file |