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