mappingservice/implementation/src/test/java/org/opendaylight/lispflowmapping/implementation/LispMappingServiceTest.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;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertNull;
  12
  13 import com.google.common.collect.Lists;
  14 import java.lang.reflect.Field;
  15 import java.util.ArrayList;
  16 import java.util.List;
  17 import org.apache.commons.lang3.tuple.ImmutablePair;
  18 import org.apache.commons.lang3.tuple.MutablePair;
  19 import org.apache.commons.lang3.tuple.Pair;
  20 import org.junit.Test;
  21 import org.junit.runner.RunWith;
  22 import org.mockito.ArgumentMatcher;
  23 import org.mockito.InjectMocks;
  24 import org.mockito.Mock;
  25 import org.mockito.Mockito;
  26 import org.mockito.junit.MockitoJUnitRunner;
  27 import org.opendaylight.lispflowmapping.implementation.lisp.MapServer;
  28 import org.opendaylight.lispflowmapping.interfaces.lisp.IMapResolverAsync;
  29 import org.opendaylight.lispflowmapping.interfaces.mappingservice.IMappingService;
  30 import org.opendaylight.lispflowmapping.lisp.type.LispMessage;
  31 import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
  32 import org.opendaylight.mdsal.binding.api.NotificationService;
  33 import org.opendaylight.mdsal.binding.api.RpcConsumerRegistry;
  34 import org.opendaylight.mdsal.singleton.common.api.ClusterSingletonServiceProvider;
  35 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.IpAddressBinary;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.Ipv4AddressBinary;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.AddMapping;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.GotMapNotify;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.GotMapReply;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapNotify;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapRegister;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapReply;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MappingKeepAlive;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.RequestMapping;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.XtrReplyMapping;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.XtrRequestMapping;
  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.map.register.cache.metadata.container.MapRegisterCacheMetadata;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.map.register.cache.metadata.container.MapRegisterCacheMetadataBuilder;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.map.register.cache.metadata.container.map.register.cache.metadata.EidLispAddress;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.map.register.cache.metadata.container.map.register.cache.metadata.EidLispAddressBuilder;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapnotifymessage.MapNotifyBuilder;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping._record.container.MappingRecordBuilder;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping._record.list.MappingRecordItemBuilder;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapreplymessage.MapReplyBuilder;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequest.SourceEidBuilder;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequestmessage.MapRequest;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequestmessage.MapRequestBuilder;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.rloc.container.Rloc;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.transport.address.TransportAddress;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.transport.address.TransportAddressBuilder;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.SendMapNotify;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.SendMapNotifyInput;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.SendMapNotifyInputBuilder;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.SendMapReply;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.SendMapReplyInputBuilder;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.SendMapRequest;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.SendMapRequestInputBuilder;
  71 import org.opendaylight.yangtools.concepts.Registration;
  72 import org.opendaylight.yangtools.yang.binding.util.BindingMap;
  73 import org.opendaylight.yangtools.yang.common.Uint16;
  74
  75 @RunWith(MockitoJUnitRunner.class)
  76 public class LispMappingServiceTest {
  77     @Mock private static MapRegister mapRegisterMock;
  78     @Mock(name = "mapServer") private static MapServer mapServerMock;
  79     @Mock(name = "mapResolver") private static IMapResolverAsync mapResolverMock;
  80     @Mock(name = "tlsMapReply") private static ThreadLocal<MapReply> tlsMapReplyMock;
  81     @Mock(name = "tlsMapNotify") private static ThreadLocal<Pair<MapNotify, List<TransportAddress>>> tlsMapNotifyMock;
  82     @Mock(name = "tlsMapRequest") private static ThreadLocal<Pair<MapRequest, TransportAddress>> tlsMapRequestMock;
  83     @Mock(name = "listenerRegistration") private static Registration listenerRegistration;
  84     @Mock(name = "cssRegistration") private static Registration cssRegistration;
  85     @Mock(name = "sendMapRequest") private static SendMapRequest sendMapRequest;
  86     @Mock(name = "sendMapReply") private static SendMapReply sendMapReply;
  87     @Mock(name = "sendMapNotify") private static SendMapNotify sendMapNotify;
  88
  89     private final NotificationService notificationService = Mockito.mock(NotificationService.class);
  90     private final RpcConsumerRegistry rpcService = Mockito.mock(RpcConsumerRegistry.class);
  91     private final IMappingService mappingService = Mockito.mock(IMappingService.class);
  92     private final ClusterSingletonServiceProvider clusterSingletonService = Mockito.mock(
  93             ClusterSingletonServiceProvider.class);
  94
  95     @InjectMocks
  96     private final LispMappingService lispMappingService = new LispMappingService(
  97             mappingService, clusterSingletonService, rpcService, notificationService);
  98
  99     private static final byte[] IPV4_BYTES_1 =       new byte[] {1, 2, 3, 0};
 100     private static final byte[] IPV4_BYTES_2 =       new byte[] {1, 2, 4, 0};
 101     private static final String IPV4_STRING_1 =      "1.2.3.0";
 102     private static final String IPV4_STRING_2 =      "1.2.3.1";
 103     private static final String IPV4_SOURCE_STRING = "192.168.0.1";
 104     private static final String IPV4_PREFIX_STRING = "/24";
 105     private static final long TIMESTAMP = 1L;
 106
 107     private static final Eid IPV4_PREFIX_EID_1 = LispAddressUtil.asIpv4PrefixEid(IPV4_STRING_1 + IPV4_PREFIX_STRING);
 108     private static final Eid IPV4_SOURCE_EID = LispAddressUtil.asIpv4Eid(IPV4_SOURCE_STRING);
 109     private static final Eid IPV4_EID_1 = LispAddressUtil.asIpv4Eid(IPV4_STRING_1);
 110     private static final Eid IPV4_EID_2 = LispAddressUtil.asIpv4Eid(IPV4_STRING_2);
 111     private static final EidItemBuilder EID_ITEM_BUILDER = new EidItemBuilder()
 112             .setEidItemId("eid-item-id")
 113             .setEid(IPV4_PREFIX_EID_1);
 114     private static final MappingRecordItemBuilder MAPPING_RECORD_ITEM_BUILDER = new MappingRecordItemBuilder()
 115             .setMappingRecord(new MappingRecordBuilder().setEid(IPV4_PREFIX_EID_1).build());
 116
 117     private static final TransportAddress TRANSPORT_ADDRESS_1 = new TransportAddressBuilder()
 118             .setIpAddress(new IpAddressBinary(new Ipv4AddressBinary(IPV4_BYTES_1)))
 119             .setPort(new PortNumber(Uint16.valueOf(9999))).build();
 120     private static final TransportAddress TRANSPORT_ADDRESS_2 = new TransportAddressBuilder()
 121             .setIpAddress(new IpAddressBinary(new Ipv4AddressBinary(IPV4_BYTES_2)))
 122             .setPort(new PortNumber(Uint16.valueOf(8888))).build();
 123     private static final TransportAddress TRANSPORT_ADDRESS = new TransportAddressBuilder()
 124             .setIpAddress(new IpAddressBinary(new Ipv4AddressBinary(IPV4_BYTES_1)))
 125             .setPort(new PortNumber(LispMessage.PORT_NUMBER)).build();
 126
 127     /**
 128      * Tests {@link LispMappingService#handleMapRequest} method.
 129      */
 130     @Test
 131     public void handleMapRequestTest() {
 132         final MapRequest mapRequest = Mockito.mock(MapRequest.class);
 133         final MapReply mapReply = new MapReplyBuilder().build();
 134         Mockito.when(tlsMapRequestMock.get()).thenReturn(null);
 135         Mockito.when(tlsMapReplyMock.get()).thenReturn(mapReply);
 136
 137         final MapReply result = lispMappingService.handleMapRequest(mapRequest);
 138
 139         Mockito.verify(tlsMapRequestMock).set(null);
 140         Mockito.verify(tlsMapRequestMock).get();
 141         Mockito.verifyNoMoreInteractions(tlsMapRequestMock);
 142         Mockito.verify(mapResolverMock).handleMapRequest(mapRequest);
 143         Mockito.verify(tlsMapReplyMock).set(Mockito.any());
 144         Mockito.verify(tlsMapReplyMock).get();
 145
 146         assertEquals(result, mapReply);
 147     }
 148
 149     /**
 150      * Tests {@link LispMappingService#handleMapRequest} method request from non-proxy xTR.
 151      */
 152     @Test
 153     public void handleMapRequestTest_NonProxy() {
 154         final MapRequest mapRequest = Mockito.mock(MapRequest.class);
 155         final Pair<MapRequest, TransportAddress> pair = getDefaultMapRequestPair();
 156         final SendMapRequestInputBuilder smrib = new SendMapRequestInputBuilder()
 157                 .setMapRequest(pair.getLeft())
 158                 .setTransportAddress(pair.getRight());
 159
 160         Mockito.when(tlsMapRequestMock.get()).thenReturn(pair);
 161
 162         assertNull(lispMappingService.handleMapRequest(mapRequest));
 163         Mockito.verify(sendMapRequest).invoke(smrib.build());
 164     }
 165
 166     /**
 167      * Tests {@link LispMappingService#handleMapRegister} method.
 168      */
 169     @Test
 170     @SuppressWarnings("unchecked")
 171     public void handleMapRegisterTest() {
 172         final Pair<MapNotify, List<TransportAddress>> pairMock = Mockito.mock(Pair.class);
 173
 174         Mockito.when(tlsMapNotifyMock.get()).thenReturn(pairMock);
 175
 176         lispMappingService.handleMapRegister(mapRegisterMock);
 177         Mockito.verify(mapServerMock).handleMapRegister(mapRegisterMock);
 178         Mockito.verify(tlsMapNotifyMock).set(Mockito.any());
 179     }
 180
 181     /**
 182      * Tests {@link LispMappingService#onAddMapping} method.
 183      */
 184     @Test
 185     public void onAddMappingTest() {
 186         final org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapregisternotification.MapRegister
 187                 mapRegister = Mockito.mock(org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105
 188                 .mapregisternotification.MapRegister.class);
 189         final AddMapping addMapping = Mockito.mock(AddMapping.class);
 190
 191         Mockito.when(addMapping.getMapRegister()).thenReturn(mapRegister);
 192         Mockito.when(tlsMapNotifyMock.get()).thenReturn(getDefaultMapNotifyPair());
 193
 194         lispMappingService.onAddMapping(addMapping);
 195         Mockito.verify(sendMapNotify, Mockito.times(2)).invoke(Mockito.argThat(new TransportAddressMatch()));
 196     }
 197
 198     /**
 199      * Tests {@link LispMappingService#onAddMapping} method with no TransportAddress.
 200      */
 201     @Test
 202     public void onAddMappingTest_noTransportAddress() {
 203         final org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapregisternotification.MapRegister
 204                 mapRegister = Mockito.mock(org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105
 205                 .mapregisternotification.MapRegister.class);
 206         final AddMapping addMapping = Mockito.mock(AddMapping.class);
 207         final MapNotify mapNotify = new MapNotifyBuilder().setKeyId((short) 1).build();
 208
 209         Mockito.when(addMapping.getMapRegister()).thenReturn(mapRegister);
 210         Mockito.when(tlsMapNotifyMock.get()).thenReturn(new MutablePair<>(mapNotify, null));
 211         Mockito.when(addMapping.getTransportAddress()).thenReturn(TRANSPORT_ADDRESS_1);
 212
 213         // result
 214         final SendMapNotifyInputBuilder smnib = new SendMapNotifyInputBuilder()
 215                 .setMapNotify(new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105
 216                         .mapnotifymessage.MapNotifyBuilder().setKeyId((short) 1).build())
 217                 .setTransportAddress(TRANSPORT_ADDRESS);
 218
 219         lispMappingService.onAddMapping(addMapping);
 220         Mockito.verify(sendMapNotify).invoke(smnib.build());
 221     }
 222
 223     /**
 224      * Tests {@link LispMappingService#onRequestMapping} method.
 225      */
 226     @Test
 227     public void onRequestMappingTest() {
 228         final RequestMapping requestMapping = Mockito.mock(RequestMapping.class);
 229         final org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequestnotification.MapRequest
 230                 mapRequest = Mockito.mock(org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105
 231                     .maprequestnotification.MapRequest.class);
 232         final MapReply mapReply = new MapReplyBuilder().build();
 233
 234         Mockito.when(requestMapping.getMapRequest()).thenReturn(mapRequest);
 235         Mockito.when(requestMapping.getTransportAddress()).thenReturn(TRANSPORT_ADDRESS_1);
 236         Mockito.when(tlsMapReplyMock.get()).thenReturn(mapReply);
 237
 238         // result
 239         final SendMapReplyInputBuilder smrib = new SendMapReplyInputBuilder()
 240                 .setMapReply(new MapReplyBuilder(mapReply).build())
 241                 .setTransportAddress(TRANSPORT_ADDRESS_1);
 242
 243         lispMappingService.onRequestMapping(requestMapping);
 244         Mockito.verify(sendMapReply).invoke(smrib.build());
 245     }
 246
 247     /**
 248      * Tests {@link LispMappingService#onRequestMapping} method with mapReply == null.
 249      */
 250     @Test
 251     public void onRequestMappingTest_withNullMapReply() {
 252         final RequestMapping requestMapping = Mockito.mock(RequestMapping.class);
 253         final org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequestnotification.MapRequest
 254                 mapRequest = Mockito.mock(org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105
 255                     .maprequestnotification.MapRequest.class);
 256
 257         Mockito.when(requestMapping.getMapRequest()).thenReturn(mapRequest);
 258         Mockito.when(tlsMapReplyMock.get()).thenReturn(null);
 259
 260         lispMappingService.onRequestMapping(requestMapping);
 261         Mockito.verifyZeroInteractions(sendMapReply);
 262     }
 263
 264     /**
 265      * Tests {@link LispMappingService#onMappingKeepAlive} method.
 266      */
 267     @Test
 268     public void onMappingKeepAliveTest() {
 269         final MappingKeepAlive mappingKeepAlive = Mockito.mock(MappingKeepAlive.class);
 270         Mockito.when(mappingKeepAlive.getMapRegisterCacheMetadata()).thenReturn(getDefaultMapRegisterCacheMetadata());
 271
 272         lispMappingService.onMappingKeepAlive(mappingKeepAlive);
 273         Mockito.verify(mappingService).refreshMappingRegistration(IPV4_EID_1, null, TIMESTAMP);
 274         Mockito.verify(mappingService).refreshMappingRegistration(IPV4_EID_2, null, TIMESTAMP);
 275     }
 276
 277     /**
 278      * Tests {@link LispMappingService#handleSMR} method.
 279      */
 280     @Test
 281     public void handleSmrTest() {
 282         final MapRequest mapRequest = Mockito.mock(MapRequest.class);
 283         final Rloc subscriber = LispAddressUtil.asIpv4Rloc(IPV4_STRING_1);
 284
 285         Mockito.when(mapRequest.getSourceEid()).thenReturn(new SourceEidBuilder().setEid(IPV4_SOURCE_EID).build());
 286         Mockito.when(mapRequest.getEidItem()).thenReturn(Lists.newArrayList(EID_ITEM_BUILDER.build()));
 287
 288         // result
 289         final SendMapRequestInputBuilder smrib = new SendMapRequestInputBuilder()
 290                 .setMapRequest(new MapRequestBuilder(mapRequest).build())
 291                 .setTransportAddress(TRANSPORT_ADDRESS);
 292
 293         lispMappingService.handleSMR(mapRequest, subscriber);
 294         Mockito.verify(sendMapRequest).invoke(smrib.build());
 295     }
 296
 297     /**
 298      * Tests {@link LispMappingService#setShouldUseSmr} method.
 299      */
 300     @Test
 301     public void setShouldUseSmrTest() {
 302         final boolean value = true;
 303
 304         lispMappingService.setShouldUseSmr(value);
 305         Mockito.verify(mapServerMock).setSubscriptionService(value);
 306         Mockito.verify(mapResolverMock).setSubscriptionService(value);
 307     }
 308
 309     /**
 310      * Tests {@link LispMappingService#handleMapNotify} method.
 311      */
 312     @Test
 313     @SuppressWarnings("unchecked")
 314     public void handleMapNotifyTest() {
 315         final MapNotify mapNotify = Mockito.mock(MapNotify.class);
 316         final List<TransportAddress> list = Mockito.mock(ArrayList.class);
 317
 318         lispMappingService.handleMapNotify(mapNotify, list);
 319         Mockito.verify(tlsMapNotifyMock).set(Mockito.any(MutablePair.class));
 320     }
 321
 322     /**
 323      * Tests {@link LispMappingService#handleNonProxyMapRequest} method.
 324      */
 325     @Test
 326     @SuppressWarnings("unchecked")
 327     public void handleNonProxyMapRequestTest() {
 328         final MapRequest mapRequest = Mockito.mock(MapRequest.class);
 329         final TransportAddress transportAddress = Mockito.mock(TransportAddress.class);
 330
 331         lispMappingService.handleNonProxyMapRequest(mapRequest, transportAddress);
 332         Mockito.verify(tlsMapRequestMock).set(Mockito.any(MutablePair.class));
 333     }
 334
 335     /**
 336      * Tests {@link LispMappingService#handleMapReply} method.
 337      */
 338     @Test
 339     public void handleMapReplyTest() {
 340         final MapReply mapReply = Mockito.mock(MapReply.class);
 341
 342         lispMappingService.handleMapReply(mapReply);
 343         Mockito.verify(tlsMapReplyMock).set(Mockito.any(MapReply.class));
 344     }
 345
 346     /**
 347      * Tests {@link LispMappingService#close} method.
 348      */
 349     @Test
 350     public void closeTest() throws Exception {
 351         setMock("listenerRegistration", listenerRegistration);
 352         setMock("cssRegistration", cssRegistration);
 353         lispMappingService.close();
 354         Mockito.verify(listenerRegistration).close();
 355         Mockito.verify(cssRegistration).close();
 356         assertNull(getField("mapResolver"));
 357         assertNull(getField("mapServer"));
 358     }
 359
 360     /**
 361      * Tests {@link LispMappingService} other setter and getter methods.
 362      */
 363     @Test
 364     public void otherTest() throws Exception {
 365         assertEquals(notificationService, lispMappingService.getNotificationService());
 366         assertEquals(true, lispMappingService.shouldUseSmr());
 367
 368         lispMappingService.setShouldAuthenticate(true);
 369         Mockito.verify(mapResolverMock).setShouldAuthenticate(true);
 370
 371         lispMappingService.onGotMapReply(Mockito.mock(GotMapReply.class));
 372         lispMappingService.onGotMapNotify(Mockito.mock(GotMapNotify.class));
 373         lispMappingService.onXtrRequestMapping(Mockito.mock(XtrRequestMapping.class));
 374         lispMappingService.onXtrReplyMapping(Mockito.mock(XtrReplyMapping.class));
 375     }
 376
 377     private void setMock(final String fieldName, final Object value)
 378             throws IllegalAccessException, NoSuchFieldException {
 379         final Field field = LispMappingService.class.getDeclaredField(fieldName);
 380         field.setAccessible(true);
 381         field.set(lispMappingService, value);
 382     }
 383
 384     @SuppressWarnings("unchecked")
 385     private <T> T getField(final String fieldName) throws NoSuchFieldException, IllegalAccessException {
 386         final Field field = LispMappingService.class.getDeclaredField(fieldName);
 387         field.setAccessible(true);
 388
 389         return (T) field.get(lispMappingService);
 390     }
 391
 392     private static Pair<MapNotify, List<TransportAddress>> getDefaultMapNotifyPair() {
 393         final MapNotify mapNotify = new MapNotifyBuilder().setKeyId((short) 1).build();
 394         return new MutablePair<>(mapNotify, Lists.newArrayList(TRANSPORT_ADDRESS_1, TRANSPORT_ADDRESS_2));
 395     }
 396
 397     private static Pair<MapRequest, TransportAddress> getDefaultMapRequestPair() {
 398         final MapRequestBuilder mapRequestBuilder = new MapRequestBuilder()
 399                 .setEidItem(Lists.newArrayList(EID_ITEM_BUILDER.build()));
 400
 401         return new ImmutablePair<>(mapRequestBuilder.build(), TRANSPORT_ADDRESS_1);
 402     }
 403
 404     private static MapRegisterCacheMetadata getDefaultMapRegisterCacheMetadata() {
 405         final EidLispAddress eidLispAddress_1 = new EidLispAddressBuilder()
 406                 .setEidLispAddressId("id-1")
 407                 .setEid(IPV4_EID_1).build();
 408         final EidLispAddress eidLispAddress_2 = new EidLispAddressBuilder()
 409                 .setEidLispAddressId("id-2")
 410                 .setEid(IPV4_EID_2).build();
 411
 412         return new MapRegisterCacheMetadataBuilder()
 413                 .setEidLispAddress(BindingMap.ordered(eidLispAddress_1, eidLispAddress_2))
 414                 .setTimestamp(TIMESTAMP).build();
 415     }
 416
 417     static class TransportAddressMatch implements ArgumentMatcher<SendMapNotifyInput> {
 418         @Override
 419         public boolean matches(final SendMapNotifyInput argument) {
 420             final TransportAddress notifyTransportAddress = argument.getTransportAddress();
 421             return TRANSPORT_ADDRESS_1.equals(notifyTransportAddress)
 422                     || TRANSPORT_ADDRESS_2.equals(notifyTransportAddress);
 423         }
 424     }
 425 }