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