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
  17 import org.junit.Before;
  18 import org.junit.Test;
  19 import org.mockito.ArgumentCaptor;
  20 import org.mockito.Mockito;
  21 import org.opendaylight.lispflowmapping.config.ConfigIni;
  22 import org.opendaylight.lispflowmapping.implementation.LispMappingService;
  23 import org.opendaylight.lispflowmapping.implementation.MappingService;
  24 import org.opendaylight.lispflowmapping.interfaces.dao.SubKeys;
  25 import org.opendaylight.lispflowmapping.interfaces.dao.SubscriberRLOC;
  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<SubscriberRLOC> 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 SubscriberRLOC SUBSCRIBER_RLOC_1 = new SubscriberRLOC(RLOC_1,
 111             LispAddressUtil.asIpv4Eid(IPV4_SOURCE), SubscriberRLOC.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
 134         Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), IPV4_PREFIX_EID_1))
 135                 .thenReturn(mappingRecordBuilder.build());
 136
 137         // result
 138         final MapReplyBuilder mapReplyBuilder = getDefaultMapReplyBuilder();
 139         mapReplyBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
 140                 .setMappingRecord(mappingRecordBuilder.build()).build());
 141
 142         mapResolver.handleMapRequest(mapRequestBuilder.build());
 143         Mockito.verify(lispMappingServiceMock).handleMapReply(mapReplyBuilder.build());
 144     }
 145
 146     /**
 147      * Tests {@link MapResolver#handleMapRequest} method.
 148      */
 149     @Test
 150     public void handleMapRequest__withNoMapping() {
 151         final MappingRecordBuilder mappingRecordBuilder = new MappingRecordBuilder()
 152                 .setAuthoritative(false)
 153                 .setMapVersion((short) 0)
 154                 .setEid(IPV4_PREFIX_EID_1)
 155                 .setAction(MappingRecord.Action.NativelyForward)
 156                 .setRecordTtl(TTL_RLOC_TIMED_OUT);
 157
 158         Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), IPV4_PREFIX_EID_1))
 159                 .thenReturn(null);
 160         Mockito.when(mapServiceMock.getAuthenticationKey(IPV4_PREFIX_EID_1))
 161                 .thenReturn(new MappingAuthkeyBuilder().build());
 162         Mockito.when(mapServiceMock.getWidestNegativePrefix(IPV4_PREFIX_EID_1)).thenReturn(IPV4_PREFIX_EID_1);
 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
 183         Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), IPV4_PREFIX_EID_1))
 184                 .thenReturn(mappingRecordBuilder.build());
 185         Mockito.when(mapServiceMock.getData(MappingOrigin.Southbound, IPV4_PREFIX_EID_1, SubKeys.SUBSCRIBERS))
 186                 .thenReturn(subscriberSetMock);
 187         Mockito.when(subscriberSetMock.contains(Mockito.any(SubscriberRLOC.class))).thenReturn(false);
 188
 189         // result
 190         final MapReplyBuilder mapReplyBuilder = getDefaultMapReplyBuilder();
 191         mapReplyBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
 192                 .setMappingRecord(mappingRecordBuilder.build()).build());
 193
 194         mapResolver.handleMapRequest(mapRequestBuilder.build());
 195         Mockito.verify(lispMappingServiceMock).handleMapReply(mapReplyBuilder.build());
 196         Mockito.verify(subscriberSetMock, Mockito.never()).remove(Mockito.any(SubscriberRLOC.class));
 197     }
 198
 199     /**
 200      * Tests {@link MapResolver#isEqualIpVersion} method.
 201      */
 202     @Test
 203     public void isEqualIpVersionTest() {
 204         // input mapping
 205         final LocatorRecordBuilder locatorRecordBuilder = getDefaultLocatorBuilder();
 206         final MappingRecordBuilder mappingRecordBuilder = getDefaultMappingRecordBuilder();
 207         mappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder.build());
 208
 209         Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), IPV4_PREFIX_EID_1))
 210                 .thenReturn(mappingRecordBuilder.build());
 211         Mockito.when(mapServiceMock.getData(MappingOrigin.Southbound, IPV4_PREFIX_EID_1, SubKeys.SUBSCRIBERS))
 212                 .thenReturn(subscriberSetMock);
 213         Mockito.when(subscriberSetMock.contains(Mockito.any(SubscriberRLOC.class))).thenReturn(false);
 214
 215         // ----------------------
 216         // with sourceRloc = null
 217         List<ItrRloc> itrRlocList = Lists.newArrayList(
 218                 newItrRloc(MacAfi.class, null),
 219                 newItrRloc(Ipv4BinaryAfi.class, IPV4_ADDRESS));
 220
 221         ArgumentCaptor<SubscriberRLOC> captor = ArgumentCaptor.forClass(SubscriberRLOC.class);
 222         mapResolver.handleMapRequest(mapRequestBuilder.setSourceRloc(null).setItrRloc(itrRlocList).build());
 223         Mockito.verify(subscriberSetMock).add(captor.capture());
 224         // Since mapRequest's sourceRloc is null, first ItrRloc from the itrRlocList must be used.
 225         assertEquals(MacAfi.class, captor.getValue().getSrcRloc().getAddressType());
 226
 227         // ----------------------
 228         // with sourceRloc address = itrRloc address
 229         itrRlocList = Lists.newArrayList(
 230                 newItrRloc(MacAfi.class, null),
 231                 newItrRloc(Ipv4BinaryAfi.class, IPV4_ADDRESS));
 232
 233         MapRequest mapRequest = mapRequestBuilder
 234                 .setSourceRloc(IPV4_ADDRESS_BINARY_1)
 235                 .setItrRloc(itrRlocList).build();
 236
 237         captor = ArgumentCaptor.forClass(SubscriberRLOC.class);
 238         mapResolver.handleMapRequest(mapRequest);
 239         Mockito.verify(subscriberSetMock, Mockito.times(2)).add(captor.capture());
 240         assertEquals(IPV4_ADDRESS, captor.getValue().getSrcRloc().getAddress());
 241
 242         // ----------------------
 243         // with sourceRloc address Afi = itrRloc address Afi (for Ipv4)
 244         itrRlocList = Lists.newArrayList(
 245                 newItrRloc(MacAfi.class, null),
 246                 newItrRloc(Ipv6Afi.class, IPV6_ADDRESS),
 247                 newItrRloc(Ipv4Afi.class, IPV4_ADDRESS));
 248
 249         mapRequest = mapRequestBuilder
 250                 .setSourceRloc(IPV6_ADDRESS_BINARY)
 251                 .setItrRloc(itrRlocList).build();
 252
 253         captor = ArgumentCaptor.forClass(SubscriberRLOC.class);
 254         mapResolver.handleMapRequest(mapRequest);
 255         Mockito.verify(subscriberSetMock, Mockito.times(3)).add(captor.capture());
 256         assertEquals(IPV6_ADDRESS, captor.getValue().getSrcRloc().getAddress());
 257
 258         // ----------------------
 259         // with sourceRloc address Afi = itrRloc address Afi (for Ipv6)
 260         itrRlocList = Lists.newArrayList(
 261                 newItrRloc(MacAfi.class, null),
 262                 newItrRloc(Ipv6Afi.class, IPV6_ADDRESS),
 263                 newItrRloc(Ipv4Afi.class, IPV4_ADDRESS));
 264
 265         mapRequest = mapRequestBuilder
 266                 .setSourceRloc(IPV4_ADDRESS_BINARY_2)
 267                 .setItrRloc(itrRlocList).build();
 268
 269         captor = ArgumentCaptor.forClass(SubscriberRLOC.class);
 270         mapResolver.handleMapRequest(mapRequest);
 271         Mockito.verify(subscriberSetMock, Mockito.times(4)).add(captor.capture());
 272         assertEquals(IPV4_ADDRESS, captor.getValue().getSrcRloc().getAddress());
 273
 274         // ----------------------
 275         // with no common ip address nor Afi
 276         final Mac mac = new MacBuilder().setMac(new MacAddress("aa:bb:cc:dd:ee:ff")).build();
 277         itrRlocList = Lists.newArrayList(
 278                 newItrRloc(MacAfi.class, mac),
 279                 newItrRloc(NoAddressAfi.class, Mockito.mock(NoAddress.class)));
 280
 281         mapRequest = mapRequestBuilder
 282                 .setSourceRloc(IPV4_ADDRESS_BINARY_1)
 283                 .setItrRloc(itrRlocList).build();
 284
 285         captor = ArgumentCaptor.forClass(SubscriberRLOC.class);
 286         mapResolver.handleMapRequest(mapRequest);
 287         Mockito.verify(subscriberSetMock, Mockito.times(5)).add(captor.capture());
 288         assertEquals(mac, captor.getValue().getSrcRloc().getAddress());
 289     }
 290
 291     /**
 292      * Tests {@link MapResolver#handleMapRequest} method.
 293      */
 294     @Test
 295     public void handleMapRequest__withSubscribersToRemove() {
 296         // input mapping
 297         final LocatorRecordBuilder locatorRecordBuilder = getDefaultLocatorBuilder();
 298         final MappingRecordBuilder mappingRecordBuilder = getDefaultMappingRecordBuilder();
 299         mappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder.build());
 300
 301         Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), IPV4_PREFIX_EID_1))
 302                 .thenReturn(mappingRecordBuilder.build());
 303         Mockito.when(mapServiceMock.getData(MappingOrigin.Southbound, IPV4_PREFIX_EID_1, SubKeys.SUBSCRIBERS))
 304                 .thenReturn(subscriberSetMock);
 305         SubscriberRLOC subscriberRLOCMock = new SubscriberRLOC(
 306                 mapRequestBuilder.getItrRloc().get(0).getRloc(),
 307                 mapRequestBuilder.getSourceEid().getEid(), SubscriberRLOC.DEFAULT_SUBSCRIBER_TIMEOUT);
 308         subscriberRLOCMock.setSubscriberTimeoutByRecordTtl(
 309                 mappingRecordBuilder.getRecordTtl());
 310         Mockito.when(subscriberSetMock.contains(subscriberRLOCMock))
 311                 .thenReturn(true);
 312
 313         // result
 314         final MapReplyBuilder mapReplyBuilder = getDefaultMapReplyBuilder();
 315         mapReplyBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
 316                 .setMappingRecord(mappingRecordBuilder.build()).build());
 317
 318         // check if a subscriber is re-instantiating when there already is one in the subscriber set
 319         mapResolver.handleMapRequest(mapRequestBuilder.build());
 320         Mockito.verify(subscriberSetMock).remove(SUBSCRIBER_RLOC_1);
 321         Mockito.verify(subscriberSetMock).add(SUBSCRIBER_RLOC_1);
 322         Mockito.verify(lispMappingServiceMock).handleMapReply(mapReplyBuilder.build());
 323         Mockito.verify(mapServiceMock).addData(MappingOrigin.Southbound, IPV4_PREFIX_EID_1,
 324                 SubKeys.SUBSCRIBERS, subscriberSetMock);
 325
 326         // verify that itrRloc is subscribed to dst address
 327         mappingRecordBuilder.setEid(SOURCE_DEST_KEY_EID);
 328         mapRequestBuilder.getEidItem().add(new EidItemBuilder().setEid(IPV4_PREFIX_EID_2).build());
 329         Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), IPV4_PREFIX_EID_2))
 330                 .thenReturn(mappingRecordBuilder.build());
 331
 332         mapResolver.handleMapRequest(mapRequestBuilder.build());
 333         Mockito.verify(mapServiceMock).getData(MappingOrigin.Southbound,
 334                 SourceDestKeyHelper.getDstBinary(SOURCE_DEST_KEY_EID), SubKeys.SUBSCRIBERS);
 335     }
 336
 337     /**
 338      * Tests {@link MapResolver#handleMapRequest} method.
 339      */
 340     @Test
 341     public void handleMapRequest_withBothPolicy() {
 342         mapResolver = new MapResolver(mapServiceMock, true, "both", lispMappingServiceMock);
 343
 344         final List<IpAddress> ipAddressList = new ArrayList<>();
 345         ipAddressList.add(IPV4_ADDRESS_1); // hop 1
 346         ipAddressList.add(IPV4_ADDRESS_2); // hop 2
 347
 348         final Rloc rloc = LispAddressUtil.asTeLcafRloc(ipAddressList);
 349         final LocatorRecordBuilder locatorRecordBuilder_1 = getDefaultLocatorBuilder();
 350         final LocatorRecordBuilder locatorRecordBuilder_2 = getDefaultLocatorBuilder().setRloc(rloc);
 351
 352         // input mapping
 353         final MappingRecordBuilder mappingRecordBuilder = getDefaultMappingRecordBuilder();
 354         mappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_1.build());
 355         mappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_2.build());
 356
 357         final MapRequestBuilder mapRequestBuilder = getDefaultMapRequestBuilder();
 358         mapRequestBuilder.getItrRloc().add(new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(IPV4_STRING_1))
 359                 .build());
 360         mapRequestBuilder.getItrRloc().add(new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(IPV4_STRING_2))
 361                 .build());
 362
 363         Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), IPV4_PREFIX_EID_1))
 364                 .thenReturn(mappingRecordBuilder.build());
 365
 366         // result
 367         final LocatorRecordBuilder locatorRecordBuilder_3 = getDefaultLocatorBuilder()
 368                 .setRloc(LispAddressUtil.asIpv4Rloc(IPV4_STRING_2)).setPriority((short) 1); // priority increased by 1
 369         final MappingRecordBuilder resultMappingRecordBuilder = getDefaultMappingRecordBuilder();
 370
 371         resultMappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_1.build()); // as Ipv4
 372         resultMappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_2.build()); // as ELP
 373         resultMappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_3.build()); // added to the result
 374
 375         final MapReplyBuilder mapReplyBuilder = getDefaultMapReplyBuilder();
 376         mapReplyBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
 377                 .setMappingRecord(resultMappingRecordBuilder.build()).build());
 378
 379         // invocation
 380         mapResolver.handleMapRequest(mapRequestBuilder.build());
 381         Mockito.verify(lispMappingServiceMock).handleMapReply(mapReplyBuilder.build());
 382     }
 383
 384     /**
 385      * Tests {@link MapResolver#handleMapRequest} method.
 386      */
 387     @Test
 388     public void handleMapRequest_withReplacePolicy() {
 389         mapResolver = new MapResolver(mapServiceMock, true, "replace", lispMappingServiceMock);
 390
 391         final List<IpAddress> ipAddressList = new ArrayList<>();
 392         ipAddressList.add(IPV4_ADDRESS_1); // hop 1
 393         ipAddressList.add(IPV4_ADDRESS_2); // hop 2
 394
 395         final Rloc rloc = LispAddressUtil.asTeLcafRloc(ipAddressList);
 396         final LocatorRecordBuilder locatorRecordBuilder_1 = getDefaultLocatorBuilder();
 397         final LocatorRecordBuilder locatorRecordBuilder_2 = getDefaultLocatorBuilder().setRloc(rloc);
 398
 399         // input mapping
 400         final MappingRecordBuilder mappingRecordBuilder = getDefaultMappingRecordBuilder();
 401         mappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_1.build());
 402         mappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_2.build());
 403
 404         final MapRequestBuilder mapRequestBuilder = getDefaultMapRequestBuilder();
 405         mapRequestBuilder.getItrRloc().add(new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(IPV4_STRING_1))
 406                 .build());
 407         mapRequestBuilder.getItrRloc().add(new ItrRlocBuilder().setRloc(LispAddressUtil.asIpv4Rloc(IPV4_STRING_2))
 408                 .build());
 409
 410         Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(), IPV4_PREFIX_EID_1))
 411                 .thenReturn(mappingRecordBuilder.build());
 412
 413         // result
 414         final LocatorRecordBuilder locatorRecordBuilder_3 = getDefaultLocatorBuilder()
 415                 .setRloc(LispAddressUtil.asIpv4Rloc(IPV4_STRING_2));
 416         final MappingRecordBuilder resultMappingRecordBuilder = getDefaultMappingRecordBuilder();
 417
 418         resultMappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_1.build()); // as Ipv4
 419         resultMappingRecordBuilder.getLocatorRecord().add(locatorRecordBuilder_3.build()); // added to the result
 420
 421         final MapReplyBuilder mapReplyBuilder = getDefaultMapReplyBuilder();
 422         mapReplyBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
 423                 .setMappingRecord(resultMappingRecordBuilder.build()).build());
 424
 425         // invocation
 426         mapResolver.handleMapRequest(mapRequestBuilder.build());
 427         Mockito.verify(lispMappingServiceMock).handleMapReply(mapReplyBuilder.build());
 428     }
 429
 430     /**
 431      * Tests {@link MapResolver#handleMapRequest} method.
 432      */
 433     @Test
 434     public void handleMapRequest_withMultipleEids() {
 435         mapRequestBuilder.getEidItem().add(new EidItemBuilder().setEid(IPV6_PREFIX_EID).build());
 436
 437         final LocatorRecordBuilder locatorRecordBuilder_1 = getDefaultLocatorBuilder();
 438         final LocatorRecordBuilder locatorRecordBuilder_2 = getDefaultLocatorBuilder();
 439         locatorRecordBuilder_2.setRloc(LispAddressUtil.asIpv6Rloc(IPV6_STRING));
 440
 441         //input mapping
 442         final MappingRecordBuilder mappingRecordBuilder_1 = getDefaultMappingRecordBuilder();
 443         mappingRecordBuilder_1.getLocatorRecord().add(locatorRecordBuilder_1.build());
 444         final MappingRecordBuilder mappingRecordBuilder_2 = getDefaultMappingRecordBuilder();
 445         mappingRecordBuilder_2.getLocatorRecord().add(locatorRecordBuilder_2.build());
 446         mappingRecordBuilder_2.setEid(IPV6_PREFIX_EID);
 447
 448         Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(),
 449                 mapRequestBuilder.getEidItem().get(0).getEid())).thenReturn(mappingRecordBuilder_1.build());
 450         Mockito.when(mapServiceMock.getMapping(mapRequestBuilder.getSourceEid().getEid(),
 451                 mapRequestBuilder.getEidItem().get(1).getEid())).thenReturn(mappingRecordBuilder_2.build());
 452
 453         //result
 454         final MapReplyBuilder mapReplyBuilder = getDefaultMapReplyBuilder();
 455         mapReplyBuilder.getMappingRecordItem()
 456                 .add(new MappingRecordItemBuilder().setMappingRecord(mappingRecordBuilder_1.build()).build());
 457         mapReplyBuilder.getMappingRecordItem()
 458                 .add(new MappingRecordItemBuilder().setMappingRecord(mappingRecordBuilder_2.build()).build());
 459
 460         mapResolver.handleMapRequest(mapRequestBuilder.build());
 461         Mockito.verify(lispMappingServiceMock).handleMapReply(mapReplyBuilder.build());
 462     }
 463
 464     private static ItrRloc newItrRloc(Class<? extends LispAddressFamily> clazz, Address address) {
 465         return new ItrRlocBuilder().setRloc(new RlocBuilder()
 466                 .setAddress(address)
 467                 .setAddressType(clazz).build()).build();
 468     }
 469
 470     private static List<ItrRloc> getDefaultItrRlocList() {
 471         final List<ItrRloc> itrRlocList = new ArrayList<>();
 472         final ItrRloc itrRloc = new ItrRlocBuilder()
 473                 .setKey(new ItrRlocKey(ITR_RLOC_KEY_STRING))
 474                 .setItrRlocId(ITR_RLOC_ID_STRING)
 475                 .setRloc(RLOC_1).build();
 476         itrRlocList.add(itrRloc);
 477
 478         return itrRlocList;
 479     }
 480
 481     private static MapRequestBuilder getDefaultMapRequestBuilder() {
 482         MapRequestBuilder mrBuilder = new MapRequestBuilder()
 483                 .setAuthoritative(false)
 484                 .setEidItem(new ArrayList<>())
 485                 .setItrRloc(new ArrayList<>())
 486                 .setMapDataPresent(true)
 487                 .setNonce((long) 0)
 488                 .setPitr(false)
 489                 .setProbe(false)
 490                 .setSmr(false)
 491                 .setSmrInvoked(true)
 492                 .setSourceEid(new SourceEidBuilder().setEid(LispAddressUtil.asIpv4Eid(IPV4_SOURCE)).build())
 493                 .setItrRloc(getDefaultItrRlocList());
 494
 495         mrBuilder.getEidItem().add(new EidItemBuilder().setEid(IPV4_PREFIX_EID_1).build());
 496
 497         return mrBuilder;
 498     }
 499
 500     private static MappingRecordBuilder getDefaultMappingRecordBuilder() {
 501         return new MappingRecordBuilder()
 502                 .setAction(MappingRecord.Action.NoAction)
 503                 .setAuthoritative(false)
 504                 .setLocatorRecord(new ArrayList<>())
 505                 .setMapVersion((short) 0)
 506                 .setRecordTtl(60)
 507                 .setEid(IPV4_PREFIX_EID_1);
 508     }
 509
 510     private static LocatorRecordBuilder getDefaultLocatorBuilder() {
 511         return new LocatorRecordBuilder()
 512                 .setLocalLocator(false)
 513                 .setMulticastPriority((short) 0)
 514                 .setMulticastWeight((short) 0)
 515                 .setPriority((short) 0)
 516                 .setRlocProbed(false)
 517                 .setRouted(true)
 518                 .setWeight((short) 0)
 519                 .setKey(LOCATOR_RECORD_KEY)
 520                 .setRloc(LispAddressUtil.asIpv4Rloc(IPV4_RLOC_STRING_1));
 521     }
 522
 523     private static MapReplyBuilder getDefaultMapReplyBuilder() {
 524         return new MapReplyBuilder()
 525                 .setEchoNonceEnabled(false)
 526                 .setProbe(false)
 527                 .setSecurityEnabled(false)
 528                 .setNonce(mapRequestBuilder.getNonce())
 529                 .setMappingRecordItem(new ArrayList<>());
 530     }
 531 }