diff options
author | Jan Srnicek <jsrnicek@cisco.com> | 2016-10-04 16:44:47 +0200 |
---|---|---|
committer | Maros Marsalek <mmarsale@cisco.com> | 2016-10-05 11:52:37 +0000 |
commit | 5d1054b26f144948be321f30204b4b2a7cbbc03e (patch) | |
tree | 2104b21d9a2e728b8275d5d9f2a554c414db8c31 /lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read | |
parent | 512143ddd9995d16d9bb055481721fa276ccfa01 (diff) |
HONEYCOMB-138 - Lisp L2 Support
Change-Id: Idff4776a64a88be2e0a45ab1927978e40876ea92
Signed-off-by: Jan Srnicek <jsrnicek@cisco.com>
Diffstat (limited to 'lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read')
13 files changed, 905 insertions, 72 deletions
diff --git a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/AdjacencyCustomizerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/AdjacencyCustomizerTest.java index 0a88f946c..861fff67c 100644 --- a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/AdjacencyCustomizerTest.java +++ b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/AdjacencyCustomizerTest.java @@ -7,10 +7,10 @@ import io.fd.honeycomb.translate.spi.read.ReaderCustomizer; import io.fd.honeycomb.vpp.test.read.ListReaderCustomizerTest; import org.junit.Before; import org.junit.Test; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.AdjacenciesBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.adjacencies.Adjacency; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.adjacencies.AdjacencyBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.adjacencies.AdjacencyKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.adjacencies.grouping.AdjacenciesBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.adjacencies.grouping.adjacencies.Adjacency; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.adjacencies.grouping.adjacencies.AdjacencyBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.adjacencies.grouping.adjacencies.AdjacencyKey; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; diff --git a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/BridgeDomainSubtableCustomizerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/BridgeDomainSubtableCustomizerTest.java new file mode 100644 index 000000000..5902028fe --- /dev/null +++ b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/BridgeDomainSubtableCustomizerTest.java @@ -0,0 +1,104 @@ +package io.fd.honeycomb.lisp.translate.read; + + +import static io.fd.honeycomb.lisp.translate.read.dump.executor.params.SubtableDumpParams.MapLevel.L2; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; + +import io.fd.honeycomb.lisp.translate.read.trait.SubtableReaderTestCase; +import io.fd.honeycomb.translate.read.ReadFailedException; +import io.fd.honeycomb.translate.spi.read.ReaderCustomizer; +import io.fd.honeycomb.translate.util.read.cache.exceptions.execution.i.DumpCallFailedException; +import io.fd.honeycomb.translate.vpp.util.NamingContext; +import io.fd.vpp.jvpp.VppCallbackException; +import org.junit.Test; +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.VniTableBuilder; +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.BridgeDomainSubtable; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.BridgeDomainSubtableBuilder; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class BridgeDomainSubtableCustomizerTest + extends SubtableReaderTestCase<BridgeDomainSubtable, BridgeDomainSubtableBuilder> { + + private InstanceIdentifier<BridgeDomainSubtable> validId; + private NamingContext bridgeDomainContext; + + public BridgeDomainSubtableCustomizerTest() { + super(BridgeDomainSubtable.class, VniTableBuilder.class); + } + + @Override + protected void setUp() throws Exception { + bridgeDomainContext = new NamingContext("br", "br-domain-context"); + validId = InstanceIdentifier.create(EidTable.class).child(VniTable.class, new VniTableKey(expectedVni)) + .child(BridgeDomainSubtable.class); + + defineMapping(mappingContext, "br-domain", expectedTableId, "br-domain-context"); + } + + @Test + public void testReadCurrentSuccessfull() throws ReadFailedException { + doReturnValidNonEmptyDataOnDump(); + BridgeDomainSubtableBuilder builder = new BridgeDomainSubtableBuilder(); + customizer.readCurrentAttributes(validId, builder, ctx); + + verifyLispEidTableMapDumpCalled(L2); + + final BridgeDomainSubtable subtable = builder.build(); + assertNotNull(subtable); + assertEquals("br-domain", subtable.getBridgeDomainRef()); + } + + + @Test + public void testReadCurrentEmptyDump() throws ReadFailedException { + doReturnEmptyDataOnDump(); + BridgeDomainSubtableBuilder builder = new BridgeDomainSubtableBuilder(); + customizer.readCurrentAttributes(validId, builder, ctx); + + verifyLispEidTableMapDumpCalled(L2); + + final BridgeDomainSubtable subtable = builder.build(); + assertNotNull(subtable); + assertNull(subtable.getBridgeDomainRef()); + } + + @Test + public void testReadCurrentFailed() { + doThrowOnDump(); + BridgeDomainSubtableBuilder builder = new BridgeDomainSubtableBuilder(); + try { + customizer.readCurrentAttributes(validId, builder, ctx); + } catch (ReadFailedException e) { + assertTrue(e.getCause() instanceof DumpCallFailedException); + assertTrue(e.getCause().getCause() instanceof VppCallbackException); + assertNull(builder.getBridgeDomainRef()); + verifyLispEidTableMapDumpNotCalled(); + + return; + } + + fail("Test should throw ReadFailedException"); + } + + @Test + public void testGetBuilder() { + final BridgeDomainSubtableBuilder builder = customizer.getBuilder(validId); + + assertNotNull(builder); + assertNull(builder.getLocalMappings()); + assertNull(builder.getRemoteMappings()); + assertNull(builder.getBridgeDomainRef()); + } + + @Override + protected ReaderCustomizer<BridgeDomainSubtable, BridgeDomainSubtableBuilder> initCustomizer() { + return new BridgeDomainSubtableCustomizer(api, bridgeDomainContext); + } +} diff --git a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/ItrRemoteLocatorSetCustomizerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/ItrRemoteLocatorSetCustomizerTest.java new file mode 100644 index 000000000..a1688ae35 --- /dev/null +++ b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/ItrRemoteLocatorSetCustomizerTest.java @@ -0,0 +1,150 @@ +package io.fd.honeycomb.lisp.translate.read; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; +import static org.mockito.Matchers.any; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import io.fd.honeycomb.translate.read.ReadFailedException; +import io.fd.honeycomb.translate.spi.read.ReaderCustomizer; +import io.fd.honeycomb.translate.util.read.cache.exceptions.execution.i.DumpCallFailedException; +import io.fd.honeycomb.vpp.test.read.ReaderCustomizerTest; +import io.fd.vpp.jvpp.VppCallbackException; +import io.fd.vpp.jvpp.core.dto.LispGetMapRequestItrRlocs; +import io.fd.vpp.jvpp.core.dto.LispGetMapRequestItrRlocsReply; +import java.nio.charset.StandardCharsets; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; +import org.junit.Before; +import org.junit.Test; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.itr.remote.locator.sets.grouping.ItrRemoteLocatorSet; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.itr.remote.locator.sets.grouping.ItrRemoteLocatorSetBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.lisp.feature.data.grouping.LispFeatureDataBuilder; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + + +public class ItrRemoteLocatorSetCustomizerTest + extends ReaderCustomizerTest<ItrRemoteLocatorSet, ItrRemoteLocatorSetBuilder> { + + private static final String EXPECTED_LOCATOR_SET_NAME = "loc-set"; + + private InstanceIdentifier<ItrRemoteLocatorSet> validId; + private ItrRemoteLocatorSetBuilder builder; + + public ItrRemoteLocatorSetCustomizerTest() { + super(ItrRemoteLocatorSet.class, LispFeatureDataBuilder.class); + } + + @Before + public void setUp() throws Exception { + validId = InstanceIdentifier.create(ItrRemoteLocatorSet.class); + builder = new ItrRemoteLocatorSetBuilder(); + } + + @Override + protected ReaderCustomizer<ItrRemoteLocatorSet, ItrRemoteLocatorSetBuilder> initCustomizer() { + return new ItrRemoteLocatorSetCustomizer(api); + } + + @Test + public void getBuilder() throws Exception { + final ItrRemoteLocatorSetBuilder itrRemoteLocatorSetBuilder = getCustomizer().getBuilder(validId); + + assertNotNull(itrRemoteLocatorSetBuilder); + assertNull(itrRemoteLocatorSetBuilder.getRemoteLocatorSetName()); + } + + @Test + public void readCurrentAttributesSuccess() throws Exception { + doReturnValidDataOnDump(); + + getCustomizer().readCurrentAttributes(validId, builder, ctx); + + assertNotNull(builder); + assertEquals(EXPECTED_LOCATOR_SET_NAME, builder.getRemoteLocatorSetName()); + verifyLispGetMapRequestItrRlocsInvokedOnce(); + } + + @Test + public void readCurrentAttributesEmptyData() throws Exception { + doReturnEmptyDataOnDump(); + getCustomizer().readCurrentAttributes(validId, builder, ctx); + verifyInvalidDataCase(builder); + } + + @Test + public void readCurrentAttributesFailedCallHalted() { + doThrowExceptionOnDump(); + try { + getCustomizer().readCurrentAttributes(validId, builder, ctx); + } catch (ReadFailedException e) { + assertTrue(e.getCause() instanceof DumpCallFailedException); + assertTrue(e.getCause().getCause() instanceof VppCallbackException); + assertNotNull(builder); + assertNull(builder.getRemoteLocatorSetName()); + + verifyLispGetMapRequestItrRlocsInvokedOnce(); + return; + } + + fail("Test should have thrown exception"); + } + + @Test + public void merge() throws Exception { + LispFeatureDataBuilder builder = new LispFeatureDataBuilder(); + ItrRemoteLocatorSet set = new ItrRemoteLocatorSetBuilder().setRemoteLocatorSetName("loc-set").build(); + getCustomizer().merge(builder, set); + + assertNotNull(builder); + assertEquals(set, builder.getItrRemoteLocatorSet()); + } + + + private void doReturnValidDataOnDump() { + LispGetMapRequestItrRlocsReply reply = new LispGetMapRequestItrRlocsReply(); + reply.locatorSetName = EXPECTED_LOCATOR_SET_NAME.getBytes(StandardCharsets.UTF_8); + + when(api.lispGetMapRequestItrRlocs(any(LispGetMapRequestItrRlocs.class))) + .thenReturn(CompletableFuture.completedFuture(reply)); + } + + private void doReturnNullDataOnDump() { + when(api.lispGetMapRequestItrRlocs(any(LispGetMapRequestItrRlocs.class))) + .thenReturn(CompletableFuture.completedFuture(null)); + } + + private void doReturnEmptyDataOnDump() { + when(api.lispGetMapRequestItrRlocs(any(LispGetMapRequestItrRlocs.class))) + .thenReturn(CompletableFuture.completedFuture(new LispGetMapRequestItrRlocsReply())); + } + + private void doThrowExceptionOnDump() { + when(api.lispGetMapRequestItrRlocs(any(LispGetMapRequestItrRlocs.class))). + thenReturn(new CompletableFuture<LispGetMapRequestItrRlocsReply>() { + @Override + public LispGetMapRequestItrRlocsReply get(final long l, final TimeUnit timeUnit) + throws InterruptedException, ExecutionException, TimeoutException { + throw new ExecutionException(new VppCallbackException("lispGetMapRequestItrRlocs", 1, -2)); + } + }); + } + + private void verifyLispGetMapRequestItrRlocsInvokedOnce() { + verify(api, times(1)).lispGetMapRequestItrRlocs(any(LispGetMapRequestItrRlocs.class)); + } + + private void verifyInvalidDataCase(final ItrRemoteLocatorSetBuilder builder) { + assertNotNull(builder); + assertNull(builder.getRemoteLocatorSetName()); + + verifyLispGetMapRequestItrRlocsInvokedOnce(); + } +}
\ No newline at end of file diff --git a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/LocalMappingCustomizerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/LocalMappingCustomizerTest.java index 3b1506e39..a7317b9cc 100644 --- a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/LocalMappingCustomizerTest.java +++ b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/LocalMappingCustomizerTest.java @@ -1,5 +1,6 @@ package io.fd.honeycomb.lisp.translate.read; +import static io.fd.honeycomb.lisp.translate.read.dump.executor.params.MappingsDumpParams.EidType.IPV4; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; import static org.mockito.Matchers.any; @@ -7,6 +8,7 @@ import static org.mockito.Mockito.when; import com.google.common.collect.ImmutableList; import io.fd.honeycomb.lisp.context.util.EidMappingContext; +import io.fd.honeycomb.lisp.translate.read.dump.executor.params.MappingsDumpParams; import io.fd.honeycomb.lisp.translate.util.EidTranslator; import io.fd.honeycomb.translate.MappingContext; import io.fd.honeycomb.translate.spi.read.ReaderCustomizer; @@ -20,15 +22,17 @@ import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types. 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.dp.subtable.grouping.LocalMappings; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.dp.subtable.grouping.LocalMappingsBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.dp.subtable.grouping.local.mappings.LocalMapping; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.dp.subtable.grouping.local.mappings.LocalMappingBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.dp.subtable.grouping.local.mappings.LocalMappingKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.dp.subtable.grouping.local.mappings.local.mapping.Eid; 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.LocalMappingsBuilder; -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.BridgeDomainSubtable; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.VrfSubtable; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; import io.fd.vpp.jvpp.core.dto.LispEidTableDetails; import io.fd.vpp.jvpp.core.dto.LispEidTableDetailsReplyDump; @@ -53,11 +57,13 @@ public class LocalMappingCustomizerTest extends public void setUp() { emptyIdentifier = InstanceIdentifier.create(EidTable.class) .child(VniTable.class, new VniTableKey(12L)) + .child(VrfSubtable.class) .child(LocalMappings.class) .child(LocalMapping.class); validIdentifier = InstanceIdentifier.create(EidTable.class) .child(VniTable.class, new VniTableKey(12L)) + .child(VrfSubtable.class) .child(LocalMappings.class) .child(LocalMapping.class, new LocalMappingKey(new MappingId("local-mapping"))); @@ -73,6 +79,7 @@ public class LocalMappingCustomizerTest extends 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; diff --git a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/MapResolverCustomizerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/MapResolverCustomizerTest.java index 7afd8dd4f..112350676 100644 --- a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/MapResolverCustomizerTest.java +++ b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/MapResolverCustomizerTest.java @@ -8,6 +8,8 @@ import static org.mockito.Mockito.when; import com.google.common.collect.ImmutableList; import io.fd.honeycomb.translate.spi.read.ReaderCustomizer; import io.fd.honeycomb.vpp.test.read.ListReaderCustomizerTest; +import io.fd.vpp.jvpp.core.dto.LispMapResolverDetails; +import io.fd.vpp.jvpp.core.dto.LispMapResolverDetailsReplyDump; import java.util.List; import org.junit.Before; import org.junit.Test; @@ -19,14 +21,11 @@ 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.rev160520.map.resolvers.grouping.map.resolvers.MapResolverBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.map.resolvers.grouping.map.resolvers.MapResolverKey; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; -import io.fd.vpp.jvpp.core.dto.LispMapResolverDetails; -import io.fd.vpp.jvpp.core.dto.LispMapResolverDetailsReplyDump; public class MapResolverCustomizerTest extends ListReaderCustomizerTest<MapResolver, MapResolverKey, MapResolverBuilder> { - private static final IpAddress IP_ADDRESS = new IpAddress(new Ipv4AddressNoZone("192.168.2.1")); private static final IpAddress IP_ADDRESS_REVERTED = new IpAddress(new Ipv4AddressNoZone("1.2.168.192")); @@ -64,7 +63,7 @@ public class MapResolverCustomizerTest final MapResolverKey key = keys.get(0); assertNotNull(key); - assertEquals("192.168.2.1", new String(key.getIpAddress().getValue())); + assertEquals("1.2.168.192", new String(key.getIpAddress().getValue())); } diff --git a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/PitrCfgCustomizerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/PitrCfgCustomizerTest.java index c46d1f454..6c345223e 100644 --- a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/PitrCfgCustomizerTest.java +++ b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/PitrCfgCustomizerTest.java @@ -11,6 +11,7 @@ import java.nio.charset.StandardCharsets; import org.junit.Before; import org.junit.Test; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.LispStateBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.lisp.feature.data.grouping.LispFeatureDataBuilder; 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.opendaylight.yangtools.yang.binding.InstanceIdentifier; @@ -22,16 +23,14 @@ public class PitrCfgCustomizerTest extends ReaderCustomizerTest<PitrCfg, PitrCfg private static final byte[] LOC_SET_NAME_BYTES = "loc-set".getBytes(StandardCharsets.UTF_8); private InstanceIdentifier<PitrCfg> emptyId; - private PitrCfg validData; public PitrCfgCustomizerTest() { - super(PitrCfg.class, LispStateBuilder.class); + super(PitrCfg.class, LispFeatureDataBuilder.class); } @Before public void init() { emptyId = InstanceIdentifier.create(PitrCfg.class); - validData = new PitrCfgBuilder().setLocatorSet("loc-set").build(); mockDumpData(); } diff --git a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/RemoteMappingCustomizerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/RemoteMappingCustomizerTest.java index a431d224c..5ab8e5996 100644 --- a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/RemoteMappingCustomizerTest.java +++ b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/RemoteMappingCustomizerTest.java @@ -2,6 +2,7 @@ package io.fd.honeycomb.lisp.translate.read; 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.Mockito.when; @@ -11,6 +12,11 @@ import io.fd.honeycomb.lisp.translate.util.EidTranslator; import io.fd.honeycomb.translate.MappingContext; import io.fd.honeycomb.translate.spi.read.ReaderCustomizer; import io.fd.honeycomb.vpp.test.read.ListReaderCustomizerTest; +import io.fd.vpp.jvpp.core.dto.LispEidTableDetails; +import io.fd.vpp.jvpp.core.dto.LispEidTableDetailsReplyDump; +import io.fd.vpp.jvpp.core.dto.LispLocatorDetails; +import io.fd.vpp.jvpp.core.dto.LispLocatorDetailsReplyDump; +import java.util.Collections; import java.util.List; import org.junit.Before; import org.junit.Test; @@ -19,19 +25,22 @@ 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.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.dp.subtable.grouping.RemoteMappings; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.dp.subtable.grouping.RemoteMappingsBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.dp.subtable.grouping.remote.mappings.RemoteMapping; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.dp.subtable.grouping.remote.mappings.RemoteMappingBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.dp.subtable.grouping.remote.mappings.RemoteMappingKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.dp.subtable.grouping.remote.mappings.remote.mapping.Eid; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.dp.subtable.grouping.remote.mappings.remote.mapping.locator.list.NegativeMapping; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.dp.subtable.grouping.remote.mappings.remote.mapping.locator.list.PositiveMapping; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.dp.subtable.grouping.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.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.RemoteMappingsBuilder; -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.VrfSubtable; 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 RemoteMappingCustomizerTest extends ListReaderCustomizerTest<RemoteMapping, RemoteMappingKey, RemoteMappingBuilder> @@ -43,7 +52,6 @@ public class RemoteMappingCustomizerTest @Mock private EidMappingContext eidMappingContext; - private InstanceIdentifier<RemoteMapping> emptyId; private InstanceIdentifier<RemoteMapping> validId; public RemoteMappingCustomizerTest() { @@ -53,22 +61,56 @@ public class RemoteMappingCustomizerTest @Before public void init() { - emptyId = InstanceIdentifier.create(EidTable.class) - .child(VniTable.class, new VniTableKey(12L)) - .child(RemoteMappings.class) - .child(RemoteMapping.class); - validId = InstanceIdentifier.create(EidTable.class) .child(VniTable.class, new VniTableKey(12L)) + .child(VrfSubtable.class) .child(RemoteMappings.class) .child(RemoteMapping.class, new RemoteMappingKey(new MappingId("remote-mapping"))); - - mockDumpData(); mockMappings(); } - private void mockDumpData() { + private void mockDumpDataActionZero() { + 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.isLocal = 0; + detail.locatorSetIndex = 1; + detail.ttl = 7; + detail.vni = 12; + + replyDump.lispEidTableDetails = ImmutableList.of(detail); + + when(api.lispEidTableDump(any())).thenReturn(future(replyDump)); + + LispLocatorDetailsReplyDump rlocs = new LispLocatorDetailsReplyDump(); + rlocs.lispLocatorDetails = Collections.emptyList(); + when(api.lispLocatorDump(any())).thenReturn(future(rlocs)); + } + + private void mockDumpDataActionOne() { + LispEidTableDetailsReplyDump replyDump = new LispEidTableDetailsReplyDump(); + LispEidTableDetails detail = new LispEidTableDetails(); + detail.action = 1; + detail.authoritative = 1; + detail.context = 4; + detail.eid = new byte[]{-64, -88, 2, 1}; + detail.eidPrefixLen = 32; + detail.isLocal = 0; + detail.locatorSetIndex = 1; + detail.ttl = 7; + detail.vni = 12; + + replyDump.lispEidTableDetails = ImmutableList.of(detail); + + when(api.lispEidTableDump(any())).thenReturn(future(replyDump)); + } + + private void mockDumpDataActionZeroWithRemotes() { LispEidTableDetailsReplyDump replyDump = new LispEidTableDetailsReplyDump(); LispEidTableDetails detail = new LispEidTableDetails(); detail.action = 0; @@ -84,8 +126,20 @@ public class RemoteMappingCustomizerTest replyDump.lispEidTableDetails = ImmutableList.of(detail); when(api.lispEidTableDump(any())).thenReturn(future(replyDump)); + + LispLocatorDetailsReplyDump rlocs = new LispLocatorDetailsReplyDump(); + LispLocatorDetails rloc = new LispLocatorDetails(); + rloc.ipAddress = new byte[]{-64, -88, 2, 1}; + rloc.isIpv6 = 0; + rloc.priority = 1; + rloc.weight = 2; + + rlocs.lispLocatorDetails = ImmutableList.of(rloc); + + when(api.lispLocatorDump(any())).thenReturn(future(rlocs)); } + private void mockMappings() { when(eidMappingContext.getId(any(Eid.class), any(MappingContext.class))) @@ -96,7 +150,41 @@ public class RemoteMappingCustomizerTest } @Test - public void readCurrentAttributes() throws Exception { + public void readCurrentAttributesNegativeMappingOne() throws Exception { + mockDumpDataActionOne(); + RemoteMappingBuilder builder = new RemoteMappingBuilder(); + getCustomizer().readCurrentAttributes(validId, builder, ctx); + + RemoteMapping mapping = builder.build(); + + assertNotNull(mapping); + assertEquals(true, compareAddresses(EID_ADDRESS, mapping.getEid().getAddress())); + assertEquals(true, mapping.getAuthoritative().isA()); + assertEquals(7L, mapping.getTtl().longValue()); + assertTrue(mapping.getLocatorList() instanceof NegativeMapping); + assertEquals(MapReplyAction.NativelyForward, + ((NegativeMapping) mapping.getLocatorList()).getMapReply().getMapReplyAction()); + } + + @Test + public void readCurrentAttributesNegativeMappingZero() throws Exception { + mockDumpDataActionZero(); + RemoteMappingBuilder builder = new RemoteMappingBuilder(); + getCustomizer().readCurrentAttributes(validId, builder, ctx); + + RemoteMapping mapping = builder.build(); + + assertNotNull(mapping); + assertEquals(true, compareAddresses(EID_ADDRESS, mapping.getEid().getAddress())); + assertEquals(true, mapping.getAuthoritative().isA()); + assertEquals(7L, mapping.getTtl().longValue()); + assertEquals(MapReplyAction.NoAction, + ((NegativeMapping) mapping.getLocatorList()).getMapReply().getMapReplyAction()); + } + + @Test + public void readCurrentAttributesPositiveMapping() throws Exception { + mockDumpDataActionZeroWithRemotes(); RemoteMappingBuilder builder = new RemoteMappingBuilder(); getCustomizer().readCurrentAttributes(validId, builder, ctx); @@ -106,11 +194,20 @@ public class RemoteMappingCustomizerTest assertEquals(true, compareAddresses(EID_ADDRESS, mapping.getEid().getAddress())); assertEquals(true, mapping.getAuthoritative().isA()); assertEquals(7L, mapping.getTtl().longValue()); + assertTrue(mapping.getLocatorList() instanceof PositiveMapping); + + final List<Locator> locators = ((PositiveMapping) mapping.getLocatorList()).getRlocs().getLocator(); + assertEquals(1, locators.size()); + final Locator locator = locators.get(0); + assertEquals("192.168.2.1", locator.getAddress().getIpv4Address().getValue()); + assertEquals(1, locator.getPriority().shortValue()); + assertEquals(2, locator.getWeight().shortValue()); } @Test public void getAllIds() throws Exception { + mockDumpDataActionOne(); final List<RemoteMappingKey> keys = getCustomizer().getAllIds(validId, ctx); assertNotNull(keys); diff --git a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/VniTableCustomizerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/VniTableCustomizerTest.java index f4fe52c5d..fe967e486 100644 --- a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/VniTableCustomizerTest.java +++ b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/VniTableCustomizerTest.java @@ -1,25 +1,34 @@ package io.fd.honeycomb.lisp.translate.read; + import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; -import static org.mockito.Matchers.any; +import static org.junit.Assert.assertTrue; import static org.mockito.Mockito.when; +import static org.mockito.MockitoAnnotations.initMocks; import com.google.common.collect.ImmutableList; +import io.fd.honeycomb.translate.read.ReadFailedException; import io.fd.honeycomb.translate.spi.read.ReaderCustomizer; +import io.fd.honeycomb.translate.util.read.cache.exceptions.execution.i.DumpCallFailedException; import io.fd.honeycomb.vpp.test.read.ListReaderCustomizerTest; +import io.fd.vpp.jvpp.VppCallbackException; +import io.fd.vpp.jvpp.core.dto.LispEidTableVniDetails; +import io.fd.vpp.jvpp.core.dto.LispEidTableVniDetailsReplyDump; import java.util.List; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; import org.junit.Before; import org.junit.Test; +import org.mockito.Mockito; 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.EidTableBuilder; 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.VniTableBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.VniTableKey; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; -import io.fd.vpp.jvpp.core.dto.LispEidTableMapDetails; -import io.fd.vpp.jvpp.core.dto.LispEidTableMapDetailsReplyDump; - public class VniTableCustomizerTest extends ListReaderCustomizerTest<VniTable, VniTableKey, VniTableBuilder> { @@ -31,41 +40,72 @@ public class VniTableCustomizerTest extends ListReaderCustomizerTest<VniTable, V @Before public void init() { - validId = InstanceIdentifier.create(EidTable.class).child(VniTable.class, new VniTableKey(2L)); - - final LispEidTableMapDetailsReplyDump replyDump = new LispEidTableMapDetailsReplyDump(); - final LispEidTableMapDetails detail = new LispEidTableMapDetails(); - detail.dpTable = 3; - detail.vni = 2; - detail.context = 4; - replyDump.lispEidTableMapDetails = ImmutableList.of(detail); - - when(api.lispEidTableMapDump(any())).thenReturn(future(replyDump)); + validId = InstanceIdentifier.create(EidTable.class).child(VniTable.class, new VniTableKey(12L)); } @Test - public void getAllIds() throws Exception { + public void testReadAllSuccessfull() throws ReadFailedException { + whenLispEidTableVniDumpReturnValid(); final List<VniTableKey> keys = getCustomizer().getAllIds(validId, ctx); - assertEquals(1, keys.size()); + assertNotNull(keys); + assertEquals(3, keys.size()); + assertTrue(keys.contains(new VniTableKey(12L))); + assertTrue(keys.contains(new VniTableKey(14L))); + assertTrue(keys.contains(new VniTableKey(16L))); + } - final VniTableKey key = keys.get(0); - assertNotNull(key); - //due to ambigous call (long,long) vs (Object,Object) - assertEquals(2L, key.getVirtualNetworkIdentifier().longValue()); + @Test + public void testReadAllFailed() { + whenLispEidTableVniDumpThrowException(); + try { + getCustomizer().getAllIds(validId, ctx); + } catch (ReadFailedException e) { + assertTrue(e instanceof ReadFailedException); + assertTrue(e.getCause() instanceof DumpCallFailedException); + assertTrue(e.getCause().getCause() instanceof VppCallbackException); + } } @Test - public void readCurrentAttributes() throws Exception { + public void testReadAttributes() throws ReadFailedException { + whenLispEidTableVniDumpReturnValid(); VniTableBuilder builder = new VniTableBuilder(); - getCustomizer().readCurrentAttributes(validId, builder, ctx); - final VniTable table = builder.build(); + customizer.readCurrentAttributes(validId, builder, ctx); + final VniTable table = builder.build(); assertNotNull(table); - assertEquals(3L, table.getTableId().longValue()); - assertEquals(2L, table.getVirtualNetworkIdentifier().longValue()); + assertEquals(12L, table.getVirtualNetworkIdentifier().longValue()); + } + + private void whenLispEidTableVniDumpReturnValid() { + + LispEidTableVniDetailsReplyDump dump = new LispEidTableVniDetailsReplyDump(); + LispEidTableVniDetails details1 = new LispEidTableVniDetails(); + details1.vni = 14; + + LispEidTableVniDetails details2 = new LispEidTableVniDetails(); + details2.vni = 12; + + LispEidTableVniDetails details3 = new LispEidTableVniDetails(); + details3.vni = 16; + + dump.lispEidTableVniDetails = ImmutableList.of(details1, details2, details3); + + when(api.lispEidTableVniDump(Mockito.any())).thenReturn(CompletableFuture.completedFuture(dump)); + } + + private void whenLispEidTableVniDumpThrowException() { + when(api.lispEidTableVniDump(Mockito.any())) + .thenReturn(new CompletableFuture<LispEidTableVniDetailsReplyDump>() { + @Override + public LispEidTableVniDetailsReplyDump get(final long l, final TimeUnit timeUnit) + throws InterruptedException, ExecutionException, TimeoutException { + throw new ExecutionException(new VppCallbackException("lispEidTableVniDump", 1, -2)); + } + }); } @Override diff --git a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/VrfSubtableCustomizerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/VrfSubtableCustomizerTest.java new file mode 100644 index 000000000..f18f349d8 --- /dev/null +++ b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/VrfSubtableCustomizerTest.java @@ -0,0 +1,107 @@ +package io.fd.honeycomb.lisp.translate.read; + + +import static io.fd.honeycomb.lisp.translate.read.dump.executor.params.SubtableDumpParams.MapLevel.L3; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; + +import io.fd.honeycomb.lisp.translate.read.trait.SubtableReaderTestCase; +import io.fd.honeycomb.translate.read.ReadFailedException; +import io.fd.honeycomb.translate.spi.read.ReaderCustomizer; +import io.fd.honeycomb.translate.util.read.cache.exceptions.execution.i.DumpCallFailedException; +import io.fd.vpp.jvpp.VppCallbackException; +import org.junit.Before; +import org.junit.Test; +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.VniTableBuilder; +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.VrfSubtable; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.VrfSubtableBuilder; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class VrfSubtableCustomizerTest extends SubtableReaderTestCase<VrfSubtable, VrfSubtableBuilder> { + + private InstanceIdentifier<VrfSubtable> validId; + + public VrfSubtableCustomizerTest() { + super(VrfSubtable.class, VrfSubtableBuilder.class); + } + + @Before + public void init() { + validId = InstanceIdentifier.create(EidTable.class).child(VniTable.class, new VniTableKey(expectedVni)) + .child(VrfSubtable.class); + } + + @Test + public void testReadCurrentSuccessfull() throws ReadFailedException { + doReturnValidNonEmptyDataOnDump(); + VrfSubtableBuilder builder = new VrfSubtableBuilder(); + customizer.readCurrentAttributes(validId, builder, ctx); + + verifyLispEidTableMapDumpCalled(L3); + + final VrfSubtable subtable = builder.build(); + assertNotNull(subtable); + assertEquals(expectedTableId, subtable.getTableId().longValue()); + } + + @Test + public void testReadCurrentEmptyDump() throws ReadFailedException { + doReturnEmptyDataOnDump(); + VrfSubtableBuilder builder = new VrfSubtableBuilder(); + customizer.readCurrentAttributes(validId, builder, ctx); + + verifyLispEidTableMapDumpCalled(L3); + + final VrfSubtable subtable = builder.build(); + assertNotNull(subtable); + assertNull(subtable.getTableId()); + } + + @Test + public void testReadCurrentFailed() { + doThrowOnDump(); + VrfSubtableBuilder builder = new VrfSubtableBuilder(); + try { + customizer.readCurrentAttributes(validId, builder, ctx); + } catch (ReadFailedException e) { + assertTrue(e.getCause() instanceof DumpCallFailedException); + assertTrue(e.getCause().getCause() instanceof VppCallbackException); + assertTrue(builder.getTableId() == null); + verifyLispEidTableMapDumpNotCalled(); + + return; + } + + fail("Test should throw ReadFailedException"); + } + + @Override + protected ReaderCustomizer<VrfSubtable, VrfSubtableBuilder> initCustomizer() { + return new VrfSubtableCustomizer(api); + } + + @Test + public void testGetBuilder() { + final VrfSubtableBuilder builder = customizer.getBuilder(validId); + + assertNotNull(builder); + assertNull(builder.getLocalMappings()); + assertNull(builder.getRemoteMappings()); + assertNull(builder.getTableId()); + } + + @Test + public void testMerge() { + VniTableBuilder parentBuilder = new VniTableBuilder(); + VrfSubtable subtable = new VrfSubtableBuilder().build(); + + customizer.merge(parentBuilder, subtable); + assertEquals(subtable, parentBuilder.getVrfSubtable()); + } +} diff --git a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/dump/executor/VniTableDumpExecutorTest.java b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/dump/executor/VniTableDumpExecutorTest.java index 3bc95d52b..b955609c5 100644 --- a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/dump/executor/VniTableDumpExecutorTest.java +++ b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/dump/executor/VniTableDumpExecutorTest.java @@ -12,6 +12,8 @@ import io.fd.honeycomb.translate.util.read.cache.exceptions.execution.DumpExecut import io.fd.honeycomb.translate.util.read.cache.exceptions.execution.i.DumpCallFailedException; import io.fd.honeycomb.translate.util.read.cache.exceptions.execution.i.DumpTimeoutException; import io.fd.honeycomb.vpp.test.read.JvppDumpExecutorTest; +import io.fd.vpp.jvpp.core.dto.LispEidTableVniDetails; +import io.fd.vpp.jvpp.core.dto.LispEidTableVniDetailsReplyDump; import java.util.concurrent.TimeoutException; import org.junit.Before; import org.junit.Test; @@ -22,28 +24,27 @@ import io.fd.vpp.jvpp.core.dto.LispEidTableMapDetailsReplyDump; public class VniTableDumpExecutorTest extends JvppDumpExecutorTest<VniTableDumpExecutor> { - private LispEidTableMapDetailsReplyDump validDump; + private LispEidTableVniDetailsReplyDump validDump; @Before public void init() { - validDump = new LispEidTableMapDetailsReplyDump(); - LispEidTableMapDetails detail = new LispEidTableMapDetails(); - detail.dpTable = 1; + validDump = new LispEidTableVniDetailsReplyDump(); + LispEidTableVniDetails detail = new LispEidTableVniDetails(); detail.vni = 2; detail.context = 4; - validDump.lispEidTableMapDetails = ImmutableList.of(detail); + validDump.lispEidTableVniDetails = ImmutableList.of(detail); } @Test(expected = DumpCallFailedException.class) public void testExecuteDumpFail() throws DumpExecutionFailedException { - doThrowFailExceptionWhen().lispEidTableMapDump(Mockito.any()); + doThrowFailExceptionWhen().lispEidTableVniDump(Mockito.any()); getExecutor().executeDump(EntityDumpExecutor.NO_PARAMS); } @Test public void testExecuteDumpTimeout() throws Exception { - doThrowTimeoutExceptionWhen().lispEidTableMapDump(Mockito.any()); + doThrowTimeoutExceptionWhen().lispEidTableVniDump(Mockito.any()); try { getExecutor().executeDump(EntityDumpExecutor.NO_PARAMS); } catch (Exception e) { @@ -57,15 +58,14 @@ public class VniTableDumpExecutorTest extends JvppDumpExecutorTest<VniTableDumpE @Test public void testExecuteDump() throws DumpExecutionFailedException { - doReturnResponseWhen(validDump).lispEidTableMapDump(Mockito.any()); - final LispEidTableMapDetailsReplyDump reply = getExecutor().executeDump(EntityDumpExecutor.NO_PARAMS); + doReturnResponseWhen(validDump).lispEidTableVniDump(Mockito.any()); + final LispEidTableVniDetailsReplyDump reply = getExecutor().executeDump(EntityDumpExecutor.NO_PARAMS); assertNotNull(reply); - assertEquals(1, reply.lispEidTableMapDetails.size()); - final LispEidTableMapDetails detail = reply.lispEidTableMapDetails.get(0); + assertEquals(1, reply.lispEidTableVniDetails.size()); + final LispEidTableVniDetails detail = reply.lispEidTableVniDetails.get(0); assertEquals(4, detail.context); - assertEquals(1, detail.dpTable); assertEquals(2, detail.vni); } diff --git a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/trait/MappingFilterProviderTest.java b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/trait/MappingFilterProviderTest.java new file mode 100644 index 000000000..6a7c3b7e7 --- /dev/null +++ b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/trait/MappingFilterProviderTest.java @@ -0,0 +1,79 @@ +package io.fd.honeycomb.lisp.translate.read.trait; + + +import static org.junit.Assert.assertEquals; + +import org.junit.Before; +import org.junit.Test; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.dp.subtable.grouping.LocalMappings; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.dp.subtable.grouping.RemoteMappings; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.dp.subtable.grouping.local.mappings.LocalMapping; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.dp.subtable.grouping.remote.mappings.RemoteMapping; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.BridgeDomainSubtable; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.VrfSubtable; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class MappingFilterProviderTest implements MappingFilterProvider { + + private InstanceIdentifier<LocalMapping> validVrfLocal; + private InstanceIdentifier<LocalMapping> validBdLocal; + private InstanceIdentifier<LocalMapping> invalidLocal; + + private InstanceIdentifier<RemoteMapping> validVrfRemote; + private InstanceIdentifier<RemoteMapping> validBdRemote; + private InstanceIdentifier<RemoteMapping> invalidRemote; + + + @Before + public void init() { + validVrfLocal = InstanceIdentifier.create(VrfSubtable.class) + .child(LocalMappings.class) + .child(LocalMapping.class); + + validBdLocal = InstanceIdentifier.create(BridgeDomainSubtable.class) + .child(LocalMappings.class) + .child(LocalMapping.class); + + invalidLocal = InstanceIdentifier.create(LocalMapping.class); + + validVrfRemote = InstanceIdentifier.create(VrfSubtable.class) + .child(RemoteMappings.class) + .child(RemoteMapping.class); + + validBdRemote = InstanceIdentifier.create(BridgeDomainSubtable.class) + .child(RemoteMappings.class) + .child(RemoteMapping.class); + + invalidRemote = InstanceIdentifier.create(RemoteMapping.class); + } + + @Test + public void testVrfLocalValid() { + assertEquals(VRF_MAPPINGS_ONLY, subtableFilterForLocalMappings(validVrfLocal)); + } + + @Test + public void testBridgeDomainLocalValid() { + assertEquals(BRIDGE_DOMAIN_MAPPINGS_ONLY, subtableFilterForLocalMappings(validBdLocal)); + } + + @Test(expected = IllegalArgumentException.class) + public void testLocalInvalid() { + subtableFilterForLocalMappings(invalidLocal); + } + + @Test + public void testVrfRemoteValid() { + assertEquals(VRF_MAPPINGS_ONLY, subtableFilterForRemoteMappings(validVrfRemote)); + } + + @Test + public void testBridgeDomainRemoteValid() { + assertEquals(BRIDGE_DOMAIN_MAPPINGS_ONLY, subtableFilterForRemoteMappings(validBdRemote)); + } + + @Test(expected = IllegalArgumentException.class) + public void testRemoteInvalid() { + subtableFilterForRemoteMappings(invalidRemote); + } +}
\ No newline at end of file diff --git a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/trait/MappingProducerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/trait/MappingProducerTest.java new file mode 100644 index 000000000..89eab3c5e --- /dev/null +++ b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/trait/MappingProducerTest.java @@ -0,0 +1,170 @@ +package io.fd.honeycomb.lisp.translate.read.trait; + + +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; + +import io.fd.honeycomb.translate.write.WriteFailedException; +import org.junit.Before; +import org.junit.Test; +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.Ipv6Afi; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.MacAfi; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.dp.subtable.grouping.LocalMappings; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.dp.subtable.grouping.RemoteMappings; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.dp.subtable.grouping.local.mappings.LocalMapping; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.dp.subtable.grouping.local.mappings.LocalMappingBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.dp.subtable.grouping.local.mappings.local.mapping.EidBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.dp.subtable.grouping.remote.mappings.RemoteMapping; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.dp.subtable.grouping.remote.mappings.RemoteMappingBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.BridgeDomainSubtable; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.eid.table.grouping.eid.table.vni.table.VrfSubtable; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class MappingProducerTest implements MappingProducer { + + private InstanceIdentifier<LocalMapping> validVrfLocalMappingId; + private InstanceIdentifier<LocalMapping> validBridgeDomainLocalMappingId; + private InstanceIdentifier<RemoteMapping> validVrfRemoteMappingId; + private InstanceIdentifier<RemoteMapping> validBridgeDomainRemoteMappingId; + + private LocalMapping ipv4LocalMapping; + private LocalMapping ipv6LocalMapping; + private LocalMapping macLocalMapping; + + private RemoteMapping ipv4RemoteMapping; + private RemoteMapping ipv6RemoteMapping; + private RemoteMapping macRemoteMapping; + + @Before + public void init() { + validVrfLocalMappingId = InstanceIdentifier.create(VrfSubtable.class) + .child(LocalMappings.class) + .child(LocalMapping.class); + + validBridgeDomainLocalMappingId = InstanceIdentifier.create(BridgeDomainSubtable.class) + .child(LocalMappings.class) + .child(LocalMapping.class); + + validVrfRemoteMappingId = InstanceIdentifier.create(VrfSubtable.class) + .child(RemoteMappings.class) + .child(RemoteMapping.class); + + validBridgeDomainRemoteMappingId = InstanceIdentifier.create(BridgeDomainSubtable.class) + .child(RemoteMappings.class) + .child(RemoteMapping.class); + + ipv4LocalMapping = new LocalMappingBuilder() + .setEid(new EidBuilder() + .setAddressType(Ipv4Afi.class) + .build()).build(); + + ipv6LocalMapping = new LocalMappingBuilder() + .setEid(new EidBuilder() + .setAddressType(Ipv6Afi.class) + .build()).build(); + macLocalMapping = new LocalMappingBuilder() + .setEid(new EidBuilder() + .setAddressType(MacAfi.class) + .build()).build(); + + ipv4RemoteMapping = new RemoteMappingBuilder() + .setEid(new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.dp.subtable.grouping.remote.mappings.remote.mapping.EidBuilder() + .setAddressType(Ipv4Afi.class).build()).build(); + + ipv6RemoteMapping = new RemoteMappingBuilder() + .setEid(new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.dp.subtable.grouping.remote.mappings.remote.mapping.EidBuilder() + .setAddressType(Ipv6Afi.class).build()).build(); + + macRemoteMapping = new RemoteMappingBuilder() + .setEid(new org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev160520.dp.subtable.grouping.remote.mappings.remote.mapping.EidBuilder() + .setAddressType(MacAfi.class).build()).build(); + } + + @Test + public void testValidVrfLocal() { + testPositiveCase(validVrfLocalMappingId, ipv4LocalMapping); + testPositiveCase(validVrfLocalMappingId, ipv6LocalMapping); + } + + @Test + public void testValidBridgeDomainLocal() { + testPositiveCase(validBridgeDomainLocalMappingId, macLocalMapping); + } + + @Test + public void testInvalidVrfLocal() { + testNegativeCase(validVrfLocalMappingId, macLocalMapping); + } + + @Test + public void testInvalidBridgeDomainLocal() { + testNegativeCase(validBridgeDomainLocalMappingId, ipv4LocalMapping); + testNegativeCase(validBridgeDomainLocalMappingId, ipv6LocalMapping); + } + + + @Test + public void testValidVrfRemote() { + testPositiveCase(validVrfRemoteMappingId, ipv4RemoteMapping); + testPositiveCase(validVrfRemoteMappingId, ipv6RemoteMapping); + } + + @Test + public void testValidBridgeDomainRemote() { + testPositiveCase(validBridgeDomainRemoteMappingId, macRemoteMapping); + } + + @Test + public void testInvalidVrfRemote() { + testNegativeCase(validVrfRemoteMappingId, macRemoteMapping); + } + + @Test + public void testInvalidBridgeDomainRemote() { + testNegativeCase(validBridgeDomainRemoteMappingId, ipv4RemoteMapping); + testNegativeCase(validBridgeDomainRemoteMappingId, ipv6RemoteMapping); + } + + private void testNegativeCase(final InstanceIdentifier<LocalMapping> identifier, final LocalMapping data) { + try { + checkAllowedCombination(identifier, data); + } catch (WriteFailedException e) { + assertTrue(e instanceof WriteFailedException.CreateFailedException); + assertTrue(e.getCause() instanceof IllegalArgumentException); + return; + } + + fail("Test should have failed"); + } + + + private void testPositiveCase(final InstanceIdentifier<LocalMapping> identifier, final LocalMapping data) { + try { + checkAllowedCombination(identifier, data); + } catch (WriteFailedException e) { + fail("Test should have passed"); + } + } + + private void testNegativeCase(final InstanceIdentifier<RemoteMapping> identifier, final RemoteMapping data) { + try { + checkAllowedCombination(identifier, data); + } catch (WriteFailedException e) { + assertTrue(e instanceof WriteFailedException.CreateFailedException); + assertTrue(e.getCause() instanceof IllegalArgumentException); + return; + } + + fail("Test should have failed"); + } + + + private void testPositiveCase(final InstanceIdentifier<RemoteMapping> identifier, final RemoteMapping data) { + try { + checkAllowedCombination(identifier, data); + } catch (WriteFailedException e) { + fail("Test should have passed"); + } + } +} diff --git a/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/trait/SubtableReaderTestCase.java b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/trait/SubtableReaderTestCase.java new file mode 100644 index 000000000..f40d72951 --- /dev/null +++ b/lisp/lisp2vpp/src/test/java/io/fd/honeycomb/lisp/translate/read/trait/SubtableReaderTestCase.java @@ -0,0 +1,81 @@ +package io.fd.honeycomb.lisp.translate.read.trait; + + +import static io.fd.honeycomb.lisp.translate.read.dump.executor.params.SubtableDumpParams.MapLevel; +import static org.junit.Assert.assertEquals; +import static org.mockito.Matchers.any; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import static org.mockito.MockitoAnnotations.initMocks; + +import com.google.common.collect.ImmutableList; +import io.fd.honeycomb.vpp.test.read.ReaderCustomizerTest; +import io.fd.vpp.jvpp.VppCallbackException; +import io.fd.vpp.jvpp.core.dto.LispEidTableMapDetails; +import io.fd.vpp.jvpp.core.dto.LispEidTableMapDetailsReplyDump; +import io.fd.vpp.jvpp.core.dto.LispEidTableMapDump; +import java.util.Collections; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; +import javax.annotation.Nonnull; +import org.junit.Before; +import org.mockito.ArgumentCaptor; +import org.mockito.Captor; +import org.opendaylight.yangtools.concepts.Builder; +import org.opendaylight.yangtools.yang.binding.DataObject; + +public abstract class SubtableReaderTestCase<D extends DataObject, B extends Builder<D>> + extends ReaderCustomizerTest<D, B> + implements SubtableReader { + + protected final long expectedVni = 12; + protected final int expectedTableId = 14; + + @Captor + protected ArgumentCaptor<LispEidTableMapDump> requestCaptor; + + public SubtableReaderTestCase(final Class<D> dataObjectClass, + final Class<? extends Builder<? extends DataObject>> parentBuilderClass) { + super(dataObjectClass, parentBuilderClass); + } + + protected void doReturnValidNonEmptyDataOnDump() { + LispEidTableMapDetailsReplyDump reply = new LispEidTableMapDetailsReplyDump(); + LispEidTableMapDetails detailFirst = new LispEidTableMapDetails(); + detailFirst.vni = Long.valueOf(expectedVni).intValue(); + detailFirst.dpTable = expectedTableId; + + LispEidTableMapDetails detailSecond = new LispEidTableMapDetails(); + detailSecond.vni = 13; + detailSecond.dpTable = 15; + + reply.lispEidTableMapDetails = ImmutableList.of(detailFirst, detailSecond); + + when(api.lispEidTableMapDump(any(LispEidTableMapDump.class))) + .thenReturn(future(reply)); + } + + protected void doReturnEmptyDataOnDump() { + LispEidTableMapDetailsReplyDump reply = new LispEidTableMapDetailsReplyDump(); + reply.lispEidTableMapDetails = Collections.emptyList(); + when(api.lispEidTableMapDump(any(LispEidTableMapDump.class))) + .thenReturn(future(reply)); + } + + protected void doThrowOnDump() { + when(api.lispEidTableMapDump(any(LispEidTableMapDump.class))) + .thenReturn(failedFuture()); + } + + protected void verifyLispEidTableMapDumpCalled(@Nonnull final MapLevel expectedLevel) { + verify(api, times(1)).lispEidTableMapDump(requestCaptor.capture()); + assertEquals(expectedLevel.getValue(), requestCaptor.getValue().isL2); + } + + protected void verifyLispEidTableMapDumpNotCalled() { + verify(api, times(1)).lispEidTableMapDump(any()); + } +} |