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

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