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