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