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