From 7ca39aa6d228dc552097857afc697ddf52bd3ad3 Mon Sep 17 00:00:00 2001 From: Jan Srnicek Date: Wed, 24 May 2017 08:45:19 +0200 Subject: HC2VPP-147 - Gpe entry implementation Change-Id: Ie7887c8e8f10678410ad677c425bfed1690bf440 Signed-off-by: Jan Srnicek --- .../translate/read/GpeFeatureCustomizerTest.java | 67 +++ .../read/GpeForwardEntryCustomizerTest.java | 520 +++++++++++++++++++++ .../translate/write/GpeFeatureCustomizerTest.java | 80 ++++ .../write/GpeForwardEntryCustomizerTest.java | 313 +++++++++++++ 4 files changed, 980 insertions(+) create mode 100644 lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/gpe/translate/read/GpeFeatureCustomizerTest.java create mode 100644 lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/gpe/translate/read/GpeForwardEntryCustomizerTest.java create mode 100644 lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/gpe/translate/write/GpeFeatureCustomizerTest.java create mode 100644 lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/gpe/translate/write/GpeForwardEntryCustomizerTest.java (limited to 'lisp/lisp2vpp/src/test/java/io') diff --git a/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/gpe/translate/read/GpeFeatureCustomizerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/gpe/translate/read/GpeFeatureCustomizerTest.java new file mode 100644 index 000000000..965906abd --- /dev/null +++ b/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/gpe/translate/read/GpeFeatureCustomizerTest.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.gpe.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.read.ReadFailedException; +import io.fd.vpp.jvpp.core.dto.ShowLispStatusReply; +import org.junit.Test; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.gpe.rev170518.Gpe; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.gpe.rev170518.GpeState; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.gpe.rev170518.GpeStateBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.gpe.rev170518.gpe.feature.data.grouping.GpeFeatureData; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.gpe.rev170518.gpe.feature.data.grouping.GpeFeatureDataBuilder; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class GpeFeatureCustomizerTest extends InitializingReaderCustomizerTest { + public GpeFeatureCustomizerTest() { + super(GpeFeatureData.class, GpeStateBuilder.class); + } + + @Override + protected GpeFeatureCustomizer initCustomizer() { + return new GpeFeatureCustomizer(api); + } + + @Test + public void testReadCurrent() throws ReadFailedException { + final ShowLispStatusReply result = new ShowLispStatusReply(); + result.gpeStatus = 1; + when(api.showLispStatus(any())).thenReturn(future(result)); + + final GpeFeatureDataBuilder builder = new GpeFeatureDataBuilder(); + getCustomizer().readCurrentAttributes(InstanceIdentifier.create(GpeFeatureData.class), builder, ctx); + assertTrue(builder.isEnable()); + } + + @Test + public void testInit() { + final InstanceIdentifier CONFIG_ID = + InstanceIdentifier.create(Gpe.class).child(GpeFeatureData.class); + + final InstanceIdentifier STATE_ID = + InstanceIdentifier.create(GpeState.class).child(GpeFeatureData.class); + + final GpeFeatureData data = new GpeFeatureDataBuilder().build(); + invokeInitTest(STATE_ID, data, CONFIG_ID, data); + } +} diff --git a/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/gpe/translate/read/GpeForwardEntryCustomizerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/gpe/translate/read/GpeForwardEntryCustomizerTest.java new file mode 100644 index 000000000..9e1958224 --- /dev/null +++ b/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/gpe/translate/read/GpeForwardEntryCustomizerTest.java @@ -0,0 +1,520 @@ +/* + * 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.gpe.translate.read; + + +import static org.junit.Assert.assertEquals; +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.InitializingListReaderCustomizerTest; +import io.fd.hc2vpp.common.translate.util.AddressTranslator; +import io.fd.hc2vpp.lisp.gpe.translate.ctx.GpeEntryIdentifier; +import io.fd.hc2vpp.lisp.gpe.translate.ctx.GpeEntryMappingContext; +import io.fd.hc2vpp.lisp.gpe.translate.ctx.GpeLocatorPair; +import io.fd.hc2vpp.lisp.gpe.translate.ctx.GpeLocatorPairMappingContext; +import io.fd.hc2vpp.lisp.gpe.translate.service.GpeStateCheckService; +import io.fd.hc2vpp.lisp.translate.read.dump.executor.params.MappingsDumpParams.EidType; +import io.fd.hc2vpp.lisp.translate.util.EidTranslator; +import io.fd.honeycomb.translate.read.ReadFailedException; +import io.fd.vpp.jvpp.core.dto.GpeFwdEntriesGet; +import io.fd.vpp.jvpp.core.dto.GpeFwdEntriesGetReply; +import io.fd.vpp.jvpp.core.dto.GpeFwdEntryPathDetails; +import io.fd.vpp.jvpp.core.dto.GpeFwdEntryPathDetailsReplyDump; +import io.fd.vpp.jvpp.core.dto.GpeFwdEntryPathDump; +import io.fd.vpp.jvpp.core.dto.GpeFwdEntryVnisGetReply; +import io.fd.vpp.jvpp.core.types.GpeFwdEntry; +import io.fd.vpp.jvpp.core.types.GpeLocator; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import org.junit.Test; +import org.mockito.Mock; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.gpe.entry.identification.context.rev170517.gpe.entry.identification.context.attributes.gpe.entry.identification.contexts.gpe.entry.identification.mappings.mapping.GpeEntryIdentificator; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.gpe.entry.identification.context.rev170517.gpe.entry.identification.context.attributes.gpe.entry.identification.contexts.gpe.entry.identification.mappings.mapping.GpeEntryIdentificatorBuilder; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.gpe.entry.identification.context.rev170517.gpe.entry.identification.context.attributes.gpe.entry.identification.contexts.gpe.entry.identification.mappings.mapping.gpe.entry.identificator.LocalEidBuilder; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.gpe.entry.identification.context.rev170517.gpe.entry.identification.context.attributes.gpe.entry.identification.contexts.gpe.entry.identification.mappings.mapping.gpe.entry.identificator.RemoteEidBuilder; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.gpe.locator.pair.identification.context.rev170517.gpe.locator.pair.identification.context.attributes.gpe.locator.pair.identification.contexts.gpe.locator.pair.identification.mappings.mapping.LocatorPairMapping; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.gpe.locator.pair.identification.context.rev170517.gpe.locator.pair.identification.context.attributes.gpe.locator.pair.identification.contexts.gpe.locator.pair.identification.mappings.mapping.LocatorPairMappingBuilder; +import org.opendaylight.yang.gen.v1.urn.honeycomb.params.xml.ns.yang.gpe.locator.pair.identification.context.rev170517.gpe.locator.pair.identification.context.attributes.gpe.locator.pair.identification.contexts.gpe.locator.pair.identification.mappings.mapping.locator.pair.mapping.PairBuilder; +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.Ipv4Prefix; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6AddressNoZone; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Prefix; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.Ipv4PrefixAfi; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.Ipv6PrefixAfi; +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.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv4PrefixBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv6PrefixBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.MacBuilder; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.gpe.rev170518.Gpe; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.gpe.rev170518.GpeState; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.gpe.rev170518.gpe.entry.table.grouping.GpeEntryTable; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.gpe.rev170518.gpe.entry.table.grouping.GpeEntryTableBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.gpe.rev170518.gpe.entry.table.grouping.gpe.entry.table.GpeEntry; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.gpe.rev170518.gpe.entry.table.grouping.gpe.entry.table.GpeEntryBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.gpe.rev170518.gpe.entry.table.grouping.gpe.entry.table.GpeEntryKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.gpe.rev170518.gpe.entry.table.grouping.gpe.entry.table.gpe.entry.LocatorPairs; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.gpe.rev170518.gpe.feature.data.grouping.GpeFeatureData; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.gpe.rev170518.locator.pair.LocatorPair; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.MapReplyAction; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.dp.subtable.grouping.local.mappings.local.mapping.Eid; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier; + +public class GpeForwardEntryCustomizerTest + extends InitializingListReaderCustomizerTest + implements AddressTranslator, EidTranslator { + + private static final String V4_ENTRY_ID = "v4-entry"; + private static final String V4_ENTRY_LOCATOR = "v4-entry-locator"; + private static final int V4_ENTRY_DP_TABLE = 10; + private static final int V4_ENTRY_FWD_INDEX = 4; + private static final int V4_ENTRY_VNI = 45; + private static final KeyedInstanceIdentifier V4_IDENTIFIER = + InstanceIdentifier.create(GpeEntryTable.class) + .child(GpeEntry.class, new GpeEntryKey(V4_ENTRY_ID)); + private static final Ipv4Prefix + V4_ENTRY_LOCAL_ADDRESS = new Ipv4Prefix("192.168.2.0/24"); + private static final Ipv4Prefix + V4_ENTRY_REMOTE_ADDRESS = new Ipv4Prefix("192.168.3.0/24"); + private static final Ipv4AddressNoZone + V4_LOCATOR_LOCAL_ADDRESS = new Ipv4AddressNoZone("192.168.5.4"); + private static final Ipv4AddressNoZone + V4_LOCATOR_REMOTE_ADDRESS = new Ipv4AddressNoZone("192.168.7.4"); + + + private static final String V6_ENTRY_ID = "v6-entry"; + private static final String V6_ENTRY_LOCATOR = "v6-entry-locator"; + private static final int V6_ENTRY_DP_TABLE = 11; + private static final int V6_ENTRY_VNI = 22; + private static final int V6_ENTRY_FWD_INDEX = 5; + private static final Ipv6Prefix + V6_ENTRY_LOCAL_ADDRESS = new Ipv6Prefix("2001:0db8:85a3:0000:0000:8a2e:0370:7334/64"); + private static final Ipv6Prefix + V6_ENTRY_REMOTE_ADDRESS = new Ipv6Prefix("2001:0db8:85a7:0000:0000:8a2e:0370:7334/64"); + private static final KeyedInstanceIdentifier V6_IDENTIFIER = + InstanceIdentifier.create(GpeEntryTable.class) + .child(GpeEntry.class, new GpeEntryKey(V6_ENTRY_ID)); + private static final Ipv6AddressNoZone + V6_LOCATOR_LOCAL_ADDRESS = new Ipv6AddressNoZone("2001:db8:85a3::8a2e:370:7334"); + private static final Ipv6AddressNoZone + V6_LOCATOR_REMOTE_ADDRESS = new Ipv6AddressNoZone("2001:db8:85a3::8a2e:222:7334"); + + private static final String MAC_ENTRY_ID = "mac-entry"; + private static final int MAC_ENTRY_FWD_INDEX = 7; + private static final int MAC_ENTRY_VNI = 18; + private static final String MAC_ENTRY_LOCATOR = "mac-entry-locator"; + private static final int MAC_ENTRY_DP_TABLE = 12; + private static final KeyedInstanceIdentifier MAC_IDENTIFIER = + InstanceIdentifier.create(GpeEntryTable.class) + .child(GpeEntry.class, new GpeEntryKey(MAC_ENTRY_ID)); + private static final String MAC_ENTRY_LOCAL_ADDRESS_VALUE = "aa:bb:cc:dd:ee:ff"; + private static final String MAC_ENTRY_REMOTE_ADDRESS_VALUE = "bb:cc:bb:cc:bb:cc"; + + private static final Ipv4AddressNoZone + MAC_LOCATOR_LOCAL_ADDRESS = new Ipv4AddressNoZone("192.168.7.4"); + private static final Ipv4AddressNoZone + MAC_LOCATOR_REMOTE_ADDRESS = new Ipv4AddressNoZone("192.168.2.4"); + public static final int V6_LOCATOR_LOCAL_WEIGHT = 3; + public static final int MAC_LOCATOR_LOCAL_WEIGHT = 7; + public static final int V4_LOCATOR_LOCAL_WEIGHT = 2; + + + @Mock + private GpeEntryMappingContext gpeEntryMappingContext; + + @Mock + private GpeLocatorPairMappingContext gpeLocatorPairMappingContext; + + @Mock + private GpeStateCheckService gpeStateCheckService; + + public GpeForwardEntryCustomizerTest() { + super(GpeEntry.class, GpeEntryTableBuilder.class); + } + + @Override + protected GpeForwardEntryCustomizer initCustomizer() { + return new GpeForwardEntryCustomizer(api, gpeStateCheckService, gpeEntryMappingContext, + gpeLocatorPairMappingContext); + } + + @Override + protected void setUp() throws Exception { + when(gpeStateCheckService.isGpeEnabled(ctx)).thenReturn(true); + when(api.gpeFwdEntriesGet(entryRequest(V4_ENTRY_VNI))) + .thenReturn(future(getGpeEntryDumpReply(getV4GpeEntry()))); + when(api.gpeFwdEntriesGet(entryRequest(V6_ENTRY_VNI))) + .thenReturn(future(getGpeEntryDumpReply(getV6GpeEntry()))); + when(api.gpeFwdEntriesGet(entryRequest(MAC_ENTRY_VNI))) + .thenReturn(future(getGpeEntryDumpReply(getMacGpeEntry()))); + when(api.gpeFwdEntryVnisGet(any())).thenReturn(future(activeVnisDump())); + mockMappingsForGpeEntries(); + mockMappingsForLocators(); + } + + @Test + public void testGetAll() throws ReadFailedException { + final List allIds = getCustomizer().getAllIds(V4_IDENTIFIER, ctx); + + assertTrue(allIds.containsAll(Arrays.asList(new GpeEntryKey(V4_ENTRY_ID), + new GpeEntryKey(V6_ENTRY_ID), + new GpeEntryKey(MAC_ENTRY_ID)))); + } + + @Test + public void testReadCurrentV4Entry() throws ReadFailedException { + mockLocatorDump(); + final GpeEntryBuilder builder = new GpeEntryBuilder(); + getCustomizer().readCurrentAttributes(V4_IDENTIFIER, builder, ctx); + + assertEquals(V4_ENTRY_ID, builder.getId()); + assertEquals(10, builder.getDpTable().intValue()); + assertTrue(compareAddresses(new Ipv4PrefixBuilder() + .setIpv4Prefix(V4_ENTRY_LOCAL_ADDRESS) + .build(), builder.getLocalEid().getAddress())); + assertEquals(Ipv4PrefixAfi.class, builder.getLocalEid().getAddressType()); + assertEquals(V4_ENTRY_VNI, builder.getLocalEid().getVirtualNetworkId().getValue().intValue()); + assertTrue(compareAddresses(new Ipv4PrefixBuilder() + .setIpv4Prefix(V4_ENTRY_REMOTE_ADDRESS) + .build(), builder.getRemoteEid().getAddress())); + assertEquals(Ipv4PrefixAfi.class, builder.getRemoteEid().getAddressType()); + assertEquals(V4_ENTRY_VNI, builder.getRemoteEid().getVirtualNetworkId().getValue().intValue()); + assertTrue(V4_ENTRY_VNI == builder.getVni()); + assertEquals(1, builder.getLocatorPairs().size()); + + final LocatorPairs locatorPair = builder.getLocatorPairs().get(0); + assertEquals(V4_ENTRY_LOCATOR, locatorPair.getId()); + + final LocatorPair pair = locatorPair.getLocatorPair(); + assertEquals(V4_LOCATOR_LOCAL_ADDRESS, pair.getLocalLocator().getIpv4Address()); + assertEquals(V4_LOCATOR_REMOTE_ADDRESS, pair.getRemoteLocator().getIpv4Address()); + assertEquals(V4_LOCATOR_LOCAL_WEIGHT, pair.getWeight().byteValue()); + } + + @Test + public void testReadCurrentV6Entry() throws ReadFailedException { + mockLocatorDump(); + final GpeEntryBuilder builder = new GpeEntryBuilder(); + getCustomizer().readCurrentAttributes(V6_IDENTIFIER, builder, ctx); + + assertEquals(V6_ENTRY_ID, builder.getId()); + assertEquals(V6_ENTRY_DP_TABLE, builder.getDpTable().intValue()); + assertTrue(compareAddresses(new Ipv6PrefixBuilder() + .setIpv6Prefix(V6_ENTRY_LOCAL_ADDRESS) + .build(), builder.getLocalEid().getAddress())); + assertEquals(Ipv6PrefixAfi.class, builder.getLocalEid().getAddressType()); + assertEquals(V6_ENTRY_VNI, builder.getLocalEid().getVirtualNetworkId().getValue().intValue()); + assertTrue(compareAddresses(new Ipv6PrefixBuilder() + .setIpv6Prefix(V6_ENTRY_REMOTE_ADDRESS) + .build(), builder.getRemoteEid().getAddress())); + assertEquals(Ipv6PrefixAfi.class, builder.getRemoteEid().getAddressType()); + assertEquals(V6_ENTRY_VNI, builder.getRemoteEid().getVirtualNetworkId().getValue().intValue()); + assertTrue(V6_ENTRY_VNI == builder.getVni()); + + assertEquals(1, builder.getLocatorPairs().size()); + + final LocatorPairs locatorPair = builder.getLocatorPairs().get(0); + assertEquals(V6_ENTRY_LOCATOR, locatorPair.getId()); + + final LocatorPair pair = locatorPair.getLocatorPair(); + assertEquals(V6_LOCATOR_LOCAL_ADDRESS, pair.getLocalLocator().getIpv6Address()); + assertEquals(V6_LOCATOR_REMOTE_ADDRESS, pair.getRemoteLocator().getIpv6Address()); + assertEquals(V6_LOCATOR_LOCAL_WEIGHT, pair.getWeight().byteValue()); + } + + @Test + public void testReadCurrentMacEntry() throws ReadFailedException { + mockLocatorDump(); + final GpeEntryBuilder builder = new GpeEntryBuilder(); + getCustomizer().readCurrentAttributes(MAC_IDENTIFIER, builder, ctx); + + assertEquals(MAC_ENTRY_ID, builder.getId()); + assertEquals(MAC_ENTRY_DP_TABLE, builder.getDpTable().intValue()); + assertTrue(compareAddresses(new MacBuilder() + .setMac(new MacAddress(MAC_ENTRY_LOCAL_ADDRESS_VALUE)) + .build(), builder.getLocalEid().getAddress())); + assertEquals(MAC_ENTRY_VNI, builder.getLocalEid().getVirtualNetworkId().getValue().intValue()); + assertEquals(MacAfi.class, builder.getLocalEid().getAddressType()); + assertTrue(compareAddresses(new MacBuilder() + .setMac(new MacAddress(MAC_ENTRY_REMOTE_ADDRESS_VALUE)) + .build(), builder.getRemoteEid().getAddress())); + assertEquals(MacAfi.class, builder.getRemoteEid().getAddressType()); + assertEquals(MAC_ENTRY_VNI, builder.getRemoteEid().getVirtualNetworkId().getValue().intValue()); + assertTrue(MAC_ENTRY_VNI == builder.getVni()); + + assertEquals(1, builder.getLocatorPairs().size()); + + final LocatorPairs locatorPair = builder.getLocatorPairs().get(0); + assertEquals(MAC_ENTRY_LOCATOR, locatorPair.getId()); + + final LocatorPair pair = locatorPair.getLocatorPair(); + assertEquals(MAC_LOCATOR_LOCAL_ADDRESS, pair.getLocalLocator().getIpv4Address()); + assertEquals(MAC_LOCATOR_REMOTE_ADDRESS, pair.getRemoteLocator().getIpv4Address()); + assertEquals(MAC_LOCATOR_LOCAL_WEIGHT, pair.getWeight().byteValue()); + } + + @Test + public void testReadCurrentNegativeMapping() throws ReadFailedException { + when(api.gpeFwdEntryPathDump(any())).thenReturn(future(new GpeFwdEntryPathDetailsReplyDump())); + final GpeEntryBuilder builder = new GpeEntryBuilder(); + getCustomizer().readCurrentAttributes(V4_IDENTIFIER, builder, ctx); + + assertEquals(V4_ENTRY_ID, builder.getId()); + assertEquals(V4_ENTRY_DP_TABLE, builder.getDpTable().intValue()); + assertTrue(compareAddresses(new Ipv4PrefixBuilder() + .setIpv4Prefix(V4_ENTRY_LOCAL_ADDRESS) + .build(), builder.getLocalEid().getAddress())); + assertEquals(Ipv4PrefixAfi.class, builder.getLocalEid().getAddressType()); + assertTrue(compareAddresses(new Ipv4PrefixBuilder() + .setIpv4Prefix(V4_ENTRY_REMOTE_ADDRESS) + .build(), builder.getRemoteEid().getAddress())); + assertEquals(Ipv4PrefixAfi.class, builder.getRemoteEid().getAddressType()); + assertEquals(MapReplyAction.Drop, builder.getAction()); + } + + @Test + public void testInit() { + final InstanceIdentifier CONFIG_ID = + InstanceIdentifier.create(Gpe.class).child(GpeFeatureData.class).child(GpeEntryTable.class) + .child(GpeEntry.class, new GpeEntryKey(V4_ENTRY_ID)); + + final InstanceIdentifier STATE_ID = + InstanceIdentifier.create(GpeState.class).child(GpeFeatureData.class).child(GpeEntryTable.class) + .child(GpeEntry.class, new GpeEntryKey(V4_ENTRY_ID)); + + final GpeEntry entry = new GpeEntryBuilder().build(); + + invokeInitTest(STATE_ID, entry, CONFIG_ID, entry); + } + + private GpeFwdEntriesGet entryRequest(final int vni) { + GpeFwdEntriesGet request = new GpeFwdEntriesGet(); + request.vni = vni; + return request; + } + + private void mockLocatorDump() { + when(api.gpeFwdEntryPathDump(pathRequest(V4_ENTRY_FWD_INDEX))).thenReturn(future(locatorDumpForV4EntryReply())); + when(api.gpeFwdEntryPathDump(pathRequest(V6_ENTRY_FWD_INDEX))).thenReturn(future(locatorDumpForV6EntryReply())); + when(api.gpeFwdEntryPathDump(pathRequest(MAC_ENTRY_FWD_INDEX))) + .thenReturn(future(locatorDumpForMacEntryReply())); + } + + private GpeFwdEntryPathDump pathRequest(final int fwdIndex) { + GpeFwdEntryPathDump request = new GpeFwdEntryPathDump(); + request.fwdEntryIndex = fwdIndex; + return request; + } + + private void mockMappingsForGpeEntries() { + when(gpeEntryMappingContext + .getIdByEntryIdentifier(GpeEntryIdentifier.fromDumpDetail(getV4GpeEntry()), mappingContext)) + .thenReturn(V4_ENTRY_ID); + when(gpeEntryMappingContext + .getIdentificatorById(V4_ENTRY_ID, mappingContext)) + .thenReturn(fromDumpDetail(getV4GpeEntry())); + when(gpeEntryMappingContext + .getIdByEntryIdentifier(GpeEntryIdentifier.fromDumpDetail(getV6GpeEntry()), mappingContext)) + .thenReturn(V6_ENTRY_ID); + when(gpeEntryMappingContext + .getIdentificatorById(V6_ENTRY_ID, mappingContext)) + .thenReturn(fromDumpDetail(getV6GpeEntry())); + when(gpeEntryMappingContext + .getIdByEntryIdentifier(GpeEntryIdentifier.fromDumpDetail(getMacGpeEntry()), mappingContext)) + .thenReturn(MAC_ENTRY_ID); + when(gpeEntryMappingContext + .getIdentificatorById(MAC_ENTRY_ID, mappingContext)) + .thenReturn(fromDumpDetail(getMacGpeEntry())); + } + + private void mockMappingsForLocators() { + mockV4LocatorMapping(); + mockV6LocatorMapping(); + mockMacLocatorMapping(); + } + + private void mockV4LocatorMapping() { + final GpeFwdEntryPathDetailsReplyDump forV4EntryReply = locatorDumpForV4EntryReply(); + final GpeFwdEntryPathDetails v4LocatorOne = forV4EntryReply.gpeFwdEntryPathDetails.get(0); + final GpeLocatorPair v4LocatorPairOne = GpeLocatorPair.fromDumpDetail(v4LocatorOne); + when(gpeLocatorPairMappingContext.getMapping(V4_ENTRY_ID, v4LocatorPairOne, mappingContext)) + .thenReturn(fromDump(V4_ENTRY_LOCATOR, v4LocatorOne)); + } + + private void mockV6LocatorMapping() { + final GpeFwdEntryPathDetailsReplyDump forV6EntryReply = locatorDumpForV6EntryReply(); + final GpeFwdEntryPathDetails v6LocatorOne = forV6EntryReply.gpeFwdEntryPathDetails.get(0); + final GpeLocatorPair v6LocatorPairOne = GpeLocatorPair.fromDumpDetail(v6LocatorOne); + when(gpeLocatorPairMappingContext.getMapping(V6_ENTRY_ID, v6LocatorPairOne, mappingContext)) + .thenReturn(fromDump(V6_ENTRY_LOCATOR, v6LocatorOne)); + } + + private void mockMacLocatorMapping() { + final GpeFwdEntryPathDetails macLocator = locatorDumpForMacEntryReply().gpeFwdEntryPathDetails.get(0); + final GpeLocatorPair macLocatorPair = GpeLocatorPair.fromDumpDetail(macLocator); + when(gpeLocatorPairMappingContext.getMapping(MAC_ENTRY_ID, macLocatorPair, mappingContext)) + .thenReturn(fromDump(MAC_ENTRY_LOCATOR, macLocator)); + } + + private LocatorPairMapping fromDump(final String id, final GpeFwdEntryPathDetails dump) { + + final boolean localV4 = byteToBoolean(dump.lclLoc.isIp4); + final boolean remoteV4 = byteToBoolean(dump.rmtLoc.isIp4); + return new LocatorPairMappingBuilder() + .setId(id) + .setPair(new PairBuilder() + .setLocalAddress(arrayToIpAddress(!localV4, dump.lclLoc.addr)) + .setRemoteAddress(arrayToIpAddress(!remoteV4, dump.rmtLoc.addr)) + .build()) + .build(); + } + + private GpeEntryIdentificator fromDumpDetail(final GpeFwdEntry entry) { + final EidType eidType = EidType.valueOf(entry.eidType); + final Eid localEid = getArrayAsEidLocal(eidType, entry.leid, entry.leidPrefixLen, entry.vni); + final Eid remoteEid = getArrayAsEidLocal(eidType, entry.reid, entry.reidPrefixLen, entry.vni); + return new GpeEntryIdentificatorBuilder() + .setLocalEid(new LocalEidBuilder() + .setAddress(localEid.getAddress()) + .setAddressType(localEid.getAddressType()) + .setVirtualNetworkId(localEid.getVirtualNetworkId()) + .build()) + .setRemoteEid(new RemoteEidBuilder() + .setAddress(remoteEid.getAddress()) + .setAddressType(remoteEid.getAddressType()) + .setVirtualNetworkId(remoteEid.getVirtualNetworkId()) + .build()) + .setVni((long) entry.vni) + .build(); + } + + private GpeFwdEntriesGetReply getGpeEntryDumpReply(final GpeFwdEntry entry) { + GpeFwdEntriesGetReply reply = new GpeFwdEntriesGetReply(); + reply.entries = new GpeFwdEntry[]{entry}; + reply.count = reply.entries.length; + return reply; + } + + private GpeFwdEntryVnisGetReply activeVnisDump() { + GpeFwdEntryVnisGetReply reply = new GpeFwdEntryVnisGetReply(); + reply.vnis = new int[]{V4_ENTRY_VNI, V6_ENTRY_VNI, MAC_ENTRY_VNI}; + return reply; + } + + private GpeFwdEntryPathDetailsReplyDump locatorDumpForV4EntryReply() { + GpeFwdEntryPathDetailsReplyDump reply = new GpeFwdEntryPathDetailsReplyDump(); + + GpeFwdEntryPathDetails entry = new GpeFwdEntryPathDetails(); + GpeLocator localLocator = new GpeLocator(); + localLocator.addr = ipv4AddressNoZoneToArray(V4_LOCATOR_LOCAL_ADDRESS); + localLocator.isIp4 = 1; + localLocator.weight = V4_LOCATOR_LOCAL_WEIGHT; + GpeLocator remoteLocator = new GpeLocator(); + remoteLocator.addr = ipv4AddressNoZoneToArray(V4_LOCATOR_REMOTE_ADDRESS); + remoteLocator.isIp4 = 1; + + entry.lclLoc = localLocator; + entry.rmtLoc = remoteLocator; + + reply.gpeFwdEntryPathDetails = Collections.singletonList(entry); + + return reply; + } + + private GpeFwdEntryPathDetailsReplyDump locatorDumpForMacEntryReply() { + GpeFwdEntryPathDetailsReplyDump reply = new GpeFwdEntryPathDetailsReplyDump(); + + GpeFwdEntryPathDetails entry = new GpeFwdEntryPathDetails(); + GpeLocator localLocator = new GpeLocator(); + localLocator.addr = ipv4AddressNoZoneToArray(MAC_LOCATOR_LOCAL_ADDRESS); + localLocator.isIp4 = 1; + localLocator.weight = MAC_LOCATOR_LOCAL_WEIGHT; + GpeLocator remoteLocator = new GpeLocator(); + remoteLocator.addr = ipv4AddressNoZoneToArray(MAC_LOCATOR_REMOTE_ADDRESS); + remoteLocator.isIp4 = 1; + + entry.lclLoc = localLocator; + entry.rmtLoc = remoteLocator; + + reply.gpeFwdEntryPathDetails = Collections.singletonList(entry); + + return reply; + } + + private GpeFwdEntryPathDetailsReplyDump locatorDumpForV6EntryReply() { + GpeFwdEntryPathDetailsReplyDump reply = new GpeFwdEntryPathDetailsReplyDump(); + + GpeFwdEntryPathDetails entry = new GpeFwdEntryPathDetails(); + GpeLocator localLocator = new GpeLocator(); + localLocator.addr = ipv6AddressNoZoneToArray(V6_LOCATOR_LOCAL_ADDRESS); + localLocator.isIp4 = 0; + localLocator.weight = V6_LOCATOR_LOCAL_WEIGHT; + GpeLocator remoteLocator = new GpeLocator(); + remoteLocator.addr = ipv6AddressNoZoneToArray(V6_LOCATOR_REMOTE_ADDRESS); + remoteLocator.isIp4 = 0; + + entry.lclLoc = localLocator; + entry.rmtLoc = remoteLocator; + + reply.gpeFwdEntryPathDetails = Collections.singletonList(entry); + + return reply; + } + + private GpeFwdEntry getMacGpeEntry() { + GpeFwdEntry entryThree = new GpeFwdEntry(); + entryThree.dpTable = MAC_ENTRY_DP_TABLE; + entryThree.vni = MAC_ENTRY_VNI; + entryThree.eidType = 2; + entryThree.fwdEntryIndex = MAC_ENTRY_FWD_INDEX; + entryThree.leid = parseMac(MAC_ENTRY_LOCAL_ADDRESS_VALUE); + entryThree.reid = parseMac(MAC_ENTRY_REMOTE_ADDRESS_VALUE); + + return entryThree; + } + + private GpeFwdEntry getV6GpeEntry() { + GpeFwdEntry entryTwo = new GpeFwdEntry(); + entryTwo.dpTable = V6_ENTRY_DP_TABLE; + entryTwo.vni = V6_ENTRY_VNI; + entryTwo.eidType = 1; + entryTwo.fwdEntryIndex = V6_ENTRY_FWD_INDEX; + entryTwo.leid = ipv6AddressPrefixToArray(V6_ENTRY_LOCAL_ADDRESS); + entryTwo.leidPrefixLen = 64; + entryTwo.reid = ipv6AddressPrefixToArray(V6_ENTRY_REMOTE_ADDRESS); + entryTwo.reidPrefixLen = 64; + return entryTwo; + } + + private GpeFwdEntry getV4GpeEntry() { + GpeFwdEntry entryOne = new GpeFwdEntry(); + entryOne.dpTable = V4_ENTRY_DP_TABLE; + entryOne.vni = V4_ENTRY_VNI; + entryOne.eidType = 0; + entryOne.action = 3; + entryOne.fwdEntryIndex = V4_ENTRY_FWD_INDEX; + entryOne.leid = ipv4AddressPrefixToArray(V4_ENTRY_LOCAL_ADDRESS); + entryOne.leidPrefixLen = 24; + entryOne.reid = ipv4AddressPrefixToArray(V4_ENTRY_REMOTE_ADDRESS); + entryOne.reidPrefixLen = 24; + return entryOne; + } +} diff --git a/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/gpe/translate/write/GpeFeatureCustomizerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/gpe/translate/write/GpeFeatureCustomizerTest.java new file mode 100644 index 000000000..c7f0ae816 --- /dev/null +++ b/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/gpe/translate/write/GpeFeatureCustomizerTest.java @@ -0,0 +1,80 @@ +/* + * 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.gpe.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.honeycomb.translate.write.WriteFailedException; +import io.fd.vpp.jvpp.core.dto.GpeEnableDisable; +import io.fd.vpp.jvpp.core.dto.GpeEnableDisableReply; +import org.junit.Test; +import org.mockito.ArgumentCaptor; +import org.mockito.Captor; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.gpe.rev170518.gpe.feature.data.grouping.GpeFeatureData; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.gpe.rev170518.gpe.feature.data.grouping.GpeFeatureDataBuilder; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class GpeFeatureCustomizerTest extends WriterCustomizerTest { + + private GpeFeatureCustomizer customizer; + + @Captor + private ArgumentCaptor requestCaptor; + + @Override + protected void setUpTest() throws Exception { + customizer = new GpeFeatureCustomizer(api); + } + + @Test + public void testWrite() throws WriteFailedException { + when(api.gpeEnableDisable(any())).thenReturn(future(new GpeEnableDisableReply())); + + customizer.writeCurrentAttributes(InstanceIdentifier.create(GpeFeatureData.class), + new GpeFeatureDataBuilder().setEnable(true).build(), writeContext); + verify(api, times(1)).gpeEnableDisable(requestCaptor.capture()); + final GpeEnableDisable request = requestCaptor.getValue(); + assertEquals(1, request.isEn); + } + + @Test + public void testDelete() throws WriteFailedException { + when(api.gpeEnableDisable(any())).thenReturn(future(new GpeEnableDisableReply())); + + customizer.deleteCurrentAttributes(InstanceIdentifier.create(GpeFeatureData.class), + new GpeFeatureDataBuilder().setEnable(true).build(), writeContext); + verify(api, times(1)).gpeEnableDisable(requestCaptor.capture()); + final GpeEnableDisable request = requestCaptor.getValue(); + assertEquals(0, request.isEn); + } + + @Test + public void testUpdate() throws WriteFailedException { + when(api.gpeEnableDisable(any())).thenReturn(future(new GpeEnableDisableReply())); + + customizer.writeCurrentAttributes(InstanceIdentifier.create(GpeFeatureData.class), + new GpeFeatureDataBuilder().setEnable(false).build(), writeContext); + verify(api, times(1)).gpeEnableDisable(requestCaptor.capture()); + final GpeEnableDisable request = requestCaptor.getValue(); + assertEquals(0, request.isEn); + } +} diff --git a/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/gpe/translate/write/GpeForwardEntryCustomizerTest.java b/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/gpe/translate/write/GpeForwardEntryCustomizerTest.java new file mode 100644 index 000000000..74c9bdeba --- /dev/null +++ b/lisp/lisp2vpp/src/test/java/io/fd/hc2vpp/lisp/gpe/translate/write/GpeForwardEntryCustomizerTest.java @@ -0,0 +1,313 @@ +/* + * 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.gpe.translate.write; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.fail; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.verifyZeroInteractions; +import static org.mockito.Mockito.when; + +import com.google.common.collect.ImmutableSet; +import io.fd.hc2vpp.common.test.write.WriterCustomizerTest; +import io.fd.hc2vpp.common.translate.util.ByteDataTranslator; +import io.fd.hc2vpp.lisp.gpe.translate.ctx.GpeEntryIdentifier; +import io.fd.hc2vpp.lisp.gpe.translate.ctx.GpeEntryMappingContext; +import io.fd.hc2vpp.lisp.gpe.translate.ctx.GpeLocatorPair; +import io.fd.hc2vpp.lisp.gpe.translate.ctx.GpeLocatorPairMappingContext; +import io.fd.hc2vpp.lisp.gpe.translate.service.GpeStateCheckService; +import io.fd.honeycomb.test.tools.HoneycombTestRunner; +import io.fd.honeycomb.test.tools.annotations.InjectTestData; +import io.fd.honeycomb.test.tools.annotations.InjectablesProcessor; +import io.fd.honeycomb.test.tools.annotations.SchemaContextProvider; +import io.fd.vpp.jvpp.core.dto.GpeAddDelFwdEntry; +import io.fd.vpp.jvpp.core.dto.GpeAddDelFwdEntryReply; +import io.fd.vpp.jvpp.core.types.GpeLocator; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.ArgumentCaptor; +import org.mockito.Captor; +import org.mockito.Mock; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.gpe.rev170518.gpe.entry.table.grouping.GpeEntryTable; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.gpe.rev170518.gpe.entry.table.grouping.gpe.entry.table.GpeEntry; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.gpe.rev170518.gpe.entry.table.grouping.gpe.entry.table.GpeEntryKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.gpe.rev170518.gpe.entry.table.grouping.gpe.entry.table.gpe.entry.LocatorPairs; +import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.lisp.rev170315.$YangModuleInfoImpl; +import org.opendaylight.yangtools.sal.binding.generator.impl.ModuleInfoBackedContext; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +@RunWith(HoneycombTestRunner.class) +public class GpeForwardEntryCustomizerTest extends WriterCustomizerTest + implements InjectablesProcessor, ByteDataTranslator { + + private static final String GPE_ENTRY_ID = "gpe-fwd-entry-1"; + private static final String GPE_ENTRY_PATH = "/gpe:gpe" + + "/gpe:gpe-feature-data" + + "/gpe:gpe-entry-table"; + private static final byte[] LOCAL_EID_ADDRESS = {-64, -88, 2, 0}; + private static final byte[] REMOTE_EID_ADDRESS = {-64, -88, 3, 0}; + private static final byte[] PAIR_2_LOCAL_ADDRESS = {-64, -88, 5, 1}; + private static final byte[] PAIR_1_LOCAL_ADDRESS = {-64, -88, 4, 1}; + private static final byte[] PAIR_2_REMOTE_ADDRESS = {-64, -88, 5, 2}; + private static final byte[] PAIR_1_REMOTE_ADDRESS = {-64, -88, 4, 2}; + private static final int LOCAL_EID_PREFIX = 24; + private static final int REMOTE_EID_PREFIX = 16; + + @Captor + private ArgumentCaptor requestCaptor; + + @Mock + private GpeEntryMappingContext gpeEntryMappingContext; + + @Mock + private GpeLocatorPairMappingContext gpeLocatorPairMappingContext; + + @Mock + private GpeStateCheckService gpeStateCheckService; + + private InstanceIdentifier id; + private GpeForwardEntryCustomizer customizer; + + @Override + protected void setUpTest() throws Exception { + id = InstanceIdentifier.create(GpeEntryTable.class) + .child(GpeEntry.class, new GpeEntryKey(GPE_ENTRY_ID)); + customizer = new GpeForwardEntryCustomizer(api, gpeStateCheckService, gpeEntryMappingContext, + gpeLocatorPairMappingContext); + } + + @SchemaContextProvider + public 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(), + org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.gpe.rev170518.$YangModuleInfoImpl + .getInstance())); + } + + @Test + public void testWriteCurrentAttributesFull(@InjectTestData(resourcePath = "/gpe/gpe-fwd-entry-full.json", + id = GPE_ENTRY_PATH) GpeEntryTable entryTable) throws Exception { + when(api.gpeAddDelFwdEntry(any())).thenReturn(future(new GpeAddDelFwdEntryReply())); + final GpeEntry entry = entryTable.getGpeEntry().get(0); + customizer.writeCurrentAttributes(id, entry, writeContext); + verify(api, times(1)).gpeAddDelFwdEntry(requestCaptor.capture()); + assertEquals(expectedFullRequest(true), requestCaptor.getValue()); + verify(gpeEntryMappingContext, times(1)) + .addMapping(entry.getId(), GpeEntryIdentifier.fromEntry(entry), mappingContext); + + final LocatorPairs locatorPairFirst = entry.getLocatorPairs().get(0); + final LocatorPairs locatorPairSecond = entry.getLocatorPairs().get(1); + verify(gpeLocatorPairMappingContext, times(1)) + .addMapping(entry.getId(), locatorPairFirst.getId(), + GpeLocatorPair.fromLocatorPair(locatorPairFirst), mappingContext); + verify(gpeLocatorPairMappingContext, times(1)) + .addMapping(entry.getId(), locatorPairSecond.getId(), + GpeLocatorPair.fromLocatorPair(locatorPairSecond), mappingContext); + } + + @Test + public void testWriteCurrentAttributesWithoutLocators( + @InjectTestData(resourcePath = "/gpe/gpe-fwd-entry-without-locators.json", + id = GPE_ENTRY_PATH) GpeEntryTable entryTable) throws Exception { + when(api.gpeAddDelFwdEntry(any())).thenReturn(future(new GpeAddDelFwdEntryReply())); + final GpeEntry entry = entryTable.getGpeEntry().get(0); + customizer.writeCurrentAttributes(id, entry, writeContext); + verify(api, times(1)).gpeAddDelFwdEntry(requestCaptor.capture()); + assertEquals(expectedLocatorLessRequest(true), requestCaptor.getValue()); + verify(gpeEntryMappingContext, times(1)) + .addMapping(entry.getId(), GpeEntryIdentifier.fromEntry(entry), mappingContext); + verifyZeroInteractions(gpeLocatorPairMappingContext); + } + + @Test + public void testWriteCurrentAttributesWithoutAction( + @InjectTestData(resourcePath = "/gpe/gpe-fwd-entry-without-action.json", + id = GPE_ENTRY_PATH) GpeEntryTable entryTable) throws Exception { + when(api.gpeAddDelFwdEntry(any())).thenReturn(future(new GpeAddDelFwdEntryReply())); + final GpeEntry entry = entryTable.getGpeEntry().get(0); + customizer.writeCurrentAttributes(id, entry, writeContext); + verify(api, times(1)).gpeAddDelFwdEntry(requestCaptor.capture()); + assertEquals(expectedActionLessRequest(true), requestCaptor.getValue()); + verify(gpeEntryMappingContext, times(1)) + .addMapping(entry.getId(), GpeEntryIdentifier.fromEntry(entry), mappingContext); + verifyZeroInteractions(gpeLocatorPairMappingContext); + } + + @Test + public void testWriteCurrentAttributesFailNoLocalEid( + @InjectTestData(resourcePath = "/gpe/invalid/invalid-gpe-fwd-entry-no-local-eid.json", + id = GPE_ENTRY_PATH) GpeEntryTable entryTable) throws Exception { + try { + customizer.writeCurrentAttributes(id, entryTable.getGpeEntry().get(0), writeContext); + } catch (IllegalArgumentException e) { + verifyZeroInteractions(api); + return; + } + fail("Test should have failed"); + } + + @Test + public void testWriteCurrentAttributesFailNoRemoteEid( + @InjectTestData(resourcePath = "/gpe/invalid/invalid-gpe-fwd-entry-no-remote-eid.json", + id = GPE_ENTRY_PATH) GpeEntryTable entryTable) throws Exception { + try { + customizer.writeCurrentAttributes(id, entryTable.getGpeEntry().get(0), writeContext); + } catch (IllegalArgumentException e) { + verifyZeroInteractions(api); + return; + } + fail("Test should have failed"); + } + + @Test + public void testDeleteCurrentAttributesFull(@InjectTestData(resourcePath = "/gpe/gpe-fwd-entry-full.json", + id = GPE_ENTRY_PATH) GpeEntryTable entryTable) throws Exception { + when(api.gpeAddDelFwdEntry(any())).thenReturn(future(new GpeAddDelFwdEntryReply())); + final GpeEntry entry = entryTable.getGpeEntry().get(0); + customizer.deleteCurrentAttributes(id, entry, writeContext); + verify(api, times(1)).gpeAddDelFwdEntry(requestCaptor.capture()); + assertEquals(expectedFullRequest(false), requestCaptor.getValue()); + verify(gpeEntryMappingContext, times(1)) + .removeMapping(entry.getId(), mappingContext); + verify(gpeLocatorPairMappingContext, times(1)) + .removeMapping(entry.getId(), mappingContext); + } + + @Test + public void testDeleteCurrentAttributesWithoutLocators( + @InjectTestData(resourcePath = "/gpe/gpe-fwd-entry-without-locators.json", + id = GPE_ENTRY_PATH) GpeEntryTable entryTable) throws Exception { + when(api.gpeAddDelFwdEntry(any())).thenReturn(future(new GpeAddDelFwdEntryReply())); + final GpeEntry entry = entryTable.getGpeEntry().get(0); + customizer.deleteCurrentAttributes(id, entry, writeContext); + verify(api, times(1)).gpeAddDelFwdEntry(requestCaptor.capture()); + assertEquals(expectedLocatorLessRequest(false), requestCaptor.getValue()); + verify(gpeEntryMappingContext, times(1)) + .removeMapping(entry.getId(), mappingContext); + verify(gpeLocatorPairMappingContext, times(1)) + .removeMapping(entry.getId(), mappingContext); + } + + @Test + public void testDeleteCurrentAttributesWithoutAction( + @InjectTestData(resourcePath = "/gpe/gpe-fwd-entry-without-action.json", + id = GPE_ENTRY_PATH) GpeEntryTable entryTable) throws Exception { + when(api.gpeAddDelFwdEntry(any())).thenReturn(future(new GpeAddDelFwdEntryReply())); + final GpeEntry entry = entryTable.getGpeEntry().get(0); + customizer.deleteCurrentAttributes(id, entry, writeContext); + verify(api, times(1)).gpeAddDelFwdEntry(requestCaptor.capture()); + assertEquals(expectedActionLessRequest(false), requestCaptor.getValue()); + verify(gpeEntryMappingContext, times(1)) + .removeMapping(entry.getId(), mappingContext); + verify(gpeLocatorPairMappingContext, times(1)) + .removeMapping(entry.getId(), mappingContext); + } + + @Test + public void testDeleteCurrentAttributesFailNoLocalEid( + @InjectTestData(resourcePath = "/gpe/invalid/invalid-gpe-fwd-entry-no-local-eid.json", + id = GPE_ENTRY_PATH) GpeEntryTable entryTable) throws Exception { + try { + customizer.deleteCurrentAttributes(id, entryTable.getGpeEntry().get(0), writeContext); + } catch (IllegalArgumentException e) { + verifyZeroInteractions(api); + return; + } + fail("Test should have failed"); + } + + @Test + public void testDeleteCurrentAttributesFailNoRemoteEid( + @InjectTestData(resourcePath = "/gpe/invalid/invalid-gpe-fwd-entry-no-remote-eid.json", + id = GPE_ENTRY_PATH) GpeEntryTable entryTable) throws Exception { + try { + customizer.deleteCurrentAttributes(id, entryTable.getGpeEntry().get(0), writeContext); + } catch (IllegalArgumentException e) { + verifyZeroInteractions(api); + return; + } + fail("Test should have failed"); + } + + private GpeAddDelFwdEntry expectedActionLessRequest(final boolean add) { + final GpeAddDelFwdEntry request = new GpeAddDelFwdEntry(); + + request.isAdd = booleanToByte(add); + request.dpTable = 10; + request.vni = 12; + request.eidType = 0; + request.action = 0; + request.lclEid = LOCAL_EID_ADDRESS; + request.lclLen = LOCAL_EID_PREFIX; + request.rmtEid = REMOTE_EID_ADDRESS; + request.rmtLen = REMOTE_EID_PREFIX; + request.locNum = 0; + return request; + } + + private GpeAddDelFwdEntry expectedLocatorLessRequest(final boolean add) { + final GpeAddDelFwdEntry request = new GpeAddDelFwdEntry(); + + request.isAdd = booleanToByte(add); + request.dpTable = 10; + request.vni = 12; + request.eidType = 0; + request.action = 1; + request.lclEid = LOCAL_EID_ADDRESS; + request.lclLen = LOCAL_EID_PREFIX; + request.rmtEid = REMOTE_EID_ADDRESS; + request.rmtLen = REMOTE_EID_PREFIX; + request.locNum = 0; + return request; + } + + + private GpeAddDelFwdEntry expectedFullRequest(final boolean add) { + final GpeAddDelFwdEntry request = new GpeAddDelFwdEntry(); + + request.isAdd = booleanToByte(add); + request.dpTable = 10; + request.vni = 12; + request.eidType = 0; + request.action = 1; + request.lclEid = LOCAL_EID_ADDRESS; + request.lclLen = LOCAL_EID_PREFIX; + request.rmtEid = REMOTE_EID_ADDRESS; + request.rmtLen = REMOTE_EID_PREFIX; + request.locNum = 4; + request.locs = new GpeLocator[]{ + gpeLocator(PAIR_2_LOCAL_ADDRESS, 1, 2), + gpeLocator(PAIR_1_LOCAL_ADDRESS, 1, 3), + gpeLocator(PAIR_1_REMOTE_ADDRESS, 1, 0), + gpeLocator(PAIR_2_REMOTE_ADDRESS, 1, 0) + }; + + return request; + } + + private GpeLocator gpeLocator(final byte[] address, final int isIpv4, final int weight) { + GpeLocator locator = new GpeLocator(); + locator.isIp4 = (byte) isIpv4; + locator.weight = (byte) weight; + locator.addr = address; + + return locator; + } +} \ No newline at end of file -- cgit 1.2.3-korg