/*
- * Copyright (c) 2014 Contextream, Inc. and others. All rights reserved.
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
* and is available at http://www.eclipse.org/legal/epl-v10.html
*/
-
package org.opendaylight.lispflowmapping.implementation.lisp;
import static org.junit.Assert.assertEquals;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
+import java.lang.reflect.Field;
import java.util.ArrayList;
-
-import junitx.framework.ArrayAssert;
-
-import org.jmock.api.Invocation;
+import java.util.Date;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
import org.junit.Before;
import org.junit.Test;
-import org.opendaylight.lispflowmapping.implementation.LispMappingService;
-import org.opendaylight.lispflowmapping.implementation.MappingService;
-import org.opendaylight.lispflowmapping.implementation.MappingSystem;
-import org.opendaylight.lispflowmapping.implementation.mdsal.DataStoreBackEnd;
-import org.opendaylight.lispflowmapping.interfaces.dao.ILispDAO;
-import org.opendaylight.lispflowmapping.interfaces.dao.MappingEntry;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.Spy;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.opendaylight.controller.md.sal.binding.api.NotificationService;
+import org.opendaylight.lispflowmapping.config.ConfigIni;
import org.opendaylight.lispflowmapping.interfaces.dao.SubKeys;
-import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
-import org.opendaylight.lispflowmapping.lisp.util.MaskUtil;
-import org.opendaylight.lispflowmapping.lisp.serializer.MapRegisterSerializer;
-import org.opendaylight.lispflowmapping.tools.junit.BaseTestCase;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.EidToLocatorRecord.Action;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.LispAFIAddress;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.MapNotify;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.MapRegister;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.eidtolocatorrecords.EidToLocatorRecord;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.eidtolocatorrecords.EidToLocatorRecordBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.LispAddressContainer;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.no.NoAddressBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.locatorrecords.LocatorRecord;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.locatorrecords.LocatorRecordBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.mapregisternotification.MapRegisterBuilder;
+import org.opendaylight.lispflowmapping.interfaces.dao.SubscriberRLOC;
+import org.opendaylight.lispflowmapping.interfaces.lisp.IMapNotifyHandler;
+import org.opendaylight.lispflowmapping.interfaces.mappingservice.IMappingService;
+import org.opendaylight.lispflowmapping.lisp.type.LispMessage;
+import org.opendaylight.lispflowmapping.lisp.type.MappingData;
+import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
+import org.opendaylight.lispflowmapping.lisp.util.SourceDestKeyHelper;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.IpAddressBinary;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.Ipv4AddressBinary;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapRegister;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.SiteId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.XtrId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.Eid;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecord;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecordBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapnotifymessage.MapNotify;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapnotifymessage.MapNotifyBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.authkey.container.MappingAuthkey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.authkey.container.MappingAuthkeyBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecord;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecordBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.list.MappingRecordItem;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.list.MappingRecordItemBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.list.MappingRecordItemKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapregistermessage.MapRegisterBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequestnotification.MapRequest;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.rloc.container.Rloc;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.transport.address.TransportAddress;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.transport.address.TransportAddressBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingOrigin;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.db.instance.Mapping;
-public class MapServerTest extends BaseTestCase {
+@RunWith(MockitoJUnitRunner.class)
+public class MapServerTest {
+
+ @Mock private static IMappingService mapService;
+ @Mock private static IMapNotifyHandler notifyHandler;
+ @Mock private static NotificationService notificationService;
+
+ @Spy private static Set<SubscriberRLOC> subscriberSetMock_1 = new HashSet<>();
+ @Spy private static Set<SubscriberRLOC> subscriberSetMock_2 = new HashSet<>();
+ @Spy private static Set<SubscriberRLOC> subscriberSetMock_3 = new HashSet<>();
+ private static MapServer mapServer;
+ private static MapRegister mapRegister;
+ private static MappingData mappingData;
+
+ private static final String IPV4_STRING_1 = "1.2.3.0";
+ private static final String IPV4_STRING_2 = "1.2.4.0";
+ private static final String IPV4_STRING_3 = "192.168.0.1";
+ private static final String IPV4_STRING_4 = "192.168.0.2";
+ private static final String IPV4_STRING_5 = "192.168.0.3";
+ private static final String IPV4_STRING_6 = "192.168.0.4";
+ private static final String IPV4_SOURCE_STRING_1 = "127.0.0.1";
+ private static final String IPV4_SOURCE_STRING_2 = "127.0.0.2";
+ private static final String IPV4_SOURCE_STRING_3 = "127.0.0.3";
+ private static final String IPV4_SOURCE_STRING_4 = "127.0.0.4";
+ private static final String IPV4_SOURCE_STRING_5 = "127.0.0.5";
+ private static final String IPV4_SOURCE_STRING_6 = "127.0.0.6";
+ private static final String IPV4_PREFIX_1 = "/24";
+ private static final String IPV4_PREFIX_2 = "/16";
+ private static final int MASK = 24;
+ private static final int VNI = 10;
+
+ private static final Eid IPV4_EID_1 = LispAddressUtil.asIpv4Eid(IPV4_STRING_1);
+ private static final Eid IPV4_EID_2 = LispAddressUtil.asIpv4Eid(IPV4_STRING_2);
+ private static final Eid IPV4_PREFIX_EID_1 = LispAddressUtil.asIpv4PrefixBinaryEid(IPV4_STRING_1 + IPV4_PREFIX_1);
+ private static final Eid IPV4_PREFIX_EID_2 = LispAddressUtil.asIpv4PrefixBinaryEid(IPV4_STRING_1 + IPV4_PREFIX_2);
+ private static final Eid IPV4_SOURCE_EID_1 = LispAddressUtil.asIpv4Eid(IPV4_SOURCE_STRING_1);
+ private static final Eid IPV4_SOURCE_EID_2 = LispAddressUtil.asIpv4Eid(IPV4_SOURCE_STRING_2);
+ private static final Eid IPV4_SOURCE_EID_3 = LispAddressUtil.asIpv4Eid(IPV4_SOURCE_STRING_3);
+ private static final Eid IPV4_SOURCE_EID_4 = LispAddressUtil.asIpv4Eid(IPV4_SOURCE_STRING_4);
+ private static final Eid IPV4_SOURCE_EID_5 = LispAddressUtil.asIpv4Eid(IPV4_SOURCE_STRING_5);
+ private static final Eid IPV4_SOURCE_EID_6 = LispAddressUtil.asIpv4Eid(IPV4_SOURCE_STRING_6);
+ private static final Rloc RLOC_1 = LispAddressUtil.asIpv4Rloc(IPV4_STRING_1);
+ private static final Rloc RLOC_2 = LispAddressUtil.asIpv4Rloc(IPV4_STRING_2);
+ private static final Rloc RLOC_3 = LispAddressUtil.asIpv4Rloc(IPV4_STRING_3);
+ private static final Rloc RLOC_4 = LispAddressUtil.asIpv4Rloc(IPV4_STRING_4);
+ private static final Rloc RLOC_5 = LispAddressUtil.asIpv4Rloc(IPV4_STRING_5);
+ private static final Rloc RLOC_6 = LispAddressUtil.asIpv4Rloc(IPV4_STRING_6);
+
+ private static final IpAddressBinary IPV4_BINARY_1 =
+ new IpAddressBinary(new Ipv4AddressBinary(new byte[] {1, 2, 3, 0}));
+ private static final IpAddressBinary IPV4_BINARY_2 =
+ new IpAddressBinary(new Ipv4AddressBinary(new byte[] {1, 2, 4, 0}));
+
+ private static final long TWO_DAYS = 86400000L * 2;
+
+ private static final SubscriberRLOC SUBSCRIBER_RLOC_1 = new SubscriberRLOC(RLOC_1, // timedOut() == true
+ IPV4_SOURCE_EID_1, SubscriberRLOC.DEFAULT_SUBSCRIBER_TIMEOUT,
+ new Date(System.currentTimeMillis() - TWO_DAYS));
+ private static final SubscriberRLOC SUBSCRIBER_RLOC_2 = new SubscriberRLOC(RLOC_2, // timedOut() == false
+ IPV4_SOURCE_EID_2, SubscriberRLOC.DEFAULT_SUBSCRIBER_TIMEOUT);
+ private static final SubscriberRLOC SUBSCRIBER_RLOC_3 = new SubscriberRLOC(RLOC_3, // timedOut() == true
+ IPV4_SOURCE_EID_3, SubscriberRLOC.DEFAULT_SUBSCRIBER_TIMEOUT,
+ new Date(System.currentTimeMillis() - TWO_DAYS));
+ private static final SubscriberRLOC SUBSCRIBER_RLOC_4 = new SubscriberRLOC(RLOC_4, // timedOut() == false
+ IPV4_SOURCE_EID_4, SubscriberRLOC.DEFAULT_SUBSCRIBER_TIMEOUT);
+ private static final SubscriberRLOC SUBSCRIBER_RLOC_5 = new SubscriberRLOC(RLOC_5, // timedOut() == true
+ IPV4_SOURCE_EID_5, SubscriberRLOC.DEFAULT_SUBSCRIBER_TIMEOUT,
+ new Date(System.currentTimeMillis() - TWO_DAYS));
+ private static final SubscriberRLOC SUBSCRIBER_RLOC_6 = new SubscriberRLOC(RLOC_6, // timedOut() == false
+ IPV4_SOURCE_EID_6, SubscriberRLOC.DEFAULT_SUBSCRIBER_TIMEOUT);
+
+ private static final Eid SOURCE_DEST_KEY_EID = LispAddressUtil
+ .asSrcDstEid(IPV4_STRING_1, IPV4_STRING_2, MASK, MASK, VNI);
+ private static final MappingAuthkey MAPPING_AUTHKEY = new MappingAuthkeyBuilder().setKeyType(0).build();
+ private static final ConfigIni CONFIG_INI = ConfigIni.getInstance();
+
+ private static final LocatorRecord LOCATOR_RECORD_1 = new LocatorRecordBuilder().setRloc(RLOC_1).build();
+ private static final LocatorRecord LOCATOR_RECORD_2 = new LocatorRecordBuilder().setRloc(RLOC_2).build();
+
+ private static final MappingRecord OLD_MAPPING_RECORD_1 = getDefaultMappingRecordBuilder()
+ .setLocatorRecord(Lists.newArrayList(LOCATOR_RECORD_1)).build();
+ private static final MappingRecord OLD_MAPPING_RECORD_2 = getDefaultMappingRecordBuilder()
+ .setLocatorRecord(Lists.newArrayList(LOCATOR_RECORD_2)).build();
+ private static final MappingData OLD_MAPPING_DATA_1 = new MappingData(OLD_MAPPING_RECORD_1);
+ private static final MappingData OLD_MAPPING_DATA_2 = new MappingData(OLD_MAPPING_RECORD_2);
+
+ private static final Set<IpAddressBinary> DEFAULT_IP_ADDRESS_SET = getDefaultIpAddressSet();
- private LispMappingService testedMapServer;
- private ILispDAO dao;
- private MappingService mapService;
- private DataStoreBackEnd dsbe;
- private MappingSystem mapSystem;
-
- private MapRegisterBuilder mapRegisterBuilder;
- private LispAddressContainer eid;
- private LispAddressContainer rloc;
- private ValueSaverAction<MappingEntry<?>[]> mappingEntriesSaver;
- private MapRegister mapRegisterWithAuthentication;
- private String eidIpv4String = "10.31.0.5";
- private String eidIpv6String = "1:1:1:1:1:1:1:0";
-
- @Override
@Before
- public void before() throws Exception {
- super.before();
- dao = context.mock(ILispDAO.class);
- dsbe = context.mock(DataStoreBackEnd.class);
-
- // map-caches init and table creation
- allowing(dao).putTable(with(MappingOrigin.Northbound.toString()));will(returnValue(dao));
- allowing(dao).putTable(with(MappingOrigin.Southbound.toString()));will(returnValue(dao));
-
- mapSystem = new MappingSystem(dao, true, true, true);
-
- mapService = new MappingService();
- mapService.setDaoService(dao);
- inject(mapService, "dsbe", dsbe);
- inject(mapService, "mappingSystem", mapSystem);
-
- testedMapServer = new LispMappingService();
- testedMapServer.setMappingService(mapService);
- testedMapServer.setShouldUseSmr(false);
- testedMapServer.basicInit();
-
- mapRegisterBuilder = new MapRegisterBuilder();
- mapRegisterBuilder.setKeyId((short) 0);
- mapRegisterBuilder.setAuthenticationData(new byte[0]);
- eid = LispAFIConvertor.asIPv4Address(eidIpv4String);
- rloc = LispAFIConvertor.asIPv4Address("192.168.136.10");
- EidToLocatorRecordBuilder recordBuilder = new EidToLocatorRecordBuilder();
- recordBuilder.setLispAddressContainer(eid).setMaskLength((short) 32);
- recordBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
- recordBuilder.getLocatorRecord().add(new LocatorRecordBuilder().setLispAddressContainer(rloc).build());
- recordBuilder.setAction(Action.NoAction).setMapVersion((short) 0).setAuthoritative(false).setRecordTtl(60).setMaskLength((short) 32);
- mapRegisterBuilder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
- mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
- mapRegisterWithAuthentication = MapRegisterSerializer.getInstance().deserialize(hexToByteBuffer("38 00 01 01 FF BB "
- //
- + "00 00 00 00 00 00 00 01 00 14 2c 61 b9 c9 9a 20 " //
- + "ba d8 f5 40 d3 55 6f 5f 6e 5a b2 0a bf b5 00 00 " //
- + "00 0a 01 20 10 00 00 00 00 01 99 10 fe 01 01 64 " //
- + "ff 00 00 05 00 01 c0 a8 88 0a"));
-
- mappingEntriesSaver = new ValueSaverAction<MappingEntry<?>[]>();
+ public void init() throws NoSuchFieldException, IllegalAccessException {
+ mapServer = new MapServer(mapService, true, notifyHandler, notificationService);
+ subscriberSetMock_1.add(SUBSCRIBER_RLOC_1);
+ subscriberSetMock_1.add(SUBSCRIBER_RLOC_2);
+ subscriberSetMock_2.add(SUBSCRIBER_RLOC_3);
+ subscriberSetMock_2.add(SUBSCRIBER_RLOC_4);
+ subscriberSetMock_3.add(SUBSCRIBER_RLOC_5);
+ subscriberSetMock_3.add(SUBSCRIBER_RLOC_6);
+ mapRegister = getDefaultMapRegisterBuilder().build();
+ mappingData = new MappingData(mapRegister.getMappingRecordItem().iterator().next().getMappingRecord(),
+ System.currentTimeMillis());
+ setConfigIniMappingMergeField(false);
}
@Test
- public void handleMapRegister__NonSetMBit() throws Exception {
- mapRegisterBuilder.setWantMapNotify(false);
+ public void handleMapRegisterTest_MappingMergeFalse() throws NoSuchFieldException, IllegalAccessException {
+ Mockito.when(mapService.getMapping(MappingOrigin.Southbound, IPV4_EID_1)).thenReturn(OLD_MAPPING_DATA_1);
+ Mockito.when(mapService.getData(MappingOrigin.Southbound, IPV4_EID_1, SubKeys.SUBSCRIBERS))
+ .thenReturn(subscriberSetMock_1);
+
+ mappingData.setMergeEnabled(false);
+ mapServer.handleMapRegister(mapRegister);
- addDefaultPutAndGetExpectations(eid);
- assertNull(testedMapServer.handleMapRegister(mapRegisterBuilder.build()));
+ final ArgumentCaptor<MappingData> captor = ArgumentCaptor.forClass(MappingData.class);
+ Mockito.verify(mapService).addMapping(Mockito.eq(MappingOrigin.Southbound), Mockito.eq(IPV4_EID_1),
+ Mockito.eq(mapRegister.getSiteId()), captor.capture());
+ assertEquals(captor.getValue().getRecord(), mappingData.getRecord());
+ Mockito.verify(mapService).addData(MappingOrigin.Southbound, IPV4_EID_1, SubKeys.SUBSCRIBERS,
+ subscriberSetMock_1);
+ Mockito.verify(notifyHandler).handleMapNotify(getDefaultMapNotifyBuilder(mapRegister)
+ .setAuthenticationData(null).build(), null);
- MappingEntry<?>[] entries = mappingEntriesSaver.lastValue;
- assertEquals(1, entries.length);
- assertEquals(SubKeys.RECORD, entries[0].getKey());
- assertEquals(rloc, ((EidToLocatorRecord) entries[0].getValue())
- .getLocatorRecord().get(0).getLispAddressContainer());
+ // only 1 subscriber has timed out.
+ assertEquals(1, subscriberSetMock_1.size());
}
@Test
- public void handleMapRegisterIpv4__ValidNotifyEchoesRegister() throws Exception {
- mapRegisterBuilder.getEidToLocatorRecord().add(
- getDefaultEidToLocatorBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(new NoAddressBuilder().build())).build());
- mapRegisterBuilder.setWantMapNotify(true);
-
- addDefaultPutAndGetExpectations(eid);
- addDefaultPutAndGetExpectations(LispAFIConvertor.toContainer(new NoAddressBuilder().build()));
- MapRegister mr = mapRegisterBuilder.build();
- MapNotify mapNotify = testedMapServer.handleMapRegister(mr);
- assertEquals(mr.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
- ArrayAssert.assertEquals(mr.getAuthenticationData(), mapNotify.getAuthenticationData());
- assertEquals(mr.getKeyId(), mapNotify.getKeyId());
- assertEquals(mr.getNonce(), mapNotify.getNonce());
+ public void handleMapRegisterTest_MappingMergeTrue() throws NoSuchFieldException, IllegalAccessException {
+ setConfigIniMappingMergeField(true);
+
+ final MappingRecordItemBuilder mappingRecordItemBuilder = new MappingRecordItemBuilder()
+ .setMappingRecord(OLD_MAPPING_RECORD_1);
+ final MapNotifyBuilder mapNotifyBuilder = getDefaultMapNotifyBuilder(mapRegister)
+ .setMappingRecordItem(new ArrayList<>());
+ mapNotifyBuilder.getMappingRecordItem().add(mappingRecordItemBuilder.build());
+
+ // no mapping changes
+ Mockito.when(mapService.getMapping(MappingOrigin.Southbound, IPV4_EID_1))
+ .thenReturn(OLD_MAPPING_DATA_1);
+
+ mappingData.setMergeEnabled(true);
+ mapServer.handleMapRegister(mapRegister);
+
+ final ArgumentCaptor<MappingData> captor = ArgumentCaptor.forClass(MappingData.class);
+ Mockito.verify(mapService).addMapping(Mockito.eq(MappingOrigin.Southbound), Mockito.eq(IPV4_EID_1),
+ Mockito.eq(mapRegister.getSiteId()), captor.capture());
+ assertEquals(captor.getValue().getRecord(), mappingData.getRecord());
+ Mockito.verify(notifyHandler).handleMapNotify(mapNotifyBuilder.setAuthenticationData(null).build(), null);
}
@Test
- public void handleMapRegisterIpv4__CloneNotOwnYouClown() throws Exception {
- mapRegisterBuilder = getDefaultMapRegisterBuilder();
- mapRegisterBuilder.setWantMapNotify(true);
- EidToLocatorRecordBuilder eidToLocatorBuilder = getDefaultEidToLocatorBuilder();
- eidToLocatorBuilder.setMaskLength((short) 32);
- eid = LispAFIConvertor.asIPv4Address("0.0.0.1");
- eidToLocatorBuilder.setLispAddressContainer(eid);
+ public void handleMapRegisterTest_findNegativeSubscribers() throws NoSuchFieldException, IllegalAccessException {
+ setConfigIniMappingMergeField(true);
- LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
- locatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("0.0.0.2")));
- locatorBuilder.setPriority((short) 55);
- eidToLocatorBuilder.getLocatorRecord().add(locatorBuilder.build());
+ mapRegister.getMappingRecordItem().clear();
+ mapRegister.getMappingRecordItem().add(getDefaultMappingRecordItemBuilder(IPV4_PREFIX_EID_1).build());
- mapRegisterBuilder.getEidToLocatorRecord().add(eidToLocatorBuilder.build());
+ final MappingRecordBuilder mappingRecordBuilder_1 = getDefaultMappingRecordBuilder()
+ // apply the change
+ .setEid(IPV4_PREFIX_EID_2);
+ final MappingRecordBuilder mappingRecordBuilder_2 = getDefaultMappingRecordBuilder();
+ final Eid maskedEid1 = LispAddressUtil.asIpv4Eid("1.2.0.0");
- addDefaultPutAndGetExpectations(eid);
+ final SubscriberRLOC subscriber1 = Mockito.mock(SubscriberRLOC.class);
+ Mockito.when(subscriber1.timedOut()).thenReturn(true);
+ Mockito.when(subscriber1.toString()).thenReturn("sub1");
- MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterBuilder.build());
+ final Set<SubscriberRLOC> set1 = Sets.newHashSet(subscriber1);
- EidToLocatorRecord actualEidToLocator = mapNotify.getEidToLocatorRecord().get(0);
- assertEquals(eid, actualEidToLocator.getLispAddressContainer());
- assertEquals((byte) 55, actualEidToLocator.getLocatorRecord().get(0).getPriority().byteValue());
+ Mockito.when(mapService.getAuthenticationKey(IPV4_PREFIX_EID_1)).thenReturn(MAPPING_AUTHKEY);
+ Mockito.when(mapService.getData(MappingOrigin.Southbound, IPV4_PREFIX_EID_1, SubKeys.SRC_RLOCS))
+ .thenReturn(DEFAULT_IP_ADDRESS_SET);
- }
+ Mockito.when(mapService.getParentPrefix(IPV4_PREFIX_EID_1)).thenReturn(maskedEid1);
+ Mockito.when(mapService.getData(MappingOrigin.Southbound, IPV4_PREFIX_EID_1, SubKeys.SUBSCRIBERS))
+ .thenReturn(null);
+ Mockito.when(mapService.getData(MappingOrigin.Southbound, maskedEid1, SubKeys.SUBSCRIBERS)).thenReturn(set1);
- @Test
- public void handleMapRegisterIpv4__ValidMask() throws Exception {
- int mask = 16;
- LispAddressContainer newEid = LispAFIConvertor.asIPv4Prefix(eidIpv4String, mask);
- mapRegisterBuilder = getDefaultMapRegisterBuilder();
- EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
- recordBuilder.setLispAddressContainer(newEid).setMaskLength((short) mask);
- LocatorRecordBuilder locator = getDefaultLocatorBuilder();
- locator.setLispAddressContainer(rloc);
- recordBuilder.getLocatorRecord().add(locator.build());
- mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
- mapRegisterBuilder.setWantMapNotify(true);
- MapRegister mr = mapRegisterBuilder.build();
-
- addDefaultPutAndGetExpectations(newEid);
-
- MapNotify mapNotify = testedMapServer.handleMapRegister(mr);
- assertEquals(newEid, mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
- ArrayAssert.assertEquals(mr.getAuthenticationData(), mapNotify.getAuthenticationData());
- assertEquals(mr.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
- assertEquals(mr.getKeyId(), mapNotify.getKeyId());
- assertEquals(mr.getNonce(), mapNotify.getNonce());
- }
+ Mockito.when(mapService.getMapping(MappingOrigin.Southbound, IPV4_PREFIX_EID_1))
+ .thenReturn(getDefaultMappingData(mappingRecordBuilder_1.build()))
+ .thenReturn(getDefaultMappingData(mappingRecordBuilder_2.build()))
+ .thenReturn(null);
- @Test
- public void handleMapRegister__NonMaskable() throws Exception {
- int mask = 16;
- mapRegisterBuilder = getDefaultMapRegisterBuilder();
- LispAddressContainer addr = LispAFIConvertor.toContainer(LispAFIConvertor.asMacAfiAddress("01:01:01:01:01:01"));
- EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
- LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
- locatorBuilder.setLispAddressContainer(rloc);
- recordBuilder.setLispAddressContainer(addr).setMaskLength((short) mask);
- recordBuilder.getLocatorRecord().add(locatorBuilder.build());
- mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
- mapRegisterBuilder.setWantMapNotify(true);
-
- addDefaultPutAndGetExpectations(addr);
-
- MapRegister mapRegister = mapRegisterBuilder.build();
-
- MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister);
- assertEquals(addr, mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
- ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData());
- assertEquals(mapRegister.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
- assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId());
- assertEquals(mapRegister.getNonce(), mapNotify.getNonce());
+ mapServer.handleMapRegister(mapRegister);
+ Mockito.verify(subscriber1).timedOut();
}
@Test
- public void handleMapRegister__ZeroMask() throws Exception {
- int mask = 0;
- mapRegisterBuilder = getDefaultMapRegisterBuilder();
- LispAddressContainer addr = LispAFIConvertor.toContainer(LispAFIConvertor.asMacAfiAddress("01:01:01:01:01:01"));
- EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
- LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
- locatorBuilder.setLispAddressContainer(rloc);
- recordBuilder.setLispAddressContainer(addr).setMaskLength((short) mask);
- recordBuilder.getLocatorRecord().add(locatorBuilder.build());
- mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
- mapRegisterBuilder.setWantMapNotify(true);
-
- addDefaultPutAndGetExpectations(addr);
-
- MapRegister mapRegister = mapRegisterBuilder.build();
-
- MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister);
- assertEquals(addr, mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
- ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData());
- assertEquals(mapRegister.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
- assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId());
- assertEquals(mapRegister.getNonce(), mapNotify.getNonce());
+ public void handleMapRegisterTest_verifyTransportAddresses() throws NoSuchFieldException, IllegalAccessException {
+ setConfigIniMappingMergeField(true);
+
+ // input
+ Mockito.when(mapService.getAuthenticationKey(IPV4_EID_1)).thenReturn(MAPPING_AUTHKEY);
+ Mockito.when(mapService.getMapping(MappingOrigin.Southbound, IPV4_EID_1))
+ .thenReturn(OLD_MAPPING_DATA_1)
+ .thenReturn(OLD_MAPPING_DATA_2)
+ .thenReturn(getDefaultMappingData(getDefaultMappingRecordBuilder().build()));
+ Mockito.when(mapService.getData(MappingOrigin.Southbound, IPV4_EID_1, SubKeys.SUBSCRIBERS))
+ .thenReturn(subscriberSetMock_1);
+ Mockito.when(mapService.getData(MappingOrigin.Southbound, IPV4_EID_1, SubKeys.SRC_RLOCS))
+ .thenReturn(DEFAULT_IP_ADDRESS_SET);
+
+ // result
+ final List<TransportAddress> transportAddressList = getTransportAddressList();
+ final MapNotifyBuilder mapNotifyBuilder = getDefaultMapNotifyBuilder(mapRegister);
+ mapNotifyBuilder.setMappingRecordItem(new ArrayList<>());
+ mapNotifyBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
+ .setMappingRecord(getDefaultMappingRecordBuilder().build()).build());
+
+ mapServer.handleMapRegister(mapRegister);
+ Mockito.verify(notifyHandler).handleMapNotify(mapNotifyBuilder.build(), transportAddressList);
}
@Test
- public void handleMapRegisterIPv4__ZeroMask() throws Exception {
- int mask = 0;
- LispAddressContainer newEid = LispAFIConvertor.asIPv4Prefix(eidIpv4String, mask);
- mapRegisterBuilder = getDefaultMapRegisterBuilder();
- EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
- recordBuilder.setLispAddressContainer(newEid).setMaskLength((short) mask);
- LocatorRecordBuilder locator = getDefaultLocatorBuilder();
- locator.setLispAddressContainer(rloc);
- recordBuilder.getLocatorRecord().add(locator.build());
- mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
- mapRegisterBuilder.setWantMapNotify(true);
- MapRegister mr = mapRegisterBuilder.build();
-
- addDefaultPutAndGetExpectations(newEid);
-
- MapNotify mapNotify = testedMapServer.handleMapRegister(mr);
- assertEquals(newEid, mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
- ArrayAssert.assertEquals(mr.getAuthenticationData(), mapNotify.getAuthenticationData());
- assertEquals(mr.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
- assertEquals(mr.getKeyId(), mapNotify.getKeyId());
- assertEquals(mr.getNonce(), mapNotify.getNonce());
+ public void handleMapRegisterTest_withTwoMappingRecords() throws NoSuchFieldException, IllegalAccessException {
+ setConfigIniMappingMergeField(true);
+
+ // Input
+ // Add a MappingRecord with SrcDestKey Eid Type
+ final MappingRecordItemBuilder mappingRecordItemBuilder = new MappingRecordItemBuilder()
+ .setMappingRecord(getDefaultMappingRecordBuilder().setEid(SOURCE_DEST_KEY_EID).build());
+ final MapRegisterBuilder mapRegisterSrcDstBuilder = getDefaultMapRegisterBuilder();
+
+ final List<MappingRecordItem> list = mapRegisterSrcDstBuilder.getMappingRecordItem();
+ list.add(mappingRecordItemBuilder.build());
+
+ // ------------- Stubbing for SourceDestKey type Eid mapping -------------------
+
+ Mockito.when(mapService.getAuthenticationKey(SOURCE_DEST_KEY_EID)).thenReturn(MAPPING_AUTHKEY);
+ Mockito.when(mapService.getMapping(MappingOrigin.Southbound, SOURCE_DEST_KEY_EID))
+ // ensure mappings are different
+ .thenReturn(OLD_MAPPING_DATA_1)
+ .thenReturn(OLD_MAPPING_DATA_2)
+ .thenReturn(OLD_MAPPING_DATA_2);
+ // return a subscriberSet for SrcDestKeyEid MappingRecord
+ Mockito.when(mapService.getData(MappingOrigin.Southbound, SOURCE_DEST_KEY_EID, SubKeys.SUBSCRIBERS))
+ .thenReturn(subscriberSetMock_1);
+
+ // return a subscriberSet for SrcDestKeyEid destination MappingRecord
+ Mockito.when(mapService.getData(MappingOrigin.Southbound, SourceDestKeyHelper.getDstBinary(SOURCE_DEST_KEY_EID),
+ SubKeys.SUBSCRIBERS)).thenReturn(subscriberSetMock_2);
+
+ // ----------------- Stubbing for Ipv4 type Eid mapping ------------------------
+
+ Mockito.when(mapService.getAuthenticationKey(IPV4_EID_1)).thenReturn(MAPPING_AUTHKEY);
+ Mockito.when(mapService.getMapping(MappingOrigin.Southbound, IPV4_EID_1))
+ // ensure mappings are different
+ .thenReturn(OLD_MAPPING_DATA_1)
+ .thenReturn(OLD_MAPPING_DATA_2);
+ // return a subscriberSet for Ipv4Eid MappingRecord
+ Mockito.when(mapService.getData(MappingOrigin.Southbound, IPV4_EID_1,SubKeys.SUBSCRIBERS))
+ .thenReturn(subscriberSetMock_3);
+
+ // -----------------------------------------------------------------------------
+
+ // result
+ mapServer.handleMapRegister(mapRegisterSrcDstBuilder.build());
+
+ // for SrcDstKey mapping
+ final ArgumentCaptor<MapRequest> captor_1 = ArgumentCaptor.forClass(MapRequest.class);
+ Mockito.verify(notifyHandler, Mockito.times(1)).handleSMR(captor_1.capture(), Mockito.eq(RLOC_2));
+ Mockito.verify(mapService).addData(MappingOrigin.Southbound, SOURCE_DEST_KEY_EID, SubKeys.SUBSCRIBERS,
+ subscriberSetMock_1);
+ final Eid resultEid_1 = captor_1.getValue().getEidItem().iterator().next().getEid();
+ assertEquals(IPV4_SOURCE_EID_2, resultEid_1);
+
+ // for SrcDst destination mapping
+ final ArgumentCaptor<MapRequest> captor_2 = ArgumentCaptor.forClass(MapRequest.class);
+ Mockito.verify(notifyHandler, Mockito.times(1)).handleSMR(captor_2.capture(), Mockito.eq(RLOC_4));
+ Mockito.verify(mapService).addData(MappingOrigin.Southbound,
+ SourceDestKeyHelper.getDstBinary(SOURCE_DEST_KEY_EID),
+ SubKeys.SUBSCRIBERS, subscriberSetMock_2);
+ final Eid resultEid_2 = captor_2.getValue().getEidItem().iterator().next().getEid();
+ assertEquals(IPV4_SOURCE_EID_4, resultEid_2);
+
+ // for Ipv4 mapping
+ final ArgumentCaptor<MapRequest> captor_3 = ArgumentCaptor.forClass(MapRequest.class);
+ Mockito.verify(notifyHandler, Mockito.times(1)).handleSMR(captor_3.capture(), Mockito.eq(RLOC_6));
+ Mockito.verify(mapService).addData(MappingOrigin.Southbound, IPV4_EID_1, SubKeys.SUBSCRIBERS,
+ subscriberSetMock_3);
+ final Eid resultEid_3 = captor_3.getValue().getEidItem().iterator().next().getEid();
+ assertEquals(IPV4_SOURCE_EID_6, resultEid_3);
}
@Test
- public void handleMapRegisterIpv4__ValidMask32() throws Exception {
- int mask = 32;
- mapRegisterBuilder = getDefaultMapRegisterBuilder();
- EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
- recordBuilder.setLispAddressContainer(eid).setMaskLength((short) mask);
- LocatorRecordBuilder locator = getDefaultLocatorBuilder();
- locator.setLispAddressContainer(rloc);
- recordBuilder.getLocatorRecord().add(locator.build());
- mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
- mapRegisterBuilder.setWantMapNotify(true);
- MapRegister mr = mapRegisterBuilder.build();
-
- addDefaultPutAndGetExpectations(eid);
-
- MapNotify mapNotify = testedMapServer.handleMapRegister(mr);
- assertEquals(eid, mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
- ArrayAssert.assertEquals(mr.getAuthenticationData(), mapNotify.getAuthenticationData());
- assertEquals(mr.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
- assertEquals(mr.getKeyId(), mapNotify.getKeyId());
- assertEquals(mr.getNonce(), mapNotify.getNonce());
- }
+ @SuppressWarnings({ "unchecked", "rawtypes" })
+ public void mappingChangedTest_withDifferentEid() throws NoSuchFieldException, IllegalAccessException {
+ setConfigIniMappingMergeField(true);
- @Test
- public void handleMapRegisterIpv6__ValidMask96() throws Exception {
- int mask = 96;
- mapRegisterBuilder = getDefaultMapRegisterBuilder();
- LispAddressContainer addr = LispAFIConvertor.asIPv6Prefix(eidIpv6String, mask);
- EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
- LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
- locatorBuilder.setLispAddressContainer(rloc);
- recordBuilder.setLispAddressContainer(addr).setMaskLength((short) mask);
- recordBuilder.getLocatorRecord().add(locatorBuilder.build());
- mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
- mapRegisterBuilder.setWantMapNotify(true);
-
- addDefaultPutAndGetExpectations(addr);
-
- MapRegister mapRegister = mapRegisterBuilder.build();
-
- MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister);
- assertEquals(addr, mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
- ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData());
- assertEquals(mapRegister.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
- assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId());
- assertEquals(mapRegister.getNonce(), mapNotify.getNonce());
- }
+ final MappingRecordBuilder mappingRecordBuilder_1 = getDefaultMappingRecordBuilder()
+ // apply the change
+ .setEid(IPV4_EID_2);
+ final MappingRecordBuilder mappingRecordBuilder_2 = getDefaultMappingRecordBuilder();
+ final ArgumentCaptor<List> captor = ArgumentCaptor.forClass(List.class);
- @Test
- public void handleMapRegisterIpv6__ZeroMask() throws Exception {
- int mask = 0;
- mapRegisterBuilder = getDefaultMapRegisterBuilder();
- LispAddressContainer addr = LispAFIConvertor.asIPv6Prefix(eidIpv6String, mask);
- EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
- LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
- locatorBuilder.setLispAddressContainer(rloc);
- recordBuilder.setLispAddressContainer(addr).setMaskLength((short) mask);
- recordBuilder.getLocatorRecord().add(locatorBuilder.build());
- mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
- mapRegisterBuilder.setWantMapNotify(true);
-
- addDefaultPutAndGetExpectations(addr);
-
- MapRegister mapRegister = mapRegisterBuilder.build();
-
- MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister);
- assertEquals(addr, mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
- ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData());
- assertEquals(mapRegister.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
- assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId());
- assertEquals(mapRegister.getNonce(), mapNotify.getNonce());
- }
+ Mockito.when(mapService.getAuthenticationKey(IPV4_EID_1)).thenReturn(MAPPING_AUTHKEY);
+ Mockito.when(mapService.getData(MappingOrigin.Southbound, IPV4_EID_1, SubKeys.SRC_RLOCS))
+ .thenReturn(DEFAULT_IP_ADDRESS_SET);
- @Test
- public void handleMapRegisterIpv6__ValidMask48() throws Exception {
- int mask = 48;
- mapRegisterBuilder = getDefaultMapRegisterBuilder();
- LispAddressContainer addr = LispAFIConvertor.asIPv6Prefix(eidIpv6String, mask);
- EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
- LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
- locatorBuilder.setLispAddressContainer(rloc);
- recordBuilder.setLispAddressContainer(addr).setMaskLength((short) mask);
- recordBuilder.getLocatorRecord().add(locatorBuilder.build());
- mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
- mapRegisterBuilder.setWantMapNotify(true);
-
- addDefaultPutAndGetExpectations(addr);
-
- MapRegister mapRegister = mapRegisterBuilder.build();
-
- MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister);
- assertEquals(addr, mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
- ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData());
- assertEquals(mapRegister.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
- assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId());
- assertEquals(mapRegister.getNonce(), mapNotify.getNonce());
- }
+ Mockito.when(mapService.getMapping(MappingOrigin.Southbound, IPV4_EID_1))
+ .thenReturn(getDefaultMappingData(mappingRecordBuilder_1.build()))
+ .thenReturn(getDefaultMappingData(mappingRecordBuilder_2.build()))
+ .thenReturn(null);
- @Test
- public void handleMapRegisterIpv6__ValidMask128() throws Exception {
- int mask = 128;
- mapRegisterBuilder = getDefaultMapRegisterBuilder();
- LispAddressContainer addr = LispAFIConvertor.asIPv6Address(eidIpv6String);
- EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
- LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
- locatorBuilder.setLispAddressContainer(rloc);
- recordBuilder.setLispAddressContainer(addr).setMaskLength((short) mask);
- recordBuilder.getLocatorRecord().add(locatorBuilder.build());
- mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
- mapRegisterBuilder.setWantMapNotify(true);
-
- addDefaultPutAndGetExpectations(addr);
-
- MapRegister mapRegister = mapRegisterBuilder.build();
-
- MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister);
- assertEquals(addr, mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
- ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData());
- assertEquals(mapRegister.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
- assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId());
- assertEquals(mapRegister.getNonce(), mapNotify.getNonce());
+ mapServer.handleMapRegister(mapRegister);
+ Mockito.verify(notifyHandler).handleMapNotify(Mockito.any(MapNotify.class), captor.capture());
+ // verify that a list of transport addresses has 2 values - happens only if mappingUpdated == true
+ assertEquals(2, captor.getValue().size());
}
@Test
- public void handleMapRegisterIPV4AndIpv6__ValidMask96() throws Exception {
- int mask = 96;
- mapRegisterBuilder = getDefaultMapRegisterBuilder();
- EidToLocatorRecordBuilder recordBuilder0 = getDefaultEidToLocatorBuilder();
- recordBuilder0.setLispAddressContainer(eid).setMaskLength((short) 32);
- LispAddressContainer addr = LispAFIConvertor.asIPv6Prefix(eidIpv6String, mask);
- EidToLocatorRecordBuilder recordBuilder1 = getDefaultEidToLocatorBuilder();
- LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
- locatorBuilder.setLispAddressContainer(rloc);
- locatorBuilder.setLispAddressContainer(rloc);
- recordBuilder1.setLispAddressContainer(addr).setMaskLength((short) mask);
- recordBuilder1.getLocatorRecord().add(locatorBuilder.build());
- mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder0.build());
- mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder1.build());
- mapRegisterBuilder.setWantMapNotify(true);
-
- addDefaultPutAndGetExpectations(eid);
- addDefaultPutAndGetExpectations(addr);
-
- MapRegister mapRegister = mapRegisterBuilder.build();
-
- MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister);
- assertEquals(eid, mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
- assertEquals(addr, mapNotify.getEidToLocatorRecord().get(1).getLispAddressContainer());
- ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData());
- assertEquals(mapRegister.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
- assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId());
- assertEquals(mapRegister.getNonce(), mapNotify.getNonce());
- }
+ @SuppressWarnings({ "unchecked", "rawtypes" })
+ public void mappingChangedTest_withDifferentRLOC() throws NoSuchFieldException, IllegalAccessException {
+ setConfigIniMappingMergeField(true);
- @Test
- public void handleMapRegister__MultipleRLOCs() throws Exception {
- addDefaultPutAndGetExpectations(eid);
-
- mapRegisterBuilder = getDefaultMapRegisterBuilder();
- LispAddressContainer rloc0 = rloc;
- LispAddressContainer rloc1 = LispAFIConvertor.asIPv6Address("0:0:0:0:0:0:0:7");
- EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
- recordBuilder.setLispAddressContainer(eid);
- LocatorRecordBuilder locatorBuilder1 = getDefaultLocatorBuilder();
- locatorBuilder1.setLispAddressContainer(rloc0);
- LocatorRecordBuilder locatorBuilder2 = getDefaultLocatorBuilder();
- locatorBuilder2.setLispAddressContainer(rloc1);
- recordBuilder.getLocatorRecord().add(locatorBuilder1.build());
- recordBuilder.getLocatorRecord().add(locatorBuilder2.build());
-
- mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
-
- testedMapServer.handleMapRegister(mapRegisterBuilder.build());
-
- MappingEntry<?>[] entries = mappingEntriesSaver.lastValue;
- assertEquals(1, entries.length);
-
- assertEquals(SubKeys.RECORD, entries[0].getKey());
- assertEquals(rloc0, ((EidToLocatorRecord) entries[0].getValue()).getLocatorRecord()
- .get(0).getLispAddressContainer());
- assertEquals(rloc1, ((EidToLocatorRecord) entries[0].getValue()).getLocatorRecord()
- .get(1).getLispAddressContainer());
+ final MappingRecordBuilder mappingRecordBuilder_1 = getDefaultMappingRecordBuilder();
+ // apply the change
+ mappingRecordBuilder_1.getLocatorRecord().add(new LocatorRecordBuilder().build());
+ final MappingRecordBuilder mappingRecordBuilder_2 = getDefaultMappingRecordBuilder();
+ final ArgumentCaptor<List> captor = ArgumentCaptor.forClass(List.class);
- }
+ Mockito.when(mapService.getAuthenticationKey(IPV4_EID_1)).thenReturn(MAPPING_AUTHKEY);
+ Mockito.when(mapService.getData(MappingOrigin.Southbound, IPV4_EID_1, SubKeys.SRC_RLOCS))
+ .thenReturn(DEFAULT_IP_ADDRESS_SET);
- @Test
- public void handleMapRegister__MultipleTypes() throws Exception {
- addDefaultPutAndGetExpectations(eid);
-
- mapRegisterBuilder = getDefaultMapRegisterBuilder();
- LispAddressContainer rloc0 = rloc;
- // LispAFIAddress rloc1 =
- // LispAFIConvertor.asIPv6AfiAddress("0:0:0:0:0:0:0:7");
- String subkey = "bla";
- LispAFIAddress rloc1 = LispAFIConvertor
- .asKeyValue(subkey, LispAFIConvertor.toPrimitive(LispAFIConvertor.asIPv6AfiAddress("0:0:0:0:0:0:0:7")));
- EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
- recordBuilder.setLispAddressContainer(eid);
- LocatorRecordBuilder locatorBuilder1 = getDefaultLocatorBuilder();
- locatorBuilder1.setLispAddressContainer(rloc0);
- LocatorRecordBuilder locatorBuilder2 = getDefaultLocatorBuilder();
- locatorBuilder2.setLispAddressContainer(LispAFIConvertor.toContainer(rloc1));
- recordBuilder.getLocatorRecord().add(locatorBuilder1.build());
- recordBuilder.getLocatorRecord().add(locatorBuilder2.build());
-
- mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
-
- testedMapServer.handleMapRegister(mapRegisterBuilder.build());
-
- MappingEntry<?>[] entries = mappingEntriesSaver.lastValue;
- assertEquals(1, entries.length);
- EidToLocatorRecord storedMapping = (EidToLocatorRecord) entries[0].getValue();
- assertEquals(2, storedMapping.getLocatorRecord().size());
- assertEquals(SubKeys.RECORD, entries[0].getKey());
- assertEquals(rloc0, storedMapping.getLocatorRecord().get(0).getLispAddressContainer());
- assertEquals(LispAFIConvertor.toContainer(rloc1), storedMapping.getLocatorRecord().get(1)
- .getLispAddressContainer());
+ Mockito.when(mapService.getMapping(MappingOrigin.Southbound, IPV4_EID_1))
+ .thenReturn(getDefaultMappingData(mappingRecordBuilder_1.build()))
+ .thenReturn(getDefaultMappingData(mappingRecordBuilder_2.build()))
+ .thenReturn(null);
+ mapServer.handleMapRegister(mapRegister);
+ Mockito.verify(notifyHandler).handleMapNotify(Mockito.any(MapNotify.class), captor.capture());
+ // verify that a list of transport addresses has 2 values - happens only if mappingUpdated == true
+ assertEquals(2, captor.getValue().size());
}
@Test
- public void handleMapRegister__TestOverwrite() throws Exception {
- addDefaultPutAndGetExpectations(eid);
+ @SuppressWarnings({ "unchecked", "rawtypes" })
+ public void mappingChangedTest_withDifferentAction() throws NoSuchFieldException, IllegalAccessException {
+ setConfigIniMappingMergeField(true);
- addEidToLocatorRecord();
+ final MappingRecordBuilder mappingRecordBuilder_1 = getDefaultMappingRecordBuilder()
+ // apply the change
+ .setAction(MappingRecord.Action.NativelyForward);
+ final MappingRecordBuilder mappingRecordBuilder_2 = getDefaultMappingRecordBuilder();
+ final ArgumentCaptor<List> captor = ArgumentCaptor.forClass(List.class);
- MappingEntry<?>[] entries = mappingEntriesSaver.lastValue;
- assertEquals(1, entries.length);
+ Mockito.when(mapService.getAuthenticationKey(IPV4_EID_1)).thenReturn(MAPPING_AUTHKEY);
+ Mockito.when(mapService.getData(MappingOrigin.Southbound, IPV4_EID_1, SubKeys.SRC_RLOCS))
+ .thenReturn(DEFAULT_IP_ADDRESS_SET);
- assertEquals(SubKeys.RECORD, entries[0].getKey());
- assertEquals(rloc, ((EidToLocatorRecord) entries[0].getValue()).getLocatorRecord()
- .get(0).getLispAddressContainer());
- }
+ Mockito.when(mapService.getMapping(MappingOrigin.Southbound, IPV4_EID_1))
+ .thenReturn(getDefaultMappingData(mappingRecordBuilder_1.build()))
+ .thenReturn(getDefaultMappingData(mappingRecordBuilder_2.build()))
+ .thenReturn(null);
-// @Test
-// public void handleMapRegister__TestDontOverwrite() throws Exception {
-// int hc = rloc.getAddress().hashCode();
-//
-// addDefaultPutAndGetExpectations(eid);
-// testedMapServer.setOverwrite(false);
-//
-// addEidToLocatorRecord();
-//
-// MappingEntry<?>[] entries = mappingEntriesSaver.lastValue;
-// assertEquals(1, entries.length);
-//
-// assertEquals(String.valueOf(hc), entries[0].getKey());
-// assertEquals(rloc, ((EidToLocatorRecord) entries[0].getValue()).getLocatorRecord()
-// .get(0).getLispAddressContainer());
-// }
-
- private void addEidToLocatorRecord() {
- EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
- recordBuilder.setLispAddressContainer(eid);
- LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
- locatorBuilder.setLispAddressContainer(rloc);
- recordBuilder.getLocatorRecord().add(locatorBuilder.build());
-
- mapRegisterBuilder = getDefaultMapRegisterBuilder();
- mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
-
- testedMapServer.handleMapRegister(mapRegisterBuilder.build());
+ mapServer.handleMapRegister(mapRegister);
+ Mockito.verify(notifyHandler).handleMapNotify(Mockito.any(MapNotify.class), captor.capture());
+ // verify that a list of transport addresses has 2 values - happens only if mappingUpdated == true
+ assertEquals(2, captor.getValue().size());
}
@Test
- public void handleMapRegister__MultipleEIDs() throws Exception {
- addDefaultPutAndGetExpectations(eid);
-
- LispAddressContainer rloc1 = LispAFIConvertor.asIPv6Address("0:0:0:0:0:0:0:7");
- mapRegisterBuilder = getDefaultMapRegisterBuilder();
- EidToLocatorRecordBuilder etlrBuilder = getDefaultEidToLocatorBuilder();
- etlrBuilder.getLocatorRecord().add(getDefaultLocatorBuilder().setLispAddressContainer(rloc1).build());
- mapRegisterBuilder.setWantMapNotify(true);
- etlrBuilder.setLispAddressContainer(eid);
-
- EidToLocatorRecordBuilder etlr2Builder = getDefaultEidToLocatorBuilder();
- LispAddressContainer address = LispAFIConvertor.asIPv4Address("1.1.1.1");
- etlr2Builder.setLispAddressContainer(address);
- etlr2Builder.setMaskLength((short) 32);
- int recordTtl = 5;
- etlr2Builder.setRecordTtl(recordTtl);
- etlr2Builder.getLocatorRecord().add(
- getDefaultLocatorBuilder().setPriority((short) 10)
- .setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("2.2.2.2"))).build());
- mapRegisterBuilder.getEidToLocatorRecord().add(etlrBuilder.build());
- mapRegisterBuilder.getEidToLocatorRecord().add(etlr2Builder.build());
- addDefaultPutAndGetExpectations(address);
- MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterBuilder.build());
-
- assertEquals(rloc1, mapNotify.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)
- .getLispAddressContainer());
- assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("2.2.2.2")), mapNotify.getEidToLocatorRecord().get(1)
- .getLocatorRecord().get(0).getLispAddressContainer());
- assertEquals(address, mapNotify.getEidToLocatorRecord().get(1).getLispAddressContainer());
- assertEquals(recordTtl, mapNotify.getEidToLocatorRecord().get(1).getRecordTtl().intValue());
+ @SuppressWarnings({ "unchecked", "rawtypes" })
+ public void mappingChangedTest_withDifferentTTL() throws NoSuchFieldException, IllegalAccessException {
+ setConfigIniMappingMergeField(true);
- }
+ final MappingRecordBuilder mappingRecordBuilder_1 = getDefaultMappingRecordBuilder()
+ // apply the change
+ .setRecordTtl(10);
+ final MappingRecordBuilder mappingRecordBuilder_2 = getDefaultMappingRecordBuilder();
+ final ArgumentCaptor<List> captor = ArgumentCaptor.forClass(List.class);
- @Test
- public void handleMapRegisterIpv4__CheckWrongPassword() throws Exception {
+ Mockito.when(mapService.getAuthenticationKey(IPV4_EID_1)).thenReturn(MAPPING_AUTHKEY);
+ Mockito.when(mapService.getData(MappingOrigin.Southbound, IPV4_EID_1, SubKeys.SRC_RLOCS))
+ .thenReturn(DEFAULT_IP_ADDRESS_SET);
- addGetExpectations(LispAFIConvertor.asIPv4Address("153.16.254.1"), 0, 31, "bla");
- MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterWithAuthentication);
- assertEquals(null, mapNotify);
- }
+ Mockito.when(mapService.getMapping(MappingOrigin.Southbound, IPV4_EID_1))
+ .thenReturn(getDefaultMappingData(mappingRecordBuilder_1.build()))
+ .thenReturn(getDefaultMappingData(mappingRecordBuilder_2.build()))
+ .thenReturn(null);
- @Test
- public void handleMapRegisterIpv4__CheckNoPasswordAndThenPassword() throws Exception {
-
- addGetExpectations(LispAFIConvertor.asIPv4Address("153.16.254.1"), 0, 25, "password");
- addPutExpectations(LispAFIConvertor.asIPv4Address("153.16.254.1"));
- MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterWithAuthentication);
- assertEquals(mapRegisterWithAuthentication.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
- assertEquals(mapRegisterWithAuthentication.getKeyId(), mapNotify.getKeyId());
- assertEquals(mapRegisterWithAuthentication.getNonce(), mapNotify.getNonce());
+ mapServer.handleMapRegister(mapRegister);
+ Mockito.verify(notifyHandler).handleMapNotify(Mockito.any(MapNotify.class), captor.capture());
+ // verify that a list of transport addresses has 2 values - happens only if mappingUpdated == true
+ assertEquals(2, captor.getValue().size());
}
@Test
- public void handleMapRegisterIpv4__CheckNoPassword() throws Exception {
+ @SuppressWarnings({ "unchecked", "rawtypes" })
+ public void mappingChangedTest_withDifferentMapVersion() throws NoSuchFieldException, IllegalAccessException {
+ setConfigIniMappingMergeField(true);
- addGetExpectations(LispAFIConvertor.asIPv4Address("153.16.254.1"), 30, 0, "password");
- MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterWithAuthentication);
- assertEquals(null, mapNotify);
- }
+ final MappingRecordBuilder mappingRecordBuilder_1 = getDefaultMappingRecordBuilder()
+ // apply the change
+ .setMapVersion((short) 10);
+ final MappingRecordBuilder mappingRecordBuilder_2 = getDefaultMappingRecordBuilder();
+ final ArgumentCaptor<List> captor = ArgumentCaptor.forClass(List.class);
- @Test
- public void handleMapRegisterIpv4__CheckNoreturn() throws Exception {
+ Mockito.when(mapService.getAuthenticationKey(IPV4_EID_1)).thenReturn(MAPPING_AUTHKEY);
+ Mockito.when(mapService.getData(MappingOrigin.Southbound, IPV4_EID_1, SubKeys.SRC_RLOCS))
+ .thenReturn(DEFAULT_IP_ADDRESS_SET);
- addGetExpectations(LispAFIConvertor.asIPv4Address("153.16.254.1"));
- MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterWithAuthentication);
- assertEquals(mapNotify, null);
+
+ Mockito.when(mapService.getMapping(MappingOrigin.Southbound, IPV4_EID_1))
+ .thenReturn(getDefaultMappingData(mappingRecordBuilder_1.build()))
+ .thenReturn(getDefaultMappingData(mappingRecordBuilder_2.build()))
+ .thenReturn(null);
+
+ mapServer.handleMapRegister(mapRegister);
+ Mockito.verify(notifyHandler).handleMapNotify(Mockito.any(MapNotify.class), captor.capture());
+ // verify that a list of transport addresses has 2 values - happens only if mappingUpdated == true
+ assertEquals(2, captor.getValue().size());
}
- private void addDefaultPutAndGetExpectations(LispAddressContainer addr) {
- addPutExpectations(addr);
- addGetExpectations(addr);
+ @Test
+ @SuppressWarnings({ "unchecked", "rawtypes" })
+ public void mappingChangedTest_withNullMap() throws NoSuchFieldException, IllegalAccessException {
+ setConfigIniMappingMergeField(true);
+
+ final MappingRecordBuilder mappingRecordBuilder_2 = getDefaultMappingRecordBuilder();
+ final ArgumentCaptor<List> captor = ArgumentCaptor.forClass(List.class);
+
+ Mockito.when(mapService.getAuthenticationKey(IPV4_EID_1)).thenReturn(MAPPING_AUTHKEY);
+ Mockito.when(mapService.getData(MappingOrigin.Southbound, IPV4_EID_1, SubKeys.SRC_RLOCS))
+ .thenReturn(DEFAULT_IP_ADDRESS_SET);
+
+ Mockito.when(mapService.getMapping(MappingOrigin.Southbound, IPV4_EID_1))
+ .thenReturn(null)
+ .thenReturn(getDefaultMappingData(mappingRecordBuilder_2.build()))
+ .thenReturn(null);
+
+ mapServer.handleMapRegister(mapRegister);
+ Mockito.verify(notifyHandler).handleMapNotify(Mockito.any(MapNotify.class), captor.capture());
+ // verify that a list of transport addresses has 2 values - happens only if mappingUpdated == true
+ assertEquals(2, captor.getValue().size());
+ }
+
+ private static MapRegisterBuilder getDefaultMapRegisterBuilder() {
+ final MapRegisterBuilder mapRegisterBuilder = new MapRegisterBuilder()
+ .setProxyMapReply(true)
+ .setWantMapNotify(true)
+ .setKeyId((short) 0)
+ .setMappingRecordItem(new ArrayList<>())
+ .setMergeEnabled(true)
+ .setNonce(1L)
+ .setSiteId(new SiteId(new byte[]{0, 1, 2, 3, 4, 5, 6, 7}))
+ .setXtrId(new XtrId(new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}))
+ .setXtrSiteIdPresent(true);
+ mapRegisterBuilder.getMappingRecordItem().add(getDefaultMappingRecordItemBuilder().build());
+
+ return mapRegisterBuilder;
+ }
+
+ private static MappingData getDefaultMappingData(MappingRecord mappingRecord) {
+ if (mappingRecord == null) {
+ mappingRecord = getDefaultMappingRecordBuilder().build();
+ }
+ return new MappingData(mappingRecord, System.currentTimeMillis());
}
- private void addGetExpectations(LispAddressContainer address) {
- addGetExpectations(address, 0, 0, SubKeys.AUTH_KEY);
+ private static MappingRecordItemBuilder getDefaultMappingRecordItemBuilder() {
+ return getDefaultMappingRecordItemBuilder(IPV4_EID_1);
}
- private EidToLocatorRecord toEidToLocatorRecord(Mapping record) {
- return new EidToLocatorRecordBuilder(
- (org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.EidToLocatorRecord) record)
- .build();
+ private static MappingRecordItemBuilder getDefaultMappingRecordItemBuilder(Eid eid) {
+ return new MappingRecordItemBuilder()
+ .setMappingRecordItemId("mapping-record-item-id")
+ .setKey(new MappingRecordItemKey("mapping-record-item-key"))
+ .setMappingRecord(getDefaultMappingRecordBuilder(eid).build());
}
- private void prepareDsbe() {
- ValueSaverAction<Mapping> dsbeAddMappingSaverAction = new ValueSaverAction<Mapping>() {
- @Override
- public Object invoke(Invocation invocation) throws Throwable {
- mapSystem.addMapping(lastValue.getOrigin(), lastValue.getLispAddressContainer(), (Object) toEidToLocatorRecord(lastValue));
- return null;
- }
- };
- oneOf(dsbe).addMapping(with(dsbeAddMappingSaverAction)); will(dsbeAddMappingSaverAction);
+ private static MappingRecordBuilder getDefaultMappingRecordBuilder() {
+ return getDefaultMappingRecordBuilder(IPV4_EID_1);
}
- private void addPutExpectations(LispAddressContainer address) {
- // needed for mapping-service addMapping
- prepareDsbe();
- exactly(2).of(dao).put(weq(address), with(mappingEntriesSaver));
+ private static MappingRecordBuilder getDefaultMappingRecordBuilder(Eid eid) {
+ return new MappingRecordBuilder()
+ .setAction(MappingRecord.Action.NoAction)
+ .setAuthoritative(false)
+ .setLocatorRecord(new ArrayList<>())
+ .setMapVersion((short) 0)
+ .setRecordTtl(60)
+ .setEid(eid);
}
- private void addGetExpectations(LispAddressContainer address, int withoutPassword, int withPassword, String password) {
- if (withoutPassword > 0) {
- String result = null;
- result = null;
- allowing(dao).getSpecific(with(address), with(SubKeys.AUTH_KEY));
- ret(result);
- }
- if (withPassword > 0) {
- String result = null;
- result = password;
- allowing(dao).getSpecific(with(address), with(SubKeys.AUTH_KEY));
- ret(result);
- }
- for (int i = MaskUtil.getMaskForAddress(address); i >= 0; i--) {
- LispAddressContainer addr = MaskUtil.normalize(address, (short) i);
- allowing(dao).getSpecific(with(addr), with(SubKeys.AUTH_KEY)); ret(null);
- // check if mapping exists before insertion
- allowing(dao).get(with(addr));will(returnValue(null));
- }
+ private static MapNotifyBuilder getDefaultMapNotifyBuilder(MapRegister mapRegister) {
+ final MapNotifyBuilder mapNotifyBuilder = new MapNotifyBuilder()
+ .setXtrSiteIdPresent(mapRegister.isXtrSiteIdPresent())
+ .setSiteId(mapRegister.getSiteId())
+ .setXtrId(mapRegister.getXtrId())
+ .setNonce(mapRegister.getNonce())
+ .setKeyId(mapRegister.getKeyId())
+ .setMergeEnabled(mapRegister.isMergeEnabled())
+ .setMappingRecordItem(new ArrayList<>())
+ .setAuthenticationData(new byte[]{});
+ mapNotifyBuilder.getMappingRecordItem().add(getDefaultMappingRecordItemBuilder().build());
+ return mapNotifyBuilder;
}
- private LispAddressContainer getDefaultKey() {
- return getKey(32);
+ private static void setConfigIniMappingMergeField(boolean value) throws NoSuchFieldException,
+ IllegalAccessException {
+ final Field mappingMergeField = CONFIG_INI.getClass().getDeclaredField("mappingMerge");
+ mappingMergeField.setAccessible(true);
+ mappingMergeField.setBoolean(CONFIG_INI, value);
}
- private LispAddressContainer getKey(int mask) {
- return MaskUtil.normalize(eid, (short)mask);
- }
+ private static Set<IpAddressBinary> getDefaultIpAddressSet() {
+ final Set<IpAddressBinary> addressSet = Sets.newHashSet(IPV4_BINARY_1, IPV4_BINARY_2);
- private MapRegisterBuilder getDefaultMapRegisterBuilder() {
- MapRegisterBuilder mrb = new MapRegisterBuilder();
- mrb.setKeyId((short) 0);
- mrb.setNonce((long) 0);
- mrb.setWantMapNotify(false);
- mrb.setProxyMapReply(false);
- mrb.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
- mrb.setAuthenticationData(new byte[0]);
- return mrb;
+ return addressSet;
}
- private EidToLocatorRecordBuilder getDefaultEidToLocatorBuilder() {
- EidToLocatorRecordBuilder builder = new EidToLocatorRecordBuilder();
- builder.setAction(Action.NoAction);
- builder.setAuthoritative(false);
- builder.setLocatorRecord(new ArrayList<LocatorRecord>());
- builder.setMapVersion((short) 0);
- builder.setMaskLength((short) 32);
- builder.setRecordTtl(60);
- return builder;
- }
+ private static List<TransportAddress> getTransportAddressList() {
+ TransportAddressBuilder transportAddressBuilder1 = new TransportAddressBuilder()
+ .setIpAddress(IPV4_BINARY_1)
+ .setPort(new PortNumber(LispMessage.PORT_NUM));
+
+ TransportAddressBuilder transportAddressBuilder2 = new TransportAddressBuilder()
+ .setIpAddress(IPV4_BINARY_2)
+ .setPort(new PortNumber(LispMessage.PORT_NUM));
+
+ final List<TransportAddress> transportAddressList = Lists.newArrayList(
+ transportAddressBuilder1.build(),
+ transportAddressBuilder2.build());
- private LocatorRecordBuilder getDefaultLocatorBuilder() {
- LocatorRecordBuilder builder = new LocatorRecordBuilder();
- builder.setLocalLocator(false);
- builder.setMulticastPriority((short) 0);
- builder.setMulticastWeight((short) 0);
- builder.setPriority((short) 0);
- builder.setRlocProbed(false);
- builder.setRouted(false);
- builder.setWeight((short) 0);
- return builder;
+ return transportAddressList;
}
}
Code Review / lispflowmapping.git / blobdiff