X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=mappingservice%2Fimplementation%2Fsrc%2Ftest%2Fjava%2Forg%2Fopendaylight%2Flispflowmapping%2Fimplementation%2Flisp%2FMapResolverTest.java;h=bd8ba5f23c709e0dd592de76c7a2c0fc3e9f31d2;hb=1f051e788b136bc72e8ef483aa2055fe49b3c224;hp=5ab644249a6b020a107c5a155aa90bd1d43f7104;hpb=0313c0f20bb9a8f229e958fe09a022ab97c2720f;p=lispflowmapping.git diff --git a/mappingservice/implementation/src/test/java/org/opendaylight/lispflowmapping/implementation/lisp/MapResolverTest.java b/mappingservice/implementation/src/test/java/org/opendaylight/lispflowmapping/implementation/lisp/MapResolverTest.java index 5ab644249..bd8ba5f23 100644 --- a/mappingservice/implementation/src/test/java/org/opendaylight/lispflowmapping/implementation/lisp/MapResolverTest.java +++ b/mappingservice/implementation/src/test/java/org/opendaylight/lispflowmapping/implementation/lisp/MapResolverTest.java @@ -1,163 +1,396 @@ -package org.opendaylight.lispflowmapping.implementation.lisp; - -import static org.junit.Assert.assertEquals; - -import java.util.HashMap; -import java.util.Map; - -import junit.framework.Assert; - -import org.junit.Before; -import org.junit.Test; -import org.opendaylight.lispflowmapping.interfaces.dao.ILispDAO; -import org.opendaylight.lispflowmapping.type.lisp.EidRecord; -import org.opendaylight.lispflowmapping.type.lisp.EidToLocatorRecord; -import org.opendaylight.lispflowmapping.type.lisp.LocatorRecord; -import org.opendaylight.lispflowmapping.type.lisp.MapReply; -import org.opendaylight.lispflowmapping.type.lisp.MapRequest; -import org.opendaylight.lispflowmapping.type.lisp.address.LispAddress; -import org.opendaylight.lispflowmapping.type.lisp.address.LispIpv4Address; -import org.opendaylight.lispflowmapping.type.lisp.address.LispIpv6Address; -import org.opendaylight.lispflowmapping.tools.junit.BaseTestCase; - /* - * Copyright (c) 2013 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; -public class MapResolverTest extends BaseTestCase { - - private MapResolver testedMapResolver; - - private ILispDAO lispDAO; - private MapRequest mapRequest; - private LispIpv4Address v4Address; +import java.util.ArrayList; +import java.util.List; +import java.util.Set; +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mockito; +import org.opendaylight.lispflowmapping.implementation.LispMappingService; +import org.opendaylight.lispflowmapping.implementation.MappingService; +import org.opendaylight.lispflowmapping.implementation.config.ConfigIni; +import org.opendaylight.lispflowmapping.interfaces.dao.SubKeys; +import org.opendaylight.lispflowmapping.interfaces.dao.SubscriberRLOC; +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.IpAddress; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.list + .MappingRecordItemBuilder; +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.eid.list.EidItemBuilder; +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.locatorrecords.LocatorRecordKey; +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.mapreplymessage.MapReplyBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequest.ItrRloc; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequest.ItrRlocBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequest.ItrRlocKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequest.SourceEidBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequestnotification.MapRequestBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.rloc.container.Rloc; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingOrigin; +import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.mapping.authkey.container + .MappingAuthkeyBuilder; + +public class MapResolverTest { + + private static MapResolver mapResolver; + private static MappingService mapServiceMock; + private static Set subscriberSetMock; + private static LispMappingService lispMappingServiceMock; + + private static final String ITR_RLOC_KEY_STRING = "itr_rloc_key"; + private static final String ITR_RLOC_ID_STRING = "itr_rloc_id"; + 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_RLOC_STRING_1 = "100.100.100.100"; + private static final String IPV4_SOURCE = "127.0.0.1"; + private static final String IPV4_PREFIX_STRING = "/24"; + private static final String IPV6_STRING = "0:0:0:0:0:0:0:1"; + private static final String IPV6_PREFIX_STRING = "/128"; + + private static final LocatorRecordKey LOCATOR_RECORD_KEY = new LocatorRecordKey("key"); + private static final int TTL_RLOC_TIMED_OUT = 1; + + private static final IpAddress IPV4_ADDRESS_1 = new IpAddress(new Ipv4Address(IPV4_STRING_1)); + private static final IpAddress IPV4_ADDRESS_2 = new IpAddress(new Ipv4Address(IPV4_STRING_2)); + + private static final Eid IPV4_PREFIX_EID_1 = LispAddressUtil.asIpv4PrefixEid(IPV4_STRING_1 + IPV4_PREFIX_STRING); + private static final Eid IPV4_PREFIX_EID_2 = LispAddressUtil.asIpv4PrefixEid(IPV4_STRING_2 + IPV4_PREFIX_STRING); + private static final Eid IPV6_PREFIX_EID = LispAddressUtil.asIpv6PrefixEid(IPV6_STRING + IPV6_PREFIX_STRING); + private static final Eid SOURCE_DEST_KEY_EID = LispAddressUtil.asSrcDstEid(IPV4_SOURCE, IPV4_STRING_2, 24, 24, 0); + + private static final Rloc RLOC_1 = LispAddressUtil.asIpv4Rloc(IPV4_RLOC_STRING_1); + private static MapRequestBuilder mapRequestBuilder = getDefaultMapRequestBuilder(); + private static final SubscriberRLOC SUBSCRIBER_RLOC_1 = new SubscriberRLOC(RLOC_1, + LispAddressUtil.asIpv4Eid(IPV4_SOURCE)); - @Override @Before - public void before() throws Exception { - super.before(); - lispDAO = context.mock(ILispDAO.class); - testedMapResolver = new MapResolver(lispDAO); - - mapRequest = new MapRequest(); - v4Address = new LispIpv4Address(0x01020304); + @SuppressWarnings("unchecked") + public void init() throws Exception { + mapServiceMock = Mockito.mock(MappingService.class, "mapService"); + subscriberSetMock = Mockito.mock(Set.class); + lispMappingServiceMock = Mockito.mock(LispMappingService.class, "requestHandler"); + mapResolver = new MapResolver(mapServiceMock, true, ConfigIni.getInstance().getElpPolicy(), + lispMappingServiceMock); + mapRequestBuilder = getDefaultMapRequestBuilder(); } + /** + * Tests {@link MapResolver#handleMapRequest} method. + */ @Test - public void handleMapRequest__NumRLOCsMismatch() throws Exception { - mapRequest.addEidRecord(new EidRecord((byte) 0, v4Address)); - Map rlocs = prepareMapping(new LispIpv4Address(0x44332211)); - rlocs.put("NumRLOCs", 5); - - MapReply mapReply = testedMapResolver.handleMapRequest(mapRequest); - - EidToLocatorRecord eidToLocators = mapReply.getEidToLocatorRecords().get(0); - assertEquals(1, eidToLocators.getLocators().size()); - assertLocator(new LispIpv4Address(0x44332211), eidToLocators.getLocators().get(0)); + public void handleMapRequest__withSingleLocator() { + // input mapping + final LocatorRecordBuilder locatorRecordBuilder = getDefaultLocatorBuilder(); + final MappingRecordBuilder mappingRecordBuilder = getDefaultMappingRecordBuilder(); + mappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder.build()); + + Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), IPV4_PREFIX_EID_1)) + .thenReturn(mappingRecordBuilder.build()); + + // result + final MapReplyBuilder mapReplyBuilder = getDefaultMapReplyBuilder(); + mapReplyBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder() + .setMappingRecord(mappingRecordBuilder.build()).build()); + + mapResolver.handleMapRequest(mapRequestBuilder.build()); + Mockito.verify(lispMappingServiceMock).handleMapReply(mapReplyBuilder.build()); } + /** + * Tests {@link MapResolver#handleMapRequest} method. + */ @Test - public void handleMapRequest__BadRLOCType() throws Exception { - mapRequest.addEidRecord(new EidRecord((byte) 0, v4Address)); - Map rlocs = prepareMapping(new LispIpv4Address(0x71717171), new LispIpv4Address(0x44332211)); - rlocs.put("RLOC0", "Ooga booga"); - - MapReply mapReply = testedMapResolver.handleMapRequest(mapRequest); - - EidToLocatorRecord eidToLocators = mapReply.getEidToLocatorRecords().get(0); - assertEquals(1, eidToLocators.getLocators().size()); - assertLocator(new LispIpv4Address(0x44332211), eidToLocators.getLocators().get(0)); + public void handleMapRequest__withNoMapping() { + final MappingRecordBuilder mappingRecordBuilder = new MappingRecordBuilder() + .setAuthoritative(false) + .setMapVersion((short) 0) + .setEid(IPV4_PREFIX_EID_1) + .setAction(MappingRecord.Action.NativelyForward) + .setRecordTtl(TTL_RLOC_TIMED_OUT); + + + Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), IPV4_PREFIX_EID_1)) + .thenReturn(null); + Mockito.when(mapServiceMock.getAuthenticationKey(IPV4_PREFIX_EID_1)) + .thenReturn(new MappingAuthkeyBuilder().build()); + Mockito.when(mapServiceMock.getWidestNegativePrefix(IPV4_PREFIX_EID_1)).thenReturn(IPV4_PREFIX_EID_1); + + // result + final MapReplyBuilder mapReplyBuilder = getDefaultMapReplyBuilder(); + mapReplyBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder() + .setMappingRecord(mappingRecordBuilder.build()).build()); + + mapResolver.handleMapRequest(mapRequestBuilder.build()); + Mockito.verify(lispMappingServiceMock).handleMapReply(mapReplyBuilder.build()); } + /** + * Tests {@link MapResolver#handleMapRequest} method. + */ @Test - public void handleMapRequest__NoNumRLOCs() throws Exception { - mapRequest.addEidRecord(new EidRecord((byte) 0, v4Address)); - allowing(lispDAO).get(wany(LispAddress.class)); - ret(new HashMap()); - - MapReply mapReply = testedMapResolver.handleMapRequest(mapRequest); - - EidToLocatorRecord eidToLocators = mapReply.getEidToLocatorRecords().get(0); - assertEquals(0, eidToLocators.getLocators().size()); + public void handleMapRequest__withSubscribers() { + // input mapping + final LocatorRecordBuilder locatorRecordBuilder = getDefaultLocatorBuilder(); + final MappingRecordBuilder mappingRecordBuilder = getDefaultMappingRecordBuilder(); + mappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder.build()); + + Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), IPV4_PREFIX_EID_1)) + .thenReturn(mappingRecordBuilder.build()); + Mockito.when(mapServiceMock.getData(MappingOrigin.Southbound, IPV4_PREFIX_EID_1, SubKeys.SUBSCRIBERS)) + .thenReturn(subscriberSetMock); + Mockito.when(subscriberSetMock.contains(Mockito.any(SubscriberRLOC.class))).thenReturn(false); + + // result + final MapReplyBuilder mapReplyBuilder = getDefaultMapReplyBuilder(); + mapReplyBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder() + .setMappingRecord(mappingRecordBuilder.build()).build()); + + mapResolver.handleMapRequest(mapRequestBuilder.build()); + Mockito.verify(lispMappingServiceMock).handleMapReply(mapReplyBuilder.build()); + Mockito.verify(subscriberSetMock, Mockito.never()).remove(Mockito.any(SubscriberRLOC.class)); } + /** + * Tests {@link MapResolver#handleMapRequest} method. + */ @Test - public void handleMapRequest__IllegalNumRLOCs() throws Exception { - mapRequest.addEidRecord(new EidRecord((byte) 0, v4Address)); - Map rlocs = prepareMapping(new LispIpv4Address(0x44332211)); - rlocs.put("NumRLOCs", "Bla"); - - MapReply mapReply = testedMapResolver.handleMapRequest(mapRequest); - - EidToLocatorRecord eidToLocators = mapReply.getEidToLocatorRecords().get(0); - assertEquals(0, eidToLocators.getLocators().size()); + public void handleMapRequest__withSubscribersToRemove() { + // input mapping + final LocatorRecordBuilder locatorRecordBuilder = getDefaultLocatorBuilder(); + final MappingRecordBuilder mappingRecordBuilder = getDefaultMappingRecordBuilder(); + mappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder.build()); + + Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), IPV4_PREFIX_EID_1)) + .thenReturn(mappingRecordBuilder.build()); + Mockito.when(mapServiceMock.getData(MappingOrigin.Southbound, IPV4_PREFIX_EID_1, SubKeys.SUBSCRIBERS)) + .thenReturn(subscriberSetMock); + Mockito.when(subscriberSetMock.contains(new SubscriberRLOC( + mapRequestBuilder.getItrRloc().get(0).getRloc(), + mapRequestBuilder.getSourceEid().getEid()))) + .thenReturn(true); + + // result + final MapReplyBuilder mapReplyBuilder = getDefaultMapReplyBuilder(); + mapReplyBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder() + .setMappingRecord(mappingRecordBuilder.build()).build()); + + // check if a subscriber is re-instantiating when there already is one in the subscriber set + mapResolver.handleMapRequest(mapRequestBuilder.build()); + Mockito.verify(subscriberSetMock).remove(SUBSCRIBER_RLOC_1); + Mockito.verify(subscriberSetMock).add(SUBSCRIBER_RLOC_1); + Mockito.verify(lispMappingServiceMock).handleMapReply(mapReplyBuilder.build()); + Mockito.verify(mapServiceMock).addData(MappingOrigin.Southbound, IPV4_PREFIX_EID_1, + SubKeys.SUBSCRIBERS, subscriberSetMock); + + // verify that itrRloc is subscribed to dst address + mappingRecordBuilder.setEid(SOURCE_DEST_KEY_EID); + mapRequestBuilder.getEidItem().add(new EidItemBuilder().setEid(IPV4_PREFIX_EID_2).build()); + Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), IPV4_PREFIX_EID_2)) + .thenReturn(mappingRecordBuilder.build()); + + mapResolver.handleMapRequest(mapRequestBuilder.build()); + Mockito.verify(mapServiceMock).getData(MappingOrigin.Southbound, + SourceDestKeyHelper.getDstBinary(SOURCE_DEST_KEY_EID), SubKeys.SUBSCRIBERS); } + /** + * Tests {@link MapResolver#handleMapRequest} method. + */ @Test - public void handleMapRequest__ReplyWithSingleLocator() throws Exception { - mapRequest.addEidRecord(new EidRecord((byte) 0, v4Address)); - - prepareMapping(new LispIpv4Address(0x04030201)); - - MapReply mapReply = testedMapResolver.handleMapRequest(mapRequest); - - EidToLocatorRecord eidToLocators = mapReply.getEidToLocatorRecords().get(0); - assertEquals(1, eidToLocators.getLocators().size()); - - assertLocator(new LispIpv4Address(0x04030201), eidToLocators.getLocators().get(0)); + public void handleMapRequest_withBothPolicy() { + mapResolver = new MapResolver(mapServiceMock, true, "both", lispMappingServiceMock); + + final List ipAddressList = new ArrayList<>(); + ipAddressList.add(IPV4_ADDRESS_1); // hop 1 + ipAddressList.add(IPV4_ADDRESS_2); // hop 2 + + final Rloc rloc = LispAddressUtil.asTeLcafRloc(ipAddressList); + final LocatorRecordBuilder locatorRecordBuilder_1 = getDefaultLocatorBuilder(); + final LocatorRecordBuilder locatorRecordBuilder_2 = getDefaultLocatorBuilder().setRloc(rloc); + + // input mapping + final MappingRecordBuilder mappingRecordBuilder = getDefaultMappingRecordBuilder(); + mappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_1.build()); + mappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_2.build()); + + final MapRequestBuilder mapRequestBuilder = getDefaultMapRequestBuilder(); + mapRequestBuilder.getItrRloc().add(new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(IPV4_STRING_1)) + .build()); + mapRequestBuilder.getItrRloc().add(new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(IPV4_STRING_2)) + .build()); + + Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), IPV4_PREFIX_EID_1)) + .thenReturn(mappingRecordBuilder.build()); + + // result + final LocatorRecordBuilder locatorRecordBuilder_3 = getDefaultLocatorBuilder() + .setRloc(LispAddressUtil.asIpv4Rloc(IPV4_STRING_2)).setPriority((short) 1); // priority increased by 1 + final MappingRecordBuilder resultMappingRecordBuilder = getDefaultMappingRecordBuilder(); + + resultMappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_1.build()); // as Ipv4 + resultMappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_2.build()); // as ELP + resultMappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_3.build()); // added to the result + + final MapReplyBuilder mapReplyBuilder = getDefaultMapReplyBuilder(); + mapReplyBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder() + .setMappingRecord(resultMappingRecordBuilder.build()).build()); + + // invocation + mapResolver.handleMapRequest(mapRequestBuilder.build()); + Mockito.verify(lispMappingServiceMock).handleMapReply(mapReplyBuilder.build()); } - private Map prepareMapping(LispAddress... address) { - Map result = null; - if (address.length > 0) { - result = new HashMap(); - result.put("NumRLOCs", address.length); - for (int i = 0; i < address.length; i++) { - result.put("RLOC" + i, address[i]); - } - } - - oneOf(lispDAO).get(weq(v4Address)); - ret(result); - - return result; + /** + * Tests {@link MapResolver#handleMapRequest} method. + */ + @Test + public void handleMapRequest_withReplacePolicy() { + mapResolver = new MapResolver(mapServiceMock, true, "replace", lispMappingServiceMock); + + final List ipAddressList = new ArrayList<>(); + ipAddressList.add(IPV4_ADDRESS_1); // hop 1 + ipAddressList.add(IPV4_ADDRESS_2); // hop 2 + + final Rloc rloc = LispAddressUtil.asTeLcafRloc(ipAddressList); + final LocatorRecordBuilder locatorRecordBuilder_1 = getDefaultLocatorBuilder(); + final LocatorRecordBuilder locatorRecordBuilder_2 = getDefaultLocatorBuilder().setRloc(rloc); + + // input mapping + final MappingRecordBuilder mappingRecordBuilder = getDefaultMappingRecordBuilder(); + mappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_1.build()); + mappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_2.build()); + + final MapRequestBuilder mapRequestBuilder = getDefaultMapRequestBuilder(); + mapRequestBuilder.getItrRloc().add(new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(IPV4_STRING_1)) + .build()); + mapRequestBuilder.getItrRloc().add(new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(IPV4_STRING_2)) + .build()); + + Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), IPV4_PREFIX_EID_1)) + .thenReturn(mappingRecordBuilder.build()); + + // result + final LocatorRecordBuilder locatorRecordBuilder_3 = getDefaultLocatorBuilder() + .setRloc(LispAddressUtil.asIpv4Rloc(IPV4_STRING_2)); + final MappingRecordBuilder resultMappingRecordBuilder = getDefaultMappingRecordBuilder(); + + resultMappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_1.build()); // as Ipv4 + resultMappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_3.build()); // added to the result + + final MapReplyBuilder mapReplyBuilder = getDefaultMapReplyBuilder(); + mapReplyBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder() + .setMappingRecord(resultMappingRecordBuilder.build()).build()); + + // invocation + mapResolver.handleMapRequest(mapRequestBuilder.build()); + Mockito.verify(lispMappingServiceMock).handleMapReply(mapReplyBuilder.build()); } + /** + * Tests {@link MapResolver#handleMapRequest} method. + */ @Test - public void handleMapRequest__VerifyBasicFields() throws Exception { - mapRequest.addEidRecord(new EidRecord((byte) 0x20, v4Address)); - prepareMapping(); - - MapReply mapReply = testedMapResolver.handleMapRequest(mapRequest); - - assertEquals(mapRequest.getNonce(), mapReply.getNonce()); - EidToLocatorRecord eidToLocators = mapReply.getEidToLocatorRecords().get(0); - assertEquals((byte) 0x20, eidToLocators.getMaskLength()); - assertEquals(v4Address, eidToLocators.getPrefix()); + public void handleMapRequest_withMultipleEids() { + mapRequestBuilder.getEidItem().add(new EidItemBuilder().setEid(IPV6_PREFIX_EID).build()); + + final LocatorRecordBuilder locatorRecordBuilder_1 = getDefaultLocatorBuilder(); + final LocatorRecordBuilder locatorRecordBuilder_2 = getDefaultLocatorBuilder(); + locatorRecordBuilder_2.setRloc(LispAddressUtil.asIpv6Rloc(IPV6_STRING)); + + //input mapping + final MappingRecordBuilder mappingRecordBuilder_1 = getDefaultMappingRecordBuilder(); + mappingRecordBuilder_1.getLocatorRecord().add(locatorRecordBuilder_1.build()); + final MappingRecordBuilder mappingRecordBuilder_2 = getDefaultMappingRecordBuilder(); + mappingRecordBuilder_2.getLocatorRecord().add(locatorRecordBuilder_2.build()); + mappingRecordBuilder_2.setEid(IPV6_PREFIX_EID); + + Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), + mapRequestBuilder.getEidItem().get(0).getEid())).thenReturn(mappingRecordBuilder_1.build()); + Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), + mapRequestBuilder.getEidItem().get(1).getEid())).thenReturn(mappingRecordBuilder_2.build()); + + //result + final MapReplyBuilder mapReplyBuilder = getDefaultMapReplyBuilder(); + mapReplyBuilder.getMappingRecordItem() + .add(new MappingRecordItemBuilder().setMappingRecord(mappingRecordBuilder_1.build()).build()); + mapReplyBuilder.getMappingRecordItem() + .add(new MappingRecordItemBuilder().setMappingRecord(mappingRecordBuilder_2.build()).build()); + + mapResolver.handleMapRequest(mapRequestBuilder.build()); + Mockito.verify(lispMappingServiceMock).handleMapReply(mapReplyBuilder.build()); } - @Test - public void handleMapRequest__ReplyWithMultipleLocators() throws Exception { - mapRequest.addEidRecord(new EidRecord((byte) 0, v4Address)); + private static List getDefaultItrRlocList() { + final List itrRlocList = new ArrayList<>(); + final ItrRloc itrRloc = new ItrRlocBuilder() + .setKey(new ItrRlocKey(ITR_RLOC_KEY_STRING)) + .setItrRlocId(ITR_RLOC_ID_STRING) + .setRloc(RLOC_1).build(); + itrRlocList.add(itrRloc); - prepareMapping(new LispIpv4Address(0x04030201), new LispIpv6Address("::1"), new LispIpv4Address("1.8.2.7")); + return itrRlocList; + } - MapReply mapReply = testedMapResolver.handleMapRequest(mapRequest); + private static MapRequestBuilder getDefaultMapRequestBuilder() { + MapRequestBuilder mrBuilder = new MapRequestBuilder() + .setAuthoritative(false) + .setEidItem(new ArrayList<>()) + .setItrRloc(new ArrayList<>()) + .setMapDataPresent(true) + .setNonce((long) 0) + .setPitr(false) + .setProbe(false) + .setSmr(false) + .setSmrInvoked(true) + .setSourceEid(new SourceEidBuilder().setEid(LispAddressUtil.asIpv4Eid(IPV4_SOURCE)).build()) + .setItrRloc(getDefaultItrRlocList()); + + mrBuilder.getEidItem().add(new EidItemBuilder().setEid(IPV4_PREFIX_EID_1).build()); + + return mrBuilder; + } - EidToLocatorRecord eidToLocators = mapReply.getEidToLocatorRecords().get(0); - assertEquals(3, eidToLocators.getLocators().size()); + private static MappingRecordBuilder getDefaultMappingRecordBuilder() { + return new MappingRecordBuilder() + .setAction(MappingRecord.Action.NoAction) + .setAuthoritative(false) + .setLocatorRecord(new ArrayList<>()) + .setMapVersion((short) 0) + .setRecordTtl(60) + .setEid(IPV4_PREFIX_EID_1); + } - assertLocator(new LispIpv4Address(0x04030201), eidToLocators.getLocators().get(0)); - assertLocator(new LispIpv6Address("::1"), eidToLocators.getLocators().get(1)); - assertLocator(new LispIpv4Address("1.8.2.7"), eidToLocators.getLocators().get(2)); + private static LocatorRecordBuilder getDefaultLocatorBuilder() { + return new LocatorRecordBuilder() + .setLocalLocator(false) + .setMulticastPriority((short) 0) + .setMulticastWeight((short) 0) + .setPriority((short) 0) + .setRlocProbed(false) + .setRouted(true) + .setWeight((short) 0) + .setKey(LOCATOR_RECORD_KEY) + .setRloc(LispAddressUtil.asIpv4Rloc(IPV4_RLOC_STRING_1)); } - private void assertLocator(LispAddress expectedAddress, LocatorRecord locatorRecord) { - assertEquals(expectedAddress, locatorRecord.getLocator()); - Assert.assertTrue(locatorRecord.isRouted()); + private static MapReplyBuilder getDefaultMapReplyBuilder() { + return new MapReplyBuilder() + .setEchoNonceEnabled(false) + .setProbe(false) + .setSecurityEnabled(false) + .setNonce(mapRequestBuilder.getNonce()) + .setMappingRecordItem(new ArrayList<>()); } }