mappingservice/implementation/src/test/java/org/opendaylight/lispflowmapping/implementation/util/MappingMergeUtilTest.java

   1 /*
   2  * Copyright (c) 2016 Cisco Systems, 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.util;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertFalse;
  12 import static org.junit.Assert.assertNotEquals;
  13 import static org.junit.Assert.assertNull;
  14 import static org.junit.Assert.assertTrue;
  15
  16 import com.google.common.collect.Lists;
  17 import com.google.common.collect.Sets;
  18
  19 import java.util.ArrayList;
  20 import java.util.Date;
  21 import java.util.Iterator;
  22 import java.util.List;
  23 import java.util.Set;
  24
  25 import org.junit.Test;
  26 import org.mockito.Mockito;
  27 import org.opendaylight.lispflowmapping.implementation.config.ConfigIni;
  28 import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.IpAddressBinary;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.Ipv4AddressBinary;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.SiteId;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.XtrId;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.Eid;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecord;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.locatorrecords.LocatorRecordBuilder;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.MappingRecord;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container
  38         .MappingRecordBuilder;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.rloc.container.Rloc;
  40
  41 public class MappingMergeUtilTest {
  42
  43     private static final String IPV4_STRING_1 =         "1.2.3.0";
  44     private static final String IPV4_STRING_2 =         "1.2.4.0";
  45     private static final String IPV4_STRING_3 =         "1.2.5.0";
  46     private static final String IPV4_STRING_4 =         "1.2.6.0";
  47     private static final String IPV6_STRING =           "1111:2222:3333:4444:5555:6666:7777:8888";
  48     private static final String IPV4_RLOC_STRING_1 =    "101.101.101.101";
  49     private static final String IPV4_RLOC_STRING_2 =    "102.102.102.102";
  50     private static final String IPV4_RLOC_STRING_3 =    "103.103.103.103";
  51     private static final String IPV4_RLOC_STRING_4 =    "104.104.104.104";
  52     private static final String IPV4_STRING_PREFIX_24 = "/24";
  53     private static final String IPV4_STRING_PREFIX_16 = "/16";
  54     private static final String IPV6_STRING_PREFIX =    "/96";
  55     private static final Eid IPV4_PREFIX_EID_1 = LispAddressUtil.asIpv4PrefixEid(IPV4_STRING_1 + IPV4_STRING_PREFIX_24);
  56     private static final Eid IPV4_PREFIX_EID_2 = LispAddressUtil.asIpv4PrefixEid(IPV4_STRING_2 + IPV4_STRING_PREFIX_16);
  57     private static final Eid IPV6_PREFIX_EID = LispAddressUtil.asIpv6PrefixEid(IPV6_STRING + IPV6_STRING_PREFIX);
  58     private static final Eid IPV4_EID_1 = LispAddressUtil.asIpv4Eid(IPV4_STRING_1);
  59     private static final Eid IPV4_EID_2 = LispAddressUtil.asIpv4Eid(IPV4_STRING_2);
  60     private static final Eid SOURCE_DEST_KEY_EID_1 = LispAddressUtil
  61             .asSrcDstEid(IPV4_STRING_3, IPV4_STRING_4, 24, 16, 1);
  62     private static final Rloc IPV4_RLOC_1 = LispAddressUtil.asIpv4Rloc(IPV4_RLOC_STRING_1);
  63     private static final Rloc IPV4_RLOC_2 = LispAddressUtil.asIpv4Rloc(IPV4_RLOC_STRING_2);
  64     private static final Rloc IPV4_RLOC_3 = LispAddressUtil.asIpv4Rloc(IPV4_RLOC_STRING_3);
  65     private static final Rloc IPV4_RLOC_4 = LispAddressUtil.asIpv4Rloc(IPV4_RLOC_STRING_4);
  66     private static final IpAddressBinary IPV4_SOURCE_RLOC_1 = new IpAddressBinary(
  67             new Ipv4AddressBinary(new byte[] {1, 1, 1, 1}));
  68     private static final IpAddressBinary IPV4_SOURCE_RLOC_2 = new IpAddressBinary(
  69             new Ipv4AddressBinary(new byte[] {2, 2, 2, 2}));
  70     private static final IpAddressBinary IPV4_SOURCE_RLOC_3 = new IpAddressBinary(
  71             new Ipv4AddressBinary(new byte[] {3, 3, 3, 3}));
  72
  73     private static final String LOCATOR_ID_STRING = "locator-id";
  74
  75     private static final XtrId XTR_ID_1 = new XtrId(new byte[] {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1});
  76     private static final XtrId XTR_ID_2 = new XtrId(new byte[] {2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2});
  77     private static final XtrId XTR_ID_3 = new XtrId(new byte[] {3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3});
  78
  79     private static final SiteId SITE_ID_1 = new SiteId(new byte[]{1, 1, 1, 1, 1, 1, 1, 1});
  80     private static final SiteId SITE_ID_2 = new SiteId(new byte[]{2, 2, 2, 2, 2, 2, 2, 2});
  81
  82     private static final long REGISTRATION_VALIDITY = ConfigIni.getInstance().getRegistrationValiditySb();
  83
  84     /**
  85      * Tests {@link MappingMergeUtil#mergeLocatorRecords} method with a new LocatorRecord equal to current
  86      * LocatorRecord and null XtrId.
  87      */
  88     @Test
  89     public void mergeLocatorRecordsTest_withSingleEqualLocator() {
  90         // current locator record
  91         final LocatorRecord currentLocatorRecord_1 = new LocatorRecordBuilder() // locator equals to newLocatorRecord_1
  92                 .setRloc(IPV4_RLOC_1)
  93                 .setLocatorId(LOCATOR_ID_STRING).build();
  94
  95         final MappingRecordBuilder currentMergedMappingBuilder = getDefaultMappingRecordBuilder();
  96         currentMergedMappingBuilder.getLocatorRecord().add(currentLocatorRecord_1);
  97
  98         // new locator record
  99         final LocatorRecord newLocatorRecord_1 = new LocatorRecordBuilder()
 100                 .setRloc(IPV4_RLOC_1)
 101                 .setLocatorId(LOCATOR_ID_STRING).build();
 102
 103         final MappingRecordBuilder newMappingRecordBuilder = getDefaultMappingRecordBuilder().setEid(IPV4_PREFIX_EID_2)
 104                 .setLocatorRecord(Lists.newArrayList())
 105                 .setXtrId(XTR_ID_2)
 106                 .setRecordTtl(1)
 107                 .setSiteId(SITE_ID_2);
 108         newMappingRecordBuilder.getLocatorRecord().add(newLocatorRecord_1);
 109
 110         // expected result
 111         MappingRecordBuilder mrb = new MappingRecordBuilder(currentMergedMappingBuilder.build())
 112                 .setXtrId(XTR_ID_2)
 113                 .setRecordTtl(1)
 114                 .setSiteId(SITE_ID_2);
 115
 116         MappingRecord result = MappingMergeUtil.mergeMappings
 117                 (currentMergedMappingBuilder.build(), newMappingRecordBuilder.build(), null, null);
 118         assertEquals(mrb.build(),result);
 119     }
 120
 121     /**
 122      * Tests {@link MappingMergeUtil#mergeLocatorRecords} method with a new LocatorRecord not equal to current
 123      * LocatorRecord but same Rloc, where current locator is local. XtrId is null.
 124      */
 125     @Test
 126     public void mergeLocatorRecordsTest_withSingleSameRloc_currentIsLocal() {
 127         // current locator record
 128         final LocatorRecord currentLocatorRecord_1 = new LocatorRecordBuilder() // Rloc equals to Rloc in
 129                 .setRloc(IPV4_RLOC_1)                                           // newLocatorRecord_1
 130                 .setLocatorId(LOCATOR_ID_STRING)
 131                 .setLocalLocator(true).build();                                 // local locator set to true
 132
 133         final MappingRecordBuilder currentMergedMappingBuilder = getDefaultMappingRecordBuilder();
 134         currentMergedMappingBuilder.getLocatorRecord().add(currentLocatorRecord_1);
 135
 136         // new locator record
 137         final LocatorRecord newLocatorRecord_1 = new LocatorRecordBuilder()
 138                 .setRloc(IPV4_RLOC_1)
 139                 .setLocatorId("locator-id-1").build();                          // different locator id
 140
 141         final MappingRecordBuilder newMappingRecordBuilder = getDefaultMappingRecordBuilder().setEid(IPV4_PREFIX_EID_2)
 142                 .setLocatorRecord(Lists.newArrayList())
 143                 .setXtrId(XTR_ID_2)
 144                 .setRecordTtl(1)
 145                 .setSiteId(SITE_ID_2);
 146         newMappingRecordBuilder.getLocatorRecord().add(newLocatorRecord_1);
 147
 148         // expected result
 149         MappingRecordBuilder mrb = new MappingRecordBuilder(getDefaultMappingRecordBuilder()
 150                     .setTimestamp(currentMergedMappingBuilder.getTimestamp()).build())
 151                 .setXtrId(XTR_ID_2)
 152                 .setRecordTtl(1)
 153                 .setSiteId(SITE_ID_2);
 154         mrb.getLocatorRecord().add(currentLocatorRecord_1);
 155
 156         MappingRecord result = MappingMergeUtil.mergeMappings
 157                 (currentMergedMappingBuilder.build(), newMappingRecordBuilder.build(), null, null);
 158         assertEquals(mrb.build(),result);
 159     }
 160
 161     /**
 162      * Tests {@link MappingMergeUtil#mergeLocatorRecords} method with a new LocatorRecord not equal to current
 163      * LocatorRecord but same Rloc, where current locator is not local. XtrId is null.
 164      */
 165     @Test
 166     public void mergeLocatorRecordsTest_withSingleSameRloc_currentIsNotLocal() {
 167         // current locator record
 168         final long timestamp = 1L;
 169         final LocatorRecord currentLocatorRecord_1 = new LocatorRecordBuilder() // Rloc equals to Rloc in
 170                 .setRloc(IPV4_RLOC_1)                                           // newLocatorRecord_1
 171                 .setLocatorId(LOCATOR_ID_STRING)
 172                 .setLocalLocator(false).build();                                // local locator set to false
 173
 174         final MappingRecordBuilder currentMergedMappingBuilder = getDefaultMappingRecordBuilder()
 175                 .setTimestamp(timestamp);
 176         currentMergedMappingBuilder.getLocatorRecord().add(currentLocatorRecord_1);
 177
 178         // new locator record
 179         final LocatorRecord newLocatorRecord_1 = new LocatorRecordBuilder()
 180                 .setRloc(IPV4_RLOC_1)
 181                 .setLocatorId("locator-id-1").build();                          // different locator id
 182
 183         final MappingRecordBuilder newMappingRecordBuilder = getDefaultMappingRecordBuilder().setEid(IPV4_PREFIX_EID_2)
 184                 .setLocatorRecord(Lists.newArrayList())
 185                 .setXtrId(XTR_ID_2)
 186                 .setRecordTtl(1)
 187                 .setSiteId(SITE_ID_2);
 188         newMappingRecordBuilder.getLocatorRecord().add(newLocatorRecord_1);
 189
 190         // expected result
 191         MappingRecordBuilder mrb = new MappingRecordBuilder(getDefaultMappingRecordBuilder().build())
 192                 .setXtrId(XTR_ID_2)
 193                 .setRecordTtl(1)
 194                 .setSiteId(SITE_ID_2).setTimestamp(timestamp);
 195         mrb.getLocatorRecord().add(newLocatorRecord_1);
 196
 197         MappingRecord result = MappingMergeUtil.mergeMappings
 198                 (currentMergedMappingBuilder.build(), newMappingRecordBuilder.build(), null, null);
 199         assertEquals(mrb.build(),result);
 200     }
 201
 202     /**
 203      * Tests {@link MappingMergeUtil#mergeLocatorRecords} method with different Rlocs. XtrId is null.
 204      */
 205     @Test
 206     public void mergeLocatorRecordsTest_withSingleDifferentRloc() {
 207         // current locator record
 208         final LocatorRecord currentLocatorRecord_1 = new LocatorRecordBuilder() // different locator record
 209                 .setRloc(IPV4_RLOC_1)
 210                 .setLocatorId(LOCATOR_ID_STRING).build();
 211
 212         final MappingRecordBuilder currentMergedMappingBuilder = getDefaultMappingRecordBuilder();
 213         currentMergedMappingBuilder.getLocatorRecord().add(currentLocatorRecord_1);
 214
 215         // new locator record
 216         final LocatorRecord newLocatorRecord_1 = new LocatorRecordBuilder() // different locator record
 217                 .setRloc(IPV4_RLOC_2)
 218                 .setLocatorId("locator-id-1").build();
 219
 220         final MappingRecordBuilder newMappingRecordBuilder = getDefaultMappingRecordBuilder().setEid(IPV4_PREFIX_EID_2)
 221                 .setLocatorRecord(Lists.newArrayList())
 222                 .setXtrId(XTR_ID_2)
 223                 .setRecordTtl(1)
 224                 .setSiteId(SITE_ID_2);
 225         newMappingRecordBuilder.getLocatorRecord().add(newLocatorRecord_1);
 226
 227         // expected result
 228         MappingRecordBuilder mrb = new MappingRecordBuilder(getDefaultMappingRecordBuilder().build())
 229                 .setXtrId(XTR_ID_2)
 230                 .setRecordTtl(1)
 231                 .setSiteId(SITE_ID_2)
 232                 .setTimestamp(currentMergedMappingBuilder.getTimestamp());
 233         mrb.getLocatorRecord().add(currentLocatorRecord_1);
 234         mrb.getLocatorRecord().add(newLocatorRecord_1);
 235
 236         MappingRecord result = MappingMergeUtil.mergeMappings
 237                 (currentMergedMappingBuilder.build(), newMappingRecordBuilder.build(), null, null);
 238         assertEquals(mrb.build(),result);
 239     }
 240
 241     /**
 242      * Tests {@link MappingMergeUtil#mergeMappings} method with multiple locator records. We assume that
 243      * provided lists of locator records are pre-ordered.
 244      */
 245     @Test
 246     public void mergeMappingsTest_withMultipleSortedLocatorRecords() {
 247         // current locator records
 248         final LocatorRecord currentLocatorRecord_1 = new LocatorRecordBuilder()
 249                 .setRloc(IPV4_RLOC_1)
 250                 .setLocatorId(LOCATOR_ID_STRING).build();
 251
 252         final LocatorRecord currentLocatorRecord_3 = new LocatorRecordBuilder()
 253                 .setRloc(IPV4_RLOC_3)
 254                 .setLocatorId(LOCATOR_ID_STRING).build();
 255
 256         final MappingRecordBuilder currentMergedMappingBuilder = getDefaultMappingRecordBuilder();
 257         currentMergedMappingBuilder.getLocatorRecord().add(currentLocatorRecord_1);
 258         currentMergedMappingBuilder.getLocatorRecord().add(currentLocatorRecord_3);
 259
 260         // new locator records
 261         final LocatorRecord newLocatorRecord_2 = new LocatorRecordBuilder()
 262                 .setRloc(IPV4_RLOC_2)
 263                 .setLocatorId(LOCATOR_ID_STRING).build();
 264
 265         final LocatorRecord newLocatorRecord_4 = new LocatorRecordBuilder()
 266                 .setRloc(IPV4_RLOC_4)
 267                 .setLocatorId(LOCATOR_ID_STRING).build();
 268
 269         final MappingRecordBuilder newMappingRecordBuilder = getDefaultMappingRecordBuilder().setEid(IPV4_PREFIX_EID_2)
 270                 .setLocatorRecord(Lists.newArrayList())
 271                 .setXtrId(XTR_ID_2)
 272                 .setRecordTtl(1)
 273                 .setSiteId(SITE_ID_2);
 274         newMappingRecordBuilder.getLocatorRecord().add(newLocatorRecord_2);
 275         newMappingRecordBuilder.getLocatorRecord().add(newLocatorRecord_4);
 276         final Date timestamp = new Date();
 277
 278         // expected result
 279         MappingRecordBuilder mrb = new MappingRecordBuilder(getDefaultMappingRecordBuilder().build())
 280                 .setXtrId(XTR_ID_3)
 281                 .setTimestamp(timestamp.getTime())
 282                 .setRecordTtl(1)
 283                 .setSiteId(SITE_ID_2);
 284         mrb.getLocatorRecord().add(currentLocatorRecord_1);
 285         mrb.getLocatorRecord().add(newLocatorRecord_2);
 286         mrb.getLocatorRecord().add(currentLocatorRecord_3);
 287         mrb.getLocatorRecord().add(newLocatorRecord_4);
 288
 289         MappingRecord result = MappingMergeUtil.mergeMappings
 290                 (currentMergedMappingBuilder.build(), newMappingRecordBuilder.build(), XTR_ID_3, timestamp);
 291         assertEquals(mrb.build(),result);
 292     }
 293
 294     /**
 295      * Tests {@link MappingMergeUtil#mergeMappings} method with multiple locator records. We assume that
 296      * provided lists of locator records are not sorted. Test returns inconsistent results based on the order of
 297      * the items.
 298      */
 299     @Test
 300     public void mergeLocatorRecordsTest_withMultipleUnsortedLocatorRecords() {
 301         // current locator records
 302         final LocatorRecord currentLocatorRecord_1 = new LocatorRecordBuilder() // locator equals to newLocatorRecord_1
 303                 .setRloc(IPV4_RLOC_1)
 304                 .setLocatorId(LOCATOR_ID_STRING).build();
 305
 306         final LocatorRecord currentLocatorRecord_2 = new LocatorRecordBuilder() // Rloc equals to Rloc in
 307                 .setRloc(IPV4_RLOC_2)                                           // newLocatorRecord_2
 308                 .setLocatorId(LOCATOR_ID_STRING)
 309                 .setLocalLocator(false).build();                                // local locator set to false
 310
 311         final LocatorRecord currentLocatorRecord_3 = new LocatorRecordBuilder()
 312                 .setRloc(IPV4_RLOC_4)
 313                 .setLocatorId(LOCATOR_ID_STRING).build();
 314
 315         final MappingRecordBuilder currentMergedMappingBuilder = getDefaultMappingRecordBuilder();
 316         currentMergedMappingBuilder.getLocatorRecord().add(currentLocatorRecord_3);
 317         currentMergedMappingBuilder.getLocatorRecord().add(currentLocatorRecord_2);
 318         currentMergedMappingBuilder.getLocatorRecord().add(currentLocatorRecord_1);
 319
 320         // new locator records
 321         final LocatorRecord newLocatorRecord_1 = new LocatorRecordBuilder()
 322                 .setRloc(IPV4_RLOC_1)
 323                 .setLocatorId(LOCATOR_ID_STRING).build();
 324
 325         final LocatorRecord newLocatorRecord_2 = new LocatorRecordBuilder()
 326                 .setRloc(IPV4_RLOC_2)
 327                 .setLocatorId(LOCATOR_ID_STRING + "-1").build();
 328
 329         final LocatorRecord newLocatorRecord_3 = new LocatorRecordBuilder() // new Rloc
 330                 .setRloc(IPV4_RLOC_3)
 331                 .setLocatorId(LOCATOR_ID_STRING).build();
 332
 333         final MappingRecordBuilder newMappingRecordBuilder = getDefaultMappingRecordBuilder().setEid(IPV4_PREFIX_EID_2)
 334                 .setLocatorRecord(Lists.newArrayList())
 335                 .setXtrId(XTR_ID_2)
 336                 .setRecordTtl(1)
 337                 .setSiteId(SITE_ID_2);
 338         newMappingRecordBuilder.getLocatorRecord().add(newLocatorRecord_3);
 339         newMappingRecordBuilder.getLocatorRecord().add(newLocatorRecord_2);
 340         newMappingRecordBuilder.getLocatorRecord().add(newLocatorRecord_1);
 341         final Date timestamp = new Date();
 342
 343         // expected result
 344         MappingRecordBuilder mrb = new MappingRecordBuilder(getDefaultMappingRecordBuilder().build())
 345                 .setXtrId(XTR_ID_3)
 346                 .setTimestamp(timestamp.getTime())
 347                 .setRecordTtl(1)
 348                 .setSiteId(SITE_ID_2);
 349         mrb.getLocatorRecord().add(currentLocatorRecord_1);
 350         mrb.getLocatorRecord().add(newLocatorRecord_2);
 351         mrb.getLocatorRecord().add(newLocatorRecord_3);
 352         mrb.getLocatorRecord().add(currentLocatorRecord_3);
 353
 354         MappingRecord result = MappingMergeUtil.mergeMappings
 355                 (currentMergedMappingBuilder.build(), newMappingRecordBuilder.build(), XTR_ID_3, timestamp);
 356         assertNotEquals(mrb.build(),result);
 357     }
 358
 359     /**
 360      * Tests {@link MappingMergeUtil#mergeMappings} method for setting the correct XtrId.
 361      */
 362     @Test
 363     public void mergeMappingsTest_withSingleEqualLocator_XtrIdNotNull() {
 364         // current locator record
 365         final LocatorRecord currentLocatorRecord_1 = new LocatorRecordBuilder() // locator equals to newLocatorRecord_1
 366                 .setRloc(IPV4_RLOC_1)
 367                 .setLocatorId(LOCATOR_ID_STRING).build();
 368
 369         final MappingRecordBuilder currentMergedMappingBuilder = getDefaultMappingRecordBuilder();
 370         currentMergedMappingBuilder.getLocatorRecord().add(currentLocatorRecord_1);
 371
 372         // new locator record
 373         final LocatorRecord newLocatorRecord_1 = new LocatorRecordBuilder()
 374                 .setRloc(IPV4_RLOC_1)
 375                 .setLocatorId(LOCATOR_ID_STRING).build();
 376
 377         final MappingRecordBuilder newMappingRecordBuilder = getDefaultMappingRecordBuilder().setEid(IPV4_PREFIX_EID_2)
 378                 .setLocatorRecord(Lists.newArrayList())
 379                 .setXtrId(XTR_ID_2)
 380                 .setRecordTtl(1)
 381                 .setSiteId(SITE_ID_2);
 382         newMappingRecordBuilder.getLocatorRecord().add(newLocatorRecord_1);
 383
 384         // result
 385         MappingRecord result = MappingMergeUtil.mergeMappings
 386                 (currentMergedMappingBuilder.build(), newMappingRecordBuilder.build(), XTR_ID_3, new Date(100L));
 387         assertEquals(XTR_ID_3, result.getXtrId());
 388         assertEquals((Long) 100L, result.getTimestamp());
 389     }
 390
 391     /**
 392      * Tests {@link MappingMergeUtil#mergeMappings} method with newMapping == null. Should throw an NPE.
 393      */
 394     @Test(expected = NullPointerException.class)
 395     public void mergeMappingsTest_withNewMappingNull() {
 396         // current locator record
 397         final LocatorRecord currentLocatorRecord_1 = new LocatorRecordBuilder()             // same locator
 398                 .setRloc(IPV4_RLOC_1)
 399                 .setLocatorId(LOCATOR_ID_STRING).build();
 400
 401         final MappingRecordBuilder currentMergedMappingBuilder = getDefaultMappingRecordBuilder();
 402         currentMergedMappingBuilder.getLocatorRecord().add(currentLocatorRecord_1);
 403
 404         MappingMergeUtil.mergeMappings(currentMergedMappingBuilder.build(), null, null, null);
 405     }
 406
 407     /**
 408      * Tests {@link MappingMergeUtil#mergeMappings} method with currentMergedMapping == null.
 409      */
 410     @Test
 411     public void mergeMappingsTest_withNullCurrentMergedMapping() {
 412         MappingRecord newMapping = Mockito.mock(MappingRecord.class);
 413
 414         assertEquals(newMapping, MappingMergeUtil.mergeMappings(null, newMapping, null, null));
 415     }
 416
 417     /**
 418      * Tests {@link MappingMergeUtil#mergeXtrIdMappings} method with two expired mappings.
 419      */
 420     @Test
 421     public void mergeXtrIdMappingsTest_verifyExpiredMappings() {
 422         MappingRecord expiredMappingRecord_1 = getDefaultMappingRecordBuilder().setTimestamp(1L).build();
 423         MappingRecord expiredMappingRecord_2 = getDefaultMappingRecordBuilder()
 424                 .setXtrId(XTR_ID_2)
 425                 .setTimestamp(1L).build();
 426         List<XtrId> expiredMappings = Lists.newArrayList();
 427         List<Object> mappingRecords =
 428                 Lists.newArrayList(expiredMappingRecord_1, expiredMappingRecord_2);
 429
 430         assertNull(MappingMergeUtil.mergeXtrIdMappings(mappingRecords, expiredMappings, null));
 431         assertEquals(2, expiredMappings.size());
 432         assertTrue(expiredMappings.contains(XTR_ID_1));
 433         assertTrue(expiredMappings.contains(XTR_ID_2));
 434     }
 435
 436     /**
 437      * Tests {@link MappingMergeUtil#mergeXtrIdMappings} method, verifies the oldest timestamp.
 438      */
 439     @Test
 440     public void mergeXtrIdMappingsTest_verifyOldestTimestamp() {
 441         final long timestamp = new Date().getTime();
 442         final long timestamp_1 = timestamp - 200L;
 443         final long timestamp_2 = timestamp - 300L; // oldest mapping
 444         final long timestamp_3 = timestamp - 100L;
 445
 446         final MappingRecord expiredMappingRecord_1 = getDefaultMappingRecordBuilder()
 447                 .setTimestamp(timestamp_1).build();
 448         final MappingRecord expiredMappingRecord_2 = getDefaultMappingRecordBuilder()
 449                 .setSourceRloc(IPV4_SOURCE_RLOC_2)
 450                 .setXtrId(XTR_ID_2)
 451                 .setTimestamp(timestamp_2).build();
 452         final MappingRecord expiredMappingRecord_3 = getDefaultMappingRecordBuilder()
 453                 .setSourceRloc(IPV4_SOURCE_RLOC_3)
 454                 .setXtrId(XTR_ID_3)
 455                 .setTimestamp(timestamp_3).build();
 456
 457         Set<IpAddressBinary> sourceRlocs = Sets.newHashSet();
 458         final List<XtrId> expiredMappings = Lists.newArrayList();
 459         final List<Object> mappingRecords =
 460                 Lists.newArrayList(expiredMappingRecord_1, expiredMappingRecord_2, expiredMappingRecord_3);
 461
 462         // result
 463         MappingRecord result = MappingMergeUtil.mergeXtrIdMappings(mappingRecords, expiredMappings, sourceRlocs);
 464         assertEquals(timestamp_2, (long) result.getTimestamp());
 465         assertEquals(XTR_ID_2, result.getXtrId());
 466
 467         assertTrue(sourceRlocs.size() == 3);
 468         assertTrue(sourceRlocs.contains(IPV4_SOURCE_RLOC_1));
 469         assertTrue(sourceRlocs.contains(IPV4_SOURCE_RLOC_2));
 470         assertTrue(sourceRlocs.contains(IPV4_SOURCE_RLOC_3));
 471
 472         assertTrue(expiredMappings.isEmpty());
 473     }
 474
 475     /**
 476      * Tests {@link MappingMergeUtil#mappingIsExpired} method.
 477      */
 478     @Test
 479     public void mappingIsExpiredTest() {
 480         long timestamp = new Date().getTime();
 481         MappingRecordBuilder mappingRecordBuilder = getDefaultMappingRecordBuilder();
 482         assertTrue(MappingMergeUtil.mappingIsExpired(mappingRecordBuilder
 483                 .setTimestamp(timestamp - (REGISTRATION_VALIDITY + 1L)).build()));
 484         assertFalse(MappingMergeUtil.mappingIsExpired(mappingRecordBuilder.setTimestamp(timestamp).build()));
 485         assertFalse(MappingMergeUtil.mappingIsExpired(mappingRecordBuilder.setTimestamp(null).build()));
 486     }
 487
 488     /**
 489      * Tests {@link MappingMergeUtil#mappingIsExpired} method, throws NPE.
 490      */
 491     @Test(expected = NullPointerException.class)
 492     public void mappingIsExpiredTest_throwsNPE() {
 493         MappingMergeUtil.mappingIsExpired(null);
 494     }
 495
 496     /**
 497      * Tests {@link MappingMergeUtil#timestampIsExpired} method, throws NPE.
 498      */
 499     @Test(expected = NullPointerException.class)
 500     public void timestampIsExpiredTest_withDate_throwsNPE() {
 501         Date date = null;
 502         MappingMergeUtil.timestampIsExpired(date);
 503     }
 504
 505     /**
 506      * Tests {@link MappingMergeUtil#timestampIsExpired} method, throws NPE.
 507      */
 508     @Test
 509     public void timestampIsExpiredTest_withDate() {
 510         long timestamp = new Date().getTime();
 511         assertTrue(MappingMergeUtil.timestampIsExpired(new Date(timestamp - (REGISTRATION_VALIDITY + 1L))));
 512         assertFalse(MappingMergeUtil.timestampIsExpired(new Date(timestamp)));
 513     }
 514
 515     /**
 516      * Tests {@link MappingMergeUtil#computeNbSbIntersection} method, Nb mask greater than SB mask.
 517      */
 518     @Test
 519     public void computeNbSbIntersectionTest_withMaskableIpv4PrefixEIDs_() {
 520         MappingRecord NBmappingRecord = getDefaultMappingRecordBuilder().setEid(IPV4_PREFIX_EID_1).build();
 521         MappingRecord SBmappingRecord = getDefaultMappingRecordBuilder().setEid(IPV4_PREFIX_EID_2).build();
 522
 523         // result
 524         MappingRecord result = (MappingRecord) MappingMergeUtil
 525                 .computeNbSbIntersection(NBmappingRecord, SBmappingRecord);
 526
 527         assertEquals(IPV4_PREFIX_EID_1, result.getEid());
 528     }
 529
 530     /**
 531      * Tests {@link MappingMergeUtil#computeNbSbIntersection} method, Nb mask less than SB mask.
 532      */
 533     @Test
 534     public void computeNbSbIntersectionTest_withMaskableIpv4PrefixEIDs() {
 535         MappingRecord NBmappingRecord = getDefaultMappingRecordBuilder().setEid(IPV4_PREFIX_EID_2).build();
 536         MappingRecord SBmappingRecord = getDefaultMappingRecordBuilder().setEid(IPV4_PREFIX_EID_1).build();
 537
 538         // result
 539         MappingRecord result = (MappingRecord) MappingMergeUtil
 540                 .computeNbSbIntersection(NBmappingRecord, SBmappingRecord);
 541
 542         assertEquals(IPV4_PREFIX_EID_1, result.getEid());
 543     }
 544
 545     /**
 546      * Tests {@link MappingMergeUtil#computeNbSbIntersection} method with SourceDestKey Eid address type, Ipv4Prefix
 547      * SB Eid, Nb mask less than SB mask.
 548      */
 549     @Test
 550     public void computeNbSbIntersectionTest_withMaskableSourceDestKeyEIDs_Ipv4SB() {
 551         MappingRecord NBmappingRecord = getDefaultMappingRecordBuilder().setEid(SOURCE_DEST_KEY_EID_1).build();
 552         MappingRecord SBmappingRecord = getDefaultMappingRecordBuilder().setEid(IPV4_PREFIX_EID_1).build();
 553
 554         // result
 555         final MappingRecord result = (MappingRecord) MappingMergeUtil
 556                 .computeNbSbIntersection(NBmappingRecord, SBmappingRecord);
 557         final Eid eid = LispAddressUtil.asSrcDstEid(IPV4_STRING_3 ,IPV4_STRING_1 ,24 , 24, 1);
 558
 559         assertEquals(eid, result.getEid());
 560     }
 561
 562     /**
 563      * Tests {@link MappingMergeUtil#computeNbSbIntersection} method with SourceDestKey Eid address type, Ipv6Prefix
 564      * SB Eid, Nb mask less than SB mask.
 565      */
 566     @Test
 567     public void computeNbSbIntersectionTest_withMaskableSourceDestKeyEIDs_Ipv6SB() {
 568         MappingRecord NBmappingRecord = getDefaultMappingRecordBuilder().setEid(SOURCE_DEST_KEY_EID_1).build();
 569         MappingRecord SBmappingRecord = getDefaultMappingRecordBuilder().setEid(IPV6_PREFIX_EID).build();
 570
 571         // result
 572         final MappingRecord result = (MappingRecord) MappingMergeUtil
 573                 .computeNbSbIntersection(NBmappingRecord, SBmappingRecord);
 574         final Eid eid = LispAddressUtil.asSrcDstEid(IPV4_STRING_3 ,IPV6_STRING ,24 , 96, 1);
 575
 576         assertEquals(eid, result.getEid());
 577     }
 578
 579     /**
 580      * Tests {@link MappingMergeUtil#getCommonLocatorRecords} method with empty list of locator records.
 581      */
 582     @Test
 583     public void getCommonLocatorRecords_withEmptyLocatorRecords() {
 584         MappingRecord NBmappingRecord = getDefaultMappingRecordBuilder().setEid(IPV4_EID_2).build();
 585         MappingRecord SBmappingRecord = getDefaultMappingRecordBuilder().setEid(IPV4_EID_1).build();
 586
 587         // result
 588         MappingRecord result = (MappingRecord) MappingMergeUtil
 589                 .computeNbSbIntersection(NBmappingRecord, SBmappingRecord);
 590         assertEquals(0, result.getLocatorRecord().size());
 591     }
 592
 593     /**
 594      * Tests {@link MappingMergeUtil#getCommonLocatorRecords} method with list of locator records == null.
 595      */
 596     @Test
 597     public void getCommonLocatorRecords_withNullLocatorRecords() {
 598         MappingRecord NBmappingRecord = getDefaultMappingRecordBuilder().setLocatorRecord(null).build();
 599         MappingRecord SBmappingRecord = getDefaultMappingRecordBuilder().setLocatorRecord(null).build();
 600
 601         // result
 602         MappingRecord result = (MappingRecord) MappingMergeUtil
 603                 .computeNbSbIntersection(NBmappingRecord, SBmappingRecord);
 604         assertNull(result.getLocatorRecord());
 605     }
 606
 607     /**
 608      * Tests {@link MappingMergeUtil#getCommonLocatorRecords} method, verifies that NB common locator's priority is set
 609      * to correct value (based on SB locator's priority).
 610      */
 611     @Test
 612     public void getCommonLocatorRecords_priorityCheck() {
 613         LocatorRecordBuilder NBlocatorRecordBuilder_1 = new LocatorRecordBuilder()
 614                 .setRloc(IPV4_RLOC_1)
 615                 .setPriority((short) 1)
 616                 .setLocatorId("NB-locator-id");
 617         LocatorRecordBuilder SBlocatorRecordBuilder_1 = new LocatorRecordBuilder()
 618                 .setRloc(IPV4_RLOC_1)
 619                 .setPriority((short) 255)
 620                 .setLocatorId("SB-locator-id");
 621
 622         LocatorRecordBuilder NBlocatorRecordBuilder_2 = new LocatorRecordBuilder()
 623                 .setRloc(IPV4_RLOC_2)
 624                 .setPriority((short) 1)
 625                 .setLocatorId("NB-locator-id");
 626         LocatorRecordBuilder SBlocatorRecordBuilder_2 = new LocatorRecordBuilder()
 627                 .setRloc(IPV4_RLOC_2)
 628                 .setPriority((short) 254)
 629                 .setLocatorId("SB-locator-id");
 630
 631         final MappingRecordBuilder NBmappingRecordBuilder = getDefaultMappingRecordBuilder();
 632         NBmappingRecordBuilder.getLocatorRecord().add(NBlocatorRecordBuilder_1.build());
 633         NBmappingRecordBuilder.getLocatorRecord().add(NBlocatorRecordBuilder_2.build());
 634
 635         final MappingRecordBuilder SBmappingRecordBuilder = getDefaultMappingRecordBuilder();
 636         SBmappingRecordBuilder.getLocatorRecord().add(SBlocatorRecordBuilder_1.build());
 637         SBmappingRecordBuilder.getLocatorRecord().add(SBlocatorRecordBuilder_2.build());
 638
 639         // result
 640         final MappingRecord result = (MappingRecord) MappingMergeUtil
 641                 .computeNbSbIntersection(NBmappingRecordBuilder.build(), SBmappingRecordBuilder.build());
 642         final Iterator<LocatorRecord> iterator = result.getLocatorRecord().iterator();
 643         final LocatorRecord resultLocator_1 = iterator.next();
 644         final LocatorRecord resultLocator_2 = iterator.next();
 645
 646         assertEquals(2, result.getLocatorRecord().size());
 647
 648         assertEquals("NB-locator-id", resultLocator_1.getLocatorId());
 649         assertEquals(255, (short) resultLocator_1.getPriority()); // priority changed to 255
 650
 651         assertEquals("NB-locator-id", resultLocator_2.getLocatorId());
 652         assertEquals(1, (short) resultLocator_2.getPriority());   // priority remains original
 653     }
 654
 655     private static MappingRecordBuilder getDefaultMappingRecordBuilder() {
 656         return new MappingRecordBuilder()
 657                 .setEid(IPV4_PREFIX_EID_1)
 658                 .setLocatorRecord(new ArrayList<>())
 659                 .setRecordTtl(2)
 660                 .setAction(MappingRecord.Action.NativelyForward)
 661                 .setAuthoritative(true)
 662                 .setMapVersion((short) 1)
 663                 .setSiteId(SITE_ID_1)
 664                 .setSourceRloc(IPV4_SOURCE_RLOC_1)
 665                 .setTimestamp(new Date().getTime())
 666                 .setXtrId(XTR_ID_1);
 667     }
 668 }