import static org.junit.Assert.assertNull;
import com.google.common.collect.Lists;
-
+import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
-
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.apache.commons.lang3.tuple.MutablePair;
import org.apache.commons.lang3.tuple.Pair;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.runners.MockitoJUnitRunner;
+import org.mockito.junit.MockitoJUnitRunner;
+import org.opendaylight.lispflowmapping.implementation.lisp.MapServer;
import org.opendaylight.lispflowmapping.interfaces.lisp.IMapResolverAsync;
-import org.opendaylight.lispflowmapping.interfaces.lisp.IMapServerAsync;
+import org.opendaylight.lispflowmapping.interfaces.mappingservice.IMappingService;
import org.opendaylight.lispflowmapping.lisp.type.LispMessage;
import org.opendaylight.lispflowmapping.lisp.util.LispAddressUtil;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.PortNumber;
+import org.opendaylight.mdsal.binding.api.NotificationService;
+import org.opendaylight.mdsal.binding.api.RpcService;
+import org.opendaylight.mdsal.singleton.api.ClusterSingletonServiceProvider;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.IpAddressBinary;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.inet.binary.types.rev160303.Ipv4AddressBinary;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.AddMapping;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.GotMapNotify;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.GotMapReply;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapNotify;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapRegister;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapReply;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MappingKeepAlive;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.RequestMapping;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.XtrReplyMapping;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.XtrRequestMapping;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.container.Eid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.eid.list.EidItemBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.MapRegister;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.map.register.cache.metadata.container.MapRegisterCacheMetadata;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.map.register.cache.metadata.container.MapRegisterCacheMetadataBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.map.register.cache.metadata.container.map.register.cache.metadata.EidLispAddress;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.map.register.cache.metadata.container.map.register.cache.metadata.EidLispAddressBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapnotifymessage.MapNotifyBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.container.
- MappingRecordBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping.record.list.
- MappingRecordItemBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping._record.container.MappingRecordBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapping._record.list.MappingRecordItemBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.mapreplymessage.MapReplyBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequest.SourceEidBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequestmessage.MapRequest;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.rloc.container.Rloc;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.transport.address.TransportAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.transport.address.TransportAddressBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.OdlLispSbService;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.SendMapNotify;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.SendMapNotifyInput;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.SendMapNotifyInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.SendMapReply;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.SendMapReplyInputBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.SendMapRequest;
import org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.sb.rev150904.SendMapRequestInputBuilder;
+import org.opendaylight.yangtools.concepts.Registration;
+import org.opendaylight.yangtools.yang.binding.util.BindingMap;
+import org.opendaylight.yangtools.yang.common.Uint16;
@RunWith(MockitoJUnitRunner.class)
public class LispMappingServiceTest {
- @Mock(name = "lispSB") private static OdlLispSbService lispSBMock;
+ @Mock private static MapRegister mapRegisterMock;
+ @Mock(name = "mapServer") private static MapServer mapServerMock;
@Mock(name = "mapResolver") private static IMapResolverAsync mapResolverMock;
- @Mock(name = "mapServer") private static IMapServerAsync mapServerMock;
@Mock(name = "tlsMapReply") private static ThreadLocal<MapReply> tlsMapReplyMock;
- @Mock(name = "tlsMapRequest") private static ThreadLocal<Pair<MapRequest, TransportAddress>> tlsMapRequestMock;
@Mock(name = "tlsMapNotify") private static ThreadLocal<Pair<MapNotify, List<TransportAddress>>> tlsMapNotifyMock;
- @Mock private static MapRegister mapRegisterMock;
- @InjectMocks private static LispMappingService lispMappingService;
+ @Mock(name = "tlsMapRequest") private static ThreadLocal<Pair<MapRequest, TransportAddress>> tlsMapRequestMock;
+ @Mock(name = "listenerRegistration") private static Registration listenerRegistration;
+ @Mock(name = "cssRegistration") private static Registration cssRegistration;
+ @Mock(name = "sendMapRequest") private static SendMapRequest sendMapRequest;
+ @Mock(name = "sendMapReply") private static SendMapReply sendMapReply;
+ @Mock(name = "sendMapNotify") private static SendMapNotify sendMapNotify;
+
+ private final NotificationService notificationService = Mockito.mock(NotificationService.class);
+ private final RpcService rpcService = Mockito.mock(RpcService.class);
+ private final IMappingService mappingService = Mockito.mock(IMappingService.class);
+ private final ClusterSingletonServiceProvider clusterSingletonService = Mockito.mock(
+ ClusterSingletonServiceProvider.class);
+
+ @InjectMocks
+ private final LispMappingService lispMappingService = new LispMappingService(
+ mappingService, clusterSingletonService, rpcService, notificationService);
private static final byte[] IPV4_BYTES_1 = new byte[] {1, 2, 3, 0};
private static final byte[] IPV4_BYTES_2 = new byte[] {1, 2, 4, 0};
private static final String IPV4_STRING_1 = "1.2.3.0";
+ private static final String IPV4_STRING_2 = "1.2.3.1";
private static final String IPV4_SOURCE_STRING = "192.168.0.1";
private static final String IPV4_PREFIX_STRING = "/24";
+ private static final long TIMESTAMP = 1L;
private static final Eid IPV4_PREFIX_EID_1 = LispAddressUtil.asIpv4PrefixEid(IPV4_STRING_1 + IPV4_PREFIX_STRING);
private static final Eid IPV4_SOURCE_EID = LispAddressUtil.asIpv4Eid(IPV4_SOURCE_STRING);
+ private static final Eid IPV4_EID_1 = LispAddressUtil.asIpv4Eid(IPV4_STRING_1);
+ private static final Eid IPV4_EID_2 = LispAddressUtil.asIpv4Eid(IPV4_STRING_2);
private static final EidItemBuilder EID_ITEM_BUILDER = new EidItemBuilder()
.setEidItemId("eid-item-id")
.setEid(IPV4_PREFIX_EID_1);
private static final TransportAddress TRANSPORT_ADDRESS_1 = new TransportAddressBuilder()
.setIpAddress(new IpAddressBinary(new Ipv4AddressBinary(IPV4_BYTES_1)))
- .setPort(new PortNumber(9999)).build();
+ .setPort(new PortNumber(Uint16.valueOf(9999))).build();
private static final TransportAddress TRANSPORT_ADDRESS_2 = new TransportAddressBuilder()
.setIpAddress(new IpAddressBinary(new Ipv4AddressBinary(IPV4_BYTES_2)))
- .setPort(new PortNumber(8888)).build();
+ .setPort(new PortNumber(Uint16.valueOf(8888))).build();
private static final TransportAddress TRANSPORT_ADDRESS = new TransportAddressBuilder()
.setIpAddress(new IpAddressBinary(new Ipv4AddressBinary(IPV4_BYTES_1)))
- .setPort(new PortNumber(LispMessage.PORT_NUM)).build();
+ .setPort(new PortNumber(LispMessage.PORT_NUMBER)).build();
/**
* Tests {@link LispMappingService#handleMapRequest} method.
public void handleMapRequestTest() {
final MapRequest mapRequest = Mockito.mock(MapRequest.class);
final MapReply mapReply = new MapReplyBuilder().build();
- Mockito.when(mapRequest.getEidItem()).thenReturn(Lists.newArrayList(EID_ITEM_BUILDER.build()));
Mockito.when(tlsMapRequestMock.get()).thenReturn(null);
Mockito.when(tlsMapReplyMock.get()).thenReturn(mapReply);
Mockito.verify(tlsMapRequestMock).get();
Mockito.verifyNoMoreInteractions(tlsMapRequestMock);
Mockito.verify(mapResolverMock).handleMapRequest(mapRequest);
- Mockito.verify(tlsMapReplyMock).set(Mockito.any(MapReply.class));
+ Mockito.verify(tlsMapReplyMock).set(Mockito.any());
Mockito.verify(tlsMapReplyMock).get();
assertEquals(result, mapReply);
.setMapRequest(pair.getLeft())
.setTransportAddress(pair.getRight());
- Mockito.when(mapRequest.getEidItem()).thenReturn(Lists.newArrayList(EID_ITEM_BUILDER.build()));
Mockito.when(tlsMapRequestMock.get()).thenReturn(pair);
assertNull(lispMappingService.handleMapRequest(mapRequest));
- Mockito.verify(lispSBMock).sendMapRequest(smrib.build());
+ Mockito.verify(sendMapRequest).invoke(smrib.build());
}
/**
public void handleMapRegisterTest() {
final Pair<MapNotify, List<TransportAddress>> pairMock = Mockito.mock(Pair.class);
- Mockito.when(mapRegisterMock.getMappingRecordItem())
- .thenReturn(Lists.newArrayList(MAPPING_RECORD_ITEM_BUILDER.build()));
Mockito.when(tlsMapNotifyMock.get()).thenReturn(pairMock);
lispMappingService.handleMapRegister(mapRegisterMock);
Mockito.verify(mapServerMock).handleMapRegister(mapRegisterMock);
- Mockito.verify(tlsMapNotifyMock).set(Mockito.any(MutablePair.class));
+ Mockito.verify(tlsMapNotifyMock).set(Mockito.any());
}
/**
final AddMapping addMapping = Mockito.mock(AddMapping.class);
Mockito.when(addMapping.getMapRegister()).thenReturn(mapRegister);
- Mockito.when(mapRegister.getMappingRecordItem())
- .thenReturn(Lists.newArrayList(MAPPING_RECORD_ITEM_BUILDER.build()));
Mockito.when(tlsMapNotifyMock.get()).thenReturn(getDefaultMapNotifyPair());
lispMappingService.onAddMapping(addMapping);
- Mockito.verify(lispSBMock, Mockito.times(2)).sendMapNotify(Mockito.argThat(new TransportAddressMatch()));
+ Mockito.verify(sendMapNotify, Mockito.times(2)).invoke(Mockito.argThat(new TransportAddressMatch()));
}
/**
final MapNotify mapNotify = new MapNotifyBuilder().setKeyId((short) 1).build();
Mockito.when(addMapping.getMapRegister()).thenReturn(mapRegister);
- Mockito.when(mapRegister.getMappingRecordItem())
- .thenReturn(Lists.newArrayList(MAPPING_RECORD_ITEM_BUILDER.build()));
Mockito.when(tlsMapNotifyMock.get()).thenReturn(new MutablePair<>(mapNotify, null));
Mockito.when(addMapping.getTransportAddress()).thenReturn(TRANSPORT_ADDRESS_1);
.setTransportAddress(TRANSPORT_ADDRESS);
lispMappingService.onAddMapping(addMapping);
- Mockito.verify(lispSBMock).sendMapNotify(smnib.build());
+ Mockito.verify(sendMapNotify).invoke(smnib.build());
}
/**
Mockito.when(requestMapping.getMapRequest()).thenReturn(mapRequest);
Mockito.when(requestMapping.getTransportAddress()).thenReturn(TRANSPORT_ADDRESS_1);
- Mockito.when(mapRequest.getEidItem()).thenReturn(Lists.newArrayList(EID_ITEM_BUILDER.build()));
Mockito.when(tlsMapReplyMock.get()).thenReturn(mapReply);
// result
.setTransportAddress(TRANSPORT_ADDRESS_1);
lispMappingService.onRequestMapping(requestMapping);
- Mockito.verify(lispSBMock).sendMapReply(smrib.build());
+ Mockito.verify(sendMapReply).invoke(smrib.build());
+ }
+
+ /**
+ * Tests {@link LispMappingService#onRequestMapping} method with mapReply == null.
+ */
+ @Test
+ public void onRequestMappingTest_withNullMapReply() {
+ final RequestMapping requestMapping = Mockito.mock(RequestMapping.class);
+ final org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105.maprequestnotification.MapRequest
+ mapRequest = Mockito.mock(org.opendaylight.yang.gen.v1.urn.opendaylight.lfm.lisp.proto.rev151105
+ .maprequestnotification.MapRequest.class);
+
+ Mockito.when(requestMapping.getMapRequest()).thenReturn(mapRequest);
+ Mockito.when(tlsMapReplyMock.get()).thenReturn(null);
+
+ lispMappingService.onRequestMapping(requestMapping);
+ Mockito.verifyZeroInteractions(sendMapReply);
+ }
+
+ /**
+ * Tests {@link LispMappingService#onMappingKeepAlive} method.
+ */
+ @Test
+ public void onMappingKeepAliveTest() {
+ final MappingKeepAlive mappingKeepAlive = Mockito.mock(MappingKeepAlive.class);
+ Mockito.when(mappingKeepAlive.getMapRegisterCacheMetadata()).thenReturn(getDefaultMapRegisterCacheMetadata());
+
+ lispMappingService.onMappingKeepAlive(mappingKeepAlive);
+ Mockito.verify(mappingService).refreshMappingRegistration(IPV4_EID_1, null, TIMESTAMP);
+ Mockito.verify(mappingService).refreshMappingRegistration(IPV4_EID_2, null, TIMESTAMP);
}
/**
.setTransportAddress(TRANSPORT_ADDRESS);
lispMappingService.handleSMR(mapRequest, subscriber);
- Mockito.verify(lispSBMock).sendMapRequest(smrib.build());
+ Mockito.verify(sendMapRequest).invoke(smrib.build());
}
/**
}
/**
- * Tests {@link LispMappingService#setShouldAuthenticate} method.
+ * Tests {@link LispMappingService#close} method.
*/
@Test
- public void setShouldAuthenticateTest() {
- final boolean value = true;
+ public void closeTest() throws Exception {
+ setMock("listenerRegistration", listenerRegistration);
+ setMock("cssRegistration", cssRegistration);
+ lispMappingService.close();
+ Mockito.verify(listenerRegistration).close();
+ Mockito.verify(cssRegistration).close();
+ assertNull(getField("mapResolver"));
+ assertNull(getField("mapServer"));
+ }
+
+ /**
+ * Tests {@link LispMappingService} other setter and getter methods.
+ */
+ @Test
+ public void otherTest() throws Exception {
+ assertEquals(notificationService, lispMappingService.getNotificationService());
+ assertEquals(true, lispMappingService.shouldUseSmr());
+
+ lispMappingService.setShouldAuthenticate(true);
+ Mockito.verify(mapResolverMock).setShouldAuthenticate(true);
+
+ lispMappingService.onGotMapReply(Mockito.mock(GotMapReply.class));
+ lispMappingService.onGotMapNotify(Mockito.mock(GotMapNotify.class));
+ lispMappingService.onXtrRequestMapping(Mockito.mock(XtrRequestMapping.class));
+ lispMappingService.onXtrReplyMapping(Mockito.mock(XtrReplyMapping.class));
+ }
+
+ private void setMock(final String fieldName, final Object value)
+ throws IllegalAccessException, NoSuchFieldException {
+ final Field field = LispMappingService.class.getDeclaredField(fieldName);
+ field.setAccessible(true);
+ field.set(lispMappingService, value);
+ }
+
+ @SuppressWarnings("unchecked")
+ private <T> T getField(final String fieldName) throws NoSuchFieldException, IllegalAccessException {
+ final Field field = LispMappingService.class.getDeclaredField(fieldName);
+ field.setAccessible(true);
- lispMappingService.setShouldAuthenticate(value);
- Mockito.verify(mapResolverMock).setShouldAuthenticate(value);
- Mockito.verify(mapServerMock).setShouldAuthenticate(value);
+ return (T) field.get(lispMappingService);
}
private static Pair<MapNotify, List<TransportAddress>> getDefaultMapNotifyPair() {
return new ImmutablePair<>(mapRequestBuilder.build(), TRANSPORT_ADDRESS_1);
}
- class TransportAddressMatch extends ArgumentMatcher<SendMapNotifyInput> {
- public boolean matches(Object sendMapNotify) {
- final SendMapNotifyInput sendMapNotifyInput = (SendMapNotifyInput) sendMapNotify;
- final TransportAddress notifyTransportAddress = sendMapNotifyInput.getTransportAddress();
+ private static MapRegisterCacheMetadata getDefaultMapRegisterCacheMetadata() {
+ final EidLispAddress eidLispAddress_1 = new EidLispAddressBuilder()
+ .setEidLispAddressId("id-1")
+ .setEid(IPV4_EID_1).build();
+ final EidLispAddress eidLispAddress_2 = new EidLispAddressBuilder()
+ .setEidLispAddressId("id-2")
+ .setEid(IPV4_EID_2).build();
+
+ return new MapRegisterCacheMetadataBuilder()
+ .setEidLispAddress(BindingMap.ordered(eidLispAddress_1, eidLispAddress_2))
+ .setTimestamp(TIMESTAMP).build();
+ }
+
+ static class TransportAddressMatch implements ArgumentMatcher<SendMapNotifyInput> {
+ @Override
+ public boolean matches(final SendMapNotifyInput argument) {
+ final TransportAddress notifyTransportAddress = argument.getTransportAddress();
return TRANSPORT_ADDRESS_1.equals(notifyTransportAddress)
|| TRANSPORT_ADDRESS_2.equals(notifyTransportAddress);
}
-
}
}
Code Review / lispflowmapping.git / blobdiff