mappingservice/implementation/src/test/java/org/opendaylight/lispflowmapping/implementation/LispMappingServiceTest.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;
   9
  10 import static org.junit.Assert.assertEquals;
  11 import static org.junit.Assert.assertNull;
  12
  13 import com.google.common.collect.Lists;
  14
  15 import java.util.ArrayList;
  16 import java.util.List;
  17
  18 import org.apache.commons.lang3.tuple.ImmutablePair;
  19 import org.apache.commons.lang3.tuple.MutablePair;
  20 import org.apache.commons.lang3.tuple.Pair;
  21 import org.junit.Test;
  22 import org.junit.runner.RunWith;
  23 import org.mockito.ArgumentMatcher;
  24 import org.mockito.InjectMocks;
  25 import org.mockito.Mock;
  26 import org.mockito.Mockito;
  27 import org.mockito.runners.MockitoJUnitRunner;
  28 import org.opendaylight.lispflowmapping.interfaces.lisp.IMapResolverAsync;
  29 import org.opendaylight.lispflowmapping.interfaces.lisp.IMapServerAsync;
  30 import org.opendaylight.lispflowmapping.lisp.type.LispMessage;
  31 import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
  32 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.PortNumber;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.IpAddressBinary;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.Ipv4AddressBinary;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.AddMapping;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapNotify;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapReply;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.RequestMapping;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.Eid;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.list.EidItemBuilder;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapRegister;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapnotifymessage.MapNotifyBuilder;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.
  44         MappingRecordBuilder;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.list.
  46         MappingRecordItemBuilder;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapreplymessage.MapReplyBuilder;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequest.SourceEidBuilder;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequestmessage.MapRequest;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequestmessage.MapRequestBuilder;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.rloc.container.Rloc;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.transport.address.TransportAddress;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.transport.address.TransportAddressBuilder;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.OdlLispSbService;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.SendMapNotifyInput;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.SendMapNotifyInputBuilder;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.SendMapReplyInputBuilder;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.SendMapRequestInputBuilder;
  59
  60 @RunWith(MockitoJUnitRunner.class)
  61 public class LispMappingServiceTest {
  62     @Mock(name = "lispSB") private static OdlLispSbService lispSBMock;
  63     @Mock(name = "mapResolver") private static IMapResolverAsync mapResolverMock;
  64     @Mock(name = "mapServer") private static IMapServerAsync mapServerMock;
  65     @Mock(name = "tlsMapReply") private static ThreadLocal<MapReply> tlsMapReplyMock;
  66     @Mock(name = "tlsMapRequest") private static ThreadLocal<Pair<MapRequest, TransportAddress>> tlsMapRequestMock;
  67     @Mock(name = "tlsMapNotify") private static ThreadLocal<Pair<MapNotify, List<TransportAddress>>> tlsMapNotifyMock;
  68     @Mock private static MapRegister mapRegisterMock;
  69     @InjectMocks private static LispMappingService lispMappingService;
  70
  71     private static final byte[] IPV4_BYTES_1 =       new byte[] {1, 2, 3, 0};
  72     private static final byte[] IPV4_BYTES_2 =       new byte[] {1, 2, 4, 0};
  73     private static final String IPV4_STRING_1 =      "1.2.3.0";
  74     private static final String IPV4_SOURCE_STRING = "192.168.0.1";
  75     private static final String IPV4_PREFIX_STRING = "/24";
  76
  77     private static final Eid IPV4_PREFIX_EID_1 = LispAddressUtil.asIpv4PrefixEid(IPV4_STRING_1 + IPV4_PREFIX_STRING);
  78     private static final Eid IPV4_SOURCE_EID = LispAddressUtil.asIpv4Eid(IPV4_SOURCE_STRING);
  79     private static final EidItemBuilder EID_ITEM_BUILDER = new EidItemBuilder()
  80             .setEidItemId("eid-item-id")
  81             .setEid(IPV4_PREFIX_EID_1);
  82     private static final MappingRecordItemBuilder MAPPING_RECORD_ITEM_BUILDER = new MappingRecordItemBuilder()
  83             .setMappingRecord(new MappingRecordBuilder().setEid(IPV4_PREFIX_EID_1).build());
  84
  85     private static final TransportAddress TRANSPORT_ADDRESS_1 = new TransportAddressBuilder()
  86             .setIpAddress(new IpAddressBinary(new Ipv4AddressBinary(IPV4_BYTES_1)))
  87             .setPort(new PortNumber(9999)).build();
  88     private static final TransportAddress TRANSPORT_ADDRESS_2 = new TransportAddressBuilder()
  89             .setIpAddress(new IpAddressBinary(new Ipv4AddressBinary(IPV4_BYTES_2)))
  90             .setPort(new PortNumber(8888)).build();
  91     private static final TransportAddress TRANSPORT_ADDRESS = new TransportAddressBuilder()
  92             .setIpAddress(new IpAddressBinary(new Ipv4AddressBinary(IPV4_BYTES_1)))
  93             .setPort(new PortNumber(LispMessage.PORT_NUM)).build();
  94
  95     /**
  96      * Tests {@link LispMappingService#handleMapRequest} method.
  97      */
  98     @Test
  99     public void handleMapRequestTest() {
 100         final MapRequest mapRequest = Mockito.mock(MapRequest.class);
 101         final MapReply mapReply = new MapReplyBuilder().build();
 102         Mockito.when(mapRequest.getEidItem()).thenReturn(Lists.newArrayList(EID_ITEM_BUILDER.build()));
 103         Mockito.when(tlsMapRequestMock.get()).thenReturn(null);
 104         Mockito.when(tlsMapReplyMock.get()).thenReturn(mapReply);
 105
 106         final MapReply result = lispMappingService.handleMapRequest(mapRequest);
 107
 108         Mockito.verify(tlsMapRequestMock).set(null);
 109         Mockito.verify(tlsMapRequestMock).get();
 110         Mockito.verifyNoMoreInteractions(tlsMapRequestMock);
 111         Mockito.verify(mapResolverMock).handleMapRequest(mapRequest);
 112         Mockito.verify(tlsMapReplyMock).set(Mockito.any(MapReply.class));
 113         Mockito.verify(tlsMapReplyMock).get();
 114
 115         assertEquals(result, mapReply);
 116     }
 117
 118     /**
 119      * Tests {@link LispMappingService#handleMapRequest} method request from non-proxy xTR.
 120      */
 121     @Test
 122     public void handleMapRequestTest_NonProxy() {
 123         final MapRequest mapRequest = Mockito.mock(MapRequest.class);
 124         final Pair<MapRequest, TransportAddress> pair = getDefaultMapRequestPair();
 125         final SendMapRequestInputBuilder smrib = new SendMapRequestInputBuilder()
 126                 .setMapRequest(pair.getLeft())
 127                 .setTransportAddress(pair.getRight());
 128
 129         Mockito.when(mapRequest.getEidItem()).thenReturn(Lists.newArrayList(EID_ITEM_BUILDER.build()));
 130         Mockito.when(tlsMapRequestMock.get()).thenReturn(pair);
 131
 132         assertNull(lispMappingService.handleMapRequest(mapRequest));
 133         Mockito.verify(lispSBMock).sendMapRequest(smrib.build());
 134     }
 135
 136     /**
 137      * Tests {@link LispMappingService#handleMapRegister} method.
 138      */
 139     @Test
 140     @SuppressWarnings("unchecked")
 141     public void handleMapRegisterTest() {
 142         final Pair<MapNotify, List<TransportAddress>> pairMock = Mockito.mock(Pair.class);
 143
 144         Mockito.when(mapRegisterMock.getMappingRecordItem())
 145                 .thenReturn(Lists.newArrayList(MAPPING_RECORD_ITEM_BUILDER.build()));
 146         Mockito.when(tlsMapNotifyMock.get()).thenReturn(pairMock);
 147
 148         lispMappingService.handleMapRegister(mapRegisterMock);
 149         Mockito.verify(mapServerMock).handleMapRegister(mapRegisterMock);
 150         Mockito.verify(tlsMapNotifyMock).set(Mockito.any(MutablePair.class));
 151     }
 152
 153     /**
 154      * Tests {@link LispMappingService#onAddMapping} method.
 155      */
 156     @Test
 157     public void onAddMappingTest() {
 158         final org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapregisternotification.MapRegister
 159                 mapRegister = Mockito.mock(org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105
 160                 .mapregisternotification.MapRegister.class);
 161         final AddMapping addMapping = Mockito.mock(AddMapping.class);
 162
 163         Mockito.when(addMapping.getMapRegister()).thenReturn(mapRegister);
 164         Mockito.when(mapRegister.getMappingRecordItem())
 165                 .thenReturn(Lists.newArrayList(MAPPING_RECORD_ITEM_BUILDER.build()));
 166         Mockito.when(tlsMapNotifyMock.get()).thenReturn(getDefaultMapNotifyPair());
 167
 168         lispMappingService.onAddMapping(addMapping);
 169         Mockito.verify(lispSBMock, Mockito.times(2)).sendMapNotify(Mockito.argThat(new TransportAddressMatch()));
 170     }
 171
 172     /**
 173      * Tests {@link LispMappingService#onAddMapping} method with no TransportAddress.
 174      */
 175     @Test
 176     public void onAddMappingTest_noTransportAddress() {
 177         final org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapregisternotification.MapRegister
 178                 mapRegister = Mockito.mock(org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105
 179                 .mapregisternotification.MapRegister.class);
 180         final AddMapping addMapping = Mockito.mock(AddMapping.class);
 181         final MapNotify mapNotify = new MapNotifyBuilder().setKeyId((short) 1).build();
 182
 183         Mockito.when(addMapping.getMapRegister()).thenReturn(mapRegister);
 184         Mockito.when(mapRegister.getMappingRecordItem())
 185                 .thenReturn(Lists.newArrayList(MAPPING_RECORD_ITEM_BUILDER.build()));
 186         Mockito.when(tlsMapNotifyMock.get()).thenReturn(new MutablePair<>(mapNotify, null));
 187         Mockito.when(addMapping.getTransportAddress()).thenReturn(TRANSPORT_ADDRESS_1);
 188
 189         // result
 190         final SendMapNotifyInputBuilder smnib = new SendMapNotifyInputBuilder()
 191                 .setMapNotify(new org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105
 192                         .mapnotifymessage.MapNotifyBuilder().setKeyId((short) 1).build())
 193                 .setTransportAddress(TRANSPORT_ADDRESS);
 194
 195         lispMappingService.onAddMapping(addMapping);
 196         Mockito.verify(lispSBMock).sendMapNotify(smnib.build());
 197     }
 198
 199     /**
 200      * Tests {@link LispMappingService#onRequestMapping} method.
 201      */
 202     @Test
 203     public void onRequestMappingTest() {
 204         final RequestMapping requestMapping = Mockito.mock(RequestMapping.class);
 205         final org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequestnotification.MapRequest
 206                 mapRequest = Mockito.mock(org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105
 207                     .maprequestnotification.MapRequest.class);
 208         final MapReply mapReply = new MapReplyBuilder().build();
 209
 210         Mockito.when(requestMapping.getMapRequest()).thenReturn(mapRequest);
 211         Mockito.when(requestMapping.getTransportAddress()).thenReturn(TRANSPORT_ADDRESS_1);
 212         Mockito.when(mapRequest.getEidItem()).thenReturn(Lists.newArrayList(EID_ITEM_BUILDER.build()));
 213         Mockito.when(tlsMapReplyMock.get()).thenReturn(mapReply);
 214
 215         // result
 216         final SendMapReplyInputBuilder smrib = new SendMapReplyInputBuilder()
 217                 .setMapReply(new MapReplyBuilder(mapReply).build())
 218                 .setTransportAddress(TRANSPORT_ADDRESS_1);
 219
 220         lispMappingService.onRequestMapping(requestMapping);
 221         Mockito.verify(lispSBMock).sendMapReply(smrib.build());
 222     }
 223
 224     /**
 225      * Tests {@link LispMappingService#handleSMR} method.
 226      */
 227     @Test
 228     public void handleSmrTest() {
 229         final MapRequest mapRequest = Mockito.mock(MapRequest.class);
 230         final Rloc subscriber = LispAddressUtil.asIpv4Rloc(IPV4_STRING_1);
 231
 232         Mockito.when(mapRequest.getSourceEid()).thenReturn(new SourceEidBuilder().setEid(IPV4_SOURCE_EID).build());
 233         Mockito.when(mapRequest.getEidItem()).thenReturn(Lists.newArrayList(EID_ITEM_BUILDER.build()));
 234
 235         // result
 236         final SendMapRequestInputBuilder smrib = new SendMapRequestInputBuilder()
 237                 .setMapRequest(new MapRequestBuilder(mapRequest).build())
 238                 .setTransportAddress(TRANSPORT_ADDRESS);
 239
 240         lispMappingService.handleSMR(mapRequest, subscriber);
 241         Mockito.verify(lispSBMock).sendMapRequest(smrib.build());
 242     }
 243
 244     /**
 245      * Tests {@link LispMappingService#setShouldUseSmr} method.
 246      */
 247     @Test
 248     public void setShouldUseSmrTest() {
 249         final boolean value = true;
 250
 251         lispMappingService.setShouldUseSmr(value);
 252         Mockito.verify(mapServerMock).setSubscriptionService(value);
 253         Mockito.verify(mapResolverMock).setSubscriptionService(value);
 254     }
 255
 256     /**
 257      * Tests {@link LispMappingService#handleMapNotify} method.
 258      */
 259     @Test
 260     @SuppressWarnings("unchecked")
 261     public void handleMapNotifyTest() {
 262         final MapNotify mapNotify = Mockito.mock(MapNotify.class);
 263         final List<TransportAddress> list = Mockito.mock(ArrayList.class);
 264
 265         lispMappingService.handleMapNotify(mapNotify, list);
 266         Mockito.verify(tlsMapNotifyMock).set(Mockito.any(MutablePair.class));
 267     }
 268
 269     /**
 270      * Tests {@link LispMappingService#handleNonProxyMapRequest} method.
 271      */
 272     @Test
 273     @SuppressWarnings("unchecked")
 274     public void handleNonProxyMapRequestTest() {
 275         final MapRequest mapRequest = Mockito.mock(MapRequest.class);
 276         final TransportAddress transportAddress = Mockito.mock(TransportAddress.class);
 277
 278         lispMappingService.handleNonProxyMapRequest(mapRequest, transportAddress);
 279         Mockito.verify(tlsMapRequestMock).set(Mockito.any(MutablePair.class));
 280     }
 281
 282     /**
 283      * Tests {@link LispMappingService#handleMapReply} method.
 284      */
 285     @Test
 286     public void handleMapReplyTest() {
 287         final MapReply mapReply = Mockito.mock(MapReply.class);
 288
 289         lispMappingService.handleMapReply(mapReply);
 290         Mockito.verify(tlsMapReplyMock).set(Mockito.any(MapReply.class));
 291     }
 292
 293     /**
 294      * Tests {@link LispMappingService#setShouldAuthenticate} method.
 295      */
 296     @Test
 297     public void setShouldAuthenticateTest() {
 298         final boolean value = true;
 299
 300         lispMappingService.setShouldAuthenticate(value);
 301         Mockito.verify(mapResolverMock).setShouldAuthenticate(value);
 302         Mockito.verify(mapServerMock).setShouldAuthenticate(value);
 303     }
 304
 305     private static Pair<MapNotify, List<TransportAddress>> getDefaultMapNotifyPair() {
 306         final MapNotify mapNotify = new MapNotifyBuilder().setKeyId((short) 1).build();
 307         return new MutablePair<>(mapNotify, Lists.newArrayList(TRANSPORT_ADDRESS_1, TRANSPORT_ADDRESS_2));
 308     }
 309
 310     private static Pair<MapRequest, TransportAddress> getDefaultMapRequestPair() {
 311         final MapRequestBuilder mapRequestBuilder = new MapRequestBuilder()
 312                 .setEidItem(Lists.newArrayList(EID_ITEM_BUILDER.build()));
 313
 314         return new ImmutablePair<>(mapRequestBuilder.build(), TRANSPORT_ADDRESS_1);
 315     }
 316
 317     class TransportAddressMatch extends ArgumentMatcher<SendMapNotifyInput> {
 318         public boolean matches(Object sendMapNotify) {
 319             final SendMapNotifyInput sendMapNotifyInput = (SendMapNotifyInput) sendMapNotify;
 320             final TransportAddress notifyTransportAddress = sendMapNotifyInput.getTransportAddress();
 321             return TRANSPORT_ADDRESS_1.equals(notifyTransportAddress)
 322                     || TRANSPORT_ADDRESS_2.equals(notifyTransportAddress);
 323         }
 324
 325     }
 326 }