2 * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
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
9 package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.endpoint;
11 import static org.mockito.Matchers.any;
12 import static org.mockito.Mockito.mock;
13 import static org.mockito.Mockito.never;
14 import static org.mockito.Mockito.spy;
15 import static org.mockito.Mockito.times;
16 import static org.mockito.Mockito.verify;
17 import static org.mockito.Mockito.when;
19 import java.lang.reflect.Method;
20 import java.util.Collection;
21 import java.util.Collections;
22 import java.util.HashSet;
23 import java.util.List;
26 import java.util.UUID;
27 import java.util.concurrent.ScheduledExecutorService;
29 import org.junit.Assert;
30 import org.junit.Before;
31 import org.junit.Test;
32 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
33 import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
34 import org.opendaylight.controller.md.sal.binding.api.NotificationService;
35 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
36 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
37 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
38 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
39 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
40 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
41 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
42 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
43 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
44 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
45 import org.opendaylight.groupbasedpolicy.dto.EgKey;
46 import org.opendaylight.groupbasedpolicy.dto.EpKey;
47 import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.EndpointListener;
48 import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.node.SwitchManager;
49 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
50 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.MacAddress;
51 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ConditionName;
52 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.EndpointGroupId;
53 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L2BridgeDomainId;
54 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L3ContextId;
55 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.Name;
56 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.NetworkDomainId;
57 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
58 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.UniqueId;
59 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.EndpointService;
60 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.Endpoints;
61 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.Endpoint;
62 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointKey;
63 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3;
64 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3Key;
65 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3Prefix;
66 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.l3endpoint.rev151217.NatAddress;
67 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.EndpointLocation.LocationType;
68 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayContext;
69 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayL3Context;
70 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayL3ContextBuilder;
71 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.Tenant;
72 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.ForwardingContext;
73 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.L2BridgeDomain;
74 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
75 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
76 import org.opendaylight.yangtools.concepts.ListenerRegistration;
77 import org.opendaylight.yangtools.yang.binding.DataObject;
78 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
79 import org.opendaylight.yangtools.yang.binding.RpcService;
81 import com.google.common.base.Optional;
82 import com.google.common.util.concurrent.CheckedFuture;
84 public class EndpointManagerTest {
86 private EndpointManager manager;
87 private DataBroker dataProvider;
88 private RpcProviderRegistry rpcRegistry;
89 private NotificationService notificationService;
90 private ScheduledExecutorService executor;
91 private SwitchManager switchManager;
92 private ListenerRegistration<DataChangeListener> listenerReg;
93 private EndpointListener endpointListener;
94 private Endpoint endpoint1;
95 private Endpoint endpoint2;
96 private TenantId tenantId;
97 private EndpointGroupId endpointGroupId;
98 private L2BridgeDomainId l2BridgeDomainId;
99 private OfOverlayContext context1;
100 private OfOverlayContext context2;
101 private NodeId nodeId1;
102 private NodeId nodeId2;
103 private EndpointL3 oldL3Ep;
104 private EndpointL3 newL3Ep;
105 private Optional<Endpoints> optionalRead;
107 @SuppressWarnings("unchecked")
109 public void initialisation() throws Exception {
110 dataProvider = mock(DataBroker.class);
111 rpcRegistry = mock(RpcProviderRegistry.class);
112 notificationService = mock(NotificationService.class);
113 executor = mock(ScheduledExecutorService.class);
114 switchManager = mock(SwitchManager.class);
115 WriteTransaction writeTransaction = mock(WriteTransaction.class);
116 when(dataProvider.newWriteOnlyTransaction()).thenReturn(writeTransaction);
117 CheckedFuture<Void, TransactionCommitFailedException> checkedFutureWrite = mock(CheckedFuture.class);
118 when(writeTransaction.submit()).thenReturn(checkedFutureWrite);
119 BindingAwareBroker.RpcRegistration<EndpointService> rpcRegistration = mock(BindingAwareBroker.RpcRegistration.class);
120 listenerReg = mock(ListenerRegistration.class);
122 dataProvider.registerDataChangeListener(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
123 any(DataChangeListener.class), any(DataChangeScope.class))).thenReturn(listenerReg);
124 when(rpcRegistry.addRpcImplementation(any(Class.class), any(RpcService.class))).thenReturn(rpcRegistration);
126 manager = spy(new EndpointManager(dataProvider, rpcRegistry, notificationService, executor, switchManager));
127 endpointListener = mock(EndpointListener.class);
128 manager.registerListener(endpointListener);
130 endpoint1 = mock(Endpoint.class);
131 endpoint2 = mock(Endpoint.class);
132 tenantId = mock(TenantId.class);
133 endpointGroupId = mock(EndpointGroupId.class);
134 l2BridgeDomainId = mock(L2BridgeDomainId.class);
135 MacAddress macAddress = mock(MacAddress.class);
136 when(endpoint1.getTenant()).thenReturn(tenantId);
137 when(endpoint1.getEndpointGroup()).thenReturn(endpointGroupId);
138 when(endpoint1.getL2Context()).thenReturn(l2BridgeDomainId);
139 when(endpoint1.getMacAddress()).thenReturn(macAddress);
140 when(endpoint2.getTenant()).thenReturn(tenantId);
141 when(endpoint2.getEndpointGroup()).thenReturn(endpointGroupId);
142 when(endpoint2.getL2Context()).thenReturn(l2BridgeDomainId);
143 when(endpoint2.getMacAddress()).thenReturn(macAddress);
144 context1 = mock(OfOverlayContext.class);
145 context2 = mock(OfOverlayContext.class);
146 when(endpoint1.getAugmentation(OfOverlayContext.class)).thenReturn(context1);
147 when(endpoint2.getAugmentation(OfOverlayContext.class)).thenReturn(context2);
148 nodeId1 = mock(NodeId.class);
149 nodeId2 = mock(NodeId.class);
150 when(context1.getNodeId()).thenReturn(nodeId1);
151 when(context2.getNodeId()).thenReturn(nodeId2);
152 when(nodeId1.getValue()).thenReturn("nodeValue1");
153 when(nodeId2.getValue()).thenReturn("nodeValue2");
156 AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change = mock(AsyncDataChangeEvent.class);
157 InstanceIdentifier<DataObject> endpointId = mock(InstanceIdentifier.class);
158 Set<InstanceIdentifier<?>> removedPaths = new HashSet<>();
159 removedPaths.add(endpointId);
160 when(change.getRemovedPaths()).thenReturn(removedPaths);
163 oldL3Ep = mock(EndpointL3.class);
164 newL3Ep = mock(EndpointL3.class);
166 // getEndpointsFromDataStore
167 ReadOnlyTransaction readTransaction = mock(ReadOnlyTransaction.class);
168 when(dataProvider.newReadOnlyTransaction()).thenReturn(readTransaction);
169 CheckedFuture<Optional<Endpoints>, ReadFailedException> checkedFutureRead = mock(CheckedFuture.class);
170 when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(
172 optionalRead = mock(Optional.class);
173 when(checkedFutureRead.checkedGet()).thenReturn(optionalRead);
174 when(optionalRead.isPresent()).thenReturn(false);
183 public void getGroupsForNodeTest() {
184 Assert.assertTrue(manager.getGroupsForNode(nodeId1).isEmpty());
185 manager.processEndpoint(null, endpoint1);
186 Assert.assertFalse(manager.getGroupsForNode(nodeId1).isEmpty());
190 public void getNodesForGroupTest() {
191 EgKey egKey = mock(EgKey.class);
192 Set<NodeId> nodesForGroup = manager.getNodesForGroup(egKey);
193 Assert.assertNotNull(nodesForGroup);
194 Assert.assertTrue(nodesForGroup.isEmpty());
198 public void getEndpointsForNodeTestNodeIdEgKey() {
199 EgKey egKey = new EgKey(tenantId, endpointGroupId);
200 Assert.assertTrue(manager.getEndpointsForNode(nodeId1, egKey).isEmpty());
201 manager.processEndpoint(null, endpoint1);
202 Assert.assertFalse(manager.getEndpointsForNode(nodeId1, egKey).isEmpty());
206 public void getEndpointsForNodeTestNodeId() {
207 Assert.assertTrue(manager.getEndpointsForNode(nodeId1).isEmpty());
208 manager.processEndpoint(null, endpoint1);
209 Assert.assertFalse(manager.getEndpointsForNode(nodeId1).isEmpty());
213 public void getEndpoint() {
214 EpKey epKey = new EpKey(endpoint1.getL2Context(), endpoint1.getMacAddress());
215 manager.processEndpoint(null, endpoint1);
216 Assert.assertEquals(endpoint1, manager.getEndpoint(epKey));
219 @SuppressWarnings("unchecked")
221 public void getEndpointsL3PrefixForTenantTest() throws Exception {
222 ReadOnlyTransaction readTransaction = mock(ReadOnlyTransaction.class);
223 when(dataProvider.newReadOnlyTransaction()).thenReturn(readTransaction);
224 CheckedFuture<Optional<Endpoints>, ReadFailedException> resultFuture = mock(CheckedFuture.class);
225 when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(
227 Optional<Endpoints> optional = mock(Optional.class);
228 when(resultFuture.checkedGet()).thenReturn(optional);
229 when(optional.isPresent()).thenReturn(true);
230 Endpoints endpoints = mock(Endpoints.class);
231 when(optional.get()).thenReturn(endpoints);
232 EndpointL3Prefix endpointL3Prefix = mock(EndpointL3Prefix.class);
233 when(endpoints.getEndpointL3Prefix()).thenReturn(Collections.singletonList(endpointL3Prefix));
234 when(endpointL3Prefix.getTenant()).thenReturn(tenantId);
236 Collection<EndpointL3Prefix> result = manager.getEndpointsL3PrefixForTenant(tenantId);
237 Assert.assertTrue(result.contains(endpointL3Prefix));
240 @SuppressWarnings("unchecked")
242 public void getEndpointsFromDataStoreTest() throws Exception {
243 ReadOnlyTransaction transaction = mock(ReadOnlyTransaction.class);
244 when(dataProvider.newReadOnlyTransaction()).thenReturn(transaction);
245 CheckedFuture<Optional<Endpoints>, ReadFailedException> checkedFuture = mock(CheckedFuture.class);
246 when(transaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(checkedFuture);
247 Optional<Endpoints> optional = mock(Optional.class);
248 when(checkedFuture.checkedGet()).thenReturn(optional);
249 when(optional.isPresent()).thenReturn(false);
250 Assert.assertNull(manager.getEndpointsFromDataStore());
252 when(optional.isPresent()).thenReturn(true);
253 Endpoints endpoints = mock(Endpoints.class);
254 when(optional.get()).thenReturn(endpoints);
255 Assert.assertEquals(endpoints, manager.getEndpointsFromDataStore());
257 manager = new EndpointManager(null, rpcRegistry, notificationService, executor, switchManager);
258 Assert.assertNull(manager.getEndpointsFromDataStore());
262 public void getL3EndpointsTestEndpointsNull() throws Exception {
263 Assert.assertNull(manager.getL3Endpoints());
267 public void getL3EndpointsTestEndpointL3Null() throws Exception {
268 when(optionalRead.isPresent()).thenReturn(true);
269 Endpoints endpoints = mock(Endpoints.class);
270 when(optionalRead.get()).thenReturn(endpoints);
271 when(endpoints.getEndpointL3()).thenReturn(null);
273 Assert.assertNull(manager.getL3Endpoints());
277 public void getL3EndpointsTest() throws Exception {
278 when(optionalRead.isPresent()).thenReturn(true);
279 Endpoints endpoints = mock(Endpoints.class);
280 when(optionalRead.get()).thenReturn(endpoints);
281 List<EndpointL3> endpointL3List = Collections.singletonList(mock(EndpointL3.class));
282 when(endpoints.getEndpointL3()).thenReturn(endpointL3List);
284 Assert.assertEquals(endpointL3List, manager.getL3Endpoints());
288 public void getL3EpWithNatByL2KeyTest() {
289 when(optionalRead.isPresent()).thenReturn(true);
290 Endpoints endpoints = mock(Endpoints.class);
291 when(optionalRead.get()).thenReturn(endpoints);
292 EndpointL3 endpointL3 = mock(EndpointL3.class);
293 List<EndpointL3> endpointL3List = Collections.singletonList(endpointL3);
294 when(endpoints.getEndpointL3()).thenReturn(endpointL3List);
296 NatAddress overlayL3Nat = mock(NatAddress.class);
297 when(endpointL3.getAugmentation(NatAddress.class)).thenReturn(overlayL3Nat);
298 when(overlayL3Nat.getNatAddress()).thenReturn(mock(IpAddress.class));
300 when(endpointL3.getL2Context()).thenReturn(mock(L2BridgeDomainId.class));
301 when(endpointL3.getMacAddress()).thenReturn(mock(MacAddress.class));
303 Map<EndpointKey, EndpointL3> result = manager.getL3EpWithNatByL2Key();
304 Assert.assertTrue(result.containsValue(endpointL3));
308 public void getL3EpWithNatByL2KeyTestL3EpsNull() {
309 Map<EndpointKey, EndpointL3> result = manager.getL3EpWithNatByL2Key();
310 Assert.assertTrue(result.isEmpty());
314 public void getL3EpWithNatByL2KeyTestGetMacAddressNull() {
315 when(optionalRead.isPresent()).thenReturn(true);
316 Endpoints endpoints = mock(Endpoints.class);
317 when(optionalRead.get()).thenReturn(endpoints);
318 EndpointL3 endpointL3 = mock(EndpointL3.class);
319 List<EndpointL3> endpointL3List = Collections.singletonList(endpointL3);
320 when(endpoints.getEndpointL3()).thenReturn(endpointL3List);
322 NatAddress overlayL3Nat = mock(NatAddress.class);
323 when(endpointL3.getAugmentation(NatAddress.class)).thenReturn(overlayL3Nat);
325 when(endpointL3.getL2Context()).thenReturn(mock(L2BridgeDomainId.class));
326 when(endpointL3.getMacAddress()).thenReturn(null);
328 Map<EndpointKey, EndpointL3> result = manager.getL3EpWithNatByL2Key();
329 Assert.assertTrue(result.isEmpty());
333 public void getL3EpWithNatByL2KeyTestGetL2ContextNull() {
334 when(optionalRead.isPresent()).thenReturn(true);
335 Endpoints endpoints = mock(Endpoints.class);
336 when(optionalRead.get()).thenReturn(endpoints);
337 EndpointL3 endpointL3 = mock(EndpointL3.class);
338 List<EndpointL3> endpointL3List = Collections.singletonList(endpointL3);
339 when(endpoints.getEndpointL3()).thenReturn(endpointL3List);
341 NatAddress overlayL3Nat = mock(NatAddress.class);
342 when(endpointL3.getAugmentation(NatAddress.class)).thenReturn(overlayL3Nat);
344 when(endpointL3.getL2Context()).thenReturn(null);
345 when(endpointL3.getMacAddress()).thenReturn(mock(MacAddress.class));
347 Map<EndpointKey, EndpointL3> result = manager.getL3EpWithNatByL2Key();
348 Assert.assertTrue(result.isEmpty());
352 public void getEndpointsForGroupTest() {
353 EgKey newEgKey = new EgKey(tenantId, endpointGroupId);
354 Assert.assertTrue(manager.getEndpointsForGroup(newEgKey).isEmpty());
355 manager.processEndpoint(null, endpoint1);
356 Assert.assertFalse(manager.getEndpointsForGroup(newEgKey).isEmpty());
360 public void getConditionsForEndpoint() {
361 Endpoint endpoint = mock(Endpoint.class);
362 when(endpoint.getCondition()).thenReturn(null);
363 Assert.assertTrue(manager.getConditionsForEndpoint(endpoint).isEmpty());
365 List<ConditionName> conditionNameList = Collections.singletonList(mock(ConditionName.class));
366 when(endpoint.getCondition()).thenReturn(conditionNameList);
367 Assert.assertEquals(conditionNameList, manager.getConditionsForEndpoint(endpoint));
371 public void updateEndpointL3TestNewL3EpValidExternalTrue() throws Exception {
372 when(newL3Ep.getTenant()).thenReturn(mock(TenantId.class));
373 when(newL3Ep.getEndpointGroup()).thenReturn(mock(EndpointGroupId.class));
374 when(newL3Ep.getL3Context()).thenReturn(mock(L3ContextId.class));
375 when(newL3Ep.getIpAddress()).thenReturn(mock(IpAddress.class));
377 OfOverlayL3Context ofOverlayL3Context = mock(OfOverlayL3Context.class);
378 when(newL3Ep.getAugmentation(OfOverlayL3Context.class)).thenReturn(ofOverlayL3Context);
379 when(ofOverlayL3Context.getLocationType()).thenReturn(LocationType.External);
381 NetworkDomainId networkDomainId = mock(NetworkDomainId.class);
382 when(newL3Ep.getNetworkContainment()).thenReturn(networkDomainId);
384 EndpointL3Key endpointL3Key = mock(EndpointL3Key.class);
385 when(newL3Ep.getKey()).thenReturn(endpointL3Key);
386 IpAddress ipAddress = mock(IpAddress.class);
387 when(endpointL3Key.getIpAddress()).thenReturn(ipAddress);
389 manager.processL3Endpoint(null, newL3Ep);
390 verify(endpointListener,never()).endpointUpdated(any(EpKey.class));
394 public void updateEndpointL3TestNewL3EpValidExternalTrueNetworkContainmentNull() throws Exception {
395 when(newL3Ep.getTenant()).thenReturn(mock(TenantId.class));
396 when(newL3Ep.getEndpointGroup()).thenReturn(mock(EndpointGroupId.class));
397 when(newL3Ep.getL3Context()).thenReturn(mock(L3ContextId.class));
398 when(newL3Ep.getIpAddress()).thenReturn(mock(IpAddress.class));
400 OfOverlayL3Context ofOverlayL3Context = mock(OfOverlayL3Context.class);
401 when(newL3Ep.getAugmentation(OfOverlayL3Context.class)).thenReturn(ofOverlayL3Context);
402 when(ofOverlayL3Context.getLocationType()).thenReturn(LocationType.External);
404 when(newL3Ep.getNetworkContainment()).thenReturn(null);
406 EndpointL3Key endpointL3Key = mock(EndpointL3Key.class);
407 when(newL3Ep.getKey()).thenReturn(endpointL3Key);
408 IpAddress ipAddress = mock(IpAddress.class);
409 when(endpointL3Key.getIpAddress()).thenReturn(ipAddress);
411 manager.processL3Endpoint(null, newL3Ep);
412 verify(endpointListener,never()).endpointUpdated(any(EpKey.class));
416 public void updateEndpointL3TestNewL3EpValidInternal() throws Exception {
417 when(newL3Ep.getTenant()).thenReturn(mock(TenantId.class));
418 when(newL3Ep.getEndpointGroup()).thenReturn(mock(EndpointGroupId.class));
419 when(newL3Ep.getL3Context()).thenReturn(mock(L3ContextId.class));
420 when(newL3Ep.getIpAddress()).thenReturn(mock(IpAddress.class));
422 OfOverlayL3Context ofOverlayL3Context = mock(OfOverlayL3Context.class);
423 when(newL3Ep.getAugmentation(OfOverlayL3Context.class)).thenReturn(ofOverlayL3Context);
424 when(ofOverlayL3Context.getLocationType()).thenReturn(LocationType.External);
426 when(newL3Ep.getNetworkContainment()).thenReturn(null);
428 when(newL3Ep.getL2Context()).thenReturn(mock(L2BridgeDomainId.class));
429 when(newL3Ep.getMacAddress()).thenReturn(mock(MacAddress.class));
431 manager.processL3Endpoint(null, newL3Ep);
432 verify(endpointListener).endpointUpdated(any(EpKey.class));
436 public void updateEndpointL3TestNewL3EpValidFalse() throws Exception {
437 when(newL3Ep.getTenant()).thenReturn(mock(TenantId.class));
438 when(newL3Ep.getEndpointGroup()).thenReturn(mock(EndpointGroupId.class));
439 when(newL3Ep.getL3Context()).thenReturn(mock(L3ContextId.class));
440 when(newL3Ep.getIpAddress()).thenReturn(null);
442 manager.processL3Endpoint(null, newL3Ep);
443 verify(endpointListener,never()).endpointUpdated(any(EpKey.class));
447 public void updateEndpointL3TestDelete() throws Exception {
448 manager.processL3Endpoint(oldL3Ep, null);
449 verify(endpointListener).endpointUpdated(any(EpKey.class));
453 public void updateEndpointTestNewEndpointRemove() {
454 Collection<Endpoint> collection;
455 manager.processEndpoint(null, endpoint2);
456 verify(endpointListener).endpointUpdated(any(EpKey.class));
457 verify(endpointListener).nodeEndpointUpdated(any(NodeId.class), any(EpKey.class));
458 collection = manager.getEndpointsForGroup(new EgKey(tenantId, endpointGroupId));
459 Assert.assertFalse(collection.isEmpty());
461 manager.processEndpoint(endpoint2, null);
462 verify(endpointListener, times(2)).endpointUpdated(any(EpKey.class));
463 verify(endpointListener, times(2)).nodeEndpointUpdated(any(NodeId.class), any(EpKey.class));
464 collection = manager.getEndpointsForGroup(new EgKey(tenantId, endpointGroupId));
465 Assert.assertTrue(collection.isEmpty());
469 public void updateEndpointTestNewLocNullOldLocNullOfOverlayContextAugmentationNull() {
470 when(endpoint1.getAugmentation(OfOverlayContext.class)).thenReturn(null);
471 when(endpoint2.getAugmentation(OfOverlayContext.class)).thenReturn(null);
473 manager.processEndpoint(endpoint1, endpoint2);
474 verify(endpointListener, never()).endpointUpdated(any(EpKey.class));
475 verify(endpointListener, never()).nodeEndpointUpdated(any(NodeId.class), any(EpKey.class));
479 public void updateEndpointTestNewLocNullOldLocNull() {
480 when(context1.getNodeId()).thenReturn(null);
481 when(context2.getNodeId()).thenReturn(null);
482 when(context1.getLocationType()).thenReturn(LocationType.External);
483 when(context2.getLocationType()).thenReturn(LocationType.External);
485 manager.processEndpoint(endpoint1, endpoint2);
486 verify(endpointListener, never()).endpointUpdated(any(EpKey.class));
487 verify(endpointListener, never()).nodeEndpointUpdated(any(NodeId.class), any(EpKey.class));
491 public void updateEndpointTestNewLocNullOldLocNullExternalPut() {
492 when(endpoint1.getAugmentation(OfOverlayContext.class)).thenReturn(null);
493 when(endpoint2.getAugmentation(OfOverlayContext.class)).thenReturn(null);
495 manager.processEndpoint(endpoint1, endpoint2);
496 verify(endpointListener, never()).endpointUpdated(any(EpKey.class));
497 verify(endpointListener, never()).nodeEndpointUpdated(any(NodeId.class), any(EpKey.class));
501 public void updateEndpointTestNewLocNullOldLocNullExternalRemove() {
502 when(context1.getNodeId()).thenReturn(null);
503 when(context1.getLocationType()).thenReturn(LocationType.External);
504 manager.processEndpoint(null, endpoint1);
506 manager.processEndpoint(endpoint1, null);
507 verify(endpointListener, never()).endpointUpdated(any(EpKey.class));
508 verify(endpointListener, never()).nodeEndpointUpdated(any(NodeId.class), any(EpKey.class));
512 * Endpoint changes it's location
515 public void updateEndpointLocationTestUpdate() {
516 Collection<Endpoint> collection;
517 manager.processEndpoint(null, endpoint1);
519 manager.processEndpoint(endpoint1, endpoint2);
520 verify(endpointListener, times(2)).endpointUpdated(any(EpKey.class));
521 // create: node1, update: node1 -> node2
522 verify(endpointListener, times(3)).nodeEndpointUpdated(any(NodeId.class), any(EpKey.class));
523 collection = manager.getEndpointsForGroup(new EgKey(tenantId, endpointGroupId));
524 Assert.assertFalse(collection.isEmpty());
528 * Endpoint changes it's EPG
531 public void updateEndpointGroupTestUpdate() {
532 Collection<Endpoint> collection;
533 EndpointGroupId otherEndpointGroupId = mock(EndpointGroupId.class);
534 when(endpoint2.getEndpointGroup()).thenReturn(otherEndpointGroupId);
535 when(endpoint2.getAugmentation(OfOverlayContext.class)).thenReturn(context1);
536 manager.processEndpoint(null, endpoint1);
538 manager.processEndpoint(endpoint1, endpoint2);
539 verify(endpointListener, times(2)).endpointUpdated(any(EpKey.class));
540 verify(endpointListener, times(1)).nodeEndpointUpdated(any(NodeId.class), any(EpKey.class));
541 collection = manager.getEndpointsForGroup(new EgKey(tenantId, endpointGroupId));
542 Assert.assertTrue(collection.isEmpty());
543 collection = manager.getEndpointsForGroup(new EgKey(tenantId, otherEndpointGroupId));
544 Assert.assertFalse(collection.isEmpty());
548 * Endpoint changes it's location and EPGs
551 public void updateEndpointLocationAndGroupTestUpdate() {
552 Collection<Endpoint> collection;
553 EndpointGroupId otherEndpointGroupId = mock(EndpointGroupId.class);
554 when(endpoint2.getEndpointGroup()).thenReturn(otherEndpointGroupId);
555 manager.processEndpoint(null, endpoint1);
557 manager.processEndpoint(endpoint1, endpoint2);
558 verify(endpointListener, times(2)).endpointUpdated(any(EpKey.class));
559 // create: node1, update: node1 -> node2
560 verify(endpointListener, times(3)).nodeEndpointUpdated(any(NodeId.class), any(EpKey.class));
561 collection = manager.getEndpointsForGroup(new EgKey(tenantId, endpointGroupId));
562 Assert.assertTrue(collection.isEmpty());
563 collection = manager.getEndpointsForGroup(new EgKey(tenantId, otherEndpointGroupId));
564 Assert.assertFalse(collection.isEmpty());
568 * Endpoint becomes external when removing it's location augmentation.
569 * This might happen when an endpoint is removed from a device.
572 public void updateEndpointLocationRemovedTestUpdate() {
573 Collection<Endpoint> collection;
574 when(endpoint2.getAugmentation(OfOverlayContext.class)).thenReturn(null);
575 manager.processEndpoint(null, endpoint1);
577 manager.processEndpoint(endpoint1, endpoint2);
578 verify(endpointListener, times(2)).endpointUpdated(any(EpKey.class));
579 verify(endpointListener, times(2)).nodeEndpointUpdated(any(NodeId.class), any(EpKey.class));
580 collection = manager.getEndpointsForGroup(new EgKey(tenantId, endpointGroupId));
581 Assert.assertTrue(collection.isEmpty());
585 * Endpoint is created when adding location augmentation.
586 * Endpoint is not external anymore.
589 public void updateEndpointLocationAddedTestUpdate() {
590 Collection<Endpoint> collection;
591 when(endpoint1.getAugmentation(OfOverlayContext.class)).thenReturn(null);
592 manager.processEndpoint(null, endpoint1);
594 manager.processEndpoint(endpoint1, endpoint2);
595 verify(endpointListener).endpointUpdated(any(EpKey.class));
596 verify(endpointListener).nodeEndpointUpdated(any(NodeId.class), any(EpKey.class));
597 collection = manager.getEndpointsForGroup(new EgKey(tenantId, endpointGroupId));
598 Assert.assertFalse(collection.isEmpty());
601 @SuppressWarnings({"unchecked"})
603 public void addEndpointFromL3EndpointTest() throws Exception {
604 EndpointL3 l3Ep = mock(EndpointL3.class);
605 ReadWriteTransaction rwTx = mock(ReadWriteTransaction.class);
606 OfOverlayL3Context ofL3Ctx = mock(OfOverlayL3Context.class);
607 when(l3Ep.getAugmentation(OfOverlayL3Context.class)).thenReturn(ofL3Ctx);
609 CheckedFuture<Optional<Tenant>, ReadFailedException> checkedFuture = mock(CheckedFuture.class);
610 when(rwTx.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(checkedFuture);
611 Optional<Tenant> optional = mock(Optional.class);
612 when(checkedFuture.checkedGet()).thenReturn(optional);
613 Tenant tenant = mock(Tenant.class);
614 ForwardingContext fwCtx = mock(ForwardingContext.class);
615 when(tenant.getForwardingContext()).thenReturn(fwCtx);
616 when(optional.isPresent()).thenReturn(true);
617 when(optional.get()).thenReturn(tenant);
619 L2BridgeDomain l2BridgeDomain = mock(L2BridgeDomain.class);
620 when(fwCtx.getL2BridgeDomain()).thenReturn(Collections.singletonList(l2BridgeDomain));
621 L2BridgeDomainId l2BridgeDomainId = mock(L2BridgeDomainId.class);
622 when(l2BridgeDomain.getId()).thenReturn(l2BridgeDomainId);
623 String l2bdValue = UUID.randomUUID().toString();
624 when(l2BridgeDomainId.getValue()).thenReturn(l2bdValue);
626 NetworkDomainId networkDomainId = mock(NetworkDomainId.class);
627 when(l3Ep.getNetworkContainment()).thenReturn(networkDomainId);
628 when(networkDomainId.getValue()).thenReturn(l2bdValue);
630 Method method = EndpointManager.class.getDeclaredMethod("addEndpointFromL3Endpoint", EndpointL3.class,
631 ReadWriteTransaction.class);
632 method.setAccessible(true);
633 method.invoke(manager, l3Ep, rwTx);
634 verify(rwTx).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Endpoint.class));
637 @SuppressWarnings({"unchecked"})
639 public void addEndpointFromL3EndpointTestTenantPresentFalse() throws Exception {
640 EndpointL3 l3Ep = mock(EndpointL3.class);
641 ReadWriteTransaction rwTx = mock(ReadWriteTransaction.class);
642 OfOverlayL3Context ofL3Ctx = mock(OfOverlayL3Context.class);
643 when(l3Ep.getAugmentation(OfOverlayL3Context.class)).thenReturn(ofL3Ctx);
645 CheckedFuture<Optional<Tenant>, ReadFailedException> checkedFuture = mock(CheckedFuture.class);
646 when(rwTx.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(checkedFuture);
647 Optional<Tenant> optional = mock(Optional.class);
648 when(checkedFuture.checkedGet()).thenReturn(optional);
649 when(optional.isPresent()).thenReturn(false);
651 Method method = EndpointManager.class.getDeclaredMethod("addEndpointFromL3Endpoint", EndpointL3.class,
652 ReadWriteTransaction.class);
653 method.setAccessible(true);
654 method.invoke(manager, l3Ep, rwTx);
655 verify(rwTx).cancel();
658 // ************************
659 // Endpoint Augmentation
660 // ************************
663 public void getOfOverlayContextFromL3EndpointTest() throws Exception {
664 OfOverlayL3ContextBuilder ofL3CtxBuilder = new OfOverlayL3ContextBuilder();
665 OfOverlayContext result;
666 Method method = EndpointManager.class.getDeclaredMethod("getOfOverlayContextFromL3Endpoint",
667 OfOverlayL3Context.class);
668 method.setAccessible(true);
670 result = (OfOverlayContext) method.invoke(manager, ofL3CtxBuilder.build());
671 Assert.assertEquals(null, result.getInterfaceId());
672 Assert.assertEquals(null, result.getLocationType());
673 Assert.assertEquals(null, result.getNodeConnectorId());
674 Assert.assertEquals(null, result.getNodeId());
675 Assert.assertEquals(null, result.getPortName());
677 UniqueId interfaceId = new UniqueId("iface");
678 ofL3CtxBuilder.setInterfaceId(interfaceId);
679 LocationType locationType = LocationType.External;
680 ofL3CtxBuilder.setLocationType(locationType);
681 NodeConnectorId nodeConnectorId = new NodeConnectorId("nc");
682 ofL3CtxBuilder.setNodeConnectorId(nodeConnectorId);
683 NodeId nodeId = new NodeId("nId");
684 ofL3CtxBuilder.setNodeId(nodeId);
685 Name portName = new Name("pName");
686 ofL3CtxBuilder.setPortName(portName);
688 result = (OfOverlayContext) method.invoke(manager, ofL3CtxBuilder.build());
689 Assert.assertEquals(interfaceId, result.getInterfaceId());
690 Assert.assertEquals(locationType, result.getLocationType());
691 Assert.assertEquals(nodeConnectorId, result.getNodeConnectorId());
692 Assert.assertEquals(nodeId, result.getNodeId());
693 Assert.assertEquals(portName, result.getPortName());
697 public void closeTest() throws Exception {
699 verify(listenerReg).close();
700 manager = new EndpointManager(null, rpcRegistry, notificationService, executor, switchManager);
702 verify(listenerReg, times(1)).close();
710 public void getEgKeyTest() {
711 Assert.assertNotNull(manager.getEgKey(endpoint1));
712 Assert.assertNull(manager.getEgKey(null));
714 when(endpoint1.getTenant()).thenReturn(null);
715 Assert.assertNull(manager.getEgKey(endpoint1));
717 when(endpoint1.getTenant()).thenReturn(tenantId);
718 when(endpoint1.getEndpointGroup()).thenReturn(null);
719 Assert.assertNotNull(manager.getEgKey(endpoint1));
721 when(endpoint1.getEndpointGroup()).thenReturn(endpointGroupId);
722 when(endpoint1.getEndpointGroups()).thenReturn(null);
723 Assert.assertNotNull(manager.getEgKey(endpoint1));
725 when(endpoint1.getEndpointGroup()).thenReturn(null);
726 Assert.assertNull(manager.getEgKey(endpoint1));
728 when(endpoint1.getEndpointGroup()).thenReturn(endpointGroupId);
729 when(endpoint1.getL2Context()).thenReturn(null);
730 Assert.assertNull(manager.getEgKey(endpoint1));
732 when(endpoint1.getL2Context()).thenReturn(l2BridgeDomainId);
733 when(endpoint1.getMacAddress()).thenReturn(null);
734 Assert.assertNull(manager.getEgKey(endpoint1));
738 public void getEgKeysForEndpointTest() {
739 Endpoint endpoint = mock(Endpoint.class);
742 when(endpoint.getEndpointGroups()).thenReturn(null);
743 egKeys = manager.getEgKeysForEndpoint(endpoint);
744 Assert.assertTrue(egKeys.isEmpty());
746 EndpointGroupId endpointGroupId = mock(EndpointGroupId.class);
747 when(endpoint.getEndpointGroup()).thenReturn(endpointGroupId);
748 egKeys = manager.getEgKeysForEndpoint(endpoint);
749 Assert.assertEquals(1, egKeys.size());
751 EndpointGroupId epgId = mock(EndpointGroupId.class);
752 List<EndpointGroupId> endpointGroups = Collections.singletonList(epgId);
753 when(endpoint.getEndpointGroups()).thenReturn(endpointGroups);
754 egKeys = manager.getEgKeysForEndpoint(endpoint);
755 Assert.assertEquals(2, egKeys.size());
759 public void isExternalIsInternalTest() {
760 Endpoint endpoint = mock(Endpoint.class);
761 when(endpoint.getAugmentation(OfOverlayContext.class)).thenReturn(null);
762 Assert.assertFalse(manager.isExternal(endpoint));
763 Assert.assertTrue(manager.isInternal(endpoint));
765 OfOverlayContext ofc = mock(OfOverlayContext.class);
766 when(endpoint.getAugmentation(OfOverlayContext.class)).thenReturn(ofc);
767 when(ofc.getLocationType()).thenReturn(null);
768 Assert.assertFalse(manager.isExternal(endpoint));
769 Assert.assertTrue(manager.isInternal(endpoint));
771 when(ofc.getLocationType()).thenReturn(LocationType.Internal);
772 Assert.assertFalse(manager.isExternal(endpoint));
773 Assert.assertTrue(manager.isInternal(endpoint));
775 when(ofc.getLocationType()).thenReturn(LocationType.External);
776 Assert.assertTrue(manager.isExternal(endpoint));
777 Assert.assertFalse(manager.isInternal(endpoint));