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