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
  15 import junitx.framework.ArrayAssert;
  16
  17 import org.jmock.api.Invocation;
  18 import org.junit.Before;
  19 import org.junit.Ignore;
  20 import org.junit.Test;
  21 import org.opendaylight.lispflowmapping.implementation.LispMappingService;
  22 import org.opendaylight.lispflowmapping.implementation.MappingService;
  23 import org.opendaylight.lispflowmapping.implementation.MappingSystem;
  24 import org.opendaylight.lispflowmapping.implementation.mdsal.DataStoreBackEnd;
  25 import org.opendaylight.lispflowmapping.interfaces.dao.ILispDAO;
  26 import org.opendaylight.lispflowmapping.interfaces.dao.MappingEntry;
  27 import org.opendaylight.lispflowmapping.interfaces.dao.SubKeys;
  28 import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
  29 import org.opendaylight.lispflowmapping.lisp.util.MaskUtil;
  30 import org.opendaylight.lispflowmapping.lisp.serializer.MapRegisterSerializer;
  31 import org.opendaylight.lispflowmapping.tools.junit.BaseTestCase;
  32 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.NoAddressAfi;
  33 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.SimpleAddressBuilder;
  34 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.Address;
  35 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.NoAddressBuilder;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapNotify;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapRegister;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.Eid;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.EidBuilder;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecord;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecordBuilder;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecord;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecord.Action;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecordBuilder;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.list.MappingRecordItem;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.list.MappingRecordItemBuilder;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapregisternotification.MapRegisterBuilder;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.rloc.container.Rloc;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.MappingOrigin;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.mappingservice.rev150906.db.instance.Mapping;
  51
  52 public class MapServerTest extends BaseTestCase {
  53
  54     private LispMappingService testedMapServer;
  55     private ILispDAO dao;
  56     private MappingService mapService;
  57     private DataStoreBackEnd dsbe;
  58     private MappingSystem mapSystem;
  59
  60     private MapRegisterBuilder mapRegisterBuilder;
  61     private Eid eid;
  62     private Rloc rloc;
  63     private ValueSaverAction<MappingEntry<?>[]> mappingEntriesSaver;
  64     private MapRegister mapRegisterWithAuthentication;
  65     private String eidIpv4String = "10.31.0.5/32";
  66     private String eidIpv6String = "1:1:1:1:1:1:1:0/128";
  67
  68     @Override
  69     @Before
  70     public void before() throws Exception {
  71         super.before();
  72         dao = context.mock(ILispDAO.class);
  73         dsbe = context.mock(DataStoreBackEnd.class);
  74
  75         // map-caches init and table creation
  76         allowing(dao).putTable(with(MappingOrigin.Northbound.toString()));will(returnValue(dao));
  77         allowing(dao).putTable(with(MappingOrigin.Southbound.toString()));will(returnValue(dao));
  78
  79         mapSystem = new MappingSystem(dao, true, true, true);
  80
  81         mapService = new MappingService();
  82         mapService.setDaoService(dao);
  83         inject(mapService, "dsbe", dsbe);
  84         inject(mapService, "mappingSystem", mapSystem);
  85
  86         testedMapServer = new LispMappingService();
  87         testedMapServer.setMappingService(mapService);
  88         testedMapServer.setShouldUseSmr(false);
  89         testedMapServer.basicInit();
  90
  91         mapRegisterBuilder = new MapRegisterBuilder();
  92         mapRegisterBuilder.setKeyId((short) 0);
  93         mapRegisterBuilder.setAuthenticationData(new byte[0]);
  94         eid = LispAddressUtil.asIpv4PrefixEid(eidIpv4String);
  95         rloc = LispAddressUtil.asIpv4Rloc("192.168.136.10");
  96         MappingRecordBuilder recordBuilder = new MappingRecordBuilder();
  97         recordBuilder.setEid(eid);
  98         recordBuilder.setLocatorRecord(new ArrayList<LocatorRecord>());
  99         recordBuilder.getLocatorRecord().add(new LocatorRecordBuilder().setRloc(rloc).build());
 100         recordBuilder.setAction(Action.NoAction).setMapVersion((short) 0).setAuthoritative(false).setRecordTtl(60)
 101                 .setMaskLength((short) 32);
 102         mapRegisterBuilder.setMappingRecordItem(new ArrayList<MappingRecordItem>());
 103         mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
 104                 .setMappingRecord(recordBuilder.build()).build());
 105         mapRegisterWithAuthentication = MapRegisterSerializer.getInstance().deserialize(
 106                 hexToByteBuffer("38 00 01 01 FF BB "
 107                 + "00 00 00 00 00 00 00 01 00 14 2c 61 b9 c9 9a 20 "
 108                 + "ba d8 f5 40 d3 55 6f 5f 6e 5a b2 0a bf b5 00 00 "
 109                 + "00 0a 01 20 10 00 00 00 00 01 99 10 fe 01 01 64 "
 110                 + "ff 00 00 05 00 01 c0 a8 88 0a"), null);
 111
 112         mappingEntriesSaver = new ValueSaverAction<MappingEntry<?>[]>();
 113     }
 114
 115     @Test
 116     @Ignore
 117     public void handleMapRegister__NonSetMBit() throws Exception {
 118         mapRegisterBuilder.setWantMapNotify(false);
 119
 120         addDefaultPutAndGetExpectations(eid);
 121         assertNull(testedMapServer.handleMapRegister(mapRegisterBuilder.build()));
 122
 123         MappingEntry<?>[] entries = mappingEntriesSaver.lastValue;
 124         assertEquals(1, entries.length);
 125         assertEquals(SubKeys.RECORD, entries[0].getKey());
 126         assertEquals(rloc, ((MappingRecord) entries[0].getValue()).getLocatorRecord().get(0).getRloc());
 127     }
 128
 129     @Test
 130     @Ignore
 131     public void handleMapRegisterIpv4__ValidNotifyEchoesRegister() throws Exception {
 132         mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder().setMappingRecord(
 133                 getDefaultMappingRecordBuilder().setEid(new EidBuilder().setAddressType(NoAddressAfi.class).setAddress(
 134                         (Address) new NoAddressBuilder().setNoAddress(true).build()).build()).build()).build());
 135         mapRegisterBuilder.setWantMapNotify(true);
 136
 137         addDefaultPutAndGetExpectations(eid);
 138         addDefaultPutAndGetExpectations(new EidBuilder().setAddressType(NoAddressAfi.class).setAddress(
 139                 (Address) new NoAddressBuilder().setNoAddress(true).build()).build());
 140         MapRegister mr = mapRegisterBuilder.build();
 141         MapNotify mapNotify = testedMapServer.handleMapRegister(mr).getLeft();
 142         assertEquals(mr.getMappingRecordItem(), mapNotify.getMappingRecordItem());
 143         ArrayAssert.assertEquals(mr.getAuthenticationData(), mapNotify.getAuthenticationData());
 144         assertEquals(mr.getKeyId(), mapNotify.getKeyId());
 145         assertEquals(mr.getNonce(), mapNotify.getNonce());
 146     }
 147
 148     @Test
 149     @Ignore
 150     public void handleMapRegisterIpv4__CloneNotOwnYouClown() throws Exception {
 151         mapRegisterBuilder = getDefaultMapRegisterBuilder();
 152         mapRegisterBuilder.setWantMapNotify(true);
 153         MappingRecordBuilder eidToLocatorBuilder = getDefaultMappingRecordBuilder();
 154         eidToLocatorBuilder.setMaskLength((short) 32);
 155         eid = LispAddressUtil.asIpv4PrefixEid("0.0.0.1/32");
 156         eidToLocatorBuilder.setEid(eid);
 157
 158         LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
 159         locatorBuilder.setRloc(LispAddressUtil.asIpv4Rloc("0.0.0.2"));
 160         locatorBuilder.setPriority((short) 55);
 161         eidToLocatorBuilder.getLocatorRecord().add(locatorBuilder.build());
 162
 163         mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
 164                 .setMappingRecord(eidToLocatorBuilder.build()).build());
 165
 166         addDefaultPutAndGetExpectations(eid);
 167
 168         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterBuilder.build()).getLeft();
 169
 170         MappingRecord actualEidToLocator = mapNotify.getMappingRecordItem().get(0).getMappingRecord();
 171         assertEquals(eid, actualEidToLocator.getEid());
 172         assertEquals((byte) 55, actualEidToLocator.getLocatorRecord().get(0).getPriority().byteValue());
 173
 174     }
 175
 176     @Test
 177     @Ignore
 178     public void handleMapRegisterIpv4__ValidMask() throws Exception {
 179         int mask = 16;
 180         Eid newEid = LispAddressUtil.asIpv4PrefixEid(eidIpv4String + "/" + mask);
 181         mapRegisterBuilder = getDefaultMapRegisterBuilder();
 182         MappingRecordBuilder recordBuilder = getDefaultMappingRecordBuilder();
 183         recordBuilder.setEid(newEid).setMaskLength((short) mask);
 184         LocatorRecordBuilder locator = getDefaultLocatorBuilder();
 185         locator.setRloc(rloc);
 186         recordBuilder.getLocatorRecord().add(locator.build());
 187         mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
 188                 .setMappingRecord(recordBuilder.build()).build());
 189         mapRegisterBuilder.setWantMapNotify(true);
 190         MapRegister mr = mapRegisterBuilder.build();
 191
 192         addDefaultPutAndGetExpectations(newEid);
 193
 194         MapNotify mapNotify = testedMapServer.handleMapRegister(mr).getLeft();
 195         assertEquals(newEid, mapNotify.getMappingRecordItem().get(0).getMappingRecord().getEid());
 196         ArrayAssert.assertEquals(mr.getAuthenticationData(), mapNotify.getAuthenticationData());
 197         assertEquals(mr.getMappingRecordItem(), mapNotify.getMappingRecordItem());
 198         assertEquals(mr.getKeyId(), mapNotify.getKeyId());
 199         assertEquals(mr.getNonce(), mapNotify.getNonce());
 200     }
 201
 202     @Test
 203     @Ignore
 204     public void handleMapRegister__NonMaskable() throws Exception {
 205         int mask = 16;
 206         mapRegisterBuilder = getDefaultMapRegisterBuilder();
 207         Eid addr = LispAddressUtil.asMacEid("01:01:01:01:01:01");
 208         MappingRecordBuilder recordBuilder = getDefaultMappingRecordBuilder();
 209         LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
 210         locatorBuilder.setRloc(rloc);
 211         recordBuilder.setEid(addr).setMaskLength((short) mask);
 212         recordBuilder.getLocatorRecord().add(locatorBuilder.build());
 213         mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
 214                 .setMappingRecord(recordBuilder.build()).build());
 215         mapRegisterBuilder.setWantMapNotify(true);
 216
 217         addDefaultPutAndGetExpectations(addr);
 218
 219         MapRegister mapRegister = mapRegisterBuilder.build();
 220
 221         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister).getLeft();
 222         assertEquals(addr, mapNotify.getMappingRecordItem().get(0).getMappingRecord().getEid());
 223         ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData());
 224         assertEquals(mapRegister.getMappingRecordItem(), mapNotify.getMappingRecordItem());
 225         assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId());
 226         assertEquals(mapRegister.getNonce(), mapNotify.getNonce());
 227     }
 228
 229     @Test
 230     @Ignore
 231     public void handleMapRegister__ZeroMask() throws Exception {
 232         int mask = 0;
 233         mapRegisterBuilder = getDefaultMapRegisterBuilder();
 234         Eid addr = LispAddressUtil.asMacEid("01:01:01:01:01:01");
 235         MappingRecordBuilder recordBuilder = getDefaultMappingRecordBuilder();
 236         LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
 237         locatorBuilder.setRloc(rloc);
 238         recordBuilder.setEid(addr).setMaskLength((short) mask);
 239         recordBuilder.getLocatorRecord().add(locatorBuilder.build());
 240         mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
 241                 .setMappingRecord(recordBuilder.build()).build());
 242         mapRegisterBuilder.setWantMapNotify(true);
 243
 244         addDefaultPutAndGetExpectations(addr);
 245
 246         MapRegister mapRegister = mapRegisterBuilder.build();
 247
 248         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister).getLeft();
 249         assertEquals(addr, mapNotify.getMappingRecordItem().get(0).getMappingRecord().getEid());
 250         ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData());
 251         assertEquals(mapRegister.getMappingRecordItem(), mapNotify.getMappingRecordItem());
 252         assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId());
 253         assertEquals(mapRegister.getNonce(), mapNotify.getNonce());
 254     }
 255
 256     @Test
 257     @Ignore
 258     public void handleMapRegisterIPv4__ZeroMask() throws Exception {
 259         int mask = 0;
 260         Eid newEid = LispAddressUtil.asIpv4PrefixEid(eidIpv4String + "/" + mask);
 261         mapRegisterBuilder = getDefaultMapRegisterBuilder();
 262         MappingRecordBuilder recordBuilder = getDefaultMappingRecordBuilder();
 263         recordBuilder.setEid(newEid).setMaskLength((short) mask);
 264         LocatorRecordBuilder locator = getDefaultLocatorBuilder();
 265         locator.setRloc(rloc);
 266         recordBuilder.getLocatorRecord().add(locator.build());
 267         mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
 268                 .setMappingRecord(recordBuilder.build()).build());
 269         mapRegisterBuilder.setWantMapNotify(true);
 270         MapRegister mr = mapRegisterBuilder.build();
 271
 272         addDefaultPutAndGetExpectations(newEid);
 273
 274         MapNotify mapNotify = testedMapServer.handleMapRegister(mr).getLeft();
 275         assertEquals(newEid, mapNotify.getMappingRecordItem().get(0).getMappingRecord().getEid());
 276         ArrayAssert.assertEquals(mr.getAuthenticationData(), mapNotify.getAuthenticationData());
 277         assertEquals(mr.getMappingRecordItem(), mapNotify.getMappingRecordItem());
 278         assertEquals(mr.getKeyId(), mapNotify.getKeyId());
 279         assertEquals(mr.getNonce(), mapNotify.getNonce());
 280     }
 281
 282     @Test
 283     @Ignore
 284     public void handleMapRegisterIpv4__ValidMask32() throws Exception {
 285         int mask = 32;
 286         mapRegisterBuilder = getDefaultMapRegisterBuilder();
 287         MappingRecordBuilder recordBuilder = getDefaultMappingRecordBuilder();
 288         recordBuilder.setEid(eid).setMaskLength((short) mask);
 289         LocatorRecordBuilder locator = getDefaultLocatorBuilder();
 290         locator.setRloc(rloc);
 291         recordBuilder.getLocatorRecord().add(locator.build());
 292         mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
 293                 .setMappingRecord(recordBuilder.build()).build());
 294         mapRegisterBuilder.setWantMapNotify(true);
 295         MapRegister mr = mapRegisterBuilder.build();
 296
 297         addDefaultPutAndGetExpectations(eid);
 298
 299         MapNotify mapNotify = testedMapServer.handleMapRegister(mr).getLeft();
 300         assertEquals(eid, mapNotify.getMappingRecordItem().get(0).getMappingRecord().getEid());
 301         ArrayAssert.assertEquals(mr.getAuthenticationData(), mapNotify.getAuthenticationData());
 302         assertEquals(mr.getMappingRecordItem(), mapNotify.getMappingRecordItem());
 303         assertEquals(mr.getKeyId(), mapNotify.getKeyId());
 304         assertEquals(mr.getNonce(), mapNotify.getNonce());
 305     }
 306
 307     @Test
 308     @Ignore
 309    public void handleMapRegisterIpv6__ValidMask96() throws Exception {
 310         int mask = 96;
 311         mapRegisterBuilder = getDefaultMapRegisterBuilder();
 312         Eid addr = LispAddressUtil.asIpv6PrefixEid(eidIpv6String + "/" + mask);
 313         MappingRecordBuilder recordBuilder = getDefaultMappingRecordBuilder();
 314         LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
 315         locatorBuilder.setRloc(rloc);
 316         recordBuilder.setEid(addr).setMaskLength((short) mask);
 317         recordBuilder.getLocatorRecord().add(locatorBuilder.build());
 318         mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
 319                 .setMappingRecord(recordBuilder.build()).build());
 320         mapRegisterBuilder.setWantMapNotify(true);
 321
 322         addDefaultPutAndGetExpectations(addr);
 323
 324         MapRegister mapRegister = mapRegisterBuilder.build();
 325
 326         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister).getLeft();
 327         assertEquals(addr, mapNotify.getMappingRecordItem().get(0).getMappingRecord().getEid());
 328         ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData());
 329         assertEquals(mapRegister.getMappingRecordItem(), mapNotify.getMappingRecordItem());
 330         assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId());
 331         assertEquals(mapRegister.getNonce(), mapNotify.getNonce());
 332     }
 333
 334     @Test
 335     @Ignore
 336     public void handleMapRegisterIpv6__ZeroMask() throws Exception {
 337         int mask = 0;
 338         mapRegisterBuilder = getDefaultMapRegisterBuilder();
 339         Eid addr = LispAddressUtil.asIpv6PrefixEid(eidIpv6String + "/" + mask);
 340         MappingRecordBuilder recordBuilder = getDefaultMappingRecordBuilder();
 341         LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
 342         locatorBuilder.setRloc(rloc);
 343         recordBuilder.setEid(addr).setMaskLength((short) mask);
 344         recordBuilder.getLocatorRecord().add(locatorBuilder.build());
 345         mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
 346                 .setMappingRecord(recordBuilder.build()).build());
 347         mapRegisterBuilder.setWantMapNotify(true);
 348
 349         addDefaultPutAndGetExpectations(addr);
 350
 351         MapRegister mapRegister = mapRegisterBuilder.build();
 352
 353         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister).getLeft();
 354         assertEquals(addr, mapNotify.getMappingRecordItem().get(0).getMappingRecord().getEid());
 355         ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData());
 356         assertEquals(mapRegister.getMappingRecordItem(), mapNotify.getMappingRecordItem());
 357         assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId());
 358         assertEquals(mapRegister.getNonce(), mapNotify.getNonce());
 359     }
 360
 361     @Test
 362     @Ignore
 363     public void handleMapRegisterIpv6__ValidMask48() throws Exception {
 364         int mask = 48;
 365         mapRegisterBuilder = getDefaultMapRegisterBuilder();
 366         Eid addr = LispAddressUtil.asIpv6PrefixEid(eidIpv6String +"/" + mask);
 367         MappingRecordBuilder recordBuilder = getDefaultMappingRecordBuilder();
 368         LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
 369         locatorBuilder.setRloc(rloc);
 370         recordBuilder.setEid(addr).setMaskLength((short) mask);
 371         recordBuilder.getLocatorRecord().add(locatorBuilder.build());
 372         mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
 373                 .setMappingRecord(recordBuilder.build()).build());
 374         mapRegisterBuilder.setWantMapNotify(true);
 375
 376         addDefaultPutAndGetExpectations(addr);
 377
 378         MapRegister mapRegister = mapRegisterBuilder.build();
 379
 380         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister).getLeft();
 381         assertEquals(addr, mapNotify.getMappingRecordItem().get(0).getMappingRecord().getEid());
 382         ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData());
 383         assertEquals(mapRegister.getMappingRecordItem(), mapNotify.getMappingRecordItem());
 384         assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId());
 385         assertEquals(mapRegister.getNonce(), mapNotify.getNonce());
 386     }
 387
 388     @Test
 389     @Ignore
 390     public void handleMapRegisterIpv6__ValidMask128() throws Exception {
 391         int mask = 128;
 392         mapRegisterBuilder = getDefaultMapRegisterBuilder();
 393         Eid addr = LispAddressUtil.asIpv6PrefixEid(eidIpv6String);
 394         MappingRecordBuilder recordBuilder = getDefaultMappingRecordBuilder();
 395         LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
 396         locatorBuilder.setRloc(rloc);
 397         recordBuilder.setEid(addr).setMaskLength((short) mask);
 398         recordBuilder.getLocatorRecord().add(locatorBuilder.build());
 399         mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
 400                 .setMappingRecord(recordBuilder.build()).build());
 401         mapRegisterBuilder.setWantMapNotify(true);
 402
 403         addDefaultPutAndGetExpectations(addr);
 404
 405         MapRegister mapRegister = mapRegisterBuilder.build();
 406
 407         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister).getLeft();
 408         assertEquals(addr, mapNotify.getMappingRecordItem().get(0).getMappingRecord().getEid());
 409         ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData());
 410         assertEquals(mapRegister.getMappingRecordItem(), mapNotify.getMappingRecordItem());
 411         assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId());
 412         assertEquals(mapRegister.getNonce(), mapNotify.getNonce());
 413     }
 414
 415     @Test
 416     @Ignore
 417     public void handleMapRegisterIPV4AndIpv6__ValidMask96() throws Exception {
 418         int mask = 96;
 419         mapRegisterBuilder = getDefaultMapRegisterBuilder();
 420         MappingRecordBuilder recordBuilder0 = getDefaultMappingRecordBuilder();
 421         recordBuilder0.setEid(eid).setMaskLength((short) 32);
 422         Eid addr = LispAddressUtil.asIpv6PrefixEid(eidIpv6String + "/" + mask);
 423         MappingRecordBuilder recordBuilder1 = getDefaultMappingRecordBuilder();
 424         LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
 425         locatorBuilder.setRloc(rloc);
 426         locatorBuilder.setRloc(rloc);
 427         recordBuilder1.setEid(addr).setMaskLength((short) mask);
 428         recordBuilder1.getLocatorRecord().add(locatorBuilder.build());
 429         mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
 430                 .setMappingRecord(recordBuilder0.build()).build());
 431         mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
 432                 .setMappingRecord(recordBuilder1.build()).build());
 433         mapRegisterBuilder.setWantMapNotify(true);
 434
 435         addDefaultPutAndGetExpectations(eid);
 436         addDefaultPutAndGetExpectations(addr);
 437
 438         MapRegister mapRegister = mapRegisterBuilder.build();
 439
 440         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegister).getLeft();
 441         assertEquals(eid, mapNotify.getMappingRecordItem().get(0).getMappingRecord().getEid());
 442         assertEquals(addr, mapNotify.getMappingRecordItem().get(1).getMappingRecord().getEid());
 443         ArrayAssert.assertEquals(mapRegister.getAuthenticationData(), mapNotify.getAuthenticationData());
 444         assertEquals(mapRegister.getMappingRecordItem(), mapNotify.getMappingRecordItem());
 445         assertEquals(mapRegister.getKeyId(), mapNotify.getKeyId());
 446         assertEquals(mapRegister.getNonce(), mapNotify.getNonce());
 447     }
 448
 449     @Test
 450     @Ignore
 451     public void handleMapRegister__MultipleRLOCs() throws Exception {
 452         addDefaultPutAndGetExpectations(eid);
 453
 454         mapRegisterBuilder = getDefaultMapRegisterBuilder();
 455         Rloc rloc0 = rloc;
 456         Rloc rloc1 = LispAddressUtil.asIpv6Rloc("0:0:0:0:0:0:0:7");
 457         MappingRecordBuilder recordBuilder = getDefaultMappingRecordBuilder();
 458         recordBuilder.setEid(eid);
 459         LocatorRecordBuilder locatorBuilder1 = getDefaultLocatorBuilder();
 460         locatorBuilder1.setRloc(rloc0);
 461         LocatorRecordBuilder locatorBuilder2 = getDefaultLocatorBuilder();
 462         locatorBuilder2.setRloc(rloc1);
 463         recordBuilder.getLocatorRecord().add(locatorBuilder1.build());
 464         recordBuilder.getLocatorRecord().add(locatorBuilder2.build());
 465
 466         mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
 467                 .setMappingRecord(recordBuilder.build()).build());
 468
 469         testedMapServer.handleMapRegister(mapRegisterBuilder.build());
 470
 471         MappingEntry<?>[] entries = mappingEntriesSaver.lastValue;
 472         assertEquals(1, entries.length);
 473
 474         assertEquals(SubKeys.RECORD, entries[0].getKey());
 475         assertEquals(rloc0, ((MappingRecord) entries[0].getValue()).getLocatorRecord()
 476                 .get(0).getRloc());
 477         assertEquals(rloc1, ((MappingRecord) entries[0].getValue()).getLocatorRecord()
 478                 .get(1).getRloc());
 479
 480     }
 481
 482     @Test
 483     @Ignore
 484     public void handleMapRegister__MultipleTypes() throws Exception {
 485         addDefaultPutAndGetExpectations(eid);
 486
 487         mapRegisterBuilder = getDefaultMapRegisterBuilder();
 488         Rloc rloc0 = rloc;
 489         // LispAFIAddress rloc1 =
 490         // LispAddressUtil.asIPv6AfiAddress("0:0:0:0:0:0:0:7");
 491         String subkey = "bla";
 492         Rloc rloc1 = LispAddressUtil.asKeyValueAddress(subkey,
 493                 SimpleAddressBuilder.getDefaultInstance("0:0:0:0:0:0:0:7"));
 494         MappingRecordBuilder recordBuilder = getDefaultMappingRecordBuilder();
 495         recordBuilder.setEid(eid);
 496         LocatorRecordBuilder locatorBuilder1 = getDefaultLocatorBuilder();
 497         locatorBuilder1.setRloc(rloc0);
 498         LocatorRecordBuilder locatorBuilder2 = getDefaultLocatorBuilder();
 499         locatorBuilder2.setRloc(rloc1);
 500         recordBuilder.getLocatorRecord().add(locatorBuilder1.build());
 501         recordBuilder.getLocatorRecord().add(locatorBuilder2.build());
 502
 503         mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
 504                 .setMappingRecord(recordBuilder.build()).build());
 505
 506         testedMapServer.handleMapRegister(mapRegisterBuilder.build());
 507
 508         MappingEntry<?>[] entries = mappingEntriesSaver.lastValue;
 509         assertEquals(1, entries.length);
 510         MappingRecord storedMapping = (MappingRecord) entries[0].getValue();
 511         assertEquals(2, storedMapping.getLocatorRecord().size());
 512         assertEquals(SubKeys.RECORD, entries[0].getKey());
 513         assertEquals(rloc0, storedMapping.getLocatorRecord().get(0).getRloc());
 514         assertEquals(rloc1, storedMapping.getLocatorRecord().get(1).getRloc());
 515
 516     }
 517
 518     @Test
 519     @Ignore
 520     public void handleMapRegister__TestOverwrite() throws Exception {
 521         addDefaultPutAndGetExpectations(eid);
 522
 523         addEidToLocatorRecord();
 524
 525         MappingEntry<?>[] entries = mappingEntriesSaver.lastValue;
 526         assertEquals(1, entries.length);
 527
 528         assertEquals(SubKeys.RECORD, entries[0].getKey());
 529         assertEquals(rloc, ((MappingRecord) entries[0].getValue()).getLocatorRecord().get(0).getRloc());
 530     }
 531
 532 //    @Test
 533 //    public void handleMapRegister__TestDontOverwrite() throws Exception {
 534 //        int hc = rloc.getAddress().hashCode();
 535 //
 536 //        addDefaultPutAndGetExpectations(eid);
 537 //        testedMapServer.setOverwrite(false);
 538 //
 539 //        addEidToLocatorRecord();
 540 //
 541 //        MappingEntry<?>[] entries = mappingEntriesSaver.lastValue;
 542 //        assertEquals(1, entries.length);
 543 //
 544 //        assertEquals(String.valueOf(hc), entries[0].getKey());
 545 //        assertEquals(rloc, ((EidToLocatorRecord) entries[0].getValue()).getLocatorRecord()
 546 //                .get(0).getEid());
 547 //    }
 548
 549     private void addEidToLocatorRecord() {
 550         MappingRecordBuilder recordBuilder = getDefaultMappingRecordBuilder();
 551         recordBuilder.setEid(eid);
 552         LocatorRecordBuilder locatorBuilder = getDefaultLocatorBuilder();
 553         locatorBuilder.setRloc(rloc);
 554         recordBuilder.getLocatorRecord().add(locatorBuilder.build());
 555
 556         mapRegisterBuilder = getDefaultMapRegisterBuilder();
 557         mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
 558                 .setMappingRecord(recordBuilder.build()).build());
 559
 560         testedMapServer.handleMapRegister(mapRegisterBuilder.build());
 561     }
 562
 563     @Test
 564     @Ignore
 565     public void handleMapRegister__MultipleEIDs() throws Exception {
 566         addDefaultPutAndGetExpectations(eid);
 567
 568         Rloc rloc1 = LispAddressUtil.asIpv6Rloc("0:0:0:0:0:0:0:7");
 569         mapRegisterBuilder = getDefaultMapRegisterBuilder();
 570         MappingRecordBuilder etlrBuilder = getDefaultMappingRecordBuilder();
 571         etlrBuilder.getLocatorRecord().add(getDefaultLocatorBuilder().setRloc(rloc1).build());
 572         mapRegisterBuilder.setWantMapNotify(true);
 573         etlrBuilder.setEid(eid);
 574
 575         MappingRecordBuilder etlr2Builder = getDefaultMappingRecordBuilder();
 576         Eid address = LispAddressUtil.asIpv4PrefixEid("1.1.1.1");
 577         etlr2Builder.setEid(address);
 578         etlr2Builder.setMaskLength((short) 32);
 579         int recordTtl = 5;
 580         etlr2Builder.setRecordTtl(recordTtl);
 581         etlr2Builder.getLocatorRecord().add(
 582                 getDefaultLocatorBuilder().setPriority((short) 10)
 583                         .setRloc(LispAddressUtil.asIpv4Rloc("2.2.2.2")).build());
 584         mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
 585                 .setMappingRecord(etlrBuilder.build()).build());
 586         mapRegisterBuilder.getMappingRecordItem().add(new MappingRecordItemBuilder()
 587                 .setMappingRecord(etlr2Builder.build()).build());
 588         addDefaultPutAndGetExpectations(address);
 589         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterBuilder.build()).getLeft();
 590
 591         assertEquals(rloc1, mapNotify.getMappingRecordItem().get(0).getMappingRecord().getLocatorRecord().get(0)
 592                 .getRloc());
 593         assertEquals(LispAddressUtil.asIpv4Rloc("2.2.2.2"), mapNotify.getMappingRecordItem().get(1).getMappingRecord()
 594                 .getLocatorRecord().get(0).getRloc());
 595         assertEquals(address, mapNotify.getMappingRecordItem().get(1).getMappingRecord().getEid());
 596         assertEquals(recordTtl, mapNotify.getMappingRecordItem().get(1).getMappingRecord().getRecordTtl().intValue());
 597
 598     }
 599
 600     @Test
 601     @Ignore
 602     public void handleMapRegisterIpv4__CheckWrongPassword() throws Exception {
 603
 604         addGetExpectations(LispAddressUtil.asIpv4PrefixEid("153.16.254.1"), 0, 31, "bla");
 605         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterWithAuthentication).getLeft();
 606         assertEquals(null, mapNotify);
 607     }
 608
 609     @Test
 610     @Ignore
 611     public void handleMapRegisterIpv4__CheckNoPasswordAndThenPassword() throws Exception {
 612
 613         addGetExpectations(LispAddressUtil.asIpv4PrefixEid("153.16.254.1"), 0, 25, "password");
 614         addPutExpectations(LispAddressUtil.asIpv4PrefixEid("153.16.254.1"));
 615         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterWithAuthentication).getLeft();
 616         assertEquals(mapRegisterWithAuthentication.getMappingRecordItem(), mapNotify.getMappingRecordItem());
 617         assertEquals(mapRegisterWithAuthentication.getKeyId(), mapNotify.getKeyId());
 618         assertEquals(mapRegisterWithAuthentication.getNonce(), mapNotify.getNonce());
 619     }
 620
 621     @Test
 622     @Ignore
 623     public void handleMapRegisterIpv4__CheckNoPassword() throws Exception {
 624
 625         addGetExpectations(LispAddressUtil.asIpv4PrefixEid("153.16.254.1/32"), 30, 0, "password");
 626         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterWithAuthentication).getLeft();
 627         assertEquals(null, mapNotify);
 628     }
 629
 630     @Test
 631     @Ignore
 632     public void handleMapRegisterIpv4__CheckNoreturn() throws Exception {
 633
 634         addGetExpectations(LispAddressUtil.asIpv4PrefixEid("153.16.254.1/32"));
 635         MapNotify mapNotify = testedMapServer.handleMapRegister(mapRegisterWithAuthentication).getLeft();
 636         assertEquals(mapNotify, null);
 637     }
 638
 639     private void addDefaultPutAndGetExpectations(Eid addr) {
 640         addPutExpectations(addr);
 641         addGetExpectations(addr);
 642     }
 643
 644     private void addGetExpectations(Eid address) {
 645         addGetExpectations(address, 0, 0, SubKeys.AUTH_KEY);
 646     }
 647
 648     private void prepareDsbe() {
 649         ValueSaverAction<Mapping> dsbeAddMappingSaverAction = new ValueSaverAction<Mapping>() {
 650             @Override
 651             public Object invoke(Invocation invocation) throws Throwable {
 652                 mapSystem.addMapping(lastValue.getOrigin(), lastValue.getMappingRecord().getEid(),
 653                         (Object) lastValue.getMappingRecord());
 654                 return null;
 655             }
 656         };
 657         oneOf(dsbe).addMapping(with(dsbeAddMappingSaverAction)); will(dsbeAddMappingSaverAction);
 658     }
 659
 660     private void addPutExpectations(Eid address) {
 661         // needed for mapping-service addMapping
 662         prepareDsbe();
 663         exactly(2).of(dao).put(weq(address), with(mappingEntriesSaver));
 664     }
 665
 666     private void addGetExpectations(Eid address, int withoutPassword, int withPassword, String password) {
 667         if (withoutPassword > 0) {
 668             String result = null;
 669             result = null;
 670             allowing(dao).getSpecific(with(address), with(SubKeys.AUTH_KEY));
 671             ret(result);
 672         }
 673         if (withPassword > 0) {
 674             String result = null;
 675             result = password;
 676             allowing(dao).getSpecific(with(address), with(SubKeys.AUTH_KEY));
 677             ret(result);
 678         }
 679         for (int i = MaskUtil.getMaskForAddress(address.getAddress()); i >= 0; i--) {
 680             Eid addr = MaskUtil.normalize(address, (short) i);
 681             allowing(dao).getSpecific(with(addr), with(SubKeys.AUTH_KEY)); ret(null);
 682             // check if mapping exists before insertion
 683             allowing(dao).get(with(addr));will(returnValue(null));
 684         }
 685
 686     }
 687
 688     private MapRegisterBuilder getDefaultMapRegisterBuilder() {
 689         MapRegisterBuilder mrb = new MapRegisterBuilder();
 690         mrb.setKeyId((short) 0);
 691         mrb.setNonce((long) 0);
 692         mrb.setWantMapNotify(false);
 693         mrb.setProxyMapReply(false);
 694         mrb.setMappingRecordItem(new ArrayList<MappingRecordItem>());
 695         mrb.setAuthenticationData(new byte[0]);
 696         return mrb;
 697     }
 698
 699     private MappingRecordBuilder getDefaultMappingRecordBuilder() {
 700         MappingRecordBuilder builder = new MappingRecordBuilder();
 701         builder.setAction(Action.NoAction);
 702         builder.setAuthoritative(false);
 703         builder.setLocatorRecord(new ArrayList<LocatorRecord>());
 704         builder.setMapVersion((short) 0);
 705         builder.setMaskLength((short) 32);
 706         builder.setRecordTtl(60);
 707         return builder;
 708     }
 709
 710     private LocatorRecordBuilder getDefaultLocatorBuilder() {
 711         LocatorRecordBuilder builder = new LocatorRecordBuilder();
 712         builder.setLocalLocator(false);
 713         builder.setMulticastPriority((short) 0);
 714         builder.setMulticastWeight((short) 0);
 715         builder.setPriority((short) 0);
 716         builder.setRlocProbed(false);
 717         builder.setRouted(false);
 718         builder.setWeight((short) 0);
 719         return builder;
 720     }
 721 }