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