mappingservice/implementation/src/test/java/org/opendaylight/lispflowmapping/implementation/lisp/MapServerTest.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.ImmutableSet;
  13 import com.google.common.collect.Lists;
  14 import com.google.common.collect.Sets;
  15 import java.lang.reflect.Field;
  16 import java.util.ArrayList;
  17 import java.util.Date;
  18 import java.util.HashSet;
  19 import java.util.List;
  20 import java.util.Set;
  21 import org.junit.Before;
  22 import org.junit.Ignore;
  23 import org.junit.Test;
  24 import org.junit.runner.RunWith;
  25 import org.mockito.ArgumentCaptor;
  26 import org.mockito.Mock;
  27 import org.mockito.Mockito;
  28 import org.mockito.Spy;
  29 import org.mockito.junit.MockitoJUnitRunner;
  30 import org.opendaylight.lispflowmapping.config.ConfigIni;
  31 import org.opendaylight.lispflowmapping.interfaces.dao.SubKeys;
  32 import org.opendaylight.lispflowmapping.interfaces.dao.Subscriber;
  33 import org.opendaylight.lispflowmapping.interfaces.lisp.IMapNotifyHandler;
  34 import org.opendaylight.lispflowmapping.interfaces.mappingservice.IMappingService;
  35 import org.opendaylight.lispflowmapping.lisp.type.LispMessage;
  36 import org.opendaylight.lispflowmapping.lisp.type.MappingData;
  37 import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
  38 import org.opendaylight.lispflowmapping.lisp.util.SourceDestKeyHelper;
  39 import org.opendaylight.mdsal.binding.api.NotificationService;
  40 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.IpAddressBinary;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.Ipv4AddressBinary;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapRegister;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.SiteId;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.XtrId;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.Eid;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecord;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecordBuilder;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecordKey;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapnotifymessage.MapNotifyBuilder;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping._record.container.MappingRecord;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping._record.container.MappingRecordBuilder;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping._record.list.MappingRecordItem;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping._record.list.MappingRecordItemBuilder;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping._record.list.MappingRecordItemKey;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.authkey.container.MappingAuthkey;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.authkey.container.MappingAuthkeyBuilder;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapregistermessage.MapRegisterBuilder;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequestnotification.MapRequest;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.rloc.container.Rloc;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.transport.address.TransportAddress;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.transport.address.TransportAddressBuilder;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingOrigin;
  64 import org.opendaylight.yangtools.yang.common.Uint16;
  65
  66 @RunWith(MockitoJUnitRunner.class)
  67 public class MapServerTest {
  68
  69     @Mock private static IMappingService mapService;
  70     @Mock private static IMapNotifyHandler notifyHandler;
  71     @Mock private static NotificationService notificationService;
  72
  73     @Spy private static Set<Subscriber> subscriberSetMock_1 = new HashSet<>();
  74     @Spy private static Set<Subscriber> subscriberSetMock_2 = new HashSet<>();
  75     @Spy private static Set<Subscriber> subscriberSetMock_3 = new HashSet<>();
  76     private static MapServer mapServer;
  77     private static MapRegister mapRegister;
  78     private static MappingData mappingData;
  79
  80     private static final String IPV4_STRING_1 =        "1.2.3.0";
  81     private static final String IPV4_STRING_2 =        "1.2.4.0";
  82     private static final String IPV4_STRING_3 =        "192.168.0.1";
  83     private static final String IPV4_STRING_4 =        "192.168.0.2";
  84     private static final String IPV4_STRING_5 =        "192.168.0.3";
  85     private static final String IPV4_STRING_6 =        "192.168.0.4";
  86     private static final String IPV4_SOURCE_STRING_1 = "127.0.0.1";
  87     private static final String IPV4_SOURCE_STRING_2 = "127.0.0.2";
  88     private static final String IPV4_SOURCE_STRING_3 = "127.0.0.3";
  89     private static final String IPV4_SOURCE_STRING_4 = "127.0.0.4";
  90     private static final String IPV4_SOURCE_STRING_5 = "127.0.0.5";
  91     private static final String IPV4_SOURCE_STRING_6 = "127.0.0.6";
  92     private static final String IPV4_PREFIX_1 =        "/24";
  93     private static final String IPV4_PREFIX_2 =        "/16";
  94     private static final int MASK = 24;
  95     private static final int VNI = 10;
  96
  97     private static final Eid IPV4_EID_1 = LispAddressUtil.asIpv4Eid(IPV4_STRING_1);
  98     private static final Eid IPV4_EID_2 = LispAddressUtil.asIpv4Eid(IPV4_STRING_2);
  99     private static final Eid IPV4_PREFIX_EID_1 = LispAddressUtil.asIpv4PrefixBinaryEid(IPV4_STRING_1 + IPV4_PREFIX_1);
 100     private static final Eid IPV4_PREFIX_EID_2 = LispAddressUtil.asIpv4PrefixBinaryEid(IPV4_STRING_1 + IPV4_PREFIX_2);
 101     private static final Eid IPV4_SOURCE_EID_1 = LispAddressUtil.asIpv4Eid(IPV4_SOURCE_STRING_1);
 102     private static final Eid IPV4_SOURCE_EID_2 = LispAddressUtil.asIpv4Eid(IPV4_SOURCE_STRING_2);
 103     private static final Eid IPV4_SOURCE_EID_3 = LispAddressUtil.asIpv4Eid(IPV4_SOURCE_STRING_3);
 104     private static final Eid IPV4_SOURCE_EID_4 = LispAddressUtil.asIpv4Eid(IPV4_SOURCE_STRING_4);
 105     private static final Eid IPV4_SOURCE_EID_5 = LispAddressUtil.asIpv4Eid(IPV4_SOURCE_STRING_5);
 106     private static final Eid IPV4_SOURCE_EID_6 = LispAddressUtil.asIpv4Eid(IPV4_SOURCE_STRING_6);
 107     private static final Rloc RLOC_1 = LispAddressUtil.asIpv4Rloc(IPV4_STRING_1);
 108     private static final Rloc RLOC_2 = LispAddressUtil.asIpv4Rloc(IPV4_STRING_2);
 109     private static final Rloc RLOC_3 = LispAddressUtil.asIpv4Rloc(IPV4_STRING_3);
 110     private static final Rloc RLOC_4 = LispAddressUtil.asIpv4Rloc(IPV4_STRING_4);
 111     private static final Rloc RLOC_5 = LispAddressUtil.asIpv4Rloc(IPV4_STRING_5);
 112     private static final Rloc RLOC_6 = LispAddressUtil.asIpv4Rloc(IPV4_STRING_6);
 113
 114     private static final IpAddressBinary IPV4_BINARY_1 =
 115             new IpAddressBinary(new Ipv4AddressBinary(new byte[] {1, 2, 3, 0}));
 116     private static final IpAddressBinary IPV4_BINARY_2 =
 117             new IpAddressBinary(new Ipv4AddressBinary(new byte[] {1, 2, 4, 0}));
 118
 119     private static final long TWO_DAYS = 86400000L * 2;
 120
 121     // timedOut() == true
 122     private static final Subscriber SUBSCRIBER_RLOC_1 = new Subscriber(RLOC_1,
 123             IPV4_SOURCE_EID_1, Subscriber.DEFAULT_SUBSCRIBER_TIMEOUT,
 124             new Date(System.currentTimeMillis() - TWO_DAYS));
 125     // timedOut() == false
 126     private static final Subscriber SUBSCRIBER_RLOC_2 = new Subscriber(RLOC_2,
 127             IPV4_SOURCE_EID_2, Subscriber.DEFAULT_SUBSCRIBER_TIMEOUT);
 128     // timedOut() == true
 129     private static final Subscriber SUBSCRIBER_RLOC_3 = new Subscriber(RLOC_3,
 130             IPV4_SOURCE_EID_3, Subscriber.DEFAULT_SUBSCRIBER_TIMEOUT,
 131             new Date(System.currentTimeMillis() - TWO_DAYS));
 132     // timedOut() == false
 133     private static final Subscriber SUBSCRIBER_RLOC_4 = new Subscriber(RLOC_4,
 134             IPV4_SOURCE_EID_4, Subscriber.DEFAULT_SUBSCRIBER_TIMEOUT);
 135     // timedOut() == true
 136     private static final Subscriber SUBSCRIBER_RLOC_5 = new Subscriber(RLOC_5,
 137             IPV4_SOURCE_EID_5, Subscriber.DEFAULT_SUBSCRIBER_TIMEOUT,
 138             new Date(System.currentTimeMillis() - TWO_DAYS));
 139     // timedOut() == false
 140     private static final Subscriber SUBSCRIBER_RLOC_6 = new Subscriber(RLOC_6,
 141             IPV4_SOURCE_EID_6, Subscriber.DEFAULT_SUBSCRIBER_TIMEOUT);
 142
 143     private static final Eid SOURCE_DEST_KEY_EID = LispAddressUtil
 144             .asSrcDstEid(IPV4_STRING_1, IPV4_STRING_2, MASK, MASK, VNI);
 145     private static final MappingAuthkey MAPPING_AUTHKEY = new MappingAuthkeyBuilder().setKeyType(Uint16.ZERO).build();
 146     private static final ConfigIni CONFIG_INI = ConfigIni.getInstance();
 147
 148     private static final LocatorRecord LOCATOR_RECORD_1 = new LocatorRecordBuilder()
 149             .withKey(new LocatorRecordKey(IPV4_STRING_1))
 150             .setRloc(RLOC_1).build();
 151     private static final LocatorRecord LOCATOR_RECORD_2 = new LocatorRecordBuilder()
 152             .withKey(new LocatorRecordKey(IPV4_STRING_2))
 153             .setRloc(RLOC_2).build();
 154
 155     private static final MappingRecord OLD_MAPPING_RECORD_1 = getDefaultMappingRecordBuilder()
 156             .setLocatorRecord(Lists.newArrayList(LOCATOR_RECORD_1)).build();
 157     private static final MappingRecord OLD_MAPPING_RECORD_2 = getDefaultMappingRecordBuilder()
 158             .setLocatorRecord(Lists.newArrayList(LOCATOR_RECORD_2)).build();
 159     private static final MappingData OLD_MAPPING_DATA_1 = new MappingData(OLD_MAPPING_RECORD_1);
 160     private static final MappingData OLD_MAPPING_DATA_2 = new MappingData(OLD_MAPPING_RECORD_2);
 161
 162     private static final Set<IpAddressBinary> DEFAULT_IP_ADDRESS_SET = getDefaultIpAddressSet();
 163
 164     @Before
 165     public void init() throws NoSuchFieldException, IllegalAccessException  {
 166         mapServer = new MapServer(mapService, true, notifyHandler, notificationService);
 167         subscriberSetMock_1.add(SUBSCRIBER_RLOC_1);
 168         subscriberSetMock_1.add(SUBSCRIBER_RLOC_2);
 169         subscriberSetMock_2.add(SUBSCRIBER_RLOC_3);
 170         subscriberSetMock_2.add(SUBSCRIBER_RLOC_4);
 171         subscriberSetMock_3.add(SUBSCRIBER_RLOC_5);
 172         subscriberSetMock_3.add(SUBSCRIBER_RLOC_6);
 173         mapRegister = getDefaultMapRegisterBuilder().build();
 174         mappingData = new MappingData(mapRegister.getMappingRecordItem().iterator().next().getMappingRecord(),
 175                 System.currentTimeMillis());
 176         setConfigIniMappingMergeField(false);
 177     }
 178
 179     @Test
 180     public void handleMapRegisterTest_MappingMergeFalse() throws NoSuchFieldException, IllegalAccessException {
 181         Mockito.when(mapService.getMapping(MappingOrigin.Southbound, IPV4_EID_1)).thenReturn(OLD_MAPPING_DATA_1);
 182
 183         mappingData.setMergeEnabled(false);
 184         mapServer.handleMapRegister(mapRegister);
 185
 186         final ArgumentCaptor<MappingData> captor = ArgumentCaptor.forClass(MappingData.class);
 187         Mockito.verify(mapService).addMapping(Mockito.eq(MappingOrigin.Southbound), Mockito.eq(IPV4_EID_1),
 188                 Mockito.eq(mapRegister.getSiteId()), captor.capture());
 189         assertEquals(captor.getValue().getRecord(), mappingData.getRecord());
 190         Mockito.verify(notifyHandler).handleMapNotify(getDefaultMapNotifyBuilder(mapRegister)
 191                 .setAuthenticationData(null).build(), null);
 192
 193         // only 1 subscriber has timed out.
 194         assertEquals(2, subscriberSetMock_1.size());
 195     }
 196
 197     @Test
 198     public void handleMapRegisterTest_MappingMergeTrue() throws NoSuchFieldException, IllegalAccessException {
 199         setConfigIniMappingMergeField(true);
 200
 201         final MappingRecordItemBuilder mappingRecordItemBuilder = new MappingRecordItemBuilder()
 202                 .withKey(new MappingRecordItemKey(IPV4_STRING_1))
 203                 .setMappingRecord(OLD_MAPPING_RECORD_1);
 204         final MapNotifyBuilder mapNotifyBuilder = getDefaultMapNotifyBuilder(mapRegister)
 205                 .setMappingRecordItem(new ArrayList<>());
 206         mapNotifyBuilder.getMappingRecordItem().add(mappingRecordItemBuilder.build());
 207
 208         // no mapping changes
 209         Mockito.when(mapService.getMapping(MappingOrigin.Southbound, IPV4_EID_1))
 210                 .thenReturn(OLD_MAPPING_DATA_1);
 211
 212         mappingData.setMergeEnabled(true);
 213         mapServer.handleMapRegister(mapRegister);
 214
 215         final ArgumentCaptor<MappingData> captor = ArgumentCaptor.forClass(MappingData.class);
 216         Mockito.verify(mapService).addMapping(Mockito.eq(MappingOrigin.Southbound), Mockito.eq(IPV4_EID_1),
 217                 Mockito.eq(mapRegister.getSiteId()), captor.capture());
 218         assertEquals(captor.getValue().getRecord(), mappingData.getRecord());
 219         Mockito.verify(notifyHandler).handleMapNotify(mapNotifyBuilder.setAuthenticationData(null).build(), null);
 220     }
 221
 222     @Test
 223     @Ignore
 224     public void handleMapRegisterTest_findNegativeSubscribers() throws NoSuchFieldException, IllegalAccessException {
 225         setConfigIniMappingMergeField(true);
 226
 227         mapRegister.getMappingRecordItem().clear();
 228         mapRegister.getMappingRecordItem().add(getDefaultMappingRecordItemBuilder(IPV4_PREFIX_EID_1).build());
 229
 230         final MappingRecordBuilder mappingRecordBuilder_1 = getDefaultMappingRecordBuilder()
 231                 // apply the change
 232                 .setEid(IPV4_PREFIX_EID_2);
 233         final MappingRecordBuilder mappingRecordBuilder_2 = getDefaultMappingRecordBuilder();
 234         final Eid maskedEid1 = LispAddressUtil.asIpv4Eid("1.2.0.0");
 235
 236         final Subscriber subscriber1 = Mockito.mock(Subscriber.class);
 237         Mockito.when(subscriber1.timedOut()).thenReturn(true);
 238         Mockito.when(subscriber1.toString()).thenReturn("sub1");
 239
 240         final Set<Subscriber> set1 = Sets.newHashSet(subscriber1);
 241
 242         Mockito.when(mapService.getAuthenticationKey(IPV4_PREFIX_EID_1)).thenReturn(MAPPING_AUTHKEY);
 243         Mockito.when(mapService.getData(MappingOrigin.Southbound, IPV4_PREFIX_EID_1, SubKeys.SRC_RLOCS))
 244                 .thenReturn(DEFAULT_IP_ADDRESS_SET);
 245
 246         Mockito.when(mapService.getParentPrefix(IPV4_PREFIX_EID_1)).thenReturn(maskedEid1);
 247         Mockito.when(mapService.getData(MappingOrigin.Southbound, IPV4_PREFIX_EID_1, SubKeys.SUBSCRIBERS))
 248                 .thenReturn(null);
 249         Mockito.when(mapService.getData(MappingOrigin.Southbound, maskedEid1, SubKeys.SUBSCRIBERS)).thenReturn(set1);
 250
 251         Mockito.when(mapService.getMapping(MappingOrigin.Southbound, IPV4_PREFIX_EID_1))
 252                 .thenReturn(getDefaultMappingData(mappingRecordBuilder_1.build()))
 253                 .thenReturn(getDefaultMappingData(mappingRecordBuilder_2.build()))
 254                 .thenReturn(null);
 255
 256         mapServer.handleMapRegister(mapRegister);
 257         Mockito.verify(subscriber1).timedOut();
 258     }
 259
 260     @Test
 261     public void handleMapRegisterTest_verifyTransportAddresses() throws NoSuchFieldException, IllegalAccessException {
 262         setConfigIniMappingMergeField(true);
 263
 264         // input
 265         Mockito.when(mapService.getAuthenticationKey(IPV4_EID_1)).thenReturn(MAPPING_AUTHKEY);
 266         Mockito.when(mapService.getMapping(MappingOrigin.Southbound, IPV4_EID_1))
 267                 .thenReturn(OLD_MAPPING_DATA_1)
 268                 .thenReturn(OLD_MAPPING_DATA_2)
 269                 .thenReturn(getDefaultMappingData(getDefaultMappingRecordBuilder().build()));
 270         Mockito.when(mapService.getData(MappingOrigin.Southbound, IPV4_EID_1, SubKeys.SRC_RLOCS))
 271                 .thenReturn(DEFAULT_IP_ADDRESS_SET);
 272
 273         // result
 274         final List<TransportAddress> transportAddressList = getTransportAddressList();
 275         final MapNotifyBuilder mapNotifyBuilder = getDefaultMapNotifyBuilder(mapRegister);
 276         mapNotifyBuilder.setMappingRecordItem(new ArrayList<>());
 277         mapNotifyBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
 278                 .withKey(new MappingRecordItemKey(IPV4_STRING_1))
 279                 .setMappingRecord(getDefaultMappingRecordBuilder().build()).build());
 280
 281         mapServer.handleMapRegister(mapRegister);
 282         Mockito.verify(notifyHandler).handleMapNotify(mapNotifyBuilder.build(), transportAddressList);
 283     }
 284
 285     @Test
 286     @Ignore
 287     public void handleMapRegisterTest_withTwoMappingRecords() throws NoSuchFieldException, IllegalAccessException {
 288         setConfigIniMappingMergeField(true);
 289
 290         // Input
 291         // Add a MappingRecord with SrcDestKey Eid Type
 292         final MappingRecordItemBuilder mappingRecordItemBuilder = new MappingRecordItemBuilder()
 293                 .setMappingRecord(getDefaultMappingRecordBuilder().setEid(SOURCE_DEST_KEY_EID).build());
 294         final MapRegisterBuilder mapRegisterSrcDstBuilder = getDefaultMapRegisterBuilder();
 295
 296         final List<MappingRecordItem> list = mapRegisterSrcDstBuilder.getMappingRecordItem();
 297         list.add(mappingRecordItemBuilder.build());
 298
 299         // ------------- Stubbing for SourceDestKey type Eid mapping -------------------
 300
 301         Mockito.when(mapService.getAuthenticationKey(SOURCE_DEST_KEY_EID)).thenReturn(MAPPING_AUTHKEY);
 302         Mockito.when(mapService.getMapping(MappingOrigin.Southbound, SOURCE_DEST_KEY_EID))
 303                 // ensure mappings are different
 304                 .thenReturn(OLD_MAPPING_DATA_1)
 305                 .thenReturn(OLD_MAPPING_DATA_2)
 306                 .thenReturn(OLD_MAPPING_DATA_2);
 307         // return a subscriberSet for SrcDestKeyEid MappingRecord
 308         Mockito.when(mapService.getData(MappingOrigin.Southbound, SOURCE_DEST_KEY_EID, SubKeys.SUBSCRIBERS))
 309                 .thenReturn(subscriberSetMock_1);
 310
 311         // return a subscriberSet for SrcDestKeyEid destination MappingRecord
 312         Mockito.when(mapService.getData(MappingOrigin.Southbound, SourceDestKeyHelper.getDstBinary(SOURCE_DEST_KEY_EID),
 313                 SubKeys.SUBSCRIBERS)).thenReturn(subscriberSetMock_2);
 314
 315         // ----------------- Stubbing for Ipv4 type Eid mapping ------------------------
 316
 317         Mockito.when(mapService.getAuthenticationKey(IPV4_EID_1)).thenReturn(MAPPING_AUTHKEY);
 318         Mockito.when(mapService.getMapping(MappingOrigin.Southbound, IPV4_EID_1))
 319                 // ensure mappings are different
 320                 .thenReturn(OLD_MAPPING_DATA_1)
 321                 .thenReturn(OLD_MAPPING_DATA_2);
 322         // return a subscriberSet for Ipv4Eid MappingRecord
 323         Mockito.when(mapService.getData(MappingOrigin.Southbound, IPV4_EID_1,SubKeys.SUBSCRIBERS))
 324                 .thenReturn(subscriberSetMock_3);
 325
 326         // -----------------------------------------------------------------------------
 327
 328         // result
 329         mapServer.handleMapRegister(mapRegisterSrcDstBuilder.build());
 330
 331         // for SrcDstKey mapping
 332         final ArgumentCaptor<MapRequest> captor_1 = ArgumentCaptor.forClass(MapRequest.class);
 333         Mockito.verify(notifyHandler, Mockito.times(1)).handleSMR(captor_1.capture(), Mockito.eq(RLOC_2));
 334         final Eid resultEid_1 = captor_1.getValue().getEidItem().iterator().next().getEid();
 335         assertEquals(IPV4_SOURCE_EID_2, resultEid_1);
 336
 337         // for SrcDst destination mapping
 338         final ArgumentCaptor<MapRequest> captor_2 = ArgumentCaptor.forClass(MapRequest.class);
 339         Mockito.verify(notifyHandler, Mockito.times(1)).handleSMR(captor_2.capture(), Mockito.eq(RLOC_4));
 340         final Eid resultEid_2 = captor_2.getValue().getEidItem().iterator().next().getEid();
 341         assertEquals(IPV4_SOURCE_EID_4, resultEid_2);
 342
 343         // for Ipv4 mapping
 344         final ArgumentCaptor<MapRequest> captor_3 = ArgumentCaptor.forClass(MapRequest.class);
 345         Mockito.verify(notifyHandler, Mockito.times(2)).handleSMR(captor_3.capture(), Mockito.eq(RLOC_6));
 346         final Eid resultEid_3 = captor_3.getValue().getEidItem().iterator().next().getEid();
 347         assertEquals(IPV4_SOURCE_EID_6, resultEid_3);
 348     }
 349
 350     private static MapRegisterBuilder getDefaultMapRegisterBuilder() {
 351         final MapRegisterBuilder mapRegisterBuilder = new MapRegisterBuilder()
 352                 .setProxyMapReply(true)
 353                 .setWantMapNotify(true)
 354                 .setKeyId((short) 0)
 355                 .setMappingRecordItem(new ArrayList<>())
 356                 .setMergeEnabled(true)
 357                 .setNonce(1L)
 358                 .setSiteId(new SiteId(new byte[]{0, 1, 2, 3, 4, 5, 6, 7}))
 359                 .setXtrId(new XtrId(new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}))
 360                 .setXtrSiteIdPresent(true);
 361         mapRegisterBuilder.getMappingRecordItem().add(getDefaultMappingRecordItemBuilder().build());
 362
 363         return mapRegisterBuilder;
 364     }
 365
 366     private static MappingData getDefaultMappingData(MappingRecord mappingRecord) {
 367         if (mappingRecord == null) {
 368             mappingRecord = getDefaultMappingRecordBuilder().build();
 369         }
 370         return new MappingData(mappingRecord, System.currentTimeMillis());
 371     }
 372
 373     private static MappingRecordItemBuilder getDefaultMappingRecordItemBuilder() {
 374         return getDefaultMappingRecordItemBuilder(IPV4_EID_1);
 375     }
 376
 377     private static MappingRecordItemBuilder getDefaultMappingRecordItemBuilder(Eid eid) {
 378         return new MappingRecordItemBuilder()
 379                 .setMappingRecordItemId("mapping-record-item-id")
 380                 .withKey(new MappingRecordItemKey("mapping-record-item-key"))
 381                 .setMappingRecord(getDefaultMappingRecordBuilder(eid).build());
 382     }
 383
 384     private static MappingRecordBuilder getDefaultMappingRecordBuilder() {
 385         return getDefaultMappingRecordBuilder(IPV4_EID_1);
 386     }
 387
 388     private static MappingRecordBuilder getDefaultMappingRecordBuilder(Eid eid) {
 389         return new MappingRecordBuilder()
 390                 .setAction(MappingRecord.Action.NoAction)
 391                 .setAuthoritative(false)
 392                 .setLocatorRecord(new ArrayList<>())
 393                 .setMapVersion((short) 0)
 394                 .setRecordTtl(60)
 395                 .setEid(eid);
 396     }
 397
 398     private static MapNotifyBuilder getDefaultMapNotifyBuilder(MapRegister mr) {
 399         final MapNotifyBuilder mapNotifyBuilder = new MapNotifyBuilder()
 400                 .setXtrSiteIdPresent(mr.getXtrSiteIdPresent())
 401                 .setSiteId(mr.getSiteId())
 402                 .setXtrId(mr.getXtrId())
 403                 .setNonce(mr.getNonce())
 404                 .setKeyId(mr.getKeyId())
 405                 .setMergeEnabled(mr.getMergeEnabled())
 406                 .setMappingRecordItem(new ArrayList<>())
 407                 .setAuthenticationData(new byte[]{});
 408         mapNotifyBuilder.getMappingRecordItem().add(getDefaultMappingRecordItemBuilder().build());
 409
 410         return mapNotifyBuilder;
 411     }
 412
 413     private static void setConfigIniMappingMergeField(boolean value) throws NoSuchFieldException,
 414             IllegalAccessException {
 415         final Field mappingMergeField = CONFIG_INI.getClass().getDeclaredField("mappingMerge");
 416         mappingMergeField.setAccessible(true);
 417         mappingMergeField.setBoolean(CONFIG_INI, value);
 418     }
 419
 420     private static Set<IpAddressBinary> getDefaultIpAddressSet() {
 421         return ImmutableSet.of(IPV4_BINARY_1, IPV4_BINARY_2);
 422     }
 423
 424     private static List<TransportAddress> getTransportAddressList() {
 425         TransportAddressBuilder transportAddressBuilder1 = new TransportAddressBuilder()
 426                 .setIpAddress(IPV4_BINARY_1)
 427                 .setPort(new PortNumber(LispMessage.PORT_NUMBER));
 428
 429         TransportAddressBuilder transportAddressBuilder2 = new TransportAddressBuilder()
 430                 .setIpAddress(IPV4_BINARY_2)
 431                 .setPort(new PortNumber(LispMessage.PORT_NUMBER));
 432
 433         final List<TransportAddress> transportAddressList = Lists.newArrayList(
 434                 transportAddressBuilder1.build(),
 435                 transportAddressBuilder2.build());
 436
 437         return transportAddressList;
 438     }
 439 }