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