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.implementation.dao.MappingKeyUtil;
  22 import org.opendaylight.lispflowmapping.implementation.util.DAOSubKeys;
  23 import org.opendaylight.lispflowmapping.interfaces.dao.ILispDAO;
  24 import org.opendaylight.lispflowmapping.interfaces.dao.IMappingKey;
  25 import org.opendaylight.lispflowmapping.interfaces.dao.MappingEntry;
  26 import org.opendaylight.lispflowmapping.interfaces.dao.RLOCGroup;
  27 import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
  28 import org.opendaylight.lispflowmapping.lisp.serializer.MapRegisterSerializer;
  29 import org.opendaylight.lispflowmapping.tools.junit.BaseTestCase;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.EidToLocatorRecord.Action;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.LispAFIAddress;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapNotify;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.MapRegister;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidtolocatorrecords.EidToLocatorRecord;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.eidtolocatorrecords.EidToLocatorRecordBuilder;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.lispaddress.lispaddresscontainer.address.no.NoAddressBuilder;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.locatorrecords.LocatorRecord;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.locatorrecords.LocatorRecordBuilder;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.control.plane.rev150314.mapregisternotification.MapRegisterBuilder;
  40
  41 public class MapServerTest extends BaseTestCase {
  42
  43     private LispMappingService testedMapServer;
  44     private ILispDAO lispDAO;
  45     private MapRegisterBuilder mapRegisterBuilder;
  46     private LispAFIAddress eid;
  47     private LispAFIAddress rloc;
  48     private ValueSaverAction<MappingEntry<?>[]> mappingEntriesSaver;
  49     private MapRegister mapRegisterWithAuthentication;
  50
  51     @Override
  52     @Before
  53     public void before() throws Exception {
  54         super.before();
  55         lispDAO = context.mock(ILispDAO.class);
  56         testedMapServer = new LispMappingService();
  57         testedMapServer.basicInit(lispDAO);
  58         mapRegisterBuilder = new MapRegisterBuilder();
  59         mapRegisterBuilder.setKeyId((short) 0);
  60         mapRegisterBuilder.setAuthenticationData(new byte[0]);
  61         eid = LispAFIConvertor.asIPAfiAddress("10.31.0.5");
  62         rloc = LispAFIConvertor.asIPAfiAddress("192.168.136.10");
  63         EidToLocatorRecordBuilder recordBuilder = new EidToLocatorRecordBuilder();
  64         recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid)).setMaskLength((short) 32);
  65         recordBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
  66         recordBuilder.getLocatorRecord().add(new LocatorRecordBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(rloc)).build());
  67         recordBuilder.setAction(Action.NoAction).setMapVersion((short) 0).setAuthoritative(false).setRecordTtl(60).setMaskLength((short) 32);
  68         mapRegisterBuilder.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
  69         mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
  70         mapRegisterWithAuthentication = MapRegisterSerializer.getInstance().deserialize(hexToByteBuffer("38 00 01 01 FF BB "
  71         //
  72                 + "00 00 00 00 00 00 00 01 00 14 2c 61 b9 c9 9a 20 " //
  73                 + "ba d8 f5 40 d3 55 6f 5f 6e 5a b2 0a bf b5 00 00 " //
  74                 + "00 0a 01 20 10 00 00 00 00 01 99 10 fe 01 01 64 " //
  75                 + "ff 00 00 05 00 01 c0 a8 88 0a"));
  76
  77         mappingEntriesSaver = new ValueSaverAction<MappingEntry<?>[]>();
  78     }
  79
  80     @Test
  81     public void handleMapRegister__NonSetMBit() throws Exception {
  82         mapRegisterBuilder.setWantMapNotify(false);
  83
  84         addDefaultPutAndGetExpectations(eid, 32);
  85         assertNull(testedMapServer.handleMapRegister(mapRegisterBuilder.build(), false));
  86
  87         MappingEntry<?>[] entries = mappingEntriesSaver.lastValue;
  88         assertEquals(1, entries.length);
  89
  90         assertEquals(DAOSubKeys.ADDRESS_SUBKEY.toString(), entries[0].getKey());
  91         assertEquals(1, ((RLOCGroup) entries[0].getValue()).getRecords().size());
  92         assertEquals(rloc, LispAFIConvertor.toAFI(((RLOCGroup) entries[0].getValue()).getRecords().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, 32);
 102         addDefaultPutAndGetExpectations(new NoAddressBuilder().build(), 32);
 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.asIPAfiAddress("0.0.0.1");
 118         eidToLocatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(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, 32);
 128
 129         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterBuilder.build(), false);
 130
 131         EidToLocatorRecord actualEidToLocator = mapNotify.getEidToLocatorRecord().get(0);
 132         assertEquals(LispAFIConvertor.toContainer(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         mapRegisterBuilder = getDefaultMapRegisterBuilder();
 141         EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
 142         recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid)).setMaskLength((short) mask);
 143         LocatorRecordBuilder locator = getDefaultLocatorBuilder();
 144         locator.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
 145         recordBuilder.getLocatorRecord().add(locator.build());
 146         mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
 147         mapRegisterBuilder.setWantMapNotify(true);
 148         MapRegister mr = mapRegisterBuilder.build();
 149
 150         addDefaultPutAndGetExpectations(eid, mask);
 151
 152         MapNotify mapNotify = testedMapServer.handleMapRegister(mr, false);
 153         assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("10.31.0.5")), mapNotify.getEidToLocatorRecord().get(0)
 154                 .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         LispAFIAddress addr = LispAFIConvertor.asMacAfiAddress("01:01:01:01:01:01");
 166         EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
 167         LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
 168         locatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
 169         recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(addr)).setMaskLength((short) mask);
 170         recordBuilder.getLocatorRecord().add(locatorBuilder.build());
 171         mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
 172         mapRegisterBuilder.setWantMapNotify(true);
 173
 174         addDefaultPutAndGetExpectations(addr, mask);
 175
 176         MapRegister mapRegister = mapRegisterBuilder.build();
 177
 178         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister, false);
 179         assertEquals(LispAFIConvertor.toContainer(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         LispAFIAddress addr = LispAFIConvertor.asMacAfiAddress("01:01:01:01:01:01");
 191         EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
 192         LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
 193         locatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
 194         recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(addr)).setMaskLength((short) mask);
 195         recordBuilder.getLocatorRecord().add(locatorBuilder.build());
 196         mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
 197         mapRegisterBuilder.setWantMapNotify(true);
 198
 199         addDefaultPutAndGetExpectations(addr, mask);
 200
 201         MapRegister mapRegister = mapRegisterBuilder.build();
 202
 203         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister, false);
 204         assertEquals(LispAFIConvertor.toContainer(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         mapRegisterBuilder = getDefaultMapRegisterBuilder();
 215         EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
 216         recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid)).setMaskLength((short) mask);
 217         LocatorRecordBuilder locator = getDefaultLocatorBuilder();
 218         locator.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
 219         recordBuilder.getLocatorRecord().add(locator.build());
 220         mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
 221         mapRegisterBuilder.setWantMapNotify(true);
 222         MapRegister mr = mapRegisterBuilder.build();
 223
 224         addDefaultPutAndGetExpectations(eid, mask);
 225
 226         MapNotify mapNotify = testedMapServer.handleMapRegister(mr, false);
 227         assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("10.31.0.5")), mapNotify.getEidToLocatorRecord().get(0)
 228                 .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(LispAFIConvertor.toContainer(eid)).setMaskLength((short) mask);
 241         LocatorRecordBuilder locator = getDefaultLocatorBuilder();
 242         locator.setLispAddressContainer(LispAFIConvertor.toContainer(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, mask);
 249
 250         MapNotify mapNotify = testedMapServer.handleMapRegister(mr, false);
 251         assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("10.31.0.5")), mapNotify.getEidToLocatorRecord().get(0)
 252                 .getLispAddressContainer());
 253         ArrayAssert.assertEquals(mr.getAuthenticationData(), mapNotify.getAuthenticationData());
 254         assertEquals(mr.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
 255         assertEquals(mr.getKeyId(), mapNotify.getKeyId());
 256         assertEquals(mr.getNonce(), mapNotify.getNonce());
 257     }
 258
 259     @Test
 260     public void handleMapRegisterIpv6__ValidMask96() throws Exception {
 261         int mask = 96;
 262         mapRegisterBuilder = getDefaultMapRegisterBuilder();
 263         LispAFIAddress addr = LispAFIConvertor.asIPv6AfiAddress("1:1:1:1:1:1:1:0");
 264         EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
 265         LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
 266         locatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
 267         recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(addr)).setMaskLength((short) mask);
 268         recordBuilder.getLocatorRecord().add(locatorBuilder.build());
 269         mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
 270         mapRegisterBuilder.setWantMapNotify(true);
 271
 272         addDefaultPutAndGetExpectations(addr, mask);
 273
 274         MapRegister mapRegister = mapRegisterBuilder.build();
 275
 276         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister, false);
 277         assertEquals(LispAFIConvertor.toContainer(addr), mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
 278         ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData());
 279         assertEquals(mapRegister.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
 280         assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId());
 281         assertEquals(mapRegister.getNonce(), mapNotify.getNonce());
 282     }
 283
 284     @Test
 285     public void handleMapRegisterIpv6__ZeroMask() throws Exception {
 286         int mask = 0;
 287         mapRegisterBuilder = getDefaultMapRegisterBuilder();
 288         LispAFIAddress addr = LispAFIConvertor.asIPv6AfiAddress("1:1:1:1:1:1:1:0");
 289         EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
 290         LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
 291         locatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
 292         recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(addr)).setMaskLength((short) mask);
 293         recordBuilder.getLocatorRecord().add(locatorBuilder.build());
 294         mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
 295         mapRegisterBuilder.setWantMapNotify(true);
 296
 297         addDefaultPutAndGetExpectations(addr, mask);
 298
 299         MapRegister mapRegister = mapRegisterBuilder.build();
 300
 301         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister, false);
 302         assertEquals(LispAFIConvertor.toContainer(addr), mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
 303         ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData());
 304         assertEquals(mapRegister.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
 305         assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId());
 306         assertEquals(mapRegister.getNonce(), mapNotify.getNonce());
 307     }
 308
 309     @Test
 310     public void handleMapRegisterIpv6__ValidMask48() throws Exception {
 311         int mask = 48;
 312         mapRegisterBuilder = getDefaultMapRegisterBuilder();
 313         LispAFIAddress addr = LispAFIConvertor.asIPv6AfiAddress("1:1:1:1:1:1:1:0");
 314         EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
 315         LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
 316         locatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
 317         recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(addr)).setMaskLength((short) mask);
 318         recordBuilder.getLocatorRecord().add(locatorBuilder.build());
 319         mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
 320         mapRegisterBuilder.setWantMapNotify(true);
 321
 322         addDefaultPutAndGetExpectations(addr, mask);
 323
 324         MapRegister mapRegister = mapRegisterBuilder.build();
 325
 326         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister, false);
 327         assertEquals(LispAFIConvertor.toContainer(addr), mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
 328         ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData());
 329         assertEquals(mapRegister.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
 330         assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId());
 331         assertEquals(mapRegister.getNonce(), mapNotify.getNonce());
 332     }
 333
 334     @Test
 335     public void handleMapRegisterIpv6__ValidMask128() throws Exception {
 336         int mask = 128;
 337         mapRegisterBuilder = getDefaultMapRegisterBuilder();
 338         LispAFIAddress addr = LispAFIConvertor.asIPv6AfiAddress("1:1:1:1:1:1:1:0");
 339         EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
 340         LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
 341         locatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
 342         recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(addr)).setMaskLength((short) mask);
 343         recordBuilder.getLocatorRecord().add(locatorBuilder.build());
 344         mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
 345         mapRegisterBuilder.setWantMapNotify(true);
 346
 347         addDefaultPutAndGetExpectations(addr, mask);
 348
 349         MapRegister mapRegister = mapRegisterBuilder.build();
 350
 351         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister, false);
 352         assertEquals(LispAFIConvertor.toContainer(addr), mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
 353         ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData());
 354         assertEquals(mapRegister.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
 355         assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId());
 356         assertEquals(mapRegister.getNonce(), mapNotify.getNonce());
 357     }
 358
 359     @Test
 360     public void handleMapRegisterIPV4AndIpv6__ValidMask96() throws Exception {
 361         int mask = 96;
 362         mapRegisterBuilder = getDefaultMapRegisterBuilder();
 363         EidToLocatorRecordBuilder recordBuilder0 = getDefaultEidToLocatorBuilder();
 364         recordBuilder0.setLispAddressContainer(LispAFIConvertor.toContainer(eid)).setMaskLength((short) 32);
 365         LispAFIAddress addr = LispAFIConvertor.asIPv6AfiAddress("1:1:1:1:1:1:1:0");
 366         EidToLocatorRecordBuilder recordBuilder1 = getDefaultEidToLocatorBuilder();
 367         LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
 368         locatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
 369         locatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
 370         recordBuilder1.setLispAddressContainer(LispAFIConvertor.toContainer(addr)).setMaskLength((short) mask);
 371         recordBuilder1.getLocatorRecord().add(locatorBuilder.build());
 372         mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder0.build());
 373         mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder1.build());
 374         mapRegisterBuilder.setWantMapNotify(true);
 375
 376         addDefaultPutAndGetExpectations(eid, 32);
 377         addDefaultPutAndGetExpectations(addr, mask);
 378
 379         MapRegister mapRegister = mapRegisterBuilder.build();
 380
 381         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister, false);
 382         assertEquals(LispAFIConvertor.toContainer(eid), mapNotify.getEidToLocatorRecord().get(0).getLispAddressContainer());
 383         assertEquals(LispAFIConvertor.toContainer(addr), mapNotify.getEidToLocatorRecord().get(1).getLispAddressContainer());
 384         ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData());
 385         assertEquals(mapRegister.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
 386         assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId());
 387         assertEquals(mapRegister.getNonce(), mapNotify.getNonce());
 388     }
 389
 390     @Test
 391     public void handleMapRegister__MultipleRLOCs() throws Exception {
 392         addDefaultPutAndGetExpectations(eid, 32);
 393
 394         mapRegisterBuilder = getDefaultMapRegisterBuilder();
 395         LispAFIAddress rloc0 = rloc;
 396         LispAFIAddress rloc1 = LispAFIConvertor.asIPv6AfiAddress("0:0:0:0:0:0:0:7");
 397         EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
 398         recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
 399         LocatorRecordBuilder locatorBuilder1 = getDefaultLocatorBuilder();
 400         locatorBuilder1.setLispAddressContainer(LispAFIConvertor.toContainer(rloc0));
 401         LocatorRecordBuilder locatorBuilder2 = getDefaultLocatorBuilder();
 402         locatorBuilder2.setLispAddressContainer(LispAFIConvertor.toContainer(rloc1));
 403         recordBuilder.getLocatorRecord().add(locatorBuilder1.build());
 404         recordBuilder.getLocatorRecord().add(locatorBuilder2.build());
 405
 406         mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
 407
 408         testedMapServer.handleMapRegister(mapRegisterBuilder.build(), false);
 409
 410         MappingEntry<?>[] entries = mappingEntriesSaver.lastValue;
 411         assertEquals(1, entries.length);
 412
 413         assertEquals(DAOSubKeys.ADDRESS_SUBKEY.toString(), entries[0].getKey());
 414         assertEquals(LispAFIConvertor.toContainer(rloc0), ((RLOCGroup) entries[0].getValue()).getRecords().get(0)
 415                 .getLispAddressContainer());
 416         assertEquals(LispAFIConvertor.toContainer(rloc1), ((RLOCGroup) entries[0].getValue()).getRecords().get(1)
 417                 .getLispAddressContainer());
 418
 419     }
 420
 421     @Test
 422     public void handleMapRegister__MultipleTypes() throws Exception {
 423         addDefaultPutAndGetExpectations(eid, 32);
 424
 425         mapRegisterBuilder = getDefaultMapRegisterBuilder();
 426         LispAFIAddress rloc0 = rloc;
 427         // LispAFIAddress rloc1 =
 428         // LispAFIConvertor.asIPv6AfiAddress("0:0:0:0:0:0:0:7");
 429         String subkey = "bla";
 430         LispAFIAddress rloc1 = LispAFIConvertor
 431                 .asKeyValue(subkey, LispAFIConvertor.toPrimitive(LispAFIConvertor.asIPv6AfiAddress("0:0:0:0:0:0:0:7")));
 432         EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
 433         recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
 434         LocatorRecordBuilder locatorBuilder1 = getDefaultLocatorBuilder();
 435         locatorBuilder1.setLispAddressContainer(LispAFIConvertor.toContainer(rloc0));
 436         LocatorRecordBuilder locatorBuilder2 = getDefaultLocatorBuilder();
 437         locatorBuilder2.setLispAddressContainer(LispAFIConvertor.toContainer(rloc1));
 438         recordBuilder.getLocatorRecord().add(locatorBuilder1.build());
 439         recordBuilder.getLocatorRecord().add(locatorBuilder2.build());
 440
 441         mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
 442
 443         testedMapServer.handleMapRegister(mapRegisterBuilder.build(), false);
 444
 445         MappingEntry<?>[] entries = mappingEntriesSaver.lastValue;
 446         assertEquals(2, entries.length);
 447
 448         assertEquals(DAOSubKeys.ADDRESS_SUBKEY.toString(), entries[0].getKey());
 449         assertEquals(subkey, entries[1].getKey());
 450         assertEquals(LispAFIConvertor.toContainer(rloc0), ((RLOCGroup) entries[0].getValue()).getRecords().get(0)
 451                 .getLispAddressContainer());
 452         assertEquals(LispAFIConvertor.toContainer(rloc1), ((RLOCGroup) entries[1].getValue()).getRecords().get(0)
 453                 .getLispAddressContainer());
 454
 455     }
 456
 457     @Test
 458     public void handleMapRegister__TestOverwrite() throws Exception {
 459         addDefaultPutAndGetExpectations(eid, 32);
 460
 461         addEidToLocatorRecord();
 462
 463         MappingEntry<?>[] entries = mappingEntriesSaver.lastValue;
 464         assertEquals(1, entries.length);
 465
 466         assertEquals(DAOSubKeys.ADDRESS_SUBKEY.toString(), entries[0].getKey());
 467         assertEquals(LispAFIConvertor.toContainer(rloc), ((RLOCGroup) entries[0].getValue()).getRecords().get(0)
 468                 .getLispAddressContainer());
 469     }
 470
 471     @Test
 472     public void handleMapRegister__TestDontOverwrite() throws Exception {
 473         int hc = LispAFIConvertor.toContainer(rloc).getAddress().hashCode();
 474
 475         addDefaultPutAndGetExpectations(eid, 32);
 476         testedMapServer.setOverwrite(false);
 477
 478         addEidToLocatorRecord();
 479
 480         MappingEntry<?>[] entries = mappingEntriesSaver.lastValue;
 481         assertEquals(1, entries.length);
 482
 483         assertEquals(String.valueOf(hc), entries[0].getKey());
 484         assertEquals(LispAFIConvertor.toContainer(rloc), ((RLOCGroup) entries[0].getValue()).getRecords().get(0)
 485                 .getLispAddressContainer());
 486     }
 487
 488     private void addEidToLocatorRecord() {
 489         EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
 490         recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
 491         LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
 492         locatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(rloc));
 493         recordBuilder.getLocatorRecord().add(locatorBuilder.build());
 494
 495         mapRegisterBuilder = getDefaultMapRegisterBuilder();
 496         mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
 497
 498         testedMapServer.handleMapRegister(mapRegisterBuilder.build(), false);
 499     }
 500
 501     @Test
 502     public void handleMapRegister__MultipleEIDs() throws Exception {
 503         addDefaultPutAndGetExpectations(eid, 32);
 504
 505         LispAFIAddress rloc1 = LispAFIConvertor.asIPv6AfiAddress("0:0:0:0:0:0:0:7");
 506         mapRegisterBuilder = getDefaultMapRegisterBuilder();
 507         EidToLocatorRecordBuilder etlrBuilder = getDefaultEidToLocatorBuilder();
 508         etlrBuilder.getLocatorRecord().add(getDefaultLocatorBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(rloc1)).build());
 509         mapRegisterBuilder.setWantMapNotify(true);
 510         etlrBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
 511
 512         EidToLocatorRecordBuilder etlr2Builder = getDefaultEidToLocatorBuilder();
 513         LispAFIAddress address = LispAFIConvertor.asIPAfiAddress("1.1.1.1");
 514         etlr2Builder.setLispAddressContainer(LispAFIConvertor.toContainer(address));
 515         etlr2Builder.setMaskLength((short) 32);
 516         int recordTtl = 5;
 517         etlr2Builder.setRecordTtl(recordTtl);
 518         etlr2Builder.getLocatorRecord().add(
 519                 getDefaultLocatorBuilder().setPriority((short) 10)
 520                         .setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("2.2.2.2"))).build());
 521         mapRegisterBuilder.getEidToLocatorRecord().add(etlrBuilder.build());
 522         mapRegisterBuilder.getEidToLocatorRecord().add(etlr2Builder.build());
 523         addDefaultPutAndGetExpectations(address, 32);
 524         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterBuilder.build(), false);
 525
 526         assertEquals(LispAFIConvertor.toContainer(rloc1), mapNotify.getEidToLocatorRecord().get(0).getLocatorRecord().get(0)
 527                 .getLispAddressContainer());
 528         assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("2.2.2.2")), mapNotify.getEidToLocatorRecord().get(1)
 529                 .getLocatorRecord().get(0).getLispAddressContainer());
 530         assertEquals(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("1.1.1.1")), mapNotify.getEidToLocatorRecord().get(1)
 531                 .getLispAddressContainer());
 532         assertEquals(recordTtl, mapNotify.getEidToLocatorRecord().get(1).getRecordTtl().intValue());
 533
 534     }
 535
 536     @Test
 537     public void handleMapRegisterIpv4__ChekWrongPassword() throws Exception {
 538
 539         addGetExpectations(LispAFIConvertor.asIPAfiAddress("153.16.254.1"), 32, 0, 31, "bla");
 540         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterWithAuthentication, false);
 541         assertEquals(null, mapNotify);
 542     }
 543
 544     @Test
 545     public void handleMapRegisterIpv4__ChcekNoPasswordAndThenPassword() throws Exception {
 546
 547         addGetExpectations(LispAFIConvertor.asIPAfiAddress("153.16.254.1"), 32, 30, 25, "password");
 548         addPutExpectations(LispAFIConvertor.asIPAfiAddress("153.16.254.1"), 32);
 549         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterWithAuthentication, false);
 550         assertEquals(mapRegisterWithAuthentication.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
 551         assertEquals(mapRegisterWithAuthentication.getKeyId(), mapNotify.getKeyId());
 552         assertEquals(mapRegisterWithAuthentication.getNonce(), mapNotify.getNonce());
 553     }
 554
 555     @Test
 556     public void handleMapRegisterIpv4__ChcekNoPassword() throws Exception {
 557
 558         addGetExpectations(LispAFIConvertor.asIPAfiAddress("153.16.254.1"), 32, 30, 0, "password");
 559         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterWithAuthentication, false);
 560         assertEquals(null, mapNotify);
 561     }
 562
 563     @Test
 564     public void handleMapRegisterIpv4__ChcekNoreturn() throws Exception {
 565
 566         addGetExpectations(LispAFIConvertor.asIPAfiAddress("153.16.254.1"), 32);
 567         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterWithAuthentication, false);
 568         assertEquals(mapNotify, null);
 569     }
 570
 571     @SuppressWarnings("unchecked")
 572     @Test
 573     public void handleAddAuthenticationKey() throws Exception {
 574         String password = "pass";
 575         IMappingKey key = getDefualtKey();
 576         oneOf(lispDAO).put(weq(key),
 577                 weq((MappingEntry<String>[]) (Arrays.asList(new MappingEntry<String>(DAOSubKeys.PASSWORD_SUBKEY.toString(), password)).toArray())));
 578         testedMapServer.addAuthenticationKey(LispAFIConvertor.toContainer(eid), key.getMask(), password);
 579     }
 580
 581     @Test
 582     public void handleGetAuthenticationKey() throws Exception {
 583         IMappingKey key = getDefualtKey();
 584         oneOf(lispDAO).getSpecific(weq(key), with(DAOSubKeys.PASSWORD_SUBKEY.toString()));
 585         ret("password");
 586         assertEquals("password", testedMapServer.getAuthenticationKey(LispAFIConvertor.toContainer(eid), key.getMask()));
 587     }
 588
 589     @Test
 590     public void handleGetAuthenticationKeyNoIteration() throws Exception {
 591         testedMapServer.setShouldIterateMask(false);
 592         IMappingKey key = getDefualtKey();
 593         IMappingKey passKey = getKey(30);
 594         oneOf(lispDAO).getSpecific(weq(key), with(DAOSubKeys.PASSWORD_SUBKEY.toString()));
 595         allowing(lispDAO).getSpecific(weq(passKey), with(DAOSubKeys.PASSWORD_SUBKEY.toString()));
 596         ret("password");
 597         assertEquals(null, testedMapServer.getAuthenticationKey(LispAFIConvertor.toContainer(eid), key.getMask()));
 598     }
 599
 600     @Test
 601     public void handleRemoveAuthenticationKey() throws Exception {
 602         IMappingKey key = getDefualtKey();
 603         oneOf(lispDAO).removeSpecific(weq(key), with(DAOSubKeys.PASSWORD_SUBKEY.toString()));
 604         testedMapServer.removeAuthenticationKey(LispAFIConvertor.toContainer(eid), key.getMask());
 605     }
 606
 607     private void addDefaultPutAndGetExpectations(LispAFIAddress addr, int mask) {
 608         addPutExpectations(addr, mask);
 609         addGetExpectations(addr, mask);
 610     }
 611
 612     private void addGetExpectations(LispAFIAddress address, int mask) {
 613         addGetExpectations(address, mask, 0, 0, "password");
 614     }
 615
 616     private void addPutExpectations(LispAFIAddress address, int mask) {
 617         oneOf(lispDAO).put(weq(MappingKeyUtil.generateMappingKey(LispAFIConvertor.toContainer(address), mask)),
 618                 with(mappingEntriesSaver));
 619     }
 620
 621     private void addGetExpectations(LispAFIAddress address, int mask, int withoutPassword, int withPassword, String password) {
 622         if (withoutPassword > 0) {
 623             String result = null;
 624             result = null;
 625             allowing(lispDAO).getSpecific(
 626                     with(MappingKeyUtil.generateMappingKey(LispAFIConvertor.toContainer(address), withoutPassword)), with("password"));
 627             ret(result);
 628         }
 629         if (withPassword > 0) {
 630             String result = null;
 631             result = password;
 632             allowing(lispDAO).getSpecific(with(MappingKeyUtil.generateMappingKey(LispAFIConvertor.toContainer(address), withPassword)),
 633                     with("password"));
 634             ret(result);
 635         }
 636         for (int i = mask; i >= 0; i--) {
 637             allowing(lispDAO).getSpecific(with(MappingKeyUtil.generateMappingKey(LispAFIConvertor.toContainer(address), i)),
 638                     with("password"));
 639             ret(null);
 640         }
 641     }
 642
 643     private IMappingKey getDefualtKey() {
 644         return getKey(32);
 645     }
 646
 647     private IMappingKey getKey(int mask) {
 648         IMappingKey key = MappingKeyUtil.generateMappingKey(LispAFIConvertor.toContainer(eid), mask);
 649         return key;
 650     }
 651
 652     private MapRegisterBuilder getDefaultMapRegisterBuilder() {
 653         MapRegisterBuilder mrb = new MapRegisterBuilder();
 654         mrb.setKeyId((short) 0);
 655         mrb.setNonce((long) 0);
 656         mrb.setWantMapNotify(false);
 657         mrb.setProxyMapReply(false);
 658         mrb.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
 659         mrb.setAuthenticationData(new byte[0]);
 660         return mrb;
 661     }
 662
 663     private EidToLocatorRecordBuilder getDefaultEidToLocatorBuilder() {
 664         EidToLocatorRecordBuilder builder = new EidToLocatorRecordBuilder();
 665         builder.setAction(Action.NoAction);
 666         builder.setAuthoritative(false);
 667         builder.setLocatorRecord(new ArrayList<LocatorRecord>());
 668         builder.setMapVersion((short) 0);
 669         builder.setMaskLength((short) 32);
 670         builder.setRecordTtl(60);
 671         return builder;
 672     }
 673
 674     private LocatorRecordBuilder getDefaultLocatorBuilder() {
 675         LocatorRecordBuilder builder = new LocatorRecordBuilder();
 676         builder.setLocalLocator(false);
 677         builder.setMulticastPriority((short) 0);
 678         builder.setMulticastWeight((short) 0);
 679         builder.setPriority((short) 0);
 680         builder.setRlocProbed(false);
 681         builder.setRouted(false);
 682         builder.setWeight((short) 0);
 683         return builder;
 684     }
 685 }