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.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;
  39
  40 public class MapServerTest extends BaseTestCase {
  41
  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;
  49
  50     @Override
  51     @Before
  52     public void before() throws Exception {
  53         super.before();
  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 "
  70         //
  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"));
  75
  76         mappingEntriesSaver = new ValueSaverAction<MappingEntry<?>[]>();
  77     }
  78
  79     @Test
  80     public void handleMapRegister__NonSetMBit() throws Exception {
  81         mapRegisterBuilder.setWantMapNotify(false);
  82
  83         addDefaultPutAndGetExpectations(eid, 32);
  84         assertNull(testedMapServer.handleMapRegister(mapRegisterBuilder.build(), false));
  85
  86         MappingEntry<?>[] entries = mappingEntriesSaver.lastValue;
  87         assertEquals(1, entries.length);
  88
  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()));
  92     }
  93
  94     @Test
  95     public void handleMapRegisterIpv4__ValidNotifyEchoesRegister() throws Exception {
  96         mapRegisterBuilder.getEidToLocatorRecord().add(
  97                 getDefaultEidToLocatorBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(new NoAddressBuilder().build())).build());
  98         mapRegisterBuilder.setWantMapNotify(true);
  99
 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());
 108     }
 109
 110     @Test
 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));
 118
 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());
 123
 124         mapRegisterBuilder.getEidToLocatorRecord().add(eidToLocatorBuilder.build());
 125
 126         addDefaultPutAndGetExpectations(eid, 32);
 127
 128         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterBuilder.build(), false);
 129
 130         EidToLocatorRecord actualEidToLocator = mapNotify.getEidToLocatorRecord().get(0);
 131         assertEquals(LispAFIConvertor.toContainer(eid), actualEidToLocator.getLispAddressContainer());
 132         assertEquals((byte) 55, actualEidToLocator.getLocatorRecord().get(0).getPriority().byteValue());
 133
 134     }
 135
 136     @Test
 137     public void handleMapRegisterIpv4__ValidMask() throws Exception {
 138         int mask = 16;
 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();
 148
 149         addDefaultPutAndGetExpectations(eid, mask);
 150
 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());
 158     }
 159
 160     @Test
 161     public void handleMapRegister__NonMaskable() throws Exception {
 162         int mask = 16;
 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);
 172
 173         addDefaultPutAndGetExpectations(addr, mask);
 174
 175         MapRegister mapRegister = mapRegisterBuilder.build();
 176
 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());
 183     }
 184
 185     @Test
 186     public void handleMapRegister__ZeroMask() throws Exception {
 187         int mask = 0;
 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);
 197
 198         addDefaultPutAndGetExpectations(addr, mask);
 199
 200         MapRegister mapRegister = mapRegisterBuilder.build();
 201
 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());
 208     }
 209
 210     @Test
 211     public void handleMapRegisterIPv4__ZeroMask() throws Exception {
 212         int mask = 0;
 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();
 222
 223         addDefaultPutAndGetExpectations(eid, mask);
 224
 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());
 232     }
 233
 234     @Test
 235     public void handleMapRegisterIpv4__ValidMask32() throws Exception {
 236         int mask = 32;
 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();
 246
 247         addDefaultPutAndGetExpectations(eid, mask);
 248
 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());
 256     }
 257
 258     @Test
 259     public void handleMapRegisterIpv6__ValidMask96() throws Exception {
 260         int mask = 96;
 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);
 270
 271         addDefaultPutAndGetExpectations(addr, mask);
 272
 273         MapRegister mapRegister = mapRegisterBuilder.build();
 274
 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());
 281     }
 282
 283     @Test
 284     public void handleMapRegisterIpv6__ZeroMask() throws Exception {
 285         int mask = 0;
 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);
 295
 296         addDefaultPutAndGetExpectations(addr, mask);
 297
 298         MapRegister mapRegister = mapRegisterBuilder.build();
 299
 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());
 306     }
 307
 308     @Test
 309     public void handleMapRegisterIpv6__ValidMask48() throws Exception {
 310         int mask = 48;
 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);
 320
 321         addDefaultPutAndGetExpectations(addr, mask);
 322
 323         MapRegister mapRegister = mapRegisterBuilder.build();
 324
 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());
 331     }
 332
 333     @Test
 334     public void handleMapRegisterIpv6__ValidMask128() throws Exception {
 335         int mask = 128;
 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);
 345
 346         addDefaultPutAndGetExpectations(addr, mask);
 347
 348         MapRegister mapRegister = mapRegisterBuilder.build();
 349
 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());
 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(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);
 374
 375         addDefaultPutAndGetExpectations(eid, 32);
 376         addDefaultPutAndGetExpectations(addr, mask);
 377
 378         MapRegister mapRegister = mapRegisterBuilder.build();
 379
 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());
 387     }
 388
 389     @Test
 390     public void handleMapRegister__MultipleRLOCs() throws Exception {
 391         addDefaultPutAndGetExpectations(eid, 32);
 392
 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());
 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(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());
 417
 418     }
 419
 420     @Test
 421     public void handleMapRegister__MultipleTypes() throws Exception {
 422         addDefaultPutAndGetExpectations(eid, 32);
 423
 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());
 439
 440         mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
 441
 442         testedMapServer.handleMapRegister(mapRegisterBuilder.build(), false);
 443
 444         MappingEntry<?>[] entries = mappingEntriesSaver.lastValue;
 445         assertEquals(2, entries.length);
 446
 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());
 453
 454     }
 455
 456     @Test
 457     public void handleMapRegister__TestOverwrite() throws Exception {
 458         addDefaultPutAndGetExpectations(eid, 32);
 459
 460         addEidToLocatorRecord();
 461
 462         MappingEntry<?>[] entries = mappingEntriesSaver.lastValue;
 463         assertEquals(1, entries.length);
 464
 465         assertEquals(AbstractLispComponent.ADDRESS_SUBKEY, entries[0].getKey());
 466         assertEquals(LispAFIConvertor.toContainer(rloc), ((MappingServiceRLOCGroup) entries[0].getValue()).getRecords().get(0)
 467                 .getLispAddressContainer());
 468     }
 469
 470     @Test
 471     public void handleMapRegister__TestDontOverwrite() throws Exception {
 472         int hc = LispAFIConvertor.toContainer(rloc).getAddress().hashCode();
 473
 474         addDefaultPutAndGetExpectations(eid, 32);
 475         testedMapServer.setOverwrite(false);
 476
 477         addEidToLocatorRecord();
 478
 479         MappingEntry<?>[] entries = mappingEntriesSaver.lastValue;
 480         assertEquals(1, entries.length);
 481
 482         assertEquals(String.valueOf(hc), entries[0].getKey());
 483         assertEquals(LispAFIConvertor.toContainer(rloc), ((MappingServiceRLOCGroup) entries[0].getValue()).getRecords().get(0)
 484                 .getLispAddressContainer());
 485     }
 486
 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());
 493
 494         mapRegisterBuilder = getDefaultMapRegisterBuilder();
 495         mapRegisterBuilder.getEidToLocatorRecord().add(recordBuilder.build());
 496
 497         testedMapServer.handleMapRegister(mapRegisterBuilder.build(), false);
 498     }
 499
 500     @Test
 501     public void handleMapRegister__MultipleEIDs() throws Exception {
 502         addDefaultPutAndGetExpectations(eid, 32);
 503
 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));
 510
 511         EidToLocatorRecordBuilder etlr2Builder = getDefaultEidToLocatorBuilder();
 512         LispAFIAddress address = LispAFIConvertor.asIPAfiAddress("1.1.1.1");
 513         etlr2Builder.setLispAddressContainer(LispAFIConvertor.toContainer(address));
 514         etlr2Builder.setMaskLength((short) 32);
 515         int recordTtl = 5;
 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);
 524
 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());
 532
 533     }
 534
 535     @Test
 536     public void handleMapRegisterIpv4__ChekWrongPassword() throws Exception {
 537
 538         addGetExpectations(LispAFIConvertor.asIPAfiAddress("153.16.254.1"), 32, 0, 31, "bla");
 539         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterWithAuthentication, false);
 540         assertEquals(null, mapNotify);
 541     }
 542
 543     @Test
 544     public void handleMapRegisterIpv4__ChcekNoPasswordAndThenPassword() throws Exception {
 545
 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());
 552     }
 553
 554     @Test
 555     public void handleMapRegisterIpv4__ChcekNoPassword() throws Exception {
 556
 557         addGetExpectations(LispAFIConvertor.asIPAfiAddress("153.16.254.1"), 32, 30, 0, "password");
 558         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterWithAuthentication, false);
 559         assertEquals(null, mapNotify);
 560     }
 561
 562     @Test
 563     public void handleMapRegisterIpv4__ChcekNoreturn() throws Exception {
 564
 565         addGetExpectations(LispAFIConvertor.asIPAfiAddress("153.16.254.1"), 32);
 566         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterWithAuthentication, false);
 567         assertEquals(mapNotify, null);
 568     }
 569
 570     @SuppressWarnings("unchecked")
 571     @Test
 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);
 578     }
 579
 580     @Test
 581     public void handleGetAuthenticationKey() throws Exception {
 582         IMappingServiceKey key = getDefualtKey();
 583         oneOf(lispDAO).getSpecific(weq(key), with(AbstractLispComponent.PASSWORD_SUBKEY));
 584         ret("password");
 585         assertEquals("password", testedMapServer.getAuthenticationKey(LispAFIConvertor.toContainer(eid), key.getMask()));
 586     }
 587
 588     @Test
 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));
 595         ret("password");
 596         assertEquals(null, testedMapServer.getAuthenticationKey(LispAFIConvertor.toContainer(eid), key.getMask()));
 597     }
 598
 599     @Test
 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());
 604     }
 605
 606     private void addDefaultPutAndGetExpectations(LispAFIAddress addr, int mask) {
 607         addPutExpectations(addr, mask);
 608         addGetExpectations(addr, mask);
 609     }
 610
 611     private void addGetExpectations(LispAFIAddress address, int mask) {
 612         addGetExpectations(address, mask, 0, 0, "password");
 613     }
 614
 615     private void addPutExpectations(LispAFIAddress address, int mask) {
 616         oneOf(lispDAO).put(weq(MappingServiceKeyUtil.generateMappingServiceKey(LispAFIConvertor.toContainer(address), mask)),
 617                 with(mappingEntriesSaver));
 618     }
 619
 620     private void addGetExpectations(LispAFIAddress address, int mask, int withoutPassword, int withPassword, String password) {
 621         if (withoutPassword > 0) {
 622             String result = null;
 623             result = null;
 624             allowing(lispDAO).getSpecific(
 625                     with(MappingServiceKeyUtil.generateMappingServiceKey(LispAFIConvertor.toContainer(address), withoutPassword)), with("password"));
 626             ret(result);
 627         }
 628         if (withPassword > 0) {
 629             String result = null;
 630             result = password;
 631             allowing(lispDAO).getSpecific(with(MappingServiceKeyUtil.generateMappingServiceKey(LispAFIConvertor.toContainer(address), withPassword)),
 632                     with("password"));
 633             ret(result);
 634         }
 635         for (int i = mask; i >= 0; i--) {
 636             allowing(lispDAO).getSpecific(with(MappingServiceKeyUtil.generateMappingServiceKey(LispAFIConvertor.toContainer(address), i)),
 637                     with("password"));
 638             ret(null);
 639         }
 640     }
 641
 642     private IMappingServiceKey getDefualtKey() {
 643         return getKey(32);
 644     }
 645
 646     private IMappingServiceKey getKey(int mask) {
 647         IMappingServiceKey key = MappingServiceKeyUtil.generateMappingServiceKey(LispAFIConvertor.toContainer(eid), mask);
 648         return key;
 649     }
 650
 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]);
 659         return mrb;
 660     }
 661
 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);
 670         return builder;
 671     }
 672
 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);
 682         return builder;
 683     }
 684 }