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.lispflowmapping.rev131031.EidToLocatorRecord.Action;
  30 import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.LispAFIAddress;
  31 import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.MapNotify;
  32 import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.MapRegister;
  33 import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.eidtolocatorrecords.EidToLocatorRecord;
  34 import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.eidtolocatorrecords.EidToLocatorRecordBuilder;
  35 import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.lispaddress.lispaddresscontainer.address.Ipv4;
  36 import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.lispaddress.lispaddresscontainer.address.NoBuilder;
  37 import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.locatorrecords.LocatorRecord;
  38 import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.locatorrecords.LocatorRecordBuilder;
  39 import org.opendaylight.yang.gen.v1.lispflowmapping.rev131031.mapregisternotification.MapRegisterBuilder;
  40
  41 public class MapServerTest extends BaseTestCase {
  42
  43     private LispMappingService testedMapServer;
  44     private ILispDAO lispDAO;
  45     private MapRegisterBuilder mapRegisterBuilder;
  46     private Ipv4 eid;
  47     private Ipv4 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(AbstractLispComponent.ADDRESS_SUBKEY, entries[0].getKey());
  91         assertEquals(1, ((MappingServiceRLOCGroup) entries[0].getValue()).getRecords().size());
  92         assertEquals(rloc, ((MappingServiceRLOCGroup) entries[0].getValue()).getRecords().get(0).getLispAddressContainer().getAddress());
  93     }
  94
  95     @Test
  96     public void handleMapRegisterIpv4__ValidNotifyEchoesRegister() throws Exception {
  97         mapRegisterBuilder.getEidToLocatorRecord().add(
  98                 getDefaultEidToLocatorBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(new NoBuilder().build())).build());
  99         mapRegisterBuilder.setWantMapNotify(true);
 100
 101         addDefaultPutAndGetExpectations(eid, 32);
 102         addDefaultPutAndGetExpectations(new NoBuilder().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(AbstractLispComponent.ADDRESS_SUBKEY, entries[0].getKey());
 414         assertEquals(LispAFIConvertor.toContainer(rloc0), ((MappingServiceRLOCGroup) entries[0].getValue()).getRecords().get(0)
 415                 .getLispAddressContainer());
 416         assertEquals(LispAFIConvertor.toContainer(rloc1), ((MappingServiceRLOCGroup) 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(AbstractLispComponent.ADDRESS_SUBKEY, entries[0].getKey());
 449         assertEquals(subkey, entries[1].getKey());
 450         assertEquals(LispAFIConvertor.toContainer(rloc0), ((MappingServiceRLOCGroup) entries[0].getValue()).getRecords().get(0)
 451                 .getLispAddressContainer());
 452         assertEquals(LispAFIConvertor.toContainer(rloc1), ((MappingServiceRLOCGroup) 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(AbstractLispComponent.ADDRESS_SUBKEY, entries[0].getKey());
 467         assertEquals(LispAFIConvertor.toContainer(rloc), ((MappingServiceRLOCGroup) entries[0].getValue()).getRecords().get(0)
 468                 .getLispAddressContainer());
 469     }
 470
 471     @Test
 472     public void handleMapRegister__TestDontOverwrite() throws Exception {
 473         addDefaultPutAndGetExpectations(eid, 32);
 474         testedMapServer.setOverwrite(false);
 475
 476         addEidToLocatorRecord();
 477
 478         MappingEntry<?>[] entries = mappingEntriesSaver.lastValue;
 479         assertEquals(1, entries.length);
 480
 481         assertEquals(String.valueOf(rloc.hashCode()), entries[0].getKey());
 482         assertEquals(LispAFIConvertor.toContainer(rloc), ((MappingServiceRLOCGroup) entries[0].getValue()).getRecords().get(0)
 483                 .getLispAddressContainer());
 484     }
 485
 486     private void addEidToLocatorRecord() {
 487         EidToLocatorRecordBuilder recordBuilder = getDefaultEidToLocatorBuilder();
 488         recordBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
 489         LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
 490         locatorBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(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, 32);
 502
 503         LispAFIAddress rloc1 = LispAFIConvertor.asIPv6AfiAddress("0:0:0:0:0:0:0:7");
 504         mapRegisterBuilder = getDefaultMapRegisterBuilder();
 505         EidToLocatorRecordBuilder etlrBuilder = getDefaultEidToLocatorBuilder();
 506         etlrBuilder.getLocatorRecord().add(getDefaultLocatorBuilder().setLispAddressContainer(LispAFIConvertor.toContainer(rloc1)).build());
 507         mapRegisterBuilder.setWantMapNotify(true);
 508         etlrBuilder.setLispAddressContainer(LispAFIConvertor.toContainer(eid));
 509
 510         EidToLocatorRecordBuilder etlr2Builder = getDefaultEidToLocatorBuilder();
 511         LispAFIAddress address = LispAFIConvertor.asIPAfiAddress("1.1.1.1");
 512         etlr2Builder.setLispAddressContainer(LispAFIConvertor.toContainer(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, 32);
 522         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterBuilder.build(), false);
 523
 524         assertEquals(LispAFIConvertor.toContainer(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(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("1.1.1.1")), mapNotify.getEidToLocatorRecord().get(1)
 529                 .getLispAddressContainer());
 530         assertEquals(recordTtl, mapNotify.getEidToLocatorRecord().get(1).getRecordTtl().intValue());
 531
 532     }
 533
 534     @Test
 535     public void handleMapRegisterIpv4__ChekWrongPassword() throws Exception {
 536
 537         addGetExpectations(LispAFIConvertor.asIPAfiAddress("153.16.254.1"), 32, 0, 31, "bla");
 538         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterWithAuthentication, false);
 539         assertEquals(null, mapNotify);
 540     }
 541
 542     @Test
 543     public void handleMapRegisterIpv4__ChcekNoPasswordAndThenPassword() throws Exception {
 544
 545         addGetExpectations(LispAFIConvertor.asIPAfiAddress("153.16.254.1"), 32, 30, 25, "password");
 546         addPutExpectations(LispAFIConvertor.asIPAfiAddress("153.16.254.1"), 32);
 547         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterWithAuthentication, false);
 548         assertEquals(mapRegisterWithAuthentication.getEidToLocatorRecord(), mapNotify.getEidToLocatorRecord());
 549         assertEquals(mapRegisterWithAuthentication.getKeyId(), mapNotify.getKeyId());
 550         assertEquals(mapRegisterWithAuthentication.getNonce(), mapNotify.getNonce());
 551     }
 552
 553     @Test
 554     public void handleMapRegisterIpv4__ChcekNoPassword() throws Exception {
 555
 556         addGetExpectations(LispAFIConvertor.asIPAfiAddress("153.16.254.1"), 32, 30, 0, "password");
 557         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterWithAuthentication, false);
 558         assertEquals(null, mapNotify);
 559     }
 560
 561     @Test
 562     public void handleMapRegisterIpv4__ChcekNoreturn() throws Exception {
 563
 564         addGetExpectations(LispAFIConvertor.asIPAfiAddress("153.16.254.1"), 32);
 565         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterWithAuthentication, false);
 566         assertEquals(mapNotify, null);
 567     }
 568
 569     @SuppressWarnings("unchecked")
 570     @Test
 571     public void handleAddAuthenticationKey() throws Exception {
 572         String password = "pass";
 573         IMappingServiceKey key = getDefualtKey();
 574         oneOf(lispDAO).put(weq(key),
 575                 weq((MappingEntry<String>[]) (Arrays.asList(new MappingEntry<String>(AbstractLispComponent.PASSWORD_SUBKEY, password)).toArray())));
 576         testedMapServer.addAuthenticationKey(LispAFIConvertor.toContainer(eid), key.getMask(), password);
 577     }
 578
 579     @Test
 580     public void handleGetAuthenticationKey() throws Exception {
 581         IMappingServiceKey key = getDefualtKey();
 582         oneOf(lispDAO).getSpecific(weq(key), with(AbstractLispComponent.PASSWORD_SUBKEY));
 583         ret("password");
 584         assertEquals("password", testedMapServer.getAuthenticationKey(LispAFIConvertor.toContainer(eid), key.getMask()));
 585     }
 586
 587     @Test
 588     public void handleGetAuthenticationKeyNoIteration() throws Exception {
 589         testedMapServer.setShouldIterateMask(false);
 590         IMappingServiceKey key = getDefualtKey();
 591         IMappingServiceKey passKey = getKey(30);
 592         oneOf(lispDAO).getSpecific(weq(key), with(AbstractLispComponent.PASSWORD_SUBKEY));
 593         allowing(lispDAO).getSpecific(weq(passKey), with(AbstractLispComponent.PASSWORD_SUBKEY));
 594         ret("password");
 595         assertEquals(null, testedMapServer.getAuthenticationKey(LispAFIConvertor.toContainer(eid), key.getMask()));
 596     }
 597
 598     @Test
 599     public void handleRemoveAuthenticationKey() throws Exception {
 600         IMappingServiceKey key = getDefualtKey();
 601         oneOf(lispDAO).removeSpecific(weq(key), with(AbstractLispComponent.PASSWORD_SUBKEY));
 602         testedMapServer.removeAuthenticationKey(LispAFIConvertor.toContainer(eid), key.getMask());
 603     }
 604
 605     private void addDefaultPutAndGetExpectations(LispAFIAddress addr, int mask) {
 606         addPutExpectations(addr, mask);
 607         addGetExpectations(addr, mask);
 608     }
 609
 610     private void addGetExpectations(LispAFIAddress address, int mask) {
 611         addGetExpectations(address, mask, 0, 0, "password");
 612     }
 613
 614     private void addPutExpectations(LispAFIAddress address, int mask) {
 615         oneOf(lispDAO).put(weq(MappingServiceKeyUtil.generateMappingServiceKey(LispAFIConvertor.toContainer(address), mask)),
 616                 with(mappingEntriesSaver));
 617     }
 618
 619     private void addGetExpectations(LispAFIAddress address, int mask, int withoutPassword, int withPassword, String password) {
 620         if (withoutPassword > 0) {
 621             String result = null;
 622             result = null;
 623             allowing(lispDAO).getSpecific(
 624                     with(MappingServiceKeyUtil.generateMappingServiceKey(LispAFIConvertor.toContainer(address), withoutPassword)), with("password"));
 625             ret(result);
 626         }
 627         if (withPassword > 0) {
 628             String result = null;
 629             result = password;
 630             allowing(lispDAO).getSpecific(with(MappingServiceKeyUtil.generateMappingServiceKey(LispAFIConvertor.toContainer(address), withPassword)),
 631                     with("password"));
 632             ret(result);
 633         }
 634         for (int i = mask; i >= 0; i--) {
 635             allowing(lispDAO).getSpecific(with(MappingServiceKeyUtil.generateMappingServiceKey(LispAFIConvertor.toContainer(address), i)),
 636                     with("password"));
 637             ret(null);
 638         }
 639     }
 640
 641     private IMappingServiceKey getDefualtKey() {
 642         return getKey(32);
 643     }
 644
 645     private IMappingServiceKey getKey(int mask) {
 646         IMappingServiceKey key = MappingServiceKeyUtil.generateMappingServiceKey(LispAFIConvertor.toContainer(eid), mask);
 647         return key;
 648     }
 649
 650     private MapRegisterBuilder getDefaultMapRegisterBuilder() {
 651         MapRegisterBuilder mrb = new MapRegisterBuilder();
 652         mrb.setKeyId((short) 0);
 653         mrb.setNonce((long) 0);
 654         mrb.setWantMapNotify(false);
 655         mrb.setProxyMapReply(false);
 656         mrb.setEidToLocatorRecord(new ArrayList<EidToLocatorRecord>());
 657         mrb.setAuthenticationData(new byte[0]);
 658         return mrb;
 659     }
 660
 661     private EidToLocatorRecordBuilder getDefaultEidToLocatorBuilder() {
 662         EidToLocatorRecordBuilder builder = new EidToLocatorRecordBuilder();
 663         builder.setAction(Action.NoAction);
 664         builder.setAuthoritative(false);
 665         builder.setLocatorRecord(new ArrayList<LocatorRecord>());
 666         builder.setMapVersion((short) 0);
 667         builder.setMaskLength((short) 32);
 668         builder.setRecordTtl(60);
 669         return builder;
 670     }
 671
 672     private LocatorRecordBuilder getDefaultLocatorBuilder() {
 673         LocatorRecordBuilder builder = new LocatorRecordBuilder();
 674         builder.setLocalLocator(false);
 675         builder.setMulticastPriority((short) 0);
 676         builder.setMulticastWeight((short) 0);
 677         builder.setPriority((short) 0);
 678         builder.setRlocProbed(false);
 679         builder.setRouted(false);
 680         builder.setWeight((short) 0);
 681         return builder;
 682     }
 683 }