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

   1 /*
   2  * Copyright (c) 2016, 2017 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.LispMessage;
  26 import org.opendaylight.lispflowmapping.lisp.type.MappingData;
  27 import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
  28 import org.opendaylight.lispflowmapping.lisp.util.SourceDestKeyHelper;
  29 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
  30 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
  31 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv6Address;
  32 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.Ipv4Afi;
  33 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.Ipv6Afi;
  34 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.LispAddressFamily;
  35 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.MacAfi;
  36 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.NoAddressAfi;
  37 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.Address;
  38 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv4Builder;
  39 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv6Builder;
  40 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Mac;
  41 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.MacBuilder;
  42 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.NoAddress;
  43 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.MacAddress;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.IpAddressBinary;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.Ipv4AddressBinary;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.Ipv6AddressBinary;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.binary.address.types.rev160504.Ipv4BinaryAfi;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapRequest;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.Eid;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.list.EidItemBuilder;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecordBuilder;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecordKey;
  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(LispMessage.NEGATIVE_MAPPING_ACTION)
 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.addNegativeMapping(IPV4_PREFIX_EID_1))
 162                 .thenReturn(getDefaultMappingData(mappingRecordBuilder.build()));
 163
 164         // result
 165         final MapReplyBuilder mapReplyBuilder = getDefaultMapReplyBuilder();
 166         mapReplyBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
 167                 .setMappingRecord(mappingRecordBuilder.build()).build());
 168
 169         mapResolver.handleMapRequest(mapRequestBuilder.build());
 170         Mockito.verify(lispMappingServiceMock).handleMapReply(mapReplyBuilder.build());
 171     }
 172
 173     /**
 174      * Tests {@link MapResolver#handleMapRequest} method.
 175      */
 176     @Test
 177     public void handleMapRequest__withSubscribers() {
 178         // input mapping
 179         final LocatorRecordBuilder locatorRecordBuilder = getDefaultLocatorBuilder();
 180         final MappingRecordBuilder mappingRecordBuilder = getDefaultMappingRecordBuilder();
 181         mappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder.build());
 182         final MappingData mappingData = getDefaultMappingData(mappingRecordBuilder.build());
 183
 184         Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), IPV4_PREFIX_EID_1))
 185                 .thenReturn(mappingData);
 186         Mockito.when(mapServiceMock.getData(MappingOrigin.Southbound, IPV4_PREFIX_EID_1, SubKeys.SUBSCRIBERS))
 187                 .thenReturn(subscriberSetMock);
 188         Mockito.when(subscriberSetMock.contains(Mockito.any(Subscriber.class))).thenReturn(false);
 189
 190         // result
 191         final MapReplyBuilder mapReplyBuilder = getDefaultMapReplyBuilder();
 192         mapReplyBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
 193                 .setMappingRecord(mappingRecordBuilder.build()).build());
 194
 195         mapResolver.handleMapRequest(mapRequestBuilder.build());
 196         Mockito.verify(lispMappingServiceMock).handleMapReply(mapReplyBuilder.build());
 197         Mockito.verify(subscriberSetMock, Mockito.never()).remove(Mockito.any(Subscriber.class));
 198     }
 199
 200     /**
 201      * Tests {@link MapResolver#isEqualIpVersion} method.
 202      */
 203     @Test
 204     public void isEqualIpVersionTest() {
 205         // input mapping
 206         final LocatorRecordBuilder locatorRecordBuilder = getDefaultLocatorBuilder();
 207         final MappingRecordBuilder mappingRecordBuilder = getDefaultMappingRecordBuilder();
 208         mappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder.build());
 209         final MappingData mappingData = getDefaultMappingData(mappingRecordBuilder.build());
 210
 211         Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), IPV4_PREFIX_EID_1))
 212                 .thenReturn(mappingData);
 213         Mockito.when(mapServiceMock.getData(MappingOrigin.Southbound, IPV4_PREFIX_EID_1, SubKeys.SUBSCRIBERS))
 214                 .thenReturn(subscriberSetMock);
 215         Mockito.when(subscriberSetMock.contains(Mockito.any(Subscriber.class))).thenReturn(false);
 216
 217         // ----------------------
 218         // with sourceRloc = null
 219         List<ItrRloc> itrRlocList = Lists.newArrayList(
 220                 newItrRloc(MacAfi.class, null),
 221                 newItrRloc(Ipv4BinaryAfi.class, IPV4_ADDRESS));
 222
 223         ArgumentCaptor<Subscriber> captor = ArgumentCaptor.forClass(Subscriber.class);
 224         mapResolver.handleMapRequest(mapRequestBuilder.setSourceRloc(null).setItrRloc(itrRlocList).build());
 225         Mockito.verify(subscriberSetMock).add(captor.capture());
 226         // Since mapRequest's sourceRloc is null, first ItrRloc from the itrRlocList must be used.
 227         assertEquals(MacAfi.class, captor.getValue().getSrcRloc().getAddressType());
 228
 229         // ----------------------
 230         // with sourceRloc address = itrRloc address
 231         itrRlocList = Lists.newArrayList(
 232                 newItrRloc(MacAfi.class, null),
 233                 newItrRloc(Ipv4BinaryAfi.class, IPV4_ADDRESS));
 234
 235         MapRequest mapRequest = mapRequestBuilder
 236                 .setSourceRloc(IPV4_ADDRESS_BINARY_1)
 237                 .setItrRloc(itrRlocList).build();
 238
 239         captor = ArgumentCaptor.forClass(Subscriber.class);
 240         mapResolver.handleMapRequest(mapRequest);
 241         Mockito.verify(subscriberSetMock, Mockito.times(2)).add(captor.capture());
 242         assertEquals(IPV4_ADDRESS, captor.getValue().getSrcRloc().getAddress());
 243
 244         // ----------------------
 245         // with sourceRloc address Afi = itrRloc address Afi (for Ipv4)
 246         itrRlocList = Lists.newArrayList(
 247                 newItrRloc(MacAfi.class, null),
 248                 newItrRloc(Ipv6Afi.class, IPV6_ADDRESS),
 249                 newItrRloc(Ipv4Afi.class, IPV4_ADDRESS));
 250
 251         mapRequest = mapRequestBuilder
 252                 .setSourceRloc(IPV6_ADDRESS_BINARY)
 253                 .setItrRloc(itrRlocList).build();
 254
 255         captor = ArgumentCaptor.forClass(Subscriber.class);
 256         mapResolver.handleMapRequest(mapRequest);
 257         Mockito.verify(subscriberSetMock, Mockito.times(3)).add(captor.capture());
 258         assertEquals(IPV6_ADDRESS, captor.getValue().getSrcRloc().getAddress());
 259
 260         // ----------------------
 261         // with sourceRloc address Afi = itrRloc address Afi (for Ipv6)
 262         itrRlocList = Lists.newArrayList(
 263                 newItrRloc(MacAfi.class, null),
 264                 newItrRloc(Ipv6Afi.class, IPV6_ADDRESS),
 265                 newItrRloc(Ipv4Afi.class, IPV4_ADDRESS));
 266
 267         mapRequest = mapRequestBuilder
 268                 .setSourceRloc(IPV4_ADDRESS_BINARY_2)
 269                 .setItrRloc(itrRlocList).build();
 270
 271         captor = ArgumentCaptor.forClass(Subscriber.class);
 272         mapResolver.handleMapRequest(mapRequest);
 273         Mockito.verify(subscriberSetMock, Mockito.times(4)).add(captor.capture());
 274         assertEquals(IPV4_ADDRESS, captor.getValue().getSrcRloc().getAddress());
 275
 276         // ----------------------
 277         // with no common ip address nor Afi
 278         final Mac mac = new MacBuilder().setMac(new MacAddress("aa:bb:cc:dd:ee:ff")).build();
 279         itrRlocList = Lists.newArrayList(
 280                 newItrRloc(MacAfi.class, mac),
 281                 newItrRloc(NoAddressAfi.class, Mockito.mock(NoAddress.class)));
 282
 283         mapRequest = mapRequestBuilder
 284                 .setSourceRloc(IPV4_ADDRESS_BINARY_1)
 285                 .setItrRloc(itrRlocList).build();
 286
 287         captor = ArgumentCaptor.forClass(Subscriber.class);
 288         mapResolver.handleMapRequest(mapRequest);
 289         Mockito.verify(subscriberSetMock, Mockito.times(5)).add(captor.capture());
 290         assertEquals(mac, captor.getValue().getSrcRloc().getAddress());
 291     }
 292
 293     /**
 294      * Tests {@link MapResolver#handleMapRequest} method.
 295      */
 296     @Test
 297     public void handleMapRequest__withSubscribersToRemove() {
 298         // input mapping
 299         final LocatorRecordBuilder locatorRecordBuilder = getDefaultLocatorBuilder();
 300         final MappingRecordBuilder mappingRecordBuilder = getDefaultMappingRecordBuilder();
 301         mappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder.build());
 302         MappingData mappingData = getDefaultMappingData(mappingRecordBuilder.build());
 303
 304         Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), IPV4_PREFIX_EID_1))
 305                 .thenReturn(mappingData);
 306         Mockito.when(mapServiceMock.getData(MappingOrigin.Southbound, IPV4_PREFIX_EID_1, SubKeys.SUBSCRIBERS))
 307                 .thenReturn(subscriberSetMock);
 308         Subscriber subscriberMock = new Subscriber(
 309                 mapRequestBuilder.getItrRloc().get(0).getRloc(),
 310                 mapRequestBuilder.getSourceEid().getEid(), Subscriber.DEFAULT_SUBSCRIBER_TIMEOUT);
 311         subscriberMock.setSubscriberTtlByRecordTtl(
 312                 mappingRecordBuilder.getRecordTtl());
 313         Mockito.when(subscriberSetMock.contains(subscriberMock))
 314                 .thenReturn(true);
 315
 316         // result
 317         final MapReplyBuilder mapReplyBuilder = getDefaultMapReplyBuilder();
 318         mapReplyBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
 319                 .setMappingRecord(mappingRecordBuilder.build()).build());
 320
 321         // check if a subscriber is re-instantiating when there already is one in the subscriber set
 322         mapResolver.handleMapRequest(mapRequestBuilder.build());
 323         Mockito.verify(subscriberSetMock).remove(subscriberMock);
 324         Mockito.verify(subscriberSetMock).add(subscriberMock);
 325         Mockito.verify(lispMappingServiceMock).handleMapReply(mapReplyBuilder.build());
 326         Mockito.verify(mapServiceMock).addData(MappingOrigin.Southbound, IPV4_PREFIX_EID_1,
 327                 SubKeys.SUBSCRIBERS, subscriberSetMock);
 328
 329         // verify that itrRloc is subscribed to dst address
 330         mappingRecordBuilder.setEid(SOURCE_DEST_KEY_EID);
 331         mapRequestBuilder.getEidItem().add(new EidItemBuilder().setEid(IPV4_PREFIX_EID_2).build());
 332         mappingData = getDefaultMappingData(mappingRecordBuilder.build());
 333         Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), IPV4_PREFIX_EID_2))
 334                 .thenReturn(mappingData);
 335
 336         mapResolver.handleMapRequest(mapRequestBuilder.build());
 337         Mockito.verify(mapServiceMock).getData(MappingOrigin.Southbound,
 338                 SourceDestKeyHelper.getDstBinary(SOURCE_DEST_KEY_EID), SubKeys.SUBSCRIBERS);
 339     }
 340
 341     /**
 342      * Tests {@link MapResolver#handleMapRequest} method.
 343      */
 344     @Test
 345     public void handleMapRequest_withBothPolicy() {
 346         mapResolver = new MapResolver(mapServiceMock, true, "both", lispMappingServiceMock);
 347
 348         final List<IpAddress> ipAddressList = new ArrayList<>();
 349         ipAddressList.add(IPV4_ADDRESS_1); // hop 1
 350         ipAddressList.add(IPV4_ADDRESS_2); // hop 2
 351
 352         final Rloc rloc = LispAddressUtil.asTeLcafRloc(ipAddressList);
 353         final LocatorRecordBuilder locatorRecordBuilder_1 = getDefaultLocatorBuilder();
 354         final LocatorRecordBuilder locatorRecordBuilder_2 = getDefaultLocatorBuilder().setRloc(rloc);
 355
 356         // input mapping
 357         final MappingRecordBuilder mappingRecordBuilder = getDefaultMappingRecordBuilder();
 358         mappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_1.build());
 359         mappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_2.build());
 360         final MappingData mappingData = getDefaultMappingData(mappingRecordBuilder.build());
 361
 362         final MapRequestBuilder mapRequestBuilder = getDefaultMapRequestBuilder();
 363         mapRequestBuilder.getItrRloc().add(new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(IPV4_STRING_1))
 364                 .build());
 365         mapRequestBuilder.getItrRloc().add(new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(IPV4_STRING_2))
 366                 .build());
 367
 368         Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), IPV4_PREFIX_EID_1))
 369                 .thenReturn(mappingData);
 370
 371         // result
 372         final LocatorRecordBuilder locatorRecordBuilder_3 = getDefaultLocatorBuilder()
 373                 .setRloc(LispAddressUtil.asIpv4Rloc(IPV4_STRING_2)).setPriority((short) 1); // priority increased by 1
 374         final MappingRecordBuilder resultMappingRecordBuilder = getDefaultMappingRecordBuilder();
 375
 376         resultMappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_1.build()); // as Ipv4
 377         resultMappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_2.build()); // as ELP
 378         resultMappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_3.build()); // added to the result
 379
 380         final MapReplyBuilder mapReplyBuilder = getDefaultMapReplyBuilder();
 381         mapReplyBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
 382                 .setMappingRecord(resultMappingRecordBuilder.build()).build());
 383
 384         // invocation
 385         mapResolver.handleMapRequest(mapRequestBuilder.build());
 386         Mockito.verify(lispMappingServiceMock).handleMapReply(mapReplyBuilder.build());
 387     }
 388
 389     /**
 390      * Tests {@link MapResolver#handleMapRequest} method.
 391      */
 392     @Test
 393     public void handleMapRequest_withReplacePolicy() {
 394         mapResolver = new MapResolver(mapServiceMock, true, "replace", lispMappingServiceMock);
 395
 396         final List<IpAddress> ipAddressList = new ArrayList<>();
 397         ipAddressList.add(IPV4_ADDRESS_1); // hop 1
 398         ipAddressList.add(IPV4_ADDRESS_2); // hop 2
 399
 400         final Rloc rloc = LispAddressUtil.asTeLcafRloc(ipAddressList);
 401         final LocatorRecordBuilder locatorRecordBuilder_1 = getDefaultLocatorBuilder();
 402         final LocatorRecordBuilder locatorRecordBuilder_2 = getDefaultLocatorBuilder().setRloc(rloc);
 403
 404         // input mapping
 405         final MappingRecordBuilder mappingRecordBuilder = getDefaultMappingRecordBuilder();
 406         mappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_1.build());
 407         mappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_2.build());
 408         final MappingData mappingData = getDefaultMappingData(mappingRecordBuilder.build());
 409
 410         final MapRequestBuilder mapRequestBuilder = getDefaultMapRequestBuilder();
 411         mapRequestBuilder.getItrRloc().add(new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(IPV4_STRING_1))
 412                 .build());
 413         mapRequestBuilder.getItrRloc().add(new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(IPV4_STRING_2))
 414                 .build());
 415
 416         Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), IPV4_PREFIX_EID_1))
 417                 .thenReturn(mappingData);
 418
 419         // result
 420         final LocatorRecordBuilder locatorRecordBuilder_3 = getDefaultLocatorBuilder()
 421                 .setRloc(LispAddressUtil.asIpv4Rloc(IPV4_STRING_2));
 422         final MappingRecordBuilder resultMappingRecordBuilder = getDefaultMappingRecordBuilder();
 423
 424         resultMappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_1.build()); // as Ipv4
 425         resultMappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_3.build()); // added to the result
 426
 427         final MapReplyBuilder mapReplyBuilder = getDefaultMapReplyBuilder();
 428         mapReplyBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
 429                 .setMappingRecord(resultMappingRecordBuilder.build()).build());
 430
 431         // invocation
 432         mapResolver.handleMapRequest(mapRequestBuilder.build());
 433         Mockito.verify(lispMappingServiceMock).handleMapReply(mapReplyBuilder.build());
 434     }
 435
 436     /**
 437      * Tests {@link MapResolver#handleMapRequest} method.
 438      */
 439     @Test
 440     public void handleMapRequest_withMultipleEids() {
 441         mapRequestBuilder.getEidItem().add(new EidItemBuilder().setEid(IPV6_PREFIX_EID).build());
 442
 443         final LocatorRecordBuilder locatorRecordBuilder_1 = getDefaultLocatorBuilder();
 444         final LocatorRecordBuilder locatorRecordBuilder_2 = getDefaultLocatorBuilder();
 445         locatorRecordBuilder_2.setRloc(LispAddressUtil.asIpv6Rloc(IPV6_STRING));
 446
 447         //input mapping
 448         final MappingRecordBuilder mappingRecordBuilder_1 = getDefaultMappingRecordBuilder();
 449         mappingRecordBuilder_1.getLocatorRecord().add(locatorRecordBuilder_1.build());
 450         final MappingData mappingData_1 = getDefaultMappingData(mappingRecordBuilder_1.build());
 451         final MappingRecordBuilder mappingRecordBuilder_2 = getDefaultMappingRecordBuilder();
 452         mappingRecordBuilder_2.getLocatorRecord().add(locatorRecordBuilder_2.build());
 453         mappingRecordBuilder_2.setEid(IPV6_PREFIX_EID);
 454         final MappingData mappingData_2 = getDefaultMappingData(mappingRecordBuilder_2.build());
 455
 456         Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(),
 457                 mapRequestBuilder.getEidItem().get(0).getEid())).thenReturn(mappingData_1);
 458         Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(),
 459                 mapRequestBuilder.getEidItem().get(1).getEid())).thenReturn(mappingData_2);
 460
 461         //result
 462         final MapReplyBuilder mapReplyBuilder = getDefaultMapReplyBuilder();
 463         mapReplyBuilder.getMappingRecordItem()
 464                 .add(new MappingRecordItemBuilder().setMappingRecord(mappingRecordBuilder_1.build()).build());
 465         mapReplyBuilder.getMappingRecordItem()
 466                 .add(new MappingRecordItemBuilder().setMappingRecord(mappingRecordBuilder_2.build()).build());
 467
 468         mapResolver.handleMapRequest(mapRequestBuilder.build());
 469         Mockito.verify(lispMappingServiceMock).handleMapReply(mapReplyBuilder.build());
 470     }
 471
 472     private static ItrRloc newItrRloc(Class<? extends LispAddressFamily> clazz, Address address) {
 473         return new ItrRlocBuilder().setRloc(new RlocBuilder()
 474                 .setAddress(address)
 475                 .setAddressType(clazz).build()).build();
 476     }
 477
 478     private static List<ItrRloc> getDefaultItrRlocList() {
 479         final List<ItrRloc> itrRlocList = new ArrayList<>();
 480         final ItrRloc itrRloc = new ItrRlocBuilder()
 481                 .setKey(new ItrRlocKey(ITR_RLOC_KEY_STRING))
 482                 .setItrRlocId(ITR_RLOC_ID_STRING)
 483                 .setRloc(RLOC_1).build();
 484         itrRlocList.add(itrRloc);
 485
 486         return itrRlocList;
 487     }
 488
 489     private static MapRequestBuilder getDefaultMapRequestBuilder() {
 490         MapRequestBuilder mrBuilder = new MapRequestBuilder()
 491                 .setAuthoritative(false)
 492                 .setEidItem(new ArrayList<>())
 493                 .setItrRloc(new ArrayList<>())
 494                 .setMapDataPresent(true)
 495                 .setNonce((long) 0)
 496                 .setPitr(false)
 497                 .setProbe(false)
 498                 .setSmr(false)
 499                 .setSmrInvoked(false)
 500                 .setSourceEid(new SourceEidBuilder().setEid(LispAddressUtil.asIpv4Eid(IPV4_SOURCE)).build())
 501                 .setItrRloc(getDefaultItrRlocList());
 502
 503         mrBuilder.getEidItem().add(new EidItemBuilder().setEid(IPV4_PREFIX_EID_1).build());
 504
 505         return mrBuilder;
 506     }
 507
 508     private static MappingData getDefaultMappingData(MappingRecord mappingRecord) {
 509         if (mappingRecord == null) {
 510             mappingRecord = getDefaultMappingRecordBuilder().build();
 511         }
 512         return new MappingData(mappingRecord, System.currentTimeMillis());
 513     }
 514
 515     private static MappingRecordBuilder getDefaultMappingRecordBuilder() {
 516         return new MappingRecordBuilder()
 517                 .setAction(MappingRecord.Action.NoAction)
 518                 .setAuthoritative(false)
 519                 .setLocatorRecord(new ArrayList<>())
 520                 .setMapVersion((short) 0)
 521                 .setRecordTtl(60)
 522                 .setEid(IPV4_PREFIX_EID_1);
 523     }
 524
 525     private static LocatorRecordBuilder getDefaultLocatorBuilder() {
 526         return new LocatorRecordBuilder()
 527                 .setLocalLocator(false)
 528                 .setMulticastPriority((short) 0)
 529                 .setMulticastWeight((short) 0)
 530                 .setPriority((short) 0)
 531                 .setRlocProbed(false)
 532                 .setRouted(true)
 533                 .setWeight((short) 0)
 534                 .setKey(LOCATOR_RECORD_KEY)
 535                 .setRloc(LispAddressUtil.asIpv4Rloc(IPV4_RLOC_STRING_1));
 536     }
 537
 538     private static MapReplyBuilder getDefaultMapReplyBuilder() {
 539         return new MapReplyBuilder()
 540                 .setEchoNonceEnabled(false)
 541                 .setProbe(false)
 542                 .setSecurityEnabled(false)
 543                 .setNonce(mapRequestBuilder.getNonce())
 544                 .setMappingRecordItem(new ArrayList<>());
 545     }
 546 }