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