mappingservice/implementation/src/test/java/org/opendaylight/lispflowmapping/implementation/lisp/MapResolverTest.java

   1 /*
   2  * Copyright (c) 2016 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.lispflowmapping.implementation.lisp;
   9
  10 import static org.junit.Assert.assertEquals;
  11
  12 import com.google.common.collect.Lists;
  13 import java.util.ArrayList;
  14 import java.util.List;
  15 import java.util.Set;
  16 import org.junit.Before;
  17 import org.junit.Test;
  18 import org.mockito.ArgumentCaptor;
  19 import org.mockito.Mockito;
  20 import org.opendaylight.lispflowmapping.config.ConfigIni;
  21 import org.opendaylight.lispflowmapping.implementation.LispMappingService;
  22 import org.opendaylight.lispflowmapping.implementation.MappingService;
  23 import org.opendaylight.lispflowmapping.interfaces.dao.SubKeys;
  24 import org.opendaylight.lispflowmapping.interfaces.dao.Subscriber;
  25 import org.opendaylight.lispflowmapping.lisp.type.MappingData;
  26 import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
  27 import org.opendaylight.lispflowmapping.lisp.util.SourceDestKeyHelper;
  28 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
  29 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
  30 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Address;
  31 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.Ipv4Afi;
  32 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.Ipv6Afi;
  33 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.LispAddressFamily;
  34 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.MacAfi;
  35 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.NoAddressAfi;
  36 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.Address;
  37 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv4Builder;
  38 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv6Builder;
  39 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Mac;
  40 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.MacBuilder;
  41 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.NoAddress;
  42 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.IpAddressBinary;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.Ipv4AddressBinary;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.Ipv6AddressBinary;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.binary.address.types.rev160504.Ipv4BinaryAfi;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapRequest;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.Eid;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.list.EidItemBuilder;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecordBuilder;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecordKey;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.authkey.container.MappingAuthkeyBuilder;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecord;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecordBuilder;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.list.MappingRecordItemBuilder;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapreplymessage.MapReplyBuilder;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequest.ItrRloc;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequest.ItrRlocBuilder;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequest.ItrRlocKey;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequest.SourceEidBuilder;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequestnotification.MapRequestBuilder;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.rloc.container.Rloc;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.rloc.container.RlocBuilder;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingOrigin;
  65
  66 public class MapResolverTest {
  67
  68     private static MapResolver mapResolver;
  69     private static MappingService mapServiceMock;
  70     private static Set<Subscriber> subscriberSetMock;
  71     private static LispMappingService lispMappingServiceMock;
  72
  73     private static final String ITR_RLOC_KEY_STRING =   "itr_rloc_key";
  74     private static final String ITR_RLOC_ID_STRING =    "itr_rloc_id";
  75     private static final String IPV4_STRING_1 =         "1.2.3.0";
  76     private static final String IPV4_STRING_2 =         "1.2.4.0";
  77     private static final String IPV4_RLOC_STRING_1 =    "100.100.100.100";
  78     private static final String IPV4_SOURCE =           "127.0.0.1";
  79     private static final String IPV4_PREFIX_STRING =    "/24";
  80     private static final String IPV6_STRING =           "0:0:0:0:0:0:0:1";
  81     private static final String IPV6_PREFIX_STRING =    "/128";
  82
  83     private static final byte[] IPV4_BINARY_BYTES_1 = new byte[]{1, 2, 3, 0};
  84     private static final byte[] IPV4_BINARY_BYTES_2 = new byte[]{1, 2, 5, 0};
  85     private static final byte[] IPV6_BINARY_BYTES_1 = new byte[]{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
  86
  87     private static final LocatorRecordKey LOCATOR_RECORD_KEY = new LocatorRecordKey("key");
  88     private static final int TTL_RLOC_TIMED_OUT = 1;
  89
  90     private static final IpAddress IPV4_ADDRESS_1 = new IpAddress(new Ipv4Address(IPV4_STRING_1));
  91     private static final IpAddress IPV4_ADDRESS_2 = new IpAddress(new Ipv4Address(IPV4_STRING_2));
  92
  93     private static final IpAddressBinary IPV4_ADDRESS_BINARY_1 =
  94             new IpAddressBinary(new Ipv4AddressBinary(IPV4_BINARY_BYTES_1));
  95     private static final IpAddressBinary IPV4_ADDRESS_BINARY_2 =
  96             new IpAddressBinary(new Ipv4AddressBinary(IPV4_BINARY_BYTES_2));
  97     private static final IpAddressBinary IPV6_ADDRESS_BINARY =
  98             new IpAddressBinary(new Ipv6AddressBinary(IPV6_BINARY_BYTES_1));
  99
 100     private static final Eid IPV4_PREFIX_EID_1 = LispAddressUtil.asIpv4PrefixEid(IPV4_STRING_1 + IPV4_PREFIX_STRING);
 101     private static final Eid IPV4_PREFIX_EID_2 = LispAddressUtil.asIpv4PrefixEid(IPV4_STRING_2 + IPV4_PREFIX_STRING);
 102     private static final Eid IPV6_PREFIX_EID = LispAddressUtil.asIpv6PrefixEid(IPV6_STRING + IPV6_PREFIX_STRING);
 103     private static final Eid SOURCE_DEST_KEY_EID = LispAddressUtil.asSrcDstEid(IPV4_SOURCE, IPV4_STRING_2, 24, 24, 0);
 104
 105     private static final Address IPV4_ADDRESS = new Ipv4Builder().setIpv4(new Ipv4Address(IPV4_STRING_1)).build();
 106     private static final Address IPV6_ADDRESS = new Ipv6Builder().setIpv6(new Ipv6Address(IPV6_STRING)).build();
 107
 108     private static final Rloc RLOC_1 = LispAddressUtil.asIpv4Rloc(IPV4_RLOC_STRING_1);
 109     private static MapRequestBuilder mapRequestBuilder = getDefaultMapRequestBuilder();
 110     private static final Subscriber SUBSCRIBER_RLOC_1 = new Subscriber(RLOC_1,
 111             LispAddressUtil.asIpv4Eid(IPV4_SOURCE), Subscriber.DEFAULT_SUBSCRIBER_TIMEOUT);
 112
 113     @Before
 114     @SuppressWarnings("unchecked")
 115     public void init() throws Exception {
 116         mapServiceMock = Mockito.mock(MappingService.class, "mapService");
 117         subscriberSetMock = Mockito.mock(Set.class);
 118         lispMappingServiceMock = Mockito.mock(LispMappingService.class, "requestHandler");
 119         mapResolver = new MapResolver(mapServiceMock, true, ConfigIni.getInstance().getElpPolicy(),
 120                 lispMappingServiceMock);
 121         mapRequestBuilder = getDefaultMapRequestBuilder();
 122     }
 123
 124     /**
 125      * Tests {@link MapResolver#handleMapRequest} method.
 126      */
 127     @Test
 128     public void handleMapRequest__withSingleLocator() {
 129         // input mapping
 130         final LocatorRecordBuilder locatorRecordBuilder = getDefaultLocatorBuilder();
 131         final MappingRecordBuilder mappingRecordBuilder = getDefaultMappingRecordBuilder();
 132         mappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder.build());
 133         final MappingData mappingData = getDefaultMappingData(mappingRecordBuilder.build());
 134
 135         Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), IPV4_PREFIX_EID_1))
 136                 .thenReturn(mappingData);
 137
 138         // result
 139         final MapReplyBuilder mapReplyBuilder = getDefaultMapReplyBuilder();
 140         mapReplyBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
 141                 .setMappingRecord(mappingRecordBuilder.build()).build());
 142
 143         mapResolver.handleMapRequest(mapRequestBuilder.build());
 144         Mockito.verify(lispMappingServiceMock).handleMapReply(mapReplyBuilder.build());
 145     }
 146
 147     /**
 148      * Tests {@link MapResolver#handleMapRequest} method.
 149      */
 150     @Test
 151     public void handleMapRequest__withNoMapping() {
 152         final MappingRecordBuilder mappingRecordBuilder = new MappingRecordBuilder()
 153                 .setAuthoritative(false)
 154                 .setMapVersion((short) 0)
 155                 .setEid(IPV4_PREFIX_EID_1)
 156                 .setAction(MappingRecord.Action.NativelyForward)
 157                 .setRecordTtl(TTL_RLOC_TIMED_OUT);
 158
 159         Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), IPV4_PREFIX_EID_1))
 160                 .thenReturn(null);
 161         Mockito.when(mapServiceMock.getAuthenticationKey(IPV4_PREFIX_EID_1))
 162                 .thenReturn(new MappingAuthkeyBuilder().build());
 163         Mockito.when(mapServiceMock.getWidestNegativePrefix(IPV4_PREFIX_EID_1)).thenReturn(IPV4_PREFIX_EID_1);
 164
 165         // result
 166         final MapReplyBuilder mapReplyBuilder = getDefaultMapReplyBuilder();
 167         mapReplyBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
 168                 .setMappingRecord(mappingRecordBuilder.build()).build());
 169
 170         mapResolver.handleMapRequest(mapRequestBuilder.build());
 171         Mockito.verify(lispMappingServiceMock).handleMapReply(mapReplyBuilder.build());
 172     }
 173
 174     /**
 175      * Tests {@link MapResolver#handleMapRequest} method.
 176      */
 177     @Test
 178     public void handleMapRequest__withSubscribers() {
 179         // input mapping
 180         final LocatorRecordBuilder locatorRecordBuilder = getDefaultLocatorBuilder();
 181         final MappingRecordBuilder mappingRecordBuilder = getDefaultMappingRecordBuilder();
 182         mappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder.build());
 183         final MappingData mappingData = getDefaultMappingData(mappingRecordBuilder.build());
 184
 185         Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), IPV4_PREFIX_EID_1))
 186                 .thenReturn(mappingData);
 187         Mockito.when(mapServiceMock.getData(MappingOrigin.Southbound, IPV4_PREFIX_EID_1, SubKeys.SUBSCRIBERS))
 188                 .thenReturn(subscriberSetMock);
 189         Mockito.when(subscriberSetMock.contains(Mockito.any(Subscriber.class))).thenReturn(false);
 190
 191         // result
 192         final MapReplyBuilder mapReplyBuilder = getDefaultMapReplyBuilder();
 193         mapReplyBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
 194                 .setMappingRecord(mappingRecordBuilder.build()).build());
 195
 196         mapResolver.handleMapRequest(mapRequestBuilder.build());
 197         Mockito.verify(lispMappingServiceMock).handleMapReply(mapReplyBuilder.build());
 198         Mockito.verify(subscriberSetMock, Mockito.never()).remove(Mockito.any(Subscriber.class));
 199     }
 200
 201     /**
 202      * Tests {@link MapResolver#isEqualIpVersion} method.
 203      */
 204     @Test
 205     public void isEqualIpVersionTest() {
 206         // input mapping
 207         final LocatorRecordBuilder locatorRecordBuilder = getDefaultLocatorBuilder();
 208         final MappingRecordBuilder mappingRecordBuilder = getDefaultMappingRecordBuilder();
 209         mappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder.build());
 210         final MappingData mappingData = getDefaultMappingData(mappingRecordBuilder.build());
 211
 212         Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), IPV4_PREFIX_EID_1))
 213                 .thenReturn(mappingData);
 214         Mockito.when(mapServiceMock.getData(MappingOrigin.Southbound, IPV4_PREFIX_EID_1, SubKeys.SUBSCRIBERS))
 215                 .thenReturn(subscriberSetMock);
 216         Mockito.when(subscriberSetMock.contains(Mockito.any(Subscriber.class))).thenReturn(false);
 217
 218         // ----------------------
 219         // with sourceRloc = null
 220         List<ItrRloc> itrRlocList = Lists.newArrayList(
 221                 newItrRloc(MacAfi.class, null),
 222                 newItrRloc(Ipv4BinaryAfi.class, IPV4_ADDRESS));
 223
 224         ArgumentCaptor<Subscriber> captor = ArgumentCaptor.forClass(Subscriber.class);
 225         mapResolver.handleMapRequest(mapRequestBuilder.setSourceRloc(null).setItrRloc(itrRlocList).build());
 226         Mockito.verify(subscriberSetMock).add(captor.capture());
 227         // Since mapRequest's sourceRloc is null, first ItrRloc from the itrRlocList must be used.
 228         assertEquals(MacAfi.class, captor.getValue().getSrcRloc().getAddressType());
 229
 230         // ----------------------
 231         // with sourceRloc address = itrRloc address
 232         itrRlocList = Lists.newArrayList(
 233                 newItrRloc(MacAfi.class, null),
 234                 newItrRloc(Ipv4BinaryAfi.class, IPV4_ADDRESS));
 235
 236         MapRequest mapRequest = mapRequestBuilder
 237                 .setSourceRloc(IPV4_ADDRESS_BINARY_1)
 238                 .setItrRloc(itrRlocList).build();
 239
 240         captor = ArgumentCaptor.forClass(Subscriber.class);
 241         mapResolver.handleMapRequest(mapRequest);
 242         Mockito.verify(subscriberSetMock, Mockito.times(2)).add(captor.capture());
 243         assertEquals(IPV4_ADDRESS, captor.getValue().getSrcRloc().getAddress());
 244
 245         // ----------------------
 246         // with sourceRloc address Afi = itrRloc address Afi (for Ipv4)
 247         itrRlocList = Lists.newArrayList(
 248                 newItrRloc(MacAfi.class, null),
 249                 newItrRloc(Ipv6Afi.class, IPV6_ADDRESS),
 250                 newItrRloc(Ipv4Afi.class, IPV4_ADDRESS));
 251
 252         mapRequest = mapRequestBuilder
 253                 .setSourceRloc(IPV6_ADDRESS_BINARY)
 254                 .setItrRloc(itrRlocList).build();
 255
 256         captor = ArgumentCaptor.forClass(Subscriber.class);
 257         mapResolver.handleMapRequest(mapRequest);
 258         Mockito.verify(subscriberSetMock, Mockito.times(3)).add(captor.capture());
 259         assertEquals(IPV6_ADDRESS, captor.getValue().getSrcRloc().getAddress());
 260
 261         // ----------------------
 262         // with sourceRloc address Afi = itrRloc address Afi (for Ipv6)
 263         itrRlocList = Lists.newArrayList(
 264                 newItrRloc(MacAfi.class, null),
 265                 newItrRloc(Ipv6Afi.class, IPV6_ADDRESS),
 266                 newItrRloc(Ipv4Afi.class, IPV4_ADDRESS));
 267
 268         mapRequest = mapRequestBuilder
 269                 .setSourceRloc(IPV4_ADDRESS_BINARY_2)
 270                 .setItrRloc(itrRlocList).build();
 271
 272         captor = ArgumentCaptor.forClass(Subscriber.class);
 273         mapResolver.handleMapRequest(mapRequest);
 274         Mockito.verify(subscriberSetMock, Mockito.times(4)).add(captor.capture());
 275         assertEquals(IPV4_ADDRESS, captor.getValue().getSrcRloc().getAddress());
 276
 277         // ----------------------
 278         // with no common ip address nor Afi
 279         final Mac mac = new MacBuilder().setMac(new MacAddress("aa:bb:cc:dd:ee:ff")).build();
 280         itrRlocList = Lists.newArrayList(
 281                 newItrRloc(MacAfi.class, mac),
 282                 newItrRloc(NoAddressAfi.class, Mockito.mock(NoAddress.class)));
 283
 284         mapRequest = mapRequestBuilder
 285                 .setSourceRloc(IPV4_ADDRESS_BINARY_1)
 286                 .setItrRloc(itrRlocList).build();
 287
 288         captor = ArgumentCaptor.forClass(Subscriber.class);
 289         mapResolver.handleMapRequest(mapRequest);
 290         Mockito.verify(subscriberSetMock, Mockito.times(5)).add(captor.capture());
 291         assertEquals(mac, captor.getValue().getSrcRloc().getAddress());
 292     }
 293
 294     /**
 295      * Tests {@link MapResolver#handleMapRequest} method.
 296      */
 297     @Test
 298     public void handleMapRequest__withSubscribersToRemove() {
 299         // input mapping
 300         final LocatorRecordBuilder locatorRecordBuilder = getDefaultLocatorBuilder();
 301         final MappingRecordBuilder mappingRecordBuilder = getDefaultMappingRecordBuilder();
 302         mappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder.build());
 303         MappingData mappingData = getDefaultMappingData(mappingRecordBuilder.build());
 304
 305         Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), IPV4_PREFIX_EID_1))
 306                 .thenReturn(mappingData);
 307         Mockito.when(mapServiceMock.getData(MappingOrigin.Southbound, IPV4_PREFIX_EID_1, SubKeys.SUBSCRIBERS))
 308                 .thenReturn(subscriberSetMock);
 309         Subscriber subscriberMock = new Subscriber(
 310                 mapRequestBuilder.getItrRloc().get(0).getRloc(),
 311                 mapRequestBuilder.getSourceEid().getEid(), Subscriber.DEFAULT_SUBSCRIBER_TIMEOUT);
 312         subscriberMock.setSubscriberTimeoutByRecordTtl(
 313                 mappingRecordBuilder.getRecordTtl());
 314         Mockito.when(subscriberSetMock.contains(subscriberMock))
 315                 .thenReturn(true);
 316
 317         // result
 318         final MapReplyBuilder mapReplyBuilder = getDefaultMapReplyBuilder();
 319         mapReplyBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
 320                 .setMappingRecord(mappingRecordBuilder.build()).build());
 321
 322         // check if a subscriber is re-instantiating when there already is one in the subscriber set
 323         mapResolver.handleMapRequest(mapRequestBuilder.build());
 324         Mockito.verify(subscriberSetMock).remove(SUBSCRIBER_RLOC_1);
 325         Mockito.verify(subscriberSetMock).add(SUBSCRIBER_RLOC_1);
 326         Mockito.verify(lispMappingServiceMock).handleMapReply(mapReplyBuilder.build());
 327         Mockito.verify(mapServiceMock).addData(MappingOrigin.Southbound, IPV4_PREFIX_EID_1,
 328                 SubKeys.SUBSCRIBERS, subscriberSetMock);
 329
 330         // verify that itrRloc is subscribed to dst address
 331         mappingRecordBuilder.setEid(SOURCE_DEST_KEY_EID);
 332         mapRequestBuilder.getEidItem().add(new EidItemBuilder().setEid(IPV4_PREFIX_EID_2).build());
 333         mappingData = getDefaultMappingData(mappingRecordBuilder.build());
 334         Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), IPV4_PREFIX_EID_2))
 335                 .thenReturn(mappingData);
 336
 337         mapResolver.handleMapRequest(mapRequestBuilder.build());
 338         Mockito.verify(mapServiceMock).getData(MappingOrigin.Southbound,
 339                 SourceDestKeyHelper.getDstBinary(SOURCE_DEST_KEY_EID), SubKeys.SUBSCRIBERS);
 340     }
 341
 342     /**
 343      * Tests {@link MapResolver#handleMapRequest} method.
 344      */
 345     @Test
 346     public void handleMapRequest_withBothPolicy() {
 347         mapResolver = new MapResolver(mapServiceMock, true, "both", lispMappingServiceMock);
 348
 349         final List<IpAddress> ipAddressList = new ArrayList<>();
 350         ipAddressList.add(IPV4_ADDRESS_1); // hop 1
 351         ipAddressList.add(IPV4_ADDRESS_2); // hop 2
 352
 353         final Rloc rloc = LispAddressUtil.asTeLcafRloc(ipAddressList);
 354         final LocatorRecordBuilder locatorRecordBuilder_1 = getDefaultLocatorBuilder();
 355         final LocatorRecordBuilder locatorRecordBuilder_2 = getDefaultLocatorBuilder().setRloc(rloc);
 356
 357         // input mapping
 358         final MappingRecordBuilder mappingRecordBuilder = getDefaultMappingRecordBuilder();
 359         mappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_1.build());
 360         mappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_2.build());
 361         final MappingData mappingData = getDefaultMappingData(mappingRecordBuilder.build());
 362
 363         final MapRequestBuilder mapRequestBuilder = getDefaultMapRequestBuilder();
 364         mapRequestBuilder.getItrRloc().add(new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(IPV4_STRING_1))
 365                 .build());
 366         mapRequestBuilder.getItrRloc().add(new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(IPV4_STRING_2))
 367                 .build());
 368
 369         Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), IPV4_PREFIX_EID_1))
 370                 .thenReturn(mappingData);
 371
 372         // result
 373         final LocatorRecordBuilder locatorRecordBuilder_3 = getDefaultLocatorBuilder()
 374                 .setRloc(LispAddressUtil.asIpv4Rloc(IPV4_STRING_2)).setPriority((short) 1); // priority increased by 1
 375         final MappingRecordBuilder resultMappingRecordBuilder = getDefaultMappingRecordBuilder();
 376
 377         resultMappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_1.build()); // as Ipv4
 378         resultMappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_2.build()); // as ELP
 379         resultMappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_3.build()); // added to the result
 380
 381         final MapReplyBuilder mapReplyBuilder = getDefaultMapReplyBuilder();
 382         mapReplyBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
 383                 .setMappingRecord(resultMappingRecordBuilder.build()).build());
 384
 385         // invocation
 386         mapResolver.handleMapRequest(mapRequestBuilder.build());
 387         Mockito.verify(lispMappingServiceMock).handleMapReply(mapReplyBuilder.build());
 388     }
 389
 390     /**
 391      * Tests {@link MapResolver#handleMapRequest} method.
 392      */
 393     @Test
 394     public void handleMapRequest_withReplacePolicy() {
 395         mapResolver = new MapResolver(mapServiceMock, true, "replace", lispMappingServiceMock);
 396
 397         final List<IpAddress> ipAddressList = new ArrayList<>();
 398         ipAddressList.add(IPV4_ADDRESS_1); // hop 1
 399         ipAddressList.add(IPV4_ADDRESS_2); // hop 2
 400
 401         final Rloc rloc = LispAddressUtil.asTeLcafRloc(ipAddressList);
 402         final LocatorRecordBuilder locatorRecordBuilder_1 = getDefaultLocatorBuilder();
 403         final LocatorRecordBuilder locatorRecordBuilder_2 = getDefaultLocatorBuilder().setRloc(rloc);
 404
 405         // input mapping
 406         final MappingRecordBuilder mappingRecordBuilder = getDefaultMappingRecordBuilder();
 407         mappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_1.build());
 408         mappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_2.build());
 409         final MappingData mappingData = getDefaultMappingData(mappingRecordBuilder.build());
 410
 411         final MapRequestBuilder mapRequestBuilder = getDefaultMapRequestBuilder();
 412         mapRequestBuilder.getItrRloc().add(new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(IPV4_STRING_1))
 413                 .build());
 414         mapRequestBuilder.getItrRloc().add(new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(IPV4_STRING_2))
 415                 .build());
 416
 417         Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), IPV4_PREFIX_EID_1))
 418                 .thenReturn(mappingData);
 419
 420         // result
 421         final LocatorRecordBuilder locatorRecordBuilder_3 = getDefaultLocatorBuilder()
 422                 .setRloc(LispAddressUtil.asIpv4Rloc(IPV4_STRING_2));
 423         final MappingRecordBuilder resultMappingRecordBuilder = getDefaultMappingRecordBuilder();
 424
 425         resultMappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_1.build()); // as Ipv4
 426         resultMappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_3.build()); // added to the result
 427
 428         final MapReplyBuilder mapReplyBuilder = getDefaultMapReplyBuilder();
 429         mapReplyBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
 430                 .setMappingRecord(resultMappingRecordBuilder.build()).build());
 431
 432         // invocation
 433         mapResolver.handleMapRequest(mapRequestBuilder.build());
 434         Mockito.verify(lispMappingServiceMock).handleMapReply(mapReplyBuilder.build());
 435     }
 436
 437     /**
 438      * Tests {@link MapResolver#handleMapRequest} method.
 439      */
 440     @Test
 441     public void handleMapRequest_withMultipleEids() {
 442         mapRequestBuilder.getEidItem().add(new EidItemBuilder().setEid(IPV6_PREFIX_EID).build());
 443
 444         final LocatorRecordBuilder locatorRecordBuilder_1 = getDefaultLocatorBuilder();
 445         final LocatorRecordBuilder locatorRecordBuilder_2 = getDefaultLocatorBuilder();
 446         locatorRecordBuilder_2.setRloc(LispAddressUtil.asIpv6Rloc(IPV6_STRING));
 447
 448         //input mapping
 449         final MappingRecordBuilder mappingRecordBuilder_1 = getDefaultMappingRecordBuilder();
 450         mappingRecordBuilder_1.getLocatorRecord().add(locatorRecordBuilder_1.build());
 451         final MappingData mappingData_1 = getDefaultMappingData(mappingRecordBuilder_1.build());
 452         final MappingRecordBuilder mappingRecordBuilder_2 = getDefaultMappingRecordBuilder();
 453         mappingRecordBuilder_2.getLocatorRecord().add(locatorRecordBuilder_2.build());
 454         mappingRecordBuilder_2.setEid(IPV6_PREFIX_EID);
 455         final MappingData mappingData_2 = getDefaultMappingData(mappingRecordBuilder_2.build());
 456
 457         Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(),
 458                 mapRequestBuilder.getEidItem().get(0).getEid())).thenReturn(mappingData_1);
 459         Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(),
 460                 mapRequestBuilder.getEidItem().get(1).getEid())).thenReturn(mappingData_2);
 461
 462         //result
 463         final MapReplyBuilder mapReplyBuilder = getDefaultMapReplyBuilder();
 464         mapReplyBuilder.getMappingRecordItem()
 465                 .add(new MappingRecordItemBuilder().setMappingRecord(mappingRecordBuilder_1.build()).build());
 466         mapReplyBuilder.getMappingRecordItem()
 467                 .add(new MappingRecordItemBuilder().setMappingRecord(mappingRecordBuilder_2.build()).build());
 468
 469         mapResolver.handleMapRequest(mapRequestBuilder.build());
 470         Mockito.verify(lispMappingServiceMock).handleMapReply(mapReplyBuilder.build());
 471     }
 472
 473     private static ItrRloc newItrRloc(Class<? extends LispAddressFamily> clazz, Address address) {
 474         return new ItrRlocBuilder().setRloc(new RlocBuilder()
 475                 .setAddress(address)
 476                 .setAddressType(clazz).build()).build();
 477     }
 478
 479     private static List<ItrRloc> getDefaultItrRlocList() {
 480         final List<ItrRloc> itrRlocList = new ArrayList<>();
 481         final ItrRloc itrRloc = new ItrRlocBuilder()
 482                 .setKey(new ItrRlocKey(ITR_RLOC_KEY_STRING))
 483                 .setItrRlocId(ITR_RLOC_ID_STRING)
 484                 .setRloc(RLOC_1).build();
 485         itrRlocList.add(itrRloc);
 486
 487         return itrRlocList;
 488     }
 489
 490     private static MapRequestBuilder getDefaultMapRequestBuilder() {
 491         MapRequestBuilder mrBuilder = new MapRequestBuilder()
 492                 .setAuthoritative(false)
 493                 .setEidItem(new ArrayList<>())
 494                 .setItrRloc(new ArrayList<>())
 495                 .setMapDataPresent(true)
 496                 .setNonce((long) 0)
 497                 .setPitr(false)
 498                 .setProbe(false)
 499                 .setSmr(false)
 500                 .setSmrInvoked(false)
 501                 .setSourceEid(new SourceEidBuilder().setEid(LispAddressUtil.asIpv4Eid(IPV4_SOURCE)).build())
 502                 .setItrRloc(getDefaultItrRlocList());
 503
 504         mrBuilder.getEidItem().add(new EidItemBuilder().setEid(IPV4_PREFIX_EID_1).build());
 505
 506         return mrBuilder;
 507     }
 508
 509     private static MappingData getDefaultMappingData(MappingRecord mappingRecord) {
 510         if (mappingRecord == null) {
 511             mappingRecord = getDefaultMappingRecordBuilder().build();
 512         }
 513         return new MappingData(mappingRecord, System.currentTimeMillis());
 514     }
 515
 516     private static MappingRecordBuilder getDefaultMappingRecordBuilder() {
 517         return new MappingRecordBuilder()
 518                 .setAction(MappingRecord.Action.NoAction)
 519                 .setAuthoritative(false)
 520                 .setLocatorRecord(new ArrayList<>())
 521                 .setMapVersion((short) 0)
 522                 .setRecordTtl(60)
 523                 .setEid(IPV4_PREFIX_EID_1);
 524     }
 525
 526     private static LocatorRecordBuilder getDefaultLocatorBuilder() {
 527         return new LocatorRecordBuilder()
 528                 .setLocalLocator(false)
 529                 .setMulticastPriority((short) 0)
 530                 .setMulticastWeight((short) 0)
 531                 .setPriority((short) 0)
 532                 .setRlocProbed(false)
 533                 .setRouted(true)
 534                 .setWeight((short) 0)
 535                 .setKey(LOCATOR_RECORD_KEY)
 536                 .setRloc(LispAddressUtil.asIpv4Rloc(IPV4_RLOC_STRING_1));
 537     }
 538
 539     private static MapReplyBuilder getDefaultMapReplyBuilder() {
 540         return new MapReplyBuilder()
 541                 .setEchoNonceEnabled(false)
 542                 .setProbe(false)
 543                 .setSecurityEnabled(false)
 544                 .setNonce(mapRequestBuilder.getNonce())
 545                 .setMappingRecordItem(new ArrayList<>());
 546     }
 547 }