mappingservice/mapcache/src/test/java/org/opendaylight/lispflowmapping/mapcache/MultiTableMapCacheTest.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.mapcache;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertNull;
  12 import static org.mockito.Mockito.mock;
  13 import static org.mockito.Mockito.verify;
  14 import static org.mockito.Mockito.verifyZeroInteractions;
  15 import static org.mockito.Mockito.when;
  16
  17 import java.util.Map;
  18 import java.util.concurrent.ConcurrentHashMap;
  19 import org.junit.Before;
  20 import org.junit.Test;
  21 import org.mockito.Mockito;
  22 import org.opendaylight.lispflowmapping.interfaces.dao.ILispDAO;
  23 import org.opendaylight.lispflowmapping.interfaces.dao.MappingEntry;
  24 import org.opendaylight.lispflowmapping.interfaces.dao.SubKeys;
  25 import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
  26 import org.opendaylight.lispflowmapping.lisp.util.MaskUtil;
  27 import org.opendaylight.lispflowmapping.lisp.util.SourceDestKeyHelper;
  28 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix;
  29 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
  30 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix;
  31 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.InstanceIdType;
  32 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.SimpleAddress;
  33 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv4Builder;
  34 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.Ipv4PrefixBuilder;
  35 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp.address.types.rev151105.lisp.address.address.SourceDestKeyBuilder;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.Eid;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.EidBuilder;
  38 import org.opendaylight.yangtools.yang.common.Uint32;
  39
  40 public class MultiTableMapCacheTest {
  41
  42     private static MultiTableMapCache multiTableMapCache;
  43     private static ILispDAO daoMock;
  44     private static ILispDAO srcDstDaoMock;
  45     private static ILispDAO tableDaoMock;
  46     private static ILispDAO dbMock;
  47
  48     private static final String IPV4_STRING_1 = "127.0.0.1/24";
  49     private static final String IPV4_STRING_2 = "127.0.0.1/24";
  50     private static final Ipv4Prefix IPV_4_PREFIX_SRC = new Ipv4Prefix(IPV4_STRING_1);
  51     private static final Ipv4Prefix IPV_4_PREFIX_DST = new Ipv4Prefix(IPV4_STRING_2);
  52     private static final long VNI = 100L;
  53
  54     private static final Eid EID_TEST = new EidBuilder().setVirtualNetworkId(new InstanceIdType(Uint32.valueOf(VNI)))
  55             .setAddress(new Ipv4Builder().setIpv4(new Ipv4Address("10.0.0.1")).build()).build();
  56     private static final Eid EID_SOURCE_DEST_KEY_TYPE = new EidBuilder()
  57             .setVirtualNetworkId(new InstanceIdType(Uint32.valueOf(VNI)))
  58             .setAddress(new SourceDestKeyBuilder()
  59                     .setSourceDestKey(new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.lisp
  60                             .address.types.rev151105.lisp.address.address.source.dest.key.SourceDestKeyBuilder()
  61                             .setSource(new SimpleAddress(new IpPrefix(IPV_4_PREFIX_SRC)))
  62                             .setDest(new SimpleAddress(new IpPrefix(IPV_4_PREFIX_DST))).build()).build()).build();
  63     private static final Eid EID_IPV4_PREFIX_SRC = LispAddressUtil.asIpv4PrefixEid(IPV4_STRING_1);
  64     private static final Eid EID_IPV4_PREFIX_DST = new EidBuilder()
  65             .setVirtualNetworkId(new InstanceIdType(Uint32.valueOf(VNI)))
  66             .setAddress(new Ipv4PrefixBuilder().setIpv4Prefix(IPV_4_PREFIX_DST).build()).build();
  67     private static final Eid NORMALIZED_SRCDST_EID = MaskUtil.normalize(EID_SOURCE_DEST_KEY_TYPE);
  68     private static final Eid NORMALIZED_PREFIX_SRC_EID = MaskUtil.normalize(EID_IPV4_PREFIX_SRC);
  69     private static final Eid NORMALIZED_EID = MaskUtil.normalize(EID_TEST);
  70     private static final Object DUMMY_OBJECT = "dummy_object";
  71     private static final Object DUMMY_OBJECT_2 = "mapping_lpm_eid";
  72
  73     @Before
  74     public void init() {
  75         daoMock = mock(ILispDAO.class);
  76         tableDaoMock = mock(ILispDAO.class);
  77         srcDstDaoMock = mock(ILispDAO.class);
  78         multiTableMapCache = new MultiTableMapCache(daoMock);
  79         dbMock = mock(ILispDAO.class);
  80     }
  81
  82     /**
  83      * Tests {@link MultiTableMapCache#addMapping} with SourceDestKey address type.
  84      */
  85     @Test
  86     public void addMappingTest_withSourceDestKey() {
  87
  88         final Eid normalized_Eid = MaskUtil.normalize(EID_SOURCE_DEST_KEY_TYPE);
  89         final Eid dstKey = SourceDestKeyHelper.getDstBinary(normalized_Eid);
  90         final Eid srcKey = SourceDestKeyHelper.getSrcBinary(normalized_Eid);
  91
  92         when(daoMock.getSpecific(VNI, SubKeys.VNI)).thenReturn(tableDaoMock);
  93         when(tableDaoMock.getSpecific(dstKey, SubKeys.LCAF_SRCDST)).thenReturn(srcDstDaoMock);
  94
  95         multiTableMapCache.addMapping(EID_SOURCE_DEST_KEY_TYPE, DUMMY_OBJECT);
  96         verify(srcDstDaoMock).put(srcKey, new MappingEntry<>(SubKeys.RECORD, DUMMY_OBJECT));
  97     }
  98
  99     /**
 100      * Tests {@link MultiTableMapCache#addMapping} with other than SourceDestKey address type.
 101      */
 102     @Test
 103     public void addMappingTest_withoutSourceDestKey() {
 104         when(daoMock.getSpecific(0L, SubKeys.VNI)).thenReturn(tableDaoMock);
 105
 106         multiTableMapCache.addMapping(EID_IPV4_PREFIX_SRC, DUMMY_OBJECT);
 107         verify(tableDaoMock).put(NORMALIZED_PREFIX_SRC_EID, new MappingEntry<>(SubKeys.RECORD, DUMMY_OBJECT));
 108     }
 109
 110     /**
 111      * Tests {@link MultiTableMapCache#getMapping} with SourceDestKey address type.
 112      */
 113     @Test
 114     public void getMappingTest_withSourceDestKey() {
 115         when(daoMock.getSpecific(VNI, SubKeys.VNI)).thenReturn(tableDaoMock);
 116
 117         final Eid dstAddr = SourceDestKeyHelper.getDstBinary(EID_SOURCE_DEST_KEY_TYPE);
 118         final Eid normalizedDstAddr = MaskUtil.normalize(dstAddr);
 119
 120         final Eid srcAddr = SourceDestKeyHelper.getSrcBinary(EID_SOURCE_DEST_KEY_TYPE);
 121         final Eid normalizedSrcAddr = MaskUtil.normalize(srcAddr);
 122
 123         final Map<String, Object> entry = getEntry1();
 124         final Map<String, Object> entry2 = getEntry2();
 125
 126         when(tableDaoMock.getBest(normalizedDstAddr)).thenReturn(entry);
 127         when(srcDstDaoMock.getBest(normalizedSrcAddr)).thenReturn(entry2);
 128
 129         assertEquals(DUMMY_OBJECT_2, multiTableMapCache.getMapping(null, EID_SOURCE_DEST_KEY_TYPE));
 130         assertNull(multiTableMapCache.getMapping(null, null));
 131         assertNull(multiTableMapCache.getMapping(EID_TEST, null));
 132     }
 133
 134     /**
 135      * Tests {@link MultiTableMapCache#getMapping} with Ipv4 address type.
 136      */
 137     @Test
 138     public void getMappingTest_withIpv4() {
 139         when(daoMock.getSpecific(VNI, SubKeys.VNI)).thenReturn(tableDaoMock);
 140         when(tableDaoMock.get(NORMALIZED_EID)).thenReturn(null);
 141
 142         assertNull(multiTableMapCache.getMapping(null, EID_TEST));
 143     }
 144
 145     /**
 146      * Tests {@link MultiTableMapCache#getMapping} with table == null.
 147      */
 148     @Test
 149     public void getMappingTest_withNullTable() {
 150         when(daoMock.getSpecific(VNI, SubKeys.VNI)).thenReturn(null);
 151         assertNull(multiTableMapCache.getMapping(null, EID_TEST));
 152     }
 153
 154     /**
 155      * Tests {@link MultiTableMapCache#getMapping} with Ipv4Prefix address type.
 156      */
 157     @Test
 158     public void getMappingTest_withIpv4Prefix() {
 159         final Eid key = MaskUtil.normalize(EID_IPV4_PREFIX_DST, (short) 24);
 160         final Eid key2 = MaskUtil.normalize(MaskUtil.normalize(EID_IPV4_PREFIX_SRC), (short) 24);
 161
 162         final Map<String, Object> entry = getEntry1();
 163         final Map<String, Object> entry2 = getEntry2();
 164
 165         when(daoMock.getSpecific(VNI, SubKeys.VNI)).thenReturn(tableDaoMock);
 166         when(tableDaoMock.getBest(key)).thenReturn(entry);
 167         when(srcDstDaoMock.getBest(LispAddressUtil.asIpPrefixBinaryEid(key2))).thenReturn(entry2);
 168
 169         assertEquals(DUMMY_OBJECT_2, multiTableMapCache.getMapping(EID_IPV4_PREFIX_SRC, EID_IPV4_PREFIX_DST));
 170         assertEquals(DUMMY_OBJECT, multiTableMapCache.getMapping(null, EID_IPV4_PREFIX_DST));
 171     }
 172
 173     /**
 174      * Tests {@link MultiTableMapCache#removeMapping} method with SourceDestKey type address.
 175      */
 176     @Test
 177     public void removeMappingTest() {
 178
 179         when(daoMock.getSpecific(VNI, SubKeys.VNI)).thenReturn(tableDaoMock);
 180         when(tableDaoMock.getSpecific(SourceDestKeyHelper
 181                 .getDstBinary(NORMALIZED_SRCDST_EID), SubKeys.LCAF_SRCDST)).thenReturn(dbMock);
 182
 183         multiTableMapCache.removeMapping(EID_SOURCE_DEST_KEY_TYPE);
 184         verify(dbMock).remove(SourceDestKeyHelper.getSrcBinary(NORMALIZED_SRCDST_EID));
 185     }
 186
 187     /**
 188      * Tests {@link MultiTableMapCache#removeMapping} method with Ipv4 type address.
 189      */
 190     @Test
 191     public void removeMappingTest_with() {
 192
 193         when(daoMock.getSpecific(VNI, SubKeys.VNI)).thenReturn(tableDaoMock);
 194
 195         multiTableMapCache.removeMapping(EID_TEST);
 196         verify(tableDaoMock).remove(NORMALIZED_EID);
 197     }
 198
 199     /**
 200      * Tests {@link MultiTableMapCache#removeMapping} method with table == null.
 201      */
 202     @Test
 203     public void removeMappingTest_withNUllTable() {
 204
 205         when(daoMock.getSpecific(VNI, SubKeys.VNI)).thenReturn(null);
 206
 207         multiTableMapCache.removeMapping(EID_SOURCE_DEST_KEY_TYPE);
 208         verifyZeroInteractions(tableDaoMock);
 209         verifyZeroInteractions(dbMock);
 210     }
 211
 212     /**
 213      * Tests {@link MultiTableMapCache#addData} with SourceDestKey address type.
 214      */
 215     @Test
 216     public void addDataTest_withSourceDestKey() {
 217         when(daoMock.getSpecific(VNI, SubKeys.VNI)).thenReturn(tableDaoMock);
 218         when(tableDaoMock.getSpecific(SourceDestKeyHelper.getDstBinary(NORMALIZED_SRCDST_EID), SubKeys.LCAF_SRCDST))
 219                 .thenReturn(srcDstDaoMock);
 220
 221         multiTableMapCache.addData(EID_SOURCE_DEST_KEY_TYPE, SubKeys.RECORD, DUMMY_OBJECT);
 222         verify(srcDstDaoMock).put(SourceDestKeyHelper.getSrcBinary(NORMALIZED_SRCDST_EID),
 223                 new MappingEntry<>(SubKeys.RECORD, DUMMY_OBJECT));
 224     }
 225
 226     /**
 227      * Tests {@link MultiTableMapCache#addData} with other than SourceDestKey address type.
 228      */
 229     @Test
 230     public void addDataTest_withIpv4() {
 231         when(daoMock.getSpecific(VNI, SubKeys.VNI)).thenReturn(tableDaoMock);
 232
 233         multiTableMapCache.addData(EID_TEST, SubKeys.RECORD, DUMMY_OBJECT);
 234         verify(tableDaoMock).put(NORMALIZED_EID, new MappingEntry<>(SubKeys.RECORD, DUMMY_OBJECT));
 235     }
 236
 237     /**
 238      * Tests {@link MultiTableMapCache#getData} with SourceDestKey address type.
 239      */
 240     @Test
 241     public void getDataTest_withSourceDestKey() {
 242         when(daoMock.getSpecific(VNI, SubKeys.VNI)).thenReturn(tableDaoMock);
 243         when(tableDaoMock.getSpecific(SourceDestKeyHelper.getDstBinary(NORMALIZED_SRCDST_EID), SubKeys.LCAF_SRCDST))
 244                 .thenReturn(srcDstDaoMock);
 245         when(srcDstDaoMock.getSpecific(SourceDestKeyHelper.getSrcBinary(NORMALIZED_SRCDST_EID), SubKeys.RECORD))
 246                 .thenReturn(DUMMY_OBJECT);
 247
 248         assertEquals(DUMMY_OBJECT, multiTableMapCache.getData(EID_SOURCE_DEST_KEY_TYPE, SubKeys.RECORD));
 249     }
 250
 251     /**
 252      * Tests {@link MultiTableMapCache#getData} with other than SourceDestKey address type.
 253      */
 254     @Test
 255     public void getDataTest_withIpv4() {
 256         when(daoMock.getSpecific(VNI, SubKeys.VNI)).thenReturn(tableDaoMock);
 257         when(tableDaoMock.getSpecific(NORMALIZED_EID, SubKeys.RECORD)).thenReturn(DUMMY_OBJECT);
 258
 259         assertEquals(DUMMY_OBJECT, multiTableMapCache.getData(EID_TEST, SubKeys.RECORD));
 260     }
 261
 262     /**
 263      * Tests {@link MultiTableMapCache#getData} with table == null.
 264      */
 265     @Test
 266     public void getDataTest_withNullTable() {
 267         when(daoMock.getSpecific(VNI, SubKeys.VNI)).thenReturn(null);
 268         assertNull(multiTableMapCache.getData(EID_TEST, SubKeys.RECORD));
 269     }
 270
 271     /**
 272      * Tests {@link MultiTableMapCache#removeData} with SourceDestKey address type.
 273      */
 274     @Test
 275     public void removeDataTest_withSourceDestKey() {
 276         when(daoMock.getSpecific(VNI, SubKeys.VNI)).thenReturn(tableDaoMock);
 277         when(tableDaoMock.getSpecific(SourceDestKeyHelper.getDstBinary(NORMALIZED_SRCDST_EID), SubKeys.LCAF_SRCDST))
 278                 .thenReturn(srcDstDaoMock);
 279
 280         multiTableMapCache.removeData(EID_SOURCE_DEST_KEY_TYPE, SubKeys.RECORD);
 281         verify(srcDstDaoMock).removeSpecific(SourceDestKeyHelper.getSrcBinary(NORMALIZED_SRCDST_EID), SubKeys.RECORD);
 282     }
 283
 284     /**
 285      * Tests {@link MultiTableMapCache#removeData} with other than SourceDestKey address type.
 286      */
 287     @Test
 288     public void removeDataTest_withIpv4() {
 289         when(daoMock.getSpecific(VNI, SubKeys.VNI)).thenReturn(tableDaoMock);
 290
 291         multiTableMapCache.removeData(EID_TEST, SubKeys.RECORD);
 292         verify(tableDaoMock).removeSpecific(NORMALIZED_EID, SubKeys.RECORD);
 293     }
 294
 295     /**
 296      * Tests {@link MultiTableMapCache#removeData} with table == null.
 297      */
 298     @Test
 299     public void removeDataTest_withNullTable() {
 300         when(daoMock.getSpecific(VNI, SubKeys.VNI)).thenReturn(null);
 301         multiTableMapCache.removeData(EID_TEST, SubKeys.RECORD);
 302
 303         Mockito.verifyZeroInteractions(tableDaoMock);
 304     }
 305
 306     /**
 307      * The following test is for coverage-increase purpose only.
 308      */
 309     @Test
 310     public void otherTest() {
 311         multiTableMapCache.printMappings();
 312     }
 313
 314     private Map<String, Object> getEntry1() {
 315         Map<String, Object> entry = new ConcurrentHashMap<>();
 316         entry.put(SubKeys.RECORD, DUMMY_OBJECT);
 317         entry.put(SubKeys.LCAF_SRCDST, srcDstDaoMock);
 318
 319         return entry;
 320     }
 321
 322     private Map<String, Object> getEntry2() {
 323         Map<String, Object> entry = new ConcurrentHashMap<>();
 324         entry.put(SubKeys.RECORD, DUMMY_OBJECT_2);
 325
 326         return entry;
 327     }
 328 }