mappingservice/implementation/src/test/java/org/opendaylight/lispflowmapping/implementation/lisp/MapServerTest.java

   1 /*
   2  * Copyright (c) 2014 Contextream, 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
   9 package org.opendaylight.lispflowmapping.implementation.lisp;
  10
  11 import static org.junit.Assert.assertEquals;
  12
  13 import java.util.ArrayList;
  14 import java.util.Arrays;
  15
  16 import junitx.framework.ArrayAssert;
  17
  18 import org.junit.Before;
  19 import org.junit.Test;
  20 import org.opendaylight.lispflowmapping.implementation.LispMappingService;
  21 import org.opendaylight.lispflowmapping.interfaces.dao.ILispDAO;
  22 import org.opendaylight.lispflowmapping.interfaces.dao.MappingEntry;
  23 import org.opendaylight.lispflowmapping.interfaces.dao.SubKeys;
  24 import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
  25 import org.opendaylight.lispflowmapping.lisp.util.MaskUtil;
  26 import org.opendaylight.lispflowmapping.lisp.serializer.MapRegisterSerializer;
  27 import org.opendaylight.lispflowmapping.tools.junit.BaseTestCase;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.EidToLocatorRecord.Action;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.LispAFIAddress;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.MapNotify;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.MapRegister;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.eidtolocatorrecords.EidToLocatorRecord;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.eidtolocatorrecords.EidToLocatorRecordBuilder;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.LispAddressContainer;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.lispaddress.lispaddresscontainer.address.no.NoAddressBuilder;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.locatorrecords.LocatorRecord;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.locatorrecords.LocatorRecordBuilder;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev150820.mapregisternotification.MapRegisterBuilder;
  39
  40 public class MapServerTest extends BaseTestCase {
  41
  42     private LispMappingService testedMapServer;
  43     private ILispDAO lispDAO;
  44     private MapRegisterBuilder mapRegisterBuilder;
  45     private LispAddressContainer eid;
  46     private LispAddressContainer rloc;
  47     private ValueSaverAction<MappingEntry<?>[]> mappingEntriesSaver;
  48     private MapRegister mapRegisterWithAuthentication;
  49     private String eidIpv4String = "10.31.0.5";
  50     private String eidIpv6String = "1:1:1:1:1:1:1:0";
  51
  52     @Override
  53     @Before
  54     public void before() throws Exception {
  55         super.before();
  56         lispDAO = context.mock(ILispDAO.class);
  57         testedMapServer = new LispMappingService();
  58         testedMapServer.basicInit(lispDAO);
  59         mapRegisterBuilder = new MapRegisterBuilder();
  60         mapRegisterBuilder.setKeyId((short) 0);
  61         mapRegisterBuilder.setAuthenticationData(new byte[0]);
  62         eid = LispAFIConvertor.asIPv4Address(eidIpv4String);
  63         rloc = LispAFIConvertor.asIPv4Address("192.168.136.10");
  64         EidToLocatorRecordBuilder recordBuilder = new EidToLocatorRecordBuilder();
  65         recordBuilder.setLispAddressContainer(eid).setMaskLength((short) 32);
  66         recordBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
  67         recordBuilder.getLocatorRecord().add(new LocatorRecordBuilder().setLispAddressContainer(rloc).build());
  68         recordBuilder.setAction(Action.NoAction).setMapVersion((short) 0).setAuthoritative(false).setRecordTtl(60).setMaskLength((short) 32);
  69         mapRegisterBuilder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
  70         mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
  71         mapRegisterWithAuthentication = MapRegisterSerializer.getInstance().deserialize(hexToByteBuffer("38 00 01 01 FF BB "
  72         //
  73                 + "00 00 00 00 00 00 00 01 00 14 2c 61 b9 c9 9a 20 " //
  74                 + "ba d8 f5 40 d3 55 6f 5f 6e 5a b2 0a bf b5 00 00 " //
  75                 + "00 0a 01 20 10 00 00 00 00 01 99 10 fe 01 01 64 " //
  76                 + "ff 00 00 05 00 01 c0 a8 88 0a"));
  77
  78         mappingEntriesSaver = new ValueSaverAction<MappingEntry<?>[]>();
  79     }
  80
  81     @Test
  82     public void handleMapRegister__NonSetMBit() throws Exception {
  83         mapRegisterBuilder.setWantMapNotify(false);
  84
  85         addDefaultPutAndGetExpectations(eid);
  86         assertNull(testedMapServer.handleMapRegister(mapRegisterBuilder.build(), false));
  87
  88         MappingEntry<?>[] entries = mappingEntriesSaver.lastValue;
  89         assertEquals(1, entries.length);
  90         assertEquals(SubKeys.RECORD, entries[0].getKey());
  91         assertEquals(rloc, ((EidToLocatorRecord) entries[0].getValue())
  92                 .getLocatorRecord().get(0).getLispAddressContainer());
  93     }
  94
  95     @Test
  96     public void handleMapRegisterIpv4__ValidNotifyEchoesRegister() throws Exception {
  97         mapRegisterBuilder.getEidToLocatorRecord().add(
  98                 getDefaultEidToLocatorBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(new NoAddressBuilder().build())).build());
  99         mapRegisterBuilder.setWantMapNotify(true);
 100
 101         addDefaultPutAndGetExpectations(eid);
 102         addDefaultPutAndGetExpectations(LispAFIConvertor.toContainer(new NoAddressBuilder().build()));
 103         MapRegister mr = mapRegisterBuilder.build();
 104         MapNotify mapNotify = testedMapServer.handleMapRegister(mr, false);
 105         assertEquals(mr.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
 106         ArrayAssert.assertEquals(mr.getAuthenticationData(), mapNotify.getAuthenticationData());
 107         assertEquals(mr.getKeyId(), mapNotify.getKeyId());
 108         assertEquals(mr.getNonce(), mapNotify.getNonce());
 109     }
 110
 111     @Test
 112     public void handleMapRegisterIpv4__CloneNotOwnYouClown() throws Exception {
 113         mapRegisterBuilder = getDefaultMapRegisterBuilder();
 114         mapRegisterBuilder.setWantMapNotify(true);
 115         EidToLocatorRecordBuilder eidToLocatorBuilder = getDefaultEidToLocatorBuilder();
 116         eidToLocatorBuilder.setMaskLength((short) 32);
 117         eid = LispAFIConvertor.asIPv4Address("0.0.0.1");
 118         eidToLocatorBuilder.setLispAddressContainer(eid);
 119
 120         LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
 121         locatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("0.0.0.2")));
 122         locatorBuilder.setPriority((short) 55);
 123         eidToLocatorBuilder.getLocatorRecord().add(locatorBuilder.build());
 124
 125         mapRegisterBuilder.getEidToLocatorRecord().add(eidToLocatorBuilder.build());
 126
 127         addDefaultPutAndGetExpectations(eid);
 128
 129         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterBuilder.build(), false);
 130
 131         EidToLocatorRecord actualEidToLocator = mapNotify.getEidToLocatorRecord().get(0);
 132         assertEquals(eid, actualEidToLocator.getLispAddressContainer());
 133         assertEquals((byte) 55, actualEidToLocator.getLocatorRecord().get(0).getPriority().byteValue());
 134
 135     }
 136
 137     @Test
 138     public void handleMapRegisterIpv4__ValidMask() throws Exception {
 139         int mask = 16;
 140         LispAddressContainer newEid = LispAFIConvertor.asIPv4Prefix(eidIpv4String, mask);
 141         mapRegisterBuilder = getDefaultMapRegisterBuilder();
 142         EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
 143         recordBuilder.setLispAddressContainer(newEid).setMaskLength((short) mask);
 144         LocatorRecordBuilder locator = getDefaultLocatorBuilder();
 145         locator.setLispAddressContainer(rloc);
 146         recordBuilder.getLocatorRecord().add(locator.build());
 147         mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
 148         mapRegisterBuilder.setWantMapNotify(true);
 149         MapRegister mr = mapRegisterBuilder.build();
 150
 151         addDefaultPutAndGetExpectations(newEid);
 152
 153         MapNotify mapNotify = testedMapServer.handleMapRegister(mr, false);
 154         assertEquals(newEid, mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
 155         ArrayAssert.assertEquals(mr.getAuthenticationData(), mapNotify.getAuthenticationData());
 156         assertEquals(mr.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
 157         assertEquals(mr.getKeyId(), mapNotify.getKeyId());
 158         assertEquals(mr.getNonce(), mapNotify.getNonce());
 159     }
 160
 161     @Test
 162     public void handleMapRegister__NonMaskable() throws Exception {
 163         int mask = 16;
 164         mapRegisterBuilder = getDefaultMapRegisterBuilder();
 165         LispAddressContainer addr = LispAFIConvertor.toContainer(LispAFIConvertor.asMacAfiAddress("01:01:01:01:01:01"));
 166         EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
 167         LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
 168         locatorBuilder.setLispAddressContainer(rloc);
 169         recordBuilder.setLispAddressContainer(addr).setMaskLength((short) mask);
 170         recordBuilder.getLocatorRecord().add(locatorBuilder.build());
 171         mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
 172         mapRegisterBuilder.setWantMapNotify(true);
 173
 174         addDefaultPutAndGetExpectations(addr);
 175
 176         MapRegister mapRegister = mapRegisterBuilder.build();
 177
 178         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister, false);
 179         assertEquals(addr, mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
 180         ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData());
 181         assertEquals(mapRegister.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
 182         assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId());
 183         assertEquals(mapRegister.getNonce(), mapNotify.getNonce());
 184     }
 185
 186     @Test
 187     public void handleMapRegister__ZeroMask() throws Exception {
 188         int mask = 0;
 189         mapRegisterBuilder = getDefaultMapRegisterBuilder();
 190         LispAddressContainer addr = LispAFIConvertor.toContainer(LispAFIConvertor.asMacAfiAddress("01:01:01:01:01:01"));
 191         EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
 192         LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
 193         locatorBuilder.setLispAddressContainer(rloc);
 194         recordBuilder.setLispAddressContainer(addr).setMaskLength((short) mask);
 195         recordBuilder.getLocatorRecord().add(locatorBuilder.build());
 196         mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
 197         mapRegisterBuilder.setWantMapNotify(true);
 198
 199         addDefaultPutAndGetExpectations(addr);
 200
 201         MapRegister mapRegister = mapRegisterBuilder.build();
 202
 203         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister, false);
 204         assertEquals(addr, mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
 205         ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData());
 206         assertEquals(mapRegister.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
 207         assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId());
 208         assertEquals(mapRegister.getNonce(), mapNotify.getNonce());
 209     }
 210
 211     @Test
 212     public void handleMapRegisterIPv4__ZeroMask() throws Exception {
 213         int mask = 0;
 214         LispAddressContainer newEid = LispAFIConvertor.asIPv4Prefix(eidIpv4String, mask);
 215         mapRegisterBuilder = getDefaultMapRegisterBuilder();
 216         EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
 217         recordBuilder.setLispAddressContainer(newEid).setMaskLength((short) mask);
 218         LocatorRecordBuilder locator = getDefaultLocatorBuilder();
 219         locator.setLispAddressContainer(rloc);
 220         recordBuilder.getLocatorRecord().add(locator.build());
 221         mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
 222         mapRegisterBuilder.setWantMapNotify(true);
 223         MapRegister mr = mapRegisterBuilder.build();
 224
 225         addDefaultPutAndGetExpectations(newEid);
 226
 227         MapNotify mapNotify = testedMapServer.handleMapRegister(mr, false);
 228         assertEquals(newEid, mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
 229         ArrayAssert.assertEquals(mr.getAuthenticationData(), mapNotify.getAuthenticationData());
 230         assertEquals(mr.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
 231         assertEquals(mr.getKeyId(), mapNotify.getKeyId());
 232         assertEquals(mr.getNonce(), mapNotify.getNonce());
 233     }
 234
 235     @Test
 236     public void handleMapRegisterIpv4__ValidMask32() throws Exception {
 237         int mask = 32;
 238         mapRegisterBuilder = getDefaultMapRegisterBuilder();
 239         EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
 240         recordBuilder.setLispAddressContainer(eid).setMaskLength((short) mask);
 241         LocatorRecordBuilder locator = getDefaultLocatorBuilder();
 242         locator.setLispAddressContainer(rloc);
 243         recordBuilder.getLocatorRecord().add(locator.build());
 244         mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
 245         mapRegisterBuilder.setWantMapNotify(true);
 246         MapRegister mr = mapRegisterBuilder.build();
 247
 248         addDefaultPutAndGetExpectations(eid);
 249
 250         MapNotify mapNotify = testedMapServer.handleMapRegister(mr, false);
 251         assertEquals(eid, mapNotify.getEidToLocatorRecord().get(0).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());
 256     }
 257
 258     @Test
 259     public void handleMapRegisterIpv6__ValidMask96() throws Exception {
 260         int mask = 96;
 261         mapRegisterBuilder = getDefaultMapRegisterBuilder();
 262         LispAddressContainer addr = LispAFIConvertor.asIPv6Prefix(eidIpv6String, mask);
 263         EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
 264         LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
 265         locatorBuilder.setLispAddressContainer(rloc);
 266         recordBuilder.setLispAddressContainer(addr).setMaskLength((short) mask);
 267         recordBuilder.getLocatorRecord().add(locatorBuilder.build());
 268         mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
 269         mapRegisterBuilder.setWantMapNotify(true);
 270
 271         addDefaultPutAndGetExpectations(addr);
 272
 273         MapRegister mapRegister = mapRegisterBuilder.build();
 274
 275         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister, false);
 276         assertEquals(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());
 281     }
 282
 283     @Test
 284     public void handleMapRegisterIpv6__ZeroMask() throws Exception {
 285         int mask = 0;
 286         mapRegisterBuilder = getDefaultMapRegisterBuilder();
 287         LispAddressContainer addr = LispAFIConvertor.asIPv6Prefix(eidIpv6String, mask);
 288         EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
 289         LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
 290         locatorBuilder.setLispAddressContainer(rloc);
 291         recordBuilder.setLispAddressContainer(addr).setMaskLength((short) mask);
 292         recordBuilder.getLocatorRecord().add(locatorBuilder.build());
 293         mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
 294         mapRegisterBuilder.setWantMapNotify(true);
 295
 296         addDefaultPutAndGetExpectations(addr);
 297
 298         MapRegister mapRegister = mapRegisterBuilder.build();
 299
 300         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister, false);
 301         assertEquals(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());
 306     }
 307
 308     @Test
 309     public void handleMapRegisterIpv6__ValidMask48() throws Exception {
 310         int mask = 48;
 311         mapRegisterBuilder = getDefaultMapRegisterBuilder();
 312         LispAddressContainer addr = LispAFIConvertor.asIPv6Prefix(eidIpv6String, mask);
 313         EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
 314         LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
 315         locatorBuilder.setLispAddressContainer(rloc);
 316         recordBuilder.setLispAddressContainer(addr).setMaskLength((short) mask);
 317         recordBuilder.getLocatorRecord().add(locatorBuilder.build());
 318         mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
 319         mapRegisterBuilder.setWantMapNotify(true);
 320
 321         addDefaultPutAndGetExpectations(addr);
 322
 323         MapRegister mapRegister = mapRegisterBuilder.build();
 324
 325         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister, false);
 326         assertEquals(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());
 331     }
 332
 333     @Test
 334     public void handleMapRegisterIpv6__ValidMask128() throws Exception {
 335         int mask = 128;
 336         mapRegisterBuilder = getDefaultMapRegisterBuilder();
 337         LispAddressContainer addr = LispAFIConvertor.asIPv6Address(eidIpv6String);
 338         EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
 339         LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
 340         locatorBuilder.setLispAddressContainer(rloc);
 341         recordBuilder.setLispAddressContainer(addr).setMaskLength((short) mask);
 342         recordBuilder.getLocatorRecord().add(locatorBuilder.build());
 343         mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
 344         mapRegisterBuilder.setWantMapNotify(true);
 345
 346         addDefaultPutAndGetExpectations(addr);
 347
 348         MapRegister mapRegister = mapRegisterBuilder.build();
 349
 350         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister, false);
 351         assertEquals(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());
 356     }
 357
 358     @Test
 359     public void handleMapRegisterIPV4AndIpv6__ValidMask96() throws Exception {
 360         int mask = 96;
 361         mapRegisterBuilder = getDefaultMapRegisterBuilder();
 362         EidToLocatorRecordBuilder recordBuilder0 = getDefaultEidToLocatorBuilder();
 363         recordBuilder0.setLispAddressContainer(eid).setMaskLength((short) 32);
 364         LispAddressContainer addr = LispAFIConvertor.asIPv6Prefix(eidIpv6String, mask);
 365         EidToLocatorRecordBuilder recordBuilder1 = getDefaultEidToLocatorBuilder();
 366         LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
 367         locatorBuilder.setLispAddressContainer(rloc);
 368         locatorBuilder.setLispAddressContainer(rloc);
 369         recordBuilder1.setLispAddressContainer(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);
 374
 375         addDefaultPutAndGetExpectations(eid);
 376         addDefaultPutAndGetExpectations(addr);
 377
 378         MapRegister mapRegister = mapRegisterBuilder.build();
 379
 380         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister, false);
 381         assertEquals(eid, mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
 382         assertEquals(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());
 387     }
 388
 389     @Test
 390     public void handleMapRegister__MultipleRLOCs() throws Exception {
 391         addDefaultPutAndGetExpectations(eid);
 392
 393         mapRegisterBuilder = getDefaultMapRegisterBuilder();
 394         LispAddressContainer rloc0 = rloc;
 395         LispAddressContainer rloc1 = LispAFIConvertor.asIPv6Address("0:0:0:0:0:0:0:7");
 396         EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
 397         recordBuilder.setLispAddressContainer(eid);
 398         LocatorRecordBuilder locatorBuilder1 = getDefaultLocatorBuilder();
 399         locatorBuilder1.setLispAddressContainer(rloc0);
 400         LocatorRecordBuilder locatorBuilder2 = getDefaultLocatorBuilder();
 401         locatorBuilder2.setLispAddressContainer(rloc1);
 402         recordBuilder.getLocatorRecord().add(locatorBuilder1.build());
 403         recordBuilder.getLocatorRecord().add(locatorBuilder2.build());
 404
 405         mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
 406
 407         testedMapServer.handleMapRegister(mapRegisterBuilder.build(), false);
 408
 409         MappingEntry<?>[] entries = mappingEntriesSaver.lastValue;
 410         assertEquals(1, entries.length);
 411
 412         assertEquals(SubKeys.RECORD, entries[0].getKey());
 413         assertEquals(rloc0, ((EidToLocatorRecord) entries[0].getValue()).getLocatorRecord()
 414                 .get(0).getLispAddressContainer());
 415         assertEquals(rloc1, ((EidToLocatorRecord) entries[0].getValue()).getLocatorRecord()
 416                 .get(1).getLispAddressContainer());
 417
 418     }
 419
 420     @Test
 421     public void handleMapRegister__MultipleTypes() throws Exception {
 422         addDefaultPutAndGetExpectations(eid);
 423
 424         mapRegisterBuilder = getDefaultMapRegisterBuilder();
 425         LispAddressContainer 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(eid);
 433         LocatorRecordBuilder locatorBuilder1 = getDefaultLocatorBuilder();
 434         locatorBuilder1.setLispAddressContainer(rloc0);
 435         LocatorRecordBuilder locatorBuilder2 = getDefaultLocatorBuilder();
 436         locatorBuilder2.setLispAddressContainer(LispAFIConvertor.toContainer(rloc1));
 437         recordBuilder.getLocatorRecord().add(locatorBuilder1.build());
 438         recordBuilder.getLocatorRecord().add(locatorBuilder2.build());
 439
 440         mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
 441
 442         testedMapServer.handleMapRegister(mapRegisterBuilder.build(), false);
 443
 444         MappingEntry<?>[] entries = mappingEntriesSaver.lastValue;
 445         assertEquals(1, entries.length);
 446         EidToLocatorRecord storedMapping = (EidToLocatorRecord) entries[0].getValue();
 447         assertEquals(2, storedMapping.getLocatorRecord().size());
 448         assertEquals(SubKeys.RECORD, entries[0].getKey());
 449         assertEquals(rloc0, storedMapping.getLocatorRecord().get(0).getLispAddressContainer());
 450         assertEquals(LispAFIConvertor.toContainer(rloc1), storedMapping.getLocatorRecord().get(1)
 451                 .getLispAddressContainer());
 452
 453     }
 454
 455     @Test
 456     public void handleMapRegister__TestOverwrite() throws Exception {
 457         addDefaultPutAndGetExpectations(eid);
 458
 459         addEidToLocatorRecord();
 460
 461         MappingEntry<?>[] entries = mappingEntriesSaver.lastValue;
 462         assertEquals(1, entries.length);
 463
 464         assertEquals(SubKeys.RECORD, entries[0].getKey());
 465         assertEquals(rloc, ((EidToLocatorRecord) entries[0].getValue()).getLocatorRecord()
 466                 .get(0).getLispAddressContainer());
 467     }
 468
 469 //    @Test
 470 //    public void handleMapRegister__TestDontOverwrite() throws Exception {
 471 //        int hc = rloc.getAddress().hashCode();
 472 //
 473 //        addDefaultPutAndGetExpectations(eid);
 474 //        testedMapServer.setOverwrite(false);
 475 //
 476 //        addEidToLocatorRecord();
 477 //
 478 //        MappingEntry<?>[] entries = mappingEntriesSaver.lastValue;
 479 //        assertEquals(1, entries.length);
 480 //
 481 //        assertEquals(String.valueOf(hc), entries[0].getKey());
 482 //        assertEquals(rloc, ((EidToLocatorRecord) entries[0].getValue()).getLocatorRecord()
 483 //                .get(0).getLispAddressContainer());
 484 //    }
 485
 486     private void addEidToLocatorRecord() {
 487         EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
 488         recordBuilder.setLispAddressContainer(eid);
 489         LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
 490         locatorBuilder.setLispAddressContainer(rloc);
 491         recordBuilder.getLocatorRecord().add(locatorBuilder.build());
 492
 493         mapRegisterBuilder = getDefaultMapRegisterBuilder();
 494         mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
 495
 496         testedMapServer.handleMapRegister(mapRegisterBuilder.build(), false);
 497     }
 498
 499     @Test
 500     public void handleMapRegister__MultipleEIDs() throws Exception {
 501         addDefaultPutAndGetExpectations(eid);
 502
 503         LispAddressContainer rloc1 = LispAFIConvertor.asIPv6Address("0:0:0:0:0:0:0:7");
 504         mapRegisterBuilder = getDefaultMapRegisterBuilder();
 505         EidToLocatorRecordBuilder etlrBuilder = getDefaultEidToLocatorBuilder();
 506         etlrBuilder.getLocatorRecord().add(getDefaultLocatorBuilder().setLispAddressContainer(rloc1).build());
 507         mapRegisterBuilder.setWantMapNotify(true);
 508         etlrBuilder.setLispAddressContainer(eid);
 509
 510         EidToLocatorRecordBuilder etlr2Builder = getDefaultEidToLocatorBuilder();
 511         LispAddressContainer address = LispAFIConvertor.asIPv4Address("1.1.1.1");
 512         etlr2Builder.setLispAddressContainer(address);
 513         etlr2Builder.setMaskLength((short) 32);
 514         int recordTtl = 5;
 515         etlr2Builder.setRecordTtl(recordTtl);
 516         etlr2Builder.getLocatorRecord().add(
 517                 getDefaultLocatorBuilder().setPriority((short) 10)
 518                         .setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("2.2.2.2"))).build());
 519         mapRegisterBuilder.getEidToLocatorRecord().add(etlrBuilder.build());
 520         mapRegisterBuilder.getEidToLocatorRecord().add(etlr2Builder.build());
 521         addDefaultPutAndGetExpectations(address);
 522         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterBuilder.build(), false);
 523
 524         assertEquals(rloc1, mapNotify.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)
 525                 .getLispAddressContainer());
 526         assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("2.2.2.2")), mapNotify.getEidToLocatorRecord().get(1)
 527                 .getLocatorRecord().get(0).getLispAddressContainer());
 528         assertEquals(address, mapNotify.getEidToLocatorRecord().get(1).getLispAddressContainer());
 529         assertEquals(recordTtl, mapNotify.getEidToLocatorRecord().get(1).getRecordTtl().intValue());
 530
 531     }
 532
 533     @Test
 534     public void handleMapRegisterIpv4__ChekWrongPassword() throws Exception {
 535
 536         addGetExpectations(LispAFIConvertor.asIPv4Address("153.16.254.1"), 0, 31, "bla");
 537         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterWithAuthentication, false);
 538         assertEquals(null, mapNotify);
 539     }
 540
 541     @Test
 542     public void handleMapRegisterIpv4__ChcekNoPasswordAndThenPassword() throws Exception {
 543
 544         addGetExpectations(LispAFIConvertor.asIPv4Address("153.16.254.1"), 0, 25, "password");
 545         addPutExpectations(LispAFIConvertor.asIPv4Address("153.16.254.1"));
 546         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterWithAuthentication, false);
 547         assertEquals(mapRegisterWithAuthentication.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
 548         assertEquals(mapRegisterWithAuthentication.getKeyId(), mapNotify.getKeyId());
 549         assertEquals(mapRegisterWithAuthentication.getNonce(), mapNotify.getNonce());
 550     }
 551
 552     @Test
 553     public void handleMapRegisterIpv4__ChcekNoPassword() throws Exception {
 554
 555         addGetExpectations(LispAFIConvertor.asIPv4Address("153.16.254.1"), 30, 0, "password");
 556         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterWithAuthentication, false);
 557         assertEquals(null, mapNotify);
 558     }
 559
 560     @Test
 561     public void handleMapRegisterIpv4__ChcekNoreturn() throws Exception {
 562
 563         addGetExpectations(LispAFIConvertor.asIPv4Address("153.16.254.1"));
 564         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterWithAuthentication, false);
 565         assertEquals(mapNotify, null);
 566     }
 567
 568     @SuppressWarnings("unchecked")
 569     @Test
 570     public void handleAddAuthenticationKey() throws Exception {
 571         String password = "pass";
 572         LispAddressContainer key = getDefaultKey();
 573         oneOf(lispDAO).put(weq(key),
 574                 weq((MappingEntry<String>[]) (Arrays.asList(new MappingEntry<String>(SubKeys.PASSWORD, password)).toArray())));
 575         testedMapServer.addAuthenticationKey(eid, password);
 576     }
 577
 578     @Test
 579     public void handleGetAuthenticationKey() throws Exception {
 580         LispAddressContainer key = getDefaultKey();
 581         oneOf(lispDAO).getSpecific(weq(key), with(SubKeys.PASSWORD));
 582         ret("password");
 583         assertEquals("password", testedMapServer.getAuthenticationKey(eid));
 584     }
 585
 586     @Test
 587     public void handleGetAuthenticationKeyNoIteration() throws Exception {
 588         testedMapServer.setShouldIterateMask(false);
 589         LispAddressContainer key = getDefaultKey();
 590         LispAddressContainer passKey = getKey(30);
 591         oneOf(lispDAO).getSpecific(weq(key), with(SubKeys.PASSWORD));
 592         allowing(lispDAO).getSpecific(weq(passKey), with(SubKeys.PASSWORD));
 593         ret("password");
 594         assertEquals(null, testedMapServer.getAuthenticationKey(eid));
 595     }
 596
 597     @Test
 598     public void handleRemoveAuthenticationKey() throws Exception {
 599         LispAddressContainer key = getDefaultKey();
 600         oneOf(lispDAO).removeSpecific(weq(key), with(SubKeys.PASSWORD));
 601         testedMapServer.removeAuthenticationKey(eid);
 602     }
 603
 604     private void addDefaultPutAndGetExpectations(LispAddressContainer addr) {
 605         addPutExpectations(addr);
 606         addGetExpectations(addr);
 607     }
 608
 609     private void addGetExpectations(LispAddressContainer address) {
 610         addGetExpectations(address,  0, 0, SubKeys.PASSWORD);
 611     }
 612
 613     private void addPutExpectations(LispAddressContainer address) {
 614         exactly(2).of(lispDAO).put(weq(address), with(mappingEntriesSaver));
 615     }
 616
 617     private void addGetExpectations(LispAddressContainer address, int withoutPassword, int withPassword, String password) {
 618         if (withoutPassword > 0) {
 619             String result = null;
 620             result = null;
 621             allowing(lispDAO).getSpecific(with(address), with(SubKeys.PASSWORD));
 622             ret(result);
 623         }
 624         if (withPassword > 0) {
 625             String result = null;
 626             result = password;
 627             allowing(lispDAO).getSpecific(with(address), with(SubKeys.PASSWORD));
 628             ret(result);
 629         }
 630         for (int i = MaskUtil.getMaskForAddress(address); i >= 0; i--) {
 631             allowing(lispDAO).getSpecific(with(MaskUtil.normalize(address, (short) i)), with(SubKeys.PASSWORD));
 632             ret(null);
 633         }
 634     }
 635
 636     private LispAddressContainer getDefaultKey() {
 637         return getKey(32);
 638     }
 639
 640     private LispAddressContainer getKey(int mask) {
 641         return MaskUtil.normalize(eid, (short)mask);
 642     }
 643
 644     private MapRegisterBuilder getDefaultMapRegisterBuilder() {
 645         MapRegisterBuilder mrb = new MapRegisterBuilder();
 646         mrb.setKeyId((short) 0);
 647         mrb.setNonce((long) 0);
 648         mrb.setWantMapNotify(false);
 649         mrb.setProxyMapReply(false);
 650         mrb.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
 651         mrb.setAuthenticationData(new byte[0]);
 652         return mrb;
 653     }
 654
 655     private EidToLocatorRecordBuilder getDefaultEidToLocatorBuilder() {
 656         EidToLocatorRecordBuilder builder = new EidToLocatorRecordBuilder();
 657         builder.setAction(Action.NoAction);
 658         builder.setAuthoritative(false);
 659         builder.setLocatorRecord(new ArrayList<LocatorRecord>());
 660         builder.setMapVersion((short) 0);
 661         builder.setMaskLength((short) 32);
 662         builder.setRecordTtl(60);
 663         return builder;
 664     }
 665
 666     private LocatorRecordBuilder getDefaultLocatorBuilder() {
 667         LocatorRecordBuilder builder = new LocatorRecordBuilder();
 668         builder.setLocalLocator(false);
 669         builder.setMulticastPriority((short) 0);
 670         builder.setMulticastWeight((short) 0);
 671         builder.setPriority((short) 0);
 672         builder.setRlocProbed(false);
 673         builder.setRouted(false);
 674         builder.setWeight((short) 0);
 675         return builder;
 676     }
 677 }