mappingservice/implementation/src/test/java/org/opendaylight/lispflowmapping/implementation/lisp/MapResolverTest.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 package org.opendaylight.lispflowmapping.implementation.lisp;
   9
  10 import static org.junit.Assert.assertEquals;
  11
  12 import java.util.ArrayList;
  13 import java.util.HashMap;
  14 import java.util.Map;
  15
  16 import org.jmock.api.Invocation;
  17 import org.junit.Assert;
  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.interfaces.dao.ILispDAO;
  24 import org.opendaylight.lispflowmapping.interfaces.dao.SubKeys;
  25 import org.opendaylight.lispflowmapping.lisp.util.LispAFIConvertor;
  26 import org.opendaylight.lispflowmapping.tools.junit.BaseTestCase;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.EidToLocatorRecord.Action;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapReply;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapRequest;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eidrecords.EidRecord;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eidrecords.EidRecordBuilder;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eidtolocatorrecords.EidToLocatorRecord;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eidtolocatorrecords.EidToLocatorRecordBuilder;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.lispaddress.LispAddressContainer;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecord;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecordBuilder;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequest.ItrRloc;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequest.SourceEidBuilder;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequestnotification.MapRequestBuilder;
  40
  41 public class MapResolverTest extends BaseTestCase {
  42
  43     // private MapResolver testedMapResolver;
  44     private LispMappingService testedMapResolver;
  45     private ILispDAO dao;
  46     private MappingService mapService;
  47     private MapRequestBuilder mapRequest;
  48     private LispAddressContainer v4Address;
  49     private LispAddressContainer v6Address;
  50
  51     private HashMap<LispAddressContainer, Map<String, EidToLocatorRecord>> daoResults;
  52
  53     @Override
  54     @Before
  55     public void before() throws Exception {
  56         super.before();
  57
  58         dao = context.mock(ILispDAO.class);
  59
  60         // map-cache init and table creation
  61         allowing(dao).putTable(wany(String.class));will(returnValue(dao));
  62
  63         MappingSystem mapSystem = new MappingSystem(dao, true, true, true);
  64         mapService = new MappingService();
  65         mapService.setDaoService(dao);
  66         inject(mapService, "mappingSystem", mapSystem);
  67
  68         testedMapResolver = new LispMappingService();
  69         testedMapResolver.setMappingService(mapService);
  70         testedMapResolver.basicInit();
  71
  72         mapRequest = new MapRequestBuilder();
  73         v4Address = LispAFIConvertor.asIPv4Address("1.2.3.4");
  74         v6Address = LispAFIConvertor.asIPv6Address("0:0:0:0:0:0:0:1");
  75         daoResults = new HashMap<LispAddressContainer, Map<String, EidToLocatorRecord>>();
  76     }
  77
  78     @Test
  79     public void handleMapRequest__ReplyWithSingleLocator() throws Exception {
  80         mapRequest = getDefaultMapRequestBuilder();
  81         mapRequest.getEidRecord().add(
  82                 new EidRecordBuilder().setMask((short) 32)
  83                         .setLispAddressContainer(LispAFIConvertor.asIPv4Address("1.2.3.4")).build());
  84
  85         EidToLocatorRecordBuilder record = getDefaultEidToLocatorBuilder();
  86         record.setLispAddressContainer(v4Address);
  87
  88         LocatorRecordBuilder locator = getDefaultLocatorBuilder();
  89         locator.setLocalLocator(false);
  90         locator.setLispAddressContainer(LispAFIConvertor.asIPv4Address("4.3.2.1"));
  91         locator.setRouted(true);
  92         locator.setMulticastPriority((short) 5);
  93         locator.setWeight((short) 17);
  94         locator.setPriority((short) 16);
  95         record.getLocatorRecord().add(locator.build());
  96         prepareMapping(record.build());
  97
  98         MapReply mapReply = testedMapResolver.handleMapRequest(mapRequest.build());
  99
 100         EidToLocatorRecord eidToLocators = mapReply.getEidToLocatorRecord().get(0);
 101         assertEquals(1, eidToLocators.getLocatorRecord().size());
 102         LocatorRecord resultLocator = mapReply.getEidToLocatorRecord().get(0).getLocatorRecord().get(0);
 103         assertEquals(locator.isLocalLocator(), resultLocator.isLocalLocator());
 104         assertEquals(locator.isRouted(), resultLocator.isRouted());
 105         assertEquals(locator.getMulticastPriority(), resultLocator.getMulticastPriority());
 106         assertEquals(locator.getMulticastWeight(), resultLocator.getMulticastWeight());
 107         assertEquals(locator.getPriority(), resultLocator.getPriority());
 108         assertEquals(locator.getWeight(), resultLocator.getWeight());
 109
 110         assertLocator(LispAFIConvertor.asIPv4Address("4.3.2.1"), eidToLocators.getLocatorRecord().get(0));
 111     }
 112
 113     @Test
 114     public void handleMapRequest__VerifyBasicFields() throws Exception {
 115         mapRequest = getDefaultMapRequestBuilder();
 116         mapRequest.getEidRecord().add(
 117                 new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(v4Address).build());
 118
 119         EidToLocatorRecordBuilder record = getDefaultEidToLocatorBuilder();
 120         record.setLispAddressContainer(v4Address);
 121         record.setRecordTtl(100);
 122
 123         record.setAuthoritative(true);
 124         LocatorRecordBuilder locator = getDefaultLocatorBuilder();
 125         locator.setLispAddressContainer(LispAFIConvertor.asIPv4Address("4.3.2.1"));
 126         record.getLocatorRecord().add(locator.build());
 127         prepareMapping(record.build());
 128
 129         MapReply mapReply = testedMapResolver.handleMapRequest(mapRequest.build());
 130
 131         assertEquals(mapRequest.getNonce(), mapReply.getNonce());
 132         EidToLocatorRecord eidToLocators = mapReply.getEidToLocatorRecord().get(0);
 133         assertEquals((byte) 32, eidToLocators.getMaskLength().byteValue());
 134         assertEquals(v4Address, eidToLocators.getLispAddressContainer());
 135         assertEquals(record.isAuthoritative(), eidToLocators.isAuthoritative());
 136         assertEquals(record.getAction(), eidToLocators.getAction());
 137         assertEquals(record.getRecordTtl(), eidToLocators.getRecordTtl());
 138     }
 139
 140     @Test
 141     public void handleMapRequest__VerifyMask() throws Exception {
 142         mapRequest = getDefaultMapRequestBuilder();
 143         mapRequest.getEidRecord().add(
 144                 new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(v4Address).build());
 145
 146         EidToLocatorRecordBuilder record = getDefaultEidToLocatorBuilder();
 147         record.setLispAddressContainer(LispAFIConvertor.asIPv4Prefix("1.2.3.0", 24));
 148         record.setMaskLength((short) 24);
 149
 150         LocatorRecordBuilder locator = getDefaultLocatorBuilder();
 151         locator.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1")));
 152         record.getLocatorRecord().add(locator.build());
 153         prepareMapping(record.build());
 154
 155         MapRequest mr = mapRequest.build();
 156         MapReply mapReply = testedMapResolver.handleMapRequest(mr);
 157
 158         assertEquals(mr.getNonce(), mapReply.getNonce());
 159         EidToLocatorRecord eidToLocators = mapReply.getEidToLocatorRecord().get(0);
 160         assertEquals((byte) 24, eidToLocators.getMaskLength().byteValue());
 161         assertEquals(LispAFIConvertor.asIPv4Prefix("1.2.3.0", 24), eidToLocators.getLispAddressContainer());
 162     }
 163
 164     @Test
 165     public void handleMapRequest__VerifyMaskIPv6() throws Exception {
 166         mapRequest = getDefaultMapRequestBuilder();
 167         mapRequest.getEidRecord().add(
 168                 new EidRecordBuilder().setMask((short) 128).setLispAddressContainer(v6Address).build());
 169
 170         EidToLocatorRecordBuilder record = getDefaultEidToLocatorBuilder();
 171         record.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPv6AfiAddress("0:0:0:0:0:0:0:0")));
 172         record.setMaskLength((short) 128);
 173
 174         LocatorRecordBuilder locator = getDefaultLocatorBuilder();
 175         locator.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1")));
 176         record.getLocatorRecord().add(locator.build());
 177         prepareMapping(record.build());
 178
 179         MapRequest mr = mapRequest.build();
 180
 181         MapReply mapReply = testedMapResolver.handleMapRequest(mr);
 182
 183         assertEquals(mr.getNonce(), mapReply.getNonce());
 184         EidToLocatorRecord eidToLocators = mapReply.getEidToLocatorRecord().get(0);
 185         assertEquals((byte) 128, eidToLocators.getMaskLength().byteValue());
 186         assertEquals(v6Address, eidToLocators.getLispAddressContainer());
 187     }
 188
 189     @Test
 190     public void handleMapRequest__VerifyMaskIPv6NoMatch() throws Exception {
 191         mapRequest = getDefaultMapRequestBuilder();
 192         mapRequest.getEidRecord().add(
 193                 new EidRecordBuilder().setMask((short) 128).setLispAddressContainer(v6Address).build());
 194
 195         EidToLocatorRecordBuilder record = getDefaultEidToLocatorBuilder();
 196         record.setLispAddressContainer(LispAFIConvertor.asIPv6Prefix("0:1:0:0:0:0:0:1", 112));
 197         record.setMaskLength((short) 112);
 198
 199         LocatorRecordBuilder locator = getDefaultLocatorBuilder();
 200         locator.setLispAddressContainer(LispAFIConvertor.asIPv4Address("4.3.2.1"));
 201         record.getLocatorRecord().add(locator.build());
 202         prepareMapping(record.build());
 203
 204         MapRequest mr = mapRequest.build();
 205
 206         MapReply mapReply = testedMapResolver.handleMapRequest(mr);
 207         EidToLocatorRecord eidToLocators = mapReply.getEidToLocatorRecord().get(0);
 208         assertEquals(null, eidToLocators.getLocatorRecord());
 209     }
 210
 211     @Test
 212     public void handleMapRequest_VerifyNativelyForwardAutherized() {
 213         MapRequest mr = getDefaultMapRequest();
 214
 215         Map<String, EidToLocatorRecord> result = new HashMap<String, EidToLocatorRecord>();
 216         result.put(SubKeys.RECORD, null);
 217
 218         MapReply mapReply = getNativelyForwardMapReply(mr, result);
 219
 220         EidToLocatorRecord eidToLocators = mapReply.getEidToLocatorRecord().get(0);
 221         assertEquals(1, eidToLocators.getRecordTtl().intValue());
 222         assertEquals(Action.NativelyForward, eidToLocators.getAction());
 223     }
 224
 225     private MapReply getNativelyForwardMapReply(MapRequest mr, Map<String, EidToLocatorRecord> result) {
 226         allowing(dao).get(wany(LispAddressContainer.class));
 227         ret(result);
 228         allowing(dao).getSpecific(wany(LispAddressContainer.class), with(SubKeys.AUTH_KEY));
 229         ret("pass");
 230         MapReply mapReply = testedMapResolver.handleMapRequest(mr);
 231         return mapReply;
 232     }
 233
 234     private MapRequest getDefaultMapRequest() {
 235         mapRequest = getDefaultMapRequestBuilder();
 236         mapRequest.getEidRecord().add(
 237                 new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(v4Address).build());
 238         MapRequest mr = mapRequest.build();
 239         return mr;
 240     }
 241
 242     @Test
 243     public void handleMapRequest__VerifyMaskNoMatch() throws Exception {
 244         mapRequest = getDefaultMapRequestBuilder();
 245         mapRequest.getEidRecord().add(
 246                 new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(v4Address).build());
 247
 248         EidToLocatorRecordBuilder record = getDefaultEidToLocatorBuilder();
 249         record.setLispAddressContainer(LispAFIConvertor.asIPv4Prefix("1.2.4.0", 24));
 250         record.setMaskLength((short) 24);
 251
 252         LocatorRecordBuilder locator = getDefaultLocatorBuilder();
 253         locator.setLispAddressContainer(LispAFIConvertor.asIPv4Address("4.3.2.1"));
 254         record.getLocatorRecord().add(locator.build());
 255         prepareMapping(record.build());
 256
 257         MapRequest mr = mapRequest.build();
 258
 259         MapReply mapReply = testedMapResolver.handleMapRequest(mr);
 260
 261         EidToLocatorRecord eidToLocators = mapReply.getEidToLocatorRecord().get(0);
 262         assertEquals(null, eidToLocators.getLocatorRecord());
 263     }
 264
 265     @Test
 266     public void handleMapRequest__ReplyWithMultipleLocators() throws Exception {
 267
 268         mapRequest = getDefaultMapRequestBuilder();
 269         mapRequest.getEidRecord().add(
 270                 new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(v4Address).build());
 271
 272         EidToLocatorRecordBuilder record = getDefaultEidToLocatorBuilder();
 273         record.setLispAddressContainer(v4Address);
 274
 275         LocatorRecordBuilder locator = getDefaultLocatorBuilder();
 276         locator.setLispAddressContainer(LispAFIConvertor.asIPv4Address("4.3.2.1"));
 277         record.getLocatorRecord().add(locator.build());
 278         locator = getDefaultLocatorBuilder();
 279         locator.setLispAddressContainer(LispAFIConvertor.asIPv6Address("0:0:0:0:0:0:0:1"));
 280         record.getLocatorRecord().add(locator.build());
 281         locator = getDefaultLocatorBuilder();
 282         locator.setLispAddressContainer(LispAFIConvertor.asIPv4Address("1.8.2.7"));
 283         record.getLocatorRecord().add(locator.build());
 284
 285         prepareMapping(record.build());
 286
 287         MapReply mapReply = testedMapResolver.handleMapRequest(mapRequest.build());
 288
 289         EidToLocatorRecord eidToLocators = mapReply.getEidToLocatorRecord().get(0);
 290         assertEquals(3, eidToLocators.getLocatorRecord().size());
 291
 292         assertLocator(LispAFIConvertor.asIPv4Address("4.3.2.1"), eidToLocators.getLocatorRecord().get(0));
 293         assertLocator(LispAFIConvertor.asIPv6Address("0:0:0:0:0:0:0:1"), eidToLocators.getLocatorRecord().get(1));
 294         assertLocator(LispAFIConvertor.asIPv4Address("1.8.2.7"), eidToLocators.getLocatorRecord().get(2));
 295     }
 296
 297     @Test
 298     public void handleMapRequest__MultipleEIDs() throws Exception {
 299
 300         mapRequest = getDefaultMapRequestBuilder();
 301         mapRequest.getEidRecord().add(
 302                 new EidRecordBuilder().setMask((short) 32).setLispAddressContainer(v4Address).build());
 303         mapRequest.getEidRecord().add(
 304                 new EidRecordBuilder().setMask((short) 128).setLispAddressContainer(v6Address).build());
 305
 306         EidToLocatorRecordBuilder record1 = getDefaultEidToLocatorBuilder();
 307         record1.setLispAddressContainer(v4Address);
 308         record1.setRecordTtl(100);
 309
 310         LocatorRecordBuilder locator1 = getDefaultLocatorBuilder();
 311         locator1.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1")));
 312         record1.getLocatorRecord().add(locator1.build());
 313
 314         EidToLocatorRecordBuilder record2 = getDefaultEidToLocatorBuilder();
 315         record2.setLispAddressContainer(v6Address);
 316         record2.setMaskLength((short) 128);
 317         record2.setRecordTtl(100);
 318
 319         LocatorRecordBuilder locator2 = getDefaultLocatorBuilder();
 320         locator2.setLispAddressContainer(LispAFIConvertor.toContainer(LispAFIConvertor.asIPv6AfiAddress("0:0:0:0:0:0:0:1")));
 321         record2.getLocatorRecord().add(locator2.build());
 322
 323         prepareMapping(record1.build(), record2.build());
 324
 325         MapReply mapReply = testedMapResolver.handleMapRequest(mapRequest.build());
 326
 327         EidToLocatorRecord eidToLocators1 = mapReply.getEidToLocatorRecord().get(0);
 328         assertEquals(1, eidToLocators1.getLocatorRecord().size());
 329         assertLocator(LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("4.3.2.1")), eidToLocators1
 330                 .getLocatorRecord().get(0));
 331
 332         EidToLocatorRecord eidToLocators2 = mapReply.getEidToLocatorRecord().get(1);
 333         assertEquals(1, eidToLocators2.getLocatorRecord().size());
 334         assertLocator(LispAFIConvertor.toContainer(LispAFIConvertor.asIPv6AfiAddress("0:0:0:0:0:0:0:1")), eidToLocators2
 335                 .getLocatorRecord().get(0));
 336     }
 337
 338     private void assertLocator(LispAddressContainer expectedAddress, LocatorRecord locatorRecord) {
 339         assertEquals(expectedAddress, locatorRecord.getLispAddressContainer());
 340         Assert.assertTrue(locatorRecord.isRouted());
 341     }
 342
 343     private Map<String, EidToLocatorRecord> prepareMapping(EidToLocatorRecord... records) {
 344         if (records.length > 0) {
 345             for (EidToLocatorRecord eidToLocatorRecord : records) {
 346                 Map<String, EidToLocatorRecord> result = new HashMap<String, EidToLocatorRecord>();
 347                 result.put(SubKeys.RECORD, eidToLocatorRecord);
 348
 349                 daoResults.put(eidToLocatorRecord.getLispAddressContainer(), result);
 350             }
 351         }
 352
 353         ValueSaverAction<LispAddressContainer> daoGetSaverAction = new ValueSaverAction<LispAddressContainer>() {
 354             @Override
 355             protected boolean validate(LispAddressContainer value) {
 356                 return true;
 357             }
 358
 359             @Override
 360             public Object invoke(Invocation invocation) throws Throwable {
 361                 return daoResults.get(lastValue);
 362             }
 363         };
 364
 365         allowing(dao).get(with(daoGetSaverAction));
 366         will(daoGetSaverAction);
 367         allowing(dao).getSpecific(wany(LispAddressContainer.class), with(SubKeys.AUTH_KEY));
 368
 369         return daoResults.get(v4Address);
 370     }
 371
 372     private MapRequestBuilder getDefaultMapRequestBuilder() {
 373         MapRequestBuilder mrBuilder = new MapRequestBuilder();
 374         mrBuilder.setAuthoritative(false);
 375         mrBuilder.setEidRecord(new ArrayList<EidRecord>());
 376         mrBuilder.setItrRloc(new ArrayList<ItrRloc>());
 377         mrBuilder.setMapDataPresent(true);
 378         mrBuilder.setNonce((long) 0);
 379         mrBuilder.setPitr(false);
 380         mrBuilder.setProbe(false);
 381         mrBuilder.setSmr(false);
 382         mrBuilder.setSmrInvoked(true);
 383         mrBuilder.setSourceEid(new SourceEidBuilder().setLispAddressContainer(
 384                 LispAFIConvertor.toContainer(LispAFIConvertor.asIPAfiAddress("127.0.0.1"))).build());
 385         return mrBuilder;
 386     }
 387
 388     private EidToLocatorRecordBuilder getDefaultEidToLocatorBuilder() {
 389         EidToLocatorRecordBuilder builder = new EidToLocatorRecordBuilder();
 390         builder.setAction(Action.NoAction);
 391         builder.setAuthoritative(false);
 392         builder.setLocatorRecord(new ArrayList<LocatorRecord>());
 393         builder.setMapVersion((short) 0);
 394         builder.setMaskLength((short) 32);
 395         builder.setRecordTtl(60);
 396         return builder;
 397     }
 398
 399     private LocatorRecordBuilder getDefaultLocatorBuilder() {
 400         LocatorRecordBuilder builder = new LocatorRecordBuilder();
 401         builder.setLocalLocator(false);
 402         builder.setMulticastPriority((short) 0);
 403         builder.setMulticastWeight((short) 0);
 404         builder.setPriority((short) 0);
 405         builder.setRlocProbed(false);
 406         builder.setRouted(true);
 407         builder.setWeight((short) 0);
 408         return builder;
 409     }
 410
 411 }