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