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