mappingservice/implementation/src/test/java/org/opendaylight/lispflowmapping/implementation/lisp/MapResolverTest.java

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