2 * Copyright (c) 2014 Contextream, Inc. and others. All rights reserved.
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
9 package org.opendaylight.lispflowmapping.implementation.lisp;
11 import static org.junit.Assert.assertEquals;
13 import java.util.ArrayList;
14 import java.util.Arrays;
16 import junitx.framework.ArrayAssert;
18 import org.junit.Before;
19 import org.junit.Test;
20 import org.opendaylight.lispflowmapping.implementation.LispMappingService;
21 import org.opendaylight.lispflowmapping.implementation.dao.MappingServiceKeyUtil;
22 import org.opendaylight.lispflowmapping.implementation.serializer.MapRegisterSerializer;
23 import org.opendaylight.lispflowmapping.implementation.util.LispAFIConvertor;
24 import org.opendaylight.lispflowmapping.interfaces.dao.ILispDAO;
25 import org.opendaylight.lispflowmapping.interfaces.dao.IMappingServiceKey;
26 import org.opendaylight.lispflowmapping.interfaces.dao.MappingEntry;
27 import org.opendaylight.lispflowmapping.interfaces.dao.MappingServiceRLOCGroup;
28 import org.opendaylight.lispflowmapping.tools.junit.BaseTestCase;
29 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.EidToLocatorRecord.Action;
30 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispAFIAddress;
31 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapNotify;
32 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapRegister;
33 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidtolocatorrecords.EidToLocatorRecord;
34 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidtolocatorrecords.EidToLocatorRecordBuilder;
35 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.no.NoAddressBuilder;
36 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.locatorrecords.LocatorRecord;
37 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.locatorrecords.LocatorRecordBuilder;
38 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.mapregisternotification.MapRegisterBuilder;
40 public class MapServerTest extends BaseTestCase {
42 private LispMappingService testedMapServer;
43 private ILispDAO lispDAO;
44 private MapRegisterBuilder mapRegisterBuilder;
45 private LispAFIAddress eid;
46 private LispAFIAddress rloc;
47 private ValueSaverAction<MappingEntry<?>[]> mappingEntriesSaver;
48 private MapRegister mapRegisterWithAuthentication;
52 public void before() throws Exception {
54 lispDAO = context.mock(ILispDAO.class);
55 testedMapServer = new LispMappingService();
56 testedMapServer.basicInit(lispDAO);
57 mapRegisterBuilder = new MapRegisterBuilder();
58 mapRegisterBuilder.setKeyId((short) 0);
59 mapRegisterBuilder.setAuthenticationData(new byte[0]);
60 eid = LispAFIConvertor.asIPAfiAddress("10.31.0.5");
61 rloc = LispAFIConvertor.asIPAfiAddress("192.168.136.10");
62 EidToLocatorRecordBuilder recordBuilder = new EidToLocatorRecordBuilder();
63 recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid)).setMaskLength((short) 32);
64 recordBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
65 recordBuilder.getLocatorRecord().add(new LocatorRecordBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(rloc)).build());
66 recordBuilder.setAction(Action.NoAction).setMapVersion((short) 0).setAuthoritative(false).setRecordTtl(60).setMaskLength((short) 32);
67 mapRegisterBuilder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
68 mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
69 mapRegisterWithAuthentication = MapRegisterSerializer.getInstance().deserialize(hexToByteBuffer("38 00 01 01 FF BB "
71 + "00 00 00 00 00 00 00 01 00 14 2c 61 b9 c9 9a 20 " //
72 + "ba d8 f5 40 d3 55 6f 5f 6e 5a b2 0a bf b5 00 00 " //
73 + "00 0a 01 20 10 00 00 00 00 01 99 10 fe 01 01 64 " //
74 + "ff 00 00 05 00 01 c0 a8 88 0a"));
76 mappingEntriesSaver = new ValueSaverAction<MappingEntry<?>[]>();
80 public void handleMapRegister__NonSetMBit() throws Exception {
81 mapRegisterBuilder.setWantMapNotify(false);
83 addDefaultPutAndGetExpectations(eid, 32);
84 assertNull(testedMapServer.handleMapRegister(mapRegisterBuilder.build(), false));
86 MappingEntry<?>[] entries = mappingEntriesSaver.lastValue;
87 assertEquals(1, entries.length);
89 assertEquals(AbstractLispComponent.ADDRESS_SUBKEY, entries[0].getKey());
90 assertEquals(1, ((MappingServiceRLOCGroup) entries[0].getValue()).getRecords().size());
91 assertEquals(rloc, LispAFIConvertor.toAFI(((MappingServiceRLOCGroup) entries[0].getValue()).getRecords().get(0).getLispAddressContainer()));
95 public void handleMapRegisterIpv4__ValidNotifyEchoesRegister() throws Exception {
96 mapRegisterBuilder.getEidToLocatorRecord().add(
97 getDefaultEidToLocatorBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(new NoAddressBuilder().build())).build());
98 mapRegisterBuilder.setWantMapNotify(true);
100 addDefaultPutAndGetExpectations(eid, 32);
101 addDefaultPutAndGetExpectations(new NoAddressBuilder().build(), 32);
102 MapRegister mr = mapRegisterBuilder.build();
103 MapNotify mapNotify = testedMapServer.handleMapRegister(mr, false);
104 assertEquals(mr.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
105 ArrayAssert.assertEquals(mr.getAuthenticationData(), mapNotify.getAuthenticationData());
106 assertEquals(mr.getKeyId(), mapNotify.getKeyId());
107 assertEquals(mr.getNonce(), mapNotify.getNonce());
111 public void handleMapRegisterIpv4__CloneNotOwnYouClown() throws Exception {
112 mapRegisterBuilder = getDefaultMapRegisterBuilder();
113 mapRegisterBuilder.setWantMapNotify(true);
114 EidToLocatorRecordBuilder eidToLocatorBuilder = getDefaultEidToLocatorBuilder();
115 eidToLocatorBuilder.setMaskLength((short) 32);
116 eid = LispAFIConvertor.asIPAfiAddress("0.0.0.1");
117 eidToLocatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
119 LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
120 locatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("0.0.0.2")));
121 locatorBuilder.setPriority((short) 55);
122 eidToLocatorBuilder.getLocatorRecord().add(locatorBuilder.build());
124 mapRegisterBuilder.getEidToLocatorRecord().add(eidToLocatorBuilder.build());
126 addDefaultPutAndGetExpectations(eid, 32);
128 MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterBuilder.build(), false);
130 EidToLocatorRecord actualEidToLocator = mapNotify.getEidToLocatorRecord().get(0);
131 assertEquals(LispAFIConvertor.toContainer(eid), actualEidToLocator.getLispAddressContainer());
132 assertEquals((byte) 55, actualEidToLocator.getLocatorRecord().get(0).getPriority().byteValue());
137 public void handleMapRegisterIpv4__ValidMask() throws Exception {
139 mapRegisterBuilder = getDefaultMapRegisterBuilder();
140 EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
141 recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid)).setMaskLength((short) mask);
142 LocatorRecordBuilder locator = getDefaultLocatorBuilder();
143 locator.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
144 recordBuilder.getLocatorRecord().add(locator.build());
145 mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
146 mapRegisterBuilder.setWantMapNotify(true);
147 MapRegister mr = mapRegisterBuilder.build();
149 addDefaultPutAndGetExpectations(eid, mask);
151 MapNotify mapNotify = testedMapServer.handleMapRegister(mr, false);
152 assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("10.31.0.5")), mapNotify.getEidToLocatorRecord().get(0)
153 .getLispAddressContainer());
154 ArrayAssert.assertEquals(mr.getAuthenticationData(), mapNotify.getAuthenticationData());
155 assertEquals(mr.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
156 assertEquals(mr.getKeyId(), mapNotify.getKeyId());
157 assertEquals(mr.getNonce(), mapNotify.getNonce());
161 public void handleMapRegister__NonMaskable() throws Exception {
163 mapRegisterBuilder = getDefaultMapRegisterBuilder();
164 LispAFIAddress addr = LispAFIConvertor.asMacAfiAddress("01:01:01:01:01:01");
165 EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
166 LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
167 locatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
168 recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(addr)).setMaskLength((short) mask);
169 recordBuilder.getLocatorRecord().add(locatorBuilder.build());
170 mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
171 mapRegisterBuilder.setWantMapNotify(true);
173 addDefaultPutAndGetExpectations(addr, mask);
175 MapRegister mapRegister = mapRegisterBuilder.build();
177 MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister, false);
178 assertEquals(LispAFIConvertor.toContainer(addr), mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
179 ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData());
180 assertEquals(mapRegister.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
181 assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId());
182 assertEquals(mapRegister.getNonce(), mapNotify.getNonce());
186 public void handleMapRegister__ZeroMask() throws Exception {
188 mapRegisterBuilder = getDefaultMapRegisterBuilder();
189 LispAFIAddress addr = LispAFIConvertor.asMacAfiAddress("01:01:01:01:01:01");
190 EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
191 LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
192 locatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
193 recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(addr)).setMaskLength((short) mask);
194 recordBuilder.getLocatorRecord().add(locatorBuilder.build());
195 mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
196 mapRegisterBuilder.setWantMapNotify(true);
198 addDefaultPutAndGetExpectations(addr, mask);
200 MapRegister mapRegister = mapRegisterBuilder.build();
202 MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister, false);
203 assertEquals(LispAFIConvertor.toContainer(addr), mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
204 ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData());
205 assertEquals(mapRegister.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
206 assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId());
207 assertEquals(mapRegister.getNonce(), mapNotify.getNonce());
211 public void handleMapRegisterIPv4__ZeroMask() throws Exception {
213 mapRegisterBuilder = getDefaultMapRegisterBuilder();
214 EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
215 recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid)).setMaskLength((short) mask);
216 LocatorRecordBuilder locator = getDefaultLocatorBuilder();
217 locator.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
218 recordBuilder.getLocatorRecord().add(locator.build());
219 mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
220 mapRegisterBuilder.setWantMapNotify(true);
221 MapRegister mr = mapRegisterBuilder.build();
223 addDefaultPutAndGetExpectations(eid, mask);
225 MapNotify mapNotify = testedMapServer.handleMapRegister(mr, false);
226 assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("10.31.0.5")), mapNotify.getEidToLocatorRecord().get(0)
227 .getLispAddressContainer());
228 ArrayAssert.assertEquals(mr.getAuthenticationData(), mapNotify.getAuthenticationData());
229 assertEquals(mr.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
230 assertEquals(mr.getKeyId(), mapNotify.getKeyId());
231 assertEquals(mr.getNonce(), mapNotify.getNonce());
235 public void handleMapRegisterIpv4__ValidMask32() throws Exception {
237 mapRegisterBuilder = getDefaultMapRegisterBuilder();
238 EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
239 recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid)).setMaskLength((short) mask);
240 LocatorRecordBuilder locator = getDefaultLocatorBuilder();
241 locator.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
242 recordBuilder.getLocatorRecord().add(locator.build());
243 mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
244 mapRegisterBuilder.setWantMapNotify(true);
245 MapRegister mr = mapRegisterBuilder.build();
247 addDefaultPutAndGetExpectations(eid, mask);
249 MapNotify mapNotify = testedMapServer.handleMapRegister(mr, false);
250 assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("10.31.0.5")), mapNotify.getEidToLocatorRecord().get(0)
251 .getLispAddressContainer());
252 ArrayAssert.assertEquals(mr.getAuthenticationData(), mapNotify.getAuthenticationData());
253 assertEquals(mr.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
254 assertEquals(mr.getKeyId(), mapNotify.getKeyId());
255 assertEquals(mr.getNonce(), mapNotify.getNonce());
259 public void handleMapRegisterIpv6__ValidMask96() throws Exception {
261 mapRegisterBuilder = getDefaultMapRegisterBuilder();
262 LispAFIAddress addr = LispAFIConvertor.asIPv6AfiAddress("1:1:1:1:1:1:1:0");
263 EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
264 LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
265 locatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
266 recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(addr)).setMaskLength((short) mask);
267 recordBuilder.getLocatorRecord().add(locatorBuilder.build());
268 mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
269 mapRegisterBuilder.setWantMapNotify(true);
271 addDefaultPutAndGetExpectations(addr, mask);
273 MapRegister mapRegister = mapRegisterBuilder.build();
275 MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister, false);
276 assertEquals(LispAFIConvertor.toContainer(addr), mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
277 ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData());
278 assertEquals(mapRegister.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
279 assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId());
280 assertEquals(mapRegister.getNonce(), mapNotify.getNonce());
284 public void handleMapRegisterIpv6__ZeroMask() throws Exception {
286 mapRegisterBuilder = getDefaultMapRegisterBuilder();
287 LispAFIAddress addr = LispAFIConvertor.asIPv6AfiAddress("1:1:1:1:1:1:1:0");
288 EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
289 LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
290 locatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
291 recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(addr)).setMaskLength((short) mask);
292 recordBuilder.getLocatorRecord().add(locatorBuilder.build());
293 mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
294 mapRegisterBuilder.setWantMapNotify(true);
296 addDefaultPutAndGetExpectations(addr, mask);
298 MapRegister mapRegister = mapRegisterBuilder.build();
300 MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister, false);
301 assertEquals(LispAFIConvertor.toContainer(addr), mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
302 ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData());
303 assertEquals(mapRegister.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
304 assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId());
305 assertEquals(mapRegister.getNonce(), mapNotify.getNonce());
309 public void handleMapRegisterIpv6__ValidMask48() throws Exception {
311 mapRegisterBuilder = getDefaultMapRegisterBuilder();
312 LispAFIAddress addr = LispAFIConvertor.asIPv6AfiAddress("1:1:1:1:1:1:1:0");
313 EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
314 LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
315 locatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
316 recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(addr)).setMaskLength((short) mask);
317 recordBuilder.getLocatorRecord().add(locatorBuilder.build());
318 mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
319 mapRegisterBuilder.setWantMapNotify(true);
321 addDefaultPutAndGetExpectations(addr, mask);
323 MapRegister mapRegister = mapRegisterBuilder.build();
325 MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister, false);
326 assertEquals(LispAFIConvertor.toContainer(addr), mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
327 ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData());
328 assertEquals(mapRegister.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
329 assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId());
330 assertEquals(mapRegister.getNonce(), mapNotify.getNonce());
334 public void handleMapRegisterIpv6__ValidMask128() throws Exception {
336 mapRegisterBuilder = getDefaultMapRegisterBuilder();
337 LispAFIAddress addr = LispAFIConvertor.asIPv6AfiAddress("1:1:1:1:1:1:1:0");
338 EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
339 LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
340 locatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
341 recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(addr)).setMaskLength((short) mask);
342 recordBuilder.getLocatorRecord().add(locatorBuilder.build());
343 mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
344 mapRegisterBuilder.setWantMapNotify(true);
346 addDefaultPutAndGetExpectations(addr, mask);
348 MapRegister mapRegister = mapRegisterBuilder.build();
350 MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister, false);
351 assertEquals(LispAFIConvertor.toContainer(addr), mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
352 ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData());
353 assertEquals(mapRegister.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
354 assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId());
355 assertEquals(mapRegister.getNonce(), mapNotify.getNonce());
359 public void handleMapRegisterIPV4AndIpv6__ValidMask96() throws Exception {
361 mapRegisterBuilder = getDefaultMapRegisterBuilder();
362 EidToLocatorRecordBuilder recordBuilder0 = getDefaultEidToLocatorBuilder();
363 recordBuilder0.setLispAddressContainer(LispAFIConvertor.toContainer(eid)).setMaskLength((short) 32);
364 LispAFIAddress addr = LispAFIConvertor.asIPv6AfiAddress("1:1:1:1:1:1:1:0");
365 EidToLocatorRecordBuilder recordBuilder1 = getDefaultEidToLocatorBuilder();
366 LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
367 locatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
368 locatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
369 recordBuilder1.setLispAddressContainer(LispAFIConvertor.toContainer(addr)).setMaskLength((short) mask);
370 recordBuilder1.getLocatorRecord().add(locatorBuilder.build());
371 mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder0.build());
372 mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder1.build());
373 mapRegisterBuilder.setWantMapNotify(true);
375 addDefaultPutAndGetExpectations(eid, 32);
376 addDefaultPutAndGetExpectations(addr, mask);
378 MapRegister mapRegister = mapRegisterBuilder.build();
380 MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister, false);
381 assertEquals(LispAFIConvertor.toContainer(eid), mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
382 assertEquals(LispAFIConvertor.toContainer(addr), mapNotify.getEidToLocatorRecord().get(1).getLispAddressContainer());
383 ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData());
384 assertEquals(mapRegister.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
385 assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId());
386 assertEquals(mapRegister.getNonce(), mapNotify.getNonce());
390 public void handleMapRegister__MultipleRLOCs() throws Exception {
391 addDefaultPutAndGetExpectations(eid, 32);
393 mapRegisterBuilder = getDefaultMapRegisterBuilder();
394 LispAFIAddress rloc0 = rloc;
395 LispAFIAddress rloc1 = LispAFIConvertor.asIPv6AfiAddress("0:0:0:0:0:0:0:7");
396 EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
397 recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
398 LocatorRecordBuilder locatorBuilder1 = getDefaultLocatorBuilder();
399 locatorBuilder1.setLispAddressContainer(LispAFIConvertor.toContainer(rloc0));
400 LocatorRecordBuilder locatorBuilder2 = getDefaultLocatorBuilder();
401 locatorBuilder2.setLispAddressContainer(LispAFIConvertor.toContainer(rloc1));
402 recordBuilder.getLocatorRecord().add(locatorBuilder1.build());
403 recordBuilder.getLocatorRecord().add(locatorBuilder2.build());
405 mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
407 testedMapServer.handleMapRegister(mapRegisterBuilder.build(), false);
409 MappingEntry<?>[] entries = mappingEntriesSaver.lastValue;
410 assertEquals(1, entries.length);
412 assertEquals(AbstractLispComponent.ADDRESS_SUBKEY, entries[0].getKey());
413 assertEquals(LispAFIConvertor.toContainer(rloc0), ((MappingServiceRLOCGroup) entries[0].getValue()).getRecords().get(0)
414 .getLispAddressContainer());
415 assertEquals(LispAFIConvertor.toContainer(rloc1), ((MappingServiceRLOCGroup) entries[0].getValue()).getRecords().get(1)
416 .getLispAddressContainer());
421 public void handleMapRegister__MultipleTypes() throws Exception {
422 addDefaultPutAndGetExpectations(eid, 32);
424 mapRegisterBuilder = getDefaultMapRegisterBuilder();
425 LispAFIAddress rloc0 = rloc;
426 // LispAFIAddress rloc1 =
427 // LispAFIConvertor.asIPv6AfiAddress("0:0:0:0:0:0:0:7");
428 String subkey = "bla";
429 LispAFIAddress rloc1 = LispAFIConvertor
430 .asKeyValue(subkey, LispAFIConvertor.toPrimitive(LispAFIConvertor.asIPv6AfiAddress("0:0:0:0:0:0:0:7")));
431 EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
432 recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
433 LocatorRecordBuilder locatorBuilder1 = getDefaultLocatorBuilder();
434 locatorBuilder1.setLispAddressContainer(LispAFIConvertor.toContainer(rloc0));
435 LocatorRecordBuilder locatorBuilder2 = getDefaultLocatorBuilder();
436 locatorBuilder2.setLispAddressContainer(LispAFIConvertor.toContainer(rloc1));
437 recordBuilder.getLocatorRecord().add(locatorBuilder1.build());
438 recordBuilder.getLocatorRecord().add(locatorBuilder2.build());
440 mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
442 testedMapServer.handleMapRegister(mapRegisterBuilder.build(), false);
444 MappingEntry<?>[] entries = mappingEntriesSaver.lastValue;
445 assertEquals(2, entries.length);
447 assertEquals(AbstractLispComponent.ADDRESS_SUBKEY, entries[0].getKey());
448 assertEquals(subkey, entries[1].getKey());
449 assertEquals(LispAFIConvertor.toContainer(rloc0), ((MappingServiceRLOCGroup) entries[0].getValue()).getRecords().get(0)
450 .getLispAddressContainer());
451 assertEquals(LispAFIConvertor.toContainer(rloc1), ((MappingServiceRLOCGroup) entries[1].getValue()).getRecords().get(0)
452 .getLispAddressContainer());
457 public void handleMapRegister__TestOverwrite() throws Exception {
458 addDefaultPutAndGetExpectations(eid, 32);
460 addEidToLocatorRecord();
462 MappingEntry<?>[] entries = mappingEntriesSaver.lastValue;
463 assertEquals(1, entries.length);
465 assertEquals(AbstractLispComponent.ADDRESS_SUBKEY, entries[0].getKey());
466 assertEquals(LispAFIConvertor.toContainer(rloc), ((MappingServiceRLOCGroup) entries[0].getValue()).getRecords().get(0)
467 .getLispAddressContainer());
471 public void handleMapRegister__TestDontOverwrite() throws Exception {
472 int hc = LispAFIConvertor.toContainer(rloc).getAddress().hashCode();
474 addDefaultPutAndGetExpectations(eid, 32);
475 testedMapServer.setOverwrite(false);
477 addEidToLocatorRecord();
479 MappingEntry<?>[] entries = mappingEntriesSaver.lastValue;
480 assertEquals(1, entries.length);
482 assertEquals(String.valueOf(hc), entries[0].getKey());
483 assertEquals(LispAFIConvertor.toContainer(rloc), ((MappingServiceRLOCGroup) entries[0].getValue()).getRecords().get(0)
484 .getLispAddressContainer());
487 private void addEidToLocatorRecord() {
488 EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
489 recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
490 LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
491 locatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
492 recordBuilder.getLocatorRecord().add(locatorBuilder.build());
494 mapRegisterBuilder = getDefaultMapRegisterBuilder();
495 mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
497 testedMapServer.handleMapRegister(mapRegisterBuilder.build(), false);
501 public void handleMapRegister__MultipleEIDs() throws Exception {
502 addDefaultPutAndGetExpectations(eid, 32);
504 LispAFIAddress rloc1 = LispAFIConvertor.asIPv6AfiAddress("0:0:0:0:0:0:0:7");
505 mapRegisterBuilder = getDefaultMapRegisterBuilder();
506 EidToLocatorRecordBuilder etlrBuilder = getDefaultEidToLocatorBuilder();
507 etlrBuilder.getLocatorRecord().add(getDefaultLocatorBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(rloc1)).build());
508 mapRegisterBuilder.setWantMapNotify(true);
509 etlrBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
511 EidToLocatorRecordBuilder etlr2Builder = getDefaultEidToLocatorBuilder();
512 LispAFIAddress address = LispAFIConvertor.asIPAfiAddress("1.1.1.1");
513 etlr2Builder.setLispAddressContainer(LispAFIConvertor.toContainer(address));
514 etlr2Builder.setMaskLength((short) 32);
516 etlr2Builder.setRecordTtl(recordTtl);
517 etlr2Builder.getLocatorRecord().add(
518 getDefaultLocatorBuilder().setPriority((short) 10)
519 .setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("2.2.2.2"))).build());
520 mapRegisterBuilder.getEidToLocatorRecord().add(etlrBuilder.build());
521 mapRegisterBuilder.getEidToLocatorRecord().add(etlr2Builder.build());
522 addDefaultPutAndGetExpectations(address, 32);
523 MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterBuilder.build(), false);
525 assertEquals(LispAFIConvertor.toContainer(rloc1), mapNotify.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)
526 .getLispAddressContainer());
527 assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("2.2.2.2")), mapNotify.getEidToLocatorRecord().get(1)
528 .getLocatorRecord().get(0).getLispAddressContainer());
529 assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("1.1.1.1")), mapNotify.getEidToLocatorRecord().get(1)
530 .getLispAddressContainer());
531 assertEquals(recordTtl, mapNotify.getEidToLocatorRecord().get(1).getRecordTtl().intValue());
536 public void handleMapRegisterIpv4__ChekWrongPassword() throws Exception {
538 addGetExpectations(LispAFIConvertor.asIPAfiAddress("153.16.254.1"), 32, 0, 31, "bla");
539 MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterWithAuthentication, false);
540 assertEquals(null, mapNotify);
544 public void handleMapRegisterIpv4__ChcekNoPasswordAndThenPassword() throws Exception {
546 addGetExpectations(LispAFIConvertor.asIPAfiAddress("153.16.254.1"), 32, 30, 25, "password");
547 addPutExpectations(LispAFIConvertor.asIPAfiAddress("153.16.254.1"), 32);
548 MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterWithAuthentication, false);
549 assertEquals(mapRegisterWithAuthentication.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
550 assertEquals(mapRegisterWithAuthentication.getKeyId(), mapNotify.getKeyId());
551 assertEquals(mapRegisterWithAuthentication.getNonce(), mapNotify.getNonce());
555 public void handleMapRegisterIpv4__ChcekNoPassword() throws Exception {
557 addGetExpectations(LispAFIConvertor.asIPAfiAddress("153.16.254.1"), 32, 30, 0, "password");
558 MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterWithAuthentication, false);
559 assertEquals(null, mapNotify);
563 public void handleMapRegisterIpv4__ChcekNoreturn() throws Exception {
565 addGetExpectations(LispAFIConvertor.asIPAfiAddress("153.16.254.1"), 32);
566 MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterWithAuthentication, false);
567 assertEquals(mapNotify, null);
570 @SuppressWarnings("unchecked")
572 public void handleAddAuthenticationKey() throws Exception {
573 String password = "pass";
574 IMappingServiceKey key = getDefualtKey();
575 oneOf(lispDAO).put(weq(key),
576 weq((MappingEntry<String>[]) (Arrays.asList(new MappingEntry<String>(AbstractLispComponent.PASSWORD_SUBKEY, password)).toArray())));
577 testedMapServer.addAuthenticationKey(LispAFIConvertor.toContainer(eid), key.getMask(), password);
581 public void handleGetAuthenticationKey() throws Exception {
582 IMappingServiceKey key = getDefualtKey();
583 oneOf(lispDAO).getSpecific(weq(key), with(AbstractLispComponent.PASSWORD_SUBKEY));
585 assertEquals("password", testedMapServer.getAuthenticationKey(LispAFIConvertor.toContainer(eid), key.getMask()));
589 public void handleGetAuthenticationKeyNoIteration() throws Exception {
590 testedMapServer.setShouldIterateMask(false);
591 IMappingServiceKey key = getDefualtKey();
592 IMappingServiceKey passKey = getKey(30);
593 oneOf(lispDAO).getSpecific(weq(key), with(AbstractLispComponent.PASSWORD_SUBKEY));
594 allowing(lispDAO).getSpecific(weq(passKey), with(AbstractLispComponent.PASSWORD_SUBKEY));
596 assertEquals(null, testedMapServer.getAuthenticationKey(LispAFIConvertor.toContainer(eid), key.getMask()));
600 public void handleRemoveAuthenticationKey() throws Exception {
601 IMappingServiceKey key = getDefualtKey();
602 oneOf(lispDAO).removeSpecific(weq(key), with(AbstractLispComponent.PASSWORD_SUBKEY));
603 testedMapServer.removeAuthenticationKey(LispAFIConvertor.toContainer(eid), key.getMask());
606 private void addDefaultPutAndGetExpectations(LispAFIAddress addr, int mask) {
607 addPutExpectations(addr, mask);
608 addGetExpectations(addr, mask);
611 private void addGetExpectations(LispAFIAddress address, int mask) {
612 addGetExpectations(address, mask, 0, 0, "password");
615 private void addPutExpectations(LispAFIAddress address, int mask) {
616 oneOf(lispDAO).put(weq(MappingServiceKeyUtil.generateMappingServiceKey(LispAFIConvertor.toContainer(address), mask)),
617 with(mappingEntriesSaver));
620 private void addGetExpectations(LispAFIAddress address, int mask, int withoutPassword, int withPassword, String password) {
621 if (withoutPassword > 0) {
622 String result = null;
624 allowing(lispDAO).getSpecific(
625 with(MappingServiceKeyUtil.generateMappingServiceKey(LispAFIConvertor.toContainer(address), withoutPassword)), with("password"));
628 if (withPassword > 0) {
629 String result = null;
631 allowing(lispDAO).getSpecific(with(MappingServiceKeyUtil.generateMappingServiceKey(LispAFIConvertor.toContainer(address), withPassword)),
635 for (int i = mask; i >= 0; i--) {
636 allowing(lispDAO).getSpecific(with(MappingServiceKeyUtil.generateMappingServiceKey(LispAFIConvertor.toContainer(address), i)),
642 private IMappingServiceKey getDefualtKey() {
646 private IMappingServiceKey getKey(int mask) {
647 IMappingServiceKey key = MappingServiceKeyUtil.generateMappingServiceKey(LispAFIConvertor.toContainer(eid), mask);
651 private MapRegisterBuilder getDefaultMapRegisterBuilder() {
652 MapRegisterBuilder mrb = new MapRegisterBuilder();
653 mrb.setKeyId((short) 0);
654 mrb.setNonce((long) 0);
655 mrb.setWantMapNotify(false);
656 mrb.setProxyMapReply(false);
657 mrb.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
658 mrb.setAuthenticationData(new byte[0]);
662 private EidToLocatorRecordBuilder getDefaultEidToLocatorBuilder() {
663 EidToLocatorRecordBuilder builder = new EidToLocatorRecordBuilder();
664 builder.setAction(Action.NoAction);
665 builder.setAuthoritative(false);
666 builder.setLocatorRecord(new ArrayList<LocatorRecord>());
667 builder.setMapVersion((short) 0);
668 builder.setMaskLength((short) 32);
669 builder.setRecordTtl(60);
673 private LocatorRecordBuilder getDefaultLocatorBuilder() {
674 LocatorRecordBuilder builder = new LocatorRecordBuilder();
675 builder.setLocalLocator(false);
676 builder.setMulticastPriority((short) 0);
677 builder.setMulticastWeight((short) 0);
678 builder.setPriority((short) 0);
679 builder.setRlocProbed(false);
680 builder.setRouted(false);
681 builder.setWeight((short) 0);