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