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.endpoint.EpKey;
46 import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.EndpointListener;
47 import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.node.SwitchManager;
48 import org.opendaylight.groupbasedpolicy.resolver.EgKey;
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.ofoverlay.rev140528.EndpointLocation.LocationType;
67 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayContext;
68 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayL3Context;
69 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayL3ContextBuilder;
70 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayL3Nat;
71 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.napt.translations.fields.NaptTranslations;
72 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.napt.translations.fields.napt.translations.NaptTranslation;
73 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.Tenant;
74 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.L2BridgeDomain;
75 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
76 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
77 import org.opendaylight.yangtools.concepts.ListenerRegistration;
78 import org.opendaylight.yangtools.yang.binding.DataObject;
79 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
80 import org.opendaylight.yangtools.yang.binding.RpcService;
82 import com.google.common.base.Optional;
83 import com.google.common.util.concurrent.CheckedFuture;
85 public class EndpointManagerTest {
87 private EndpointManager manager;
88 private DataBroker dataProvider;
89 private RpcProviderRegistry rpcRegistry;
90 private NotificationService notificationService;
91 private ScheduledExecutorService executor;
92 private SwitchManager switchManager;
93 private ListenerRegistration<DataChangeListener> listenerReg;
94 private EndpointListener endpointListener;
95 private Endpoint endpoint1;
96 private Endpoint endpoint2;
97 private TenantId tenantId;
98 private EndpointGroupId endpointGroupId;
99 private L2BridgeDomainId l2BridgeDomainId;
100 private OfOverlayContext context1;
101 private OfOverlayContext context2;
102 private NodeId nodeId1;
103 private NodeId nodeId2;
104 private EndpointL3 oldL3Ep;
105 private EndpointL3 newL3Ep;
106 private Optional<Endpoints> optionalRead;
108 @SuppressWarnings("unchecked")
110 public void initialisation() throws Exception {
111 dataProvider = mock(DataBroker.class);
112 rpcRegistry = mock(RpcProviderRegistry.class);
113 notificationService = mock(NotificationService.class);
114 executor = mock(ScheduledExecutorService.class);
115 switchManager = mock(SwitchManager.class);
116 WriteTransaction writeTransaction = mock(WriteTransaction.class);
117 when(dataProvider.newWriteOnlyTransaction()).thenReturn(writeTransaction);
118 CheckedFuture<Void, TransactionCommitFailedException> checkedFutureWrite = mock(CheckedFuture.class);
119 when(writeTransaction.submit()).thenReturn(checkedFutureWrite);
120 BindingAwareBroker.RpcRegistration<EndpointService> rpcRegistration = mock(BindingAwareBroker.RpcRegistration.class);
121 listenerReg = mock(ListenerRegistration.class);
123 dataProvider.registerDataChangeListener(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
124 any(DataChangeListener.class), any(DataChangeScope.class))).thenReturn(listenerReg);
125 when(rpcRegistry.addRpcImplementation(any(Class.class), any(RpcService.class))).thenReturn(rpcRegistration);
127 manager = spy(new EndpointManager(dataProvider, rpcRegistry, notificationService, executor, switchManager));
128 endpointListener = mock(EndpointListener.class);
129 manager.registerListener(endpointListener);
131 endpoint1 = mock(Endpoint.class);
132 endpoint2 = mock(Endpoint.class);
133 tenantId = mock(TenantId.class);
134 endpointGroupId = mock(EndpointGroupId.class);
135 l2BridgeDomainId = mock(L2BridgeDomainId.class);
136 MacAddress macAddress = mock(MacAddress.class);
137 when(endpoint1.getTenant()).thenReturn(tenantId);
138 when(endpoint1.getEndpointGroup()).thenReturn(endpointGroupId);
139 when(endpoint1.getL2Context()).thenReturn(l2BridgeDomainId);
140 when(endpoint1.getMacAddress()).thenReturn(macAddress);
141 when(endpoint2.getTenant()).thenReturn(tenantId);
142 when(endpoint2.getEndpointGroup()).thenReturn(endpointGroupId);
143 when(endpoint2.getL2Context()).thenReturn(l2BridgeDomainId);
144 when(endpoint2.getMacAddress()).thenReturn(macAddress);
145 context1 = mock(OfOverlayContext.class);
146 context2 = mock(OfOverlayContext.class);
147 when(endpoint1.getAugmentation(OfOverlayContext.class)).thenReturn(context1);
148 when(endpoint2.getAugmentation(OfOverlayContext.class)).thenReturn(context2);
149 nodeId1 = mock(NodeId.class);
150 nodeId2 = mock(NodeId.class);
151 when(context1.getNodeId()).thenReturn(nodeId1);
152 when(context2.getNodeId()).thenReturn(nodeId2);
153 when(nodeId1.getValue()).thenReturn("nodeValue1");
154 when(nodeId2.getValue()).thenReturn("nodeValue2");
157 AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change = mock(AsyncDataChangeEvent.class);
158 InstanceIdentifier<DataObject> endpointId = mock(InstanceIdentifier.class);
159 Set<InstanceIdentifier<?>> removedPaths = new HashSet<>();
160 removedPaths.add(endpointId);
161 when(change.getRemovedPaths()).thenReturn(removedPaths);
164 oldL3Ep = mock(EndpointL3.class);
165 newL3Ep = mock(EndpointL3.class);
167 // getEndpointsFromDataStore
168 ReadOnlyTransaction readTransaction = mock(ReadOnlyTransaction.class);
169 when(dataProvider.newReadOnlyTransaction()).thenReturn(readTransaction);
170 CheckedFuture<Optional<Endpoints>, ReadFailedException> checkedFutureRead = mock(CheckedFuture.class);
171 when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(
173 optionalRead = mock(Optional.class);
174 when(checkedFutureRead.checkedGet()).thenReturn(optionalRead);
175 when(optionalRead.isPresent()).thenReturn(false);
184 public void getGroupsForNodeTest() {
185 Assert.assertTrue(manager.getGroupsForNode(nodeId1).isEmpty());
186 manager.processEndpoint(null, endpoint1);
187 Assert.assertFalse(manager.getGroupsForNode(nodeId1).isEmpty());
191 public void getNodesForGroupTest() {
192 EgKey egKey = mock(EgKey.class);
193 Set<NodeId> nodesForGroup = manager.getNodesForGroup(egKey);
194 Assert.assertNotNull(nodesForGroup);
195 Assert.assertTrue(nodesForGroup.isEmpty());
199 public void getEndpointsForNodeTestNodeIdEgKey() {
200 EgKey egKey = new EgKey(tenantId, endpointGroupId);
201 Assert.assertTrue(manager.getEndpointsForNode(nodeId1, egKey).isEmpty());
202 manager.processEndpoint(null, endpoint1);
203 Assert.assertFalse(manager.getEndpointsForNode(nodeId1, egKey).isEmpty());
207 public void getEndpointsForNodeTestNodeId() {
208 Assert.assertTrue(manager.getEndpointsForNode(nodeId1).isEmpty());
209 manager.processEndpoint(null, endpoint1);
210 Assert.assertFalse(manager.getEndpointsForNode(nodeId1).isEmpty());
214 public void getEndpoint() {
215 EpKey epKey = new EpKey(endpoint1.getL2Context(), endpoint1.getMacAddress());
216 manager.processEndpoint(null, endpoint1);
217 Assert.assertEquals(endpoint1, manager.getEndpoint(epKey));
220 @SuppressWarnings("unchecked")
222 public void getEndpointsL3PrefixForTenantTest() throws Exception {
223 ReadOnlyTransaction readTransaction = mock(ReadOnlyTransaction.class);
224 when(dataProvider.newReadOnlyTransaction()).thenReturn(readTransaction);
225 CheckedFuture<Optional<Endpoints>, ReadFailedException> resultFuture = mock(CheckedFuture.class);
226 when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(
228 Optional<Endpoints> optional = mock(Optional.class);
229 when(resultFuture.checkedGet()).thenReturn(optional);
230 when(optional.isPresent()).thenReturn(true);
231 Endpoints endpoints = mock(Endpoints.class);
232 when(optional.get()).thenReturn(endpoints);
233 EndpointL3Prefix endpointL3Prefix = mock(EndpointL3Prefix.class);
234 when(endpoints.getEndpointL3Prefix()).thenReturn(Collections.singletonList(endpointL3Prefix));
235 when(endpointL3Prefix.getTenant()).thenReturn(tenantId);
237 Collection<EndpointL3Prefix> result = manager.getEndpointsL3PrefixForTenant(tenantId);
238 Assert.assertTrue(result.contains(endpointL3Prefix));
241 @SuppressWarnings("unchecked")
243 public void getEndpointsFromDataStoreTest() throws Exception {
244 ReadOnlyTransaction transaction = mock(ReadOnlyTransaction.class);
245 when(dataProvider.newReadOnlyTransaction()).thenReturn(transaction);
246 CheckedFuture<Optional<Endpoints>, ReadFailedException> checkedFuture = mock(CheckedFuture.class);
247 when(transaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(checkedFuture);
248 Optional<Endpoints> optional = mock(Optional.class);
249 when(checkedFuture.checkedGet()).thenReturn(optional);
250 when(optional.isPresent()).thenReturn(false);
251 Assert.assertNull(manager.getEndpointsFromDataStore());
253 when(optional.isPresent()).thenReturn(true);
254 Endpoints endpoints = mock(Endpoints.class);
255 when(optional.get()).thenReturn(endpoints);
256 Assert.assertEquals(endpoints, manager.getEndpointsFromDataStore());
258 manager = new EndpointManager(null, rpcRegistry, notificationService, executor, switchManager);
259 Assert.assertNull(manager.getEndpointsFromDataStore());
263 public void getL3EndpointsTestEndpointsNull() throws Exception {
264 Assert.assertNull(manager.getL3Endpoints());
268 public void getL3EndpointsTestEndpointL3Null() throws Exception {
269 when(optionalRead.isPresent()).thenReturn(true);
270 Endpoints endpoints = mock(Endpoints.class);
271 when(optionalRead.get()).thenReturn(endpoints);
272 when(endpoints.getEndpointL3()).thenReturn(null);
274 Assert.assertNull(manager.getL3Endpoints());
278 public void getL3EndpointsTest() throws Exception {
279 when(optionalRead.isPresent()).thenReturn(true);
280 Endpoints endpoints = mock(Endpoints.class);
281 when(optionalRead.get()).thenReturn(endpoints);
282 List<EndpointL3> endpointL3List = Collections.singletonList(mock(EndpointL3.class));
283 when(endpoints.getEndpointL3()).thenReturn(endpointL3List);
285 Assert.assertEquals(endpointL3List, manager.getL3Endpoints());
289 public void getL3EpWithNatByL2KeyTest() {
290 when(optionalRead.isPresent()).thenReturn(true);
291 Endpoints endpoints = mock(Endpoints.class);
292 when(optionalRead.get()).thenReturn(endpoints);
293 EndpointL3 endpointL3 = mock(EndpointL3.class);
294 List<EndpointL3> endpointL3List = Collections.singletonList(endpointL3);
295 when(endpoints.getEndpointL3()).thenReturn(endpointL3List);
297 OfOverlayL3Nat overlayL3Nat = mock(OfOverlayL3Nat.class);
298 when(endpointL3.getAugmentation(OfOverlayL3Nat.class)).thenReturn(overlayL3Nat);
299 NaptTranslations naptTranslations = mock(NaptTranslations.class);
300 when(overlayL3Nat.getNaptTranslations()).thenReturn(mock(NaptTranslations.class));
301 when(naptTranslations.getNaptTranslation()).thenReturn(Collections.singletonList(mock(NaptTranslation.class)));
303 when(endpointL3.getL2Context()).thenReturn(mock(L2BridgeDomainId.class));
304 when(endpointL3.getMacAddress()).thenReturn(mock(MacAddress.class));
306 Map<EndpointKey, EndpointL3> result = manager.getL3EpWithNatByL2Key();
307 Assert.assertTrue(result.containsValue(endpointL3));
311 public void getL3EpWithNatByL2KeyTestL3EpsNull() {
312 Map<EndpointKey, EndpointL3> result = manager.getL3EpWithNatByL2Key();
313 Assert.assertTrue(result.isEmpty());
317 public void getL3EpWithNatByL2KeyTestGetMacAddressNull() {
318 when(optionalRead.isPresent()).thenReturn(true);
319 Endpoints endpoints = mock(Endpoints.class);
320 when(optionalRead.get()).thenReturn(endpoints);
321 EndpointL3 endpointL3 = mock(EndpointL3.class);
322 List<EndpointL3> endpointL3List = Collections.singletonList(endpointL3);
323 when(endpoints.getEndpointL3()).thenReturn(endpointL3List);
325 OfOverlayL3Nat overlayL3Nat = mock(OfOverlayL3Nat.class);
326 when(endpointL3.getAugmentation(OfOverlayL3Nat.class)).thenReturn(overlayL3Nat);
327 NaptTranslations naptTranslations = mock(NaptTranslations.class);
328 when(overlayL3Nat.getNaptTranslations()).thenReturn(mock(NaptTranslations.class));
329 when(naptTranslations.getNaptTranslation()).thenReturn(Collections.singletonList(mock(NaptTranslation.class)));
331 when(endpointL3.getL2Context()).thenReturn(mock(L2BridgeDomainId.class));
332 when(endpointL3.getMacAddress()).thenReturn(null);
334 Map<EndpointKey, EndpointL3> result = manager.getL3EpWithNatByL2Key();
335 Assert.assertTrue(result.isEmpty());
339 public void getL3EpWithNatByL2KeyTestGetL2ContextNull() {
340 when(optionalRead.isPresent()).thenReturn(true);
341 Endpoints endpoints = mock(Endpoints.class);
342 when(optionalRead.get()).thenReturn(endpoints);
343 EndpointL3 endpointL3 = mock(EndpointL3.class);
344 List<EndpointL3> endpointL3List = Collections.singletonList(endpointL3);
345 when(endpoints.getEndpointL3()).thenReturn(endpointL3List);
347 OfOverlayL3Nat overlayL3Nat = mock(OfOverlayL3Nat.class);
348 when(endpointL3.getAugmentation(OfOverlayL3Nat.class)).thenReturn(overlayL3Nat);
349 NaptTranslations naptTranslations = mock(NaptTranslations.class);
350 when(overlayL3Nat.getNaptTranslations()).thenReturn(mock(NaptTranslations.class));
351 when(naptTranslations.getNaptTranslation()).thenReturn(Collections.singletonList(mock(NaptTranslation.class)));
353 when(endpointL3.getL2Context()).thenReturn(null);
354 when(endpointL3.getMacAddress()).thenReturn(mock(MacAddress.class));
356 Map<EndpointKey, EndpointL3> result = manager.getL3EpWithNatByL2Key();
357 Assert.assertTrue(result.isEmpty());
361 public void getNaptAugL3EndpointTest() {
362 EndpointL3 endpointL3 = mock(EndpointL3.class);
363 OfOverlayL3Nat ofOverlayL3Nat = mock(OfOverlayL3Nat.class);
364 when(endpointL3.getAugmentation(OfOverlayL3Nat.class)).thenReturn(ofOverlayL3Nat);
365 NaptTranslations naptTranslations = mock(NaptTranslations.class);
366 when(ofOverlayL3Nat.getNaptTranslations()).thenReturn(naptTranslations);
367 when(naptTranslations.getNaptTranslation()).thenReturn(null);
368 when(naptTranslations.getNaptTranslation()).thenReturn(Collections.singletonList(mock(NaptTranslation.class)));
370 Assert.assertNotNull(manager.getNaptAugL3Endpoint(endpointL3));
374 public void getNaptAugL3EndpointTestNull() {
375 EndpointL3 endpointL3 = mock(EndpointL3.class);
376 when(endpointL3.getAugmentation(OfOverlayL3Nat.class)).thenReturn(null);
377 Assert.assertNull(manager.getNaptAugL3Endpoint(endpointL3));
379 OfOverlayL3Nat ofOverlayL3Nat = mock(OfOverlayL3Nat.class);
380 when(endpointL3.getAugmentation(OfOverlayL3Nat.class)).thenReturn(ofOverlayL3Nat);
381 when(ofOverlayL3Nat.getNaptTranslations()).thenReturn(null);
382 Assert.assertNull(manager.getNaptAugL3Endpoint(endpointL3));
384 NaptTranslations naptTranslations = mock(NaptTranslations.class);
385 when(ofOverlayL3Nat.getNaptTranslations()).thenReturn(naptTranslations);
386 when(naptTranslations.getNaptTranslation()).thenReturn(null);
387 Assert.assertNull(manager.getNaptAugL3Endpoint(endpointL3));
391 public void getEndpointsForGroupTest() {
392 EgKey newEgKey = new EgKey(tenantId, endpointGroupId);
393 Assert.assertTrue(manager.getEndpointsForGroup(newEgKey).isEmpty());
394 manager.processEndpoint(null, endpoint1);
395 Assert.assertFalse(manager.getEndpointsForGroup(newEgKey).isEmpty());
399 public void getConditionsForEndpoint() {
400 Endpoint endpoint = mock(Endpoint.class);
401 when(endpoint.getCondition()).thenReturn(null);
402 Assert.assertTrue(manager.getConditionsForEndpoint(endpoint).isEmpty());
404 List<ConditionName> conditionNameList = Collections.singletonList(mock(ConditionName.class));
405 when(endpoint.getCondition()).thenReturn(conditionNameList);
406 Assert.assertEquals(conditionNameList, manager.getConditionsForEndpoint(endpoint));
410 public void updateEndpointL3TestNewL3EpValidExternalTrue() throws Exception {
411 when(newL3Ep.getTenant()).thenReturn(mock(TenantId.class));
412 when(newL3Ep.getEndpointGroup()).thenReturn(mock(EndpointGroupId.class));
413 when(newL3Ep.getL3Context()).thenReturn(mock(L3ContextId.class));
414 when(newL3Ep.getIpAddress()).thenReturn(mock(IpAddress.class));
416 OfOverlayL3Context ofOverlayL3Context = mock(OfOverlayL3Context.class);
417 when(newL3Ep.getAugmentation(OfOverlayL3Context.class)).thenReturn(ofOverlayL3Context);
418 when(ofOverlayL3Context.getLocationType()).thenReturn(LocationType.External);
420 NetworkDomainId networkDomainId = mock(NetworkDomainId.class);
421 when(newL3Ep.getNetworkContainment()).thenReturn(networkDomainId);
423 EndpointL3Key endpointL3Key = mock(EndpointL3Key.class);
424 when(newL3Ep.getKey()).thenReturn(endpointL3Key);
425 IpAddress ipAddress = mock(IpAddress.class);
426 when(endpointL3Key.getIpAddress()).thenReturn(ipAddress);
428 manager.processL3Endpoint(null, newL3Ep);
429 verify(endpointListener,never()).endpointUpdated(any(EpKey.class));
433 public void updateEndpointL3TestNewL3EpValidExternalTrueNetworkContainmentNull() throws Exception {
434 when(newL3Ep.getTenant()).thenReturn(mock(TenantId.class));
435 when(newL3Ep.getEndpointGroup()).thenReturn(mock(EndpointGroupId.class));
436 when(newL3Ep.getL3Context()).thenReturn(mock(L3ContextId.class));
437 when(newL3Ep.getIpAddress()).thenReturn(mock(IpAddress.class));
439 OfOverlayL3Context ofOverlayL3Context = mock(OfOverlayL3Context.class);
440 when(newL3Ep.getAugmentation(OfOverlayL3Context.class)).thenReturn(ofOverlayL3Context);
441 when(ofOverlayL3Context.getLocationType()).thenReturn(LocationType.External);
443 when(newL3Ep.getNetworkContainment()).thenReturn(null);
445 EndpointL3Key endpointL3Key = mock(EndpointL3Key.class);
446 when(newL3Ep.getKey()).thenReturn(endpointL3Key);
447 IpAddress ipAddress = mock(IpAddress.class);
448 when(endpointL3Key.getIpAddress()).thenReturn(ipAddress);
450 manager.processL3Endpoint(null, newL3Ep);
451 verify(endpointListener,never()).endpointUpdated(any(EpKey.class));
455 public void updateEndpointL3TestNewL3EpValidInternal() throws Exception {
456 when(newL3Ep.getTenant()).thenReturn(mock(TenantId.class));
457 when(newL3Ep.getEndpointGroup()).thenReturn(mock(EndpointGroupId.class));
458 when(newL3Ep.getL3Context()).thenReturn(mock(L3ContextId.class));
459 when(newL3Ep.getIpAddress()).thenReturn(mock(IpAddress.class));
461 OfOverlayL3Context ofOverlayL3Context = mock(OfOverlayL3Context.class);
462 when(newL3Ep.getAugmentation(OfOverlayL3Context.class)).thenReturn(ofOverlayL3Context);
463 when(ofOverlayL3Context.getLocationType()).thenReturn(LocationType.External);
465 when(newL3Ep.getNetworkContainment()).thenReturn(null);
467 when(newL3Ep.getL2Context()).thenReturn(mock(L2BridgeDomainId.class));
468 when(newL3Ep.getMacAddress()).thenReturn(mock(MacAddress.class));
470 manager.processL3Endpoint(null, newL3Ep);
471 verify(endpointListener).endpointUpdated(any(EpKey.class));
475 public void updateEndpointL3TestNewL3EpValidFalse() throws Exception {
476 when(newL3Ep.getTenant()).thenReturn(mock(TenantId.class));
477 when(newL3Ep.getEndpointGroup()).thenReturn(mock(EndpointGroupId.class));
478 when(newL3Ep.getL3Context()).thenReturn(mock(L3ContextId.class));
479 when(newL3Ep.getIpAddress()).thenReturn(null);
481 manager.processL3Endpoint(null, newL3Ep);
482 verify(endpointListener,never()).endpointUpdated(any(EpKey.class));
486 public void updateEndpointL3TestDelete() throws Exception {
487 manager.processL3Endpoint(oldL3Ep, null);
488 verify(endpointListener).endpointUpdated(any(EpKey.class));
492 public void updateEndpointTestNewEndpointRemove() {
493 Collection<Endpoint> collection;
494 manager.processEndpoint(null, endpoint2);
495 verify(endpointListener).endpointUpdated(any(EpKey.class));
496 verify(endpointListener).nodeEndpointUpdated(any(NodeId.class), any(EpKey.class));
497 collection = manager.getEndpointsForGroup(new EgKey(tenantId, endpointGroupId));
498 Assert.assertFalse(collection.isEmpty());
500 manager.processEndpoint(endpoint2, null);
501 verify(endpointListener, times(2)).endpointUpdated(any(EpKey.class));
502 verify(endpointListener, times(2)).nodeEndpointUpdated(any(NodeId.class), any(EpKey.class));
503 collection = manager.getEndpointsForGroup(new EgKey(tenantId, endpointGroupId));
504 Assert.assertTrue(collection.isEmpty());
508 public void updateEndpointTestNewLocNullOldLocNullOfOverlayContextAugmentationNull() {
509 when(endpoint1.getAugmentation(OfOverlayContext.class)).thenReturn(null);
510 when(endpoint2.getAugmentation(OfOverlayContext.class)).thenReturn(null);
512 manager.processEndpoint(endpoint1, endpoint2);
513 verify(endpointListener, never()).endpointUpdated(any(EpKey.class));
514 verify(endpointListener, never()).nodeEndpointUpdated(any(NodeId.class), any(EpKey.class));
518 public void updateEndpointTestNewLocNullOldLocNull() {
519 when(context1.getNodeId()).thenReturn(null);
520 when(context2.getNodeId()).thenReturn(null);
521 when(context1.getLocationType()).thenReturn(LocationType.External);
522 when(context2.getLocationType()).thenReturn(LocationType.External);
524 manager.processEndpoint(endpoint1, endpoint2);
525 verify(endpointListener, never()).endpointUpdated(any(EpKey.class));
526 verify(endpointListener, never()).nodeEndpointUpdated(any(NodeId.class), any(EpKey.class));
530 public void updateEndpointTestNewLocNullOldLocNullExternalPut() {
531 when(endpoint1.getAugmentation(OfOverlayContext.class)).thenReturn(null);
532 when(endpoint2.getAugmentation(OfOverlayContext.class)).thenReturn(null);
534 manager.processEndpoint(endpoint1, endpoint2);
535 verify(endpointListener, never()).endpointUpdated(any(EpKey.class));
536 verify(endpointListener, never()).nodeEndpointUpdated(any(NodeId.class), any(EpKey.class));
540 public void updateEndpointTestNewLocNullOldLocNullExternalRemove() {
541 when(context1.getNodeId()).thenReturn(null);
542 when(context1.getLocationType()).thenReturn(LocationType.External);
544 manager.processEndpoint(endpoint1, null);
545 verify(endpointListener, never()).endpointUpdated(any(EpKey.class));
546 verify(endpointListener, never()).nodeEndpointUpdated(any(NodeId.class), any(EpKey.class));
550 public void updateEndpointTestUpdate() {
551 Collection<Endpoint> collection;
552 when(nodeId2.getValue()).thenReturn("nodeValue1");
554 manager.processEndpoint(endpoint1, endpoint2);
555 verify(endpointListener).endpointUpdated(any(EpKey.class));
556 verify(endpointListener).nodeEndpointUpdated(any(NodeId.class), any(EpKey.class));
557 collection = manager.getEndpointsForGroup(new EgKey(tenantId, endpointGroupId));
558 Assert.assertFalse(collection.isEmpty());
561 @SuppressWarnings({"unchecked"})
563 public void addEndpointFromL3EndpointTest() throws Exception {
564 EndpointL3 l3Ep = mock(EndpointL3.class);
565 ReadWriteTransaction rwTx = mock(ReadWriteTransaction.class);
566 OfOverlayL3Context ofL3Ctx = mock(OfOverlayL3Context.class);
567 when(l3Ep.getAugmentation(OfOverlayL3Context.class)).thenReturn(ofL3Ctx);
569 CheckedFuture<Optional<Tenant>, ReadFailedException> checkedFuture = mock(CheckedFuture.class);
570 when(rwTx.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(checkedFuture);
571 Optional<Tenant> optional = mock(Optional.class);
572 when(checkedFuture.checkedGet()).thenReturn(optional);
573 Tenant tenant = mock(Tenant.class);
574 when(optional.isPresent()).thenReturn(true);
575 when(optional.get()).thenReturn(tenant);
577 L2BridgeDomain l2BridgeDomain = mock(L2BridgeDomain.class);
578 when(tenant.getL2BridgeDomain()).thenReturn(Collections.singletonList(l2BridgeDomain));
579 L2BridgeDomainId l2BridgeDomainId = mock(L2BridgeDomainId.class);
580 when(l2BridgeDomain.getId()).thenReturn(l2BridgeDomainId);
581 String l2bdValue = UUID.randomUUID().toString();
582 when(l2BridgeDomainId.getValue()).thenReturn(l2bdValue);
584 NetworkDomainId networkDomainId = mock(NetworkDomainId.class);
585 when(l3Ep.getNetworkContainment()).thenReturn(networkDomainId);
586 when(networkDomainId.getValue()).thenReturn(l2bdValue);
588 Method method = EndpointManager.class.getDeclaredMethod("addEndpointFromL3Endpoint", EndpointL3.class,
589 ReadWriteTransaction.class);
590 method.setAccessible(true);
591 method.invoke(manager, l3Ep, rwTx);
592 verify(rwTx).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Endpoint.class));
595 @SuppressWarnings({"unchecked"})
597 public void addEndpointFromL3EndpointTestTenantPresentFalse() throws Exception {
598 EndpointL3 l3Ep = mock(EndpointL3.class);
599 ReadWriteTransaction rwTx = mock(ReadWriteTransaction.class);
600 OfOverlayL3Context ofL3Ctx = mock(OfOverlayL3Context.class);
601 when(l3Ep.getAugmentation(OfOverlayL3Context.class)).thenReturn(ofL3Ctx);
603 CheckedFuture<Optional<Tenant>, ReadFailedException> checkedFuture = mock(CheckedFuture.class);
604 when(rwTx.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(checkedFuture);
605 Optional<Tenant> optional = mock(Optional.class);
606 when(checkedFuture.checkedGet()).thenReturn(optional);
607 when(optional.isPresent()).thenReturn(false);
609 Method method = EndpointManager.class.getDeclaredMethod("addEndpointFromL3Endpoint", EndpointL3.class,
610 ReadWriteTransaction.class);
611 method.setAccessible(true);
612 method.invoke(manager, l3Ep, rwTx);
613 verify(rwTx).cancel();
616 // ************************
617 // Endpoint Augmentation
618 // ************************
621 public void getOfOverlayContextFromL3EndpointTest() throws Exception {
622 OfOverlayL3ContextBuilder ofL3CtxBuilder = new OfOverlayL3ContextBuilder();
623 OfOverlayContext result;
624 Method method = EndpointManager.class.getDeclaredMethod("getOfOverlayContextFromL3Endpoint",
625 OfOverlayL3Context.class);
626 method.setAccessible(true);
628 result = (OfOverlayContext) method.invoke(manager, ofL3CtxBuilder.build());
629 Assert.assertEquals(null, result.getInterfaceId());
630 Assert.assertEquals(null, result.getLocationType());
631 Assert.assertEquals(null, result.getNodeConnectorId());
632 Assert.assertEquals(null, result.getNodeId());
633 Assert.assertEquals(null, result.getPortName());
635 UniqueId interfaceId = new UniqueId("iface");
636 ofL3CtxBuilder.setInterfaceId(interfaceId);
637 LocationType locationType = LocationType.External;
638 ofL3CtxBuilder.setLocationType(locationType);
639 NodeConnectorId nodeConnectorId = new NodeConnectorId("nc");
640 ofL3CtxBuilder.setNodeConnectorId(nodeConnectorId);
641 NodeId nodeId = new NodeId("nId");
642 ofL3CtxBuilder.setNodeId(nodeId);
643 Name portName = new Name("pName");
644 ofL3CtxBuilder.setPortName(portName);
646 result = (OfOverlayContext) method.invoke(manager, ofL3CtxBuilder.build());
647 Assert.assertEquals(interfaceId, result.getInterfaceId());
648 Assert.assertEquals(locationType, result.getLocationType());
649 Assert.assertEquals(nodeConnectorId, result.getNodeConnectorId());
650 Assert.assertEquals(nodeId, result.getNodeId());
651 Assert.assertEquals(portName, result.getPortName());
655 public void closeTest() throws Exception {
657 verify(listenerReg).close();
658 manager = new EndpointManager(null, rpcRegistry, notificationService, executor, switchManager);
660 verify(listenerReg, times(1)).close();
668 public void getEgKeyTest() {
669 Assert.assertNotNull(manager.getEgKey(endpoint1));
670 Assert.assertNull(manager.getEgKey(null));
672 when(endpoint1.getTenant()).thenReturn(null);
673 Assert.assertNull(manager.getEgKey(endpoint1));
675 when(endpoint1.getTenant()).thenReturn(tenantId);
676 when(endpoint1.getEndpointGroup()).thenReturn(null);
677 Assert.assertNotNull(manager.getEgKey(endpoint1));
679 when(endpoint1.getEndpointGroup()).thenReturn(endpointGroupId);
680 when(endpoint1.getEndpointGroups()).thenReturn(null);
681 Assert.assertNotNull(manager.getEgKey(endpoint1));
683 when(endpoint1.getEndpointGroup()).thenReturn(null);
684 Assert.assertNull(manager.getEgKey(endpoint1));
686 when(endpoint1.getEndpointGroup()).thenReturn(endpointGroupId);
687 when(endpoint1.getL2Context()).thenReturn(null);
688 Assert.assertNull(manager.getEgKey(endpoint1));
690 when(endpoint1.getL2Context()).thenReturn(l2BridgeDomainId);
691 when(endpoint1.getMacAddress()).thenReturn(null);
692 Assert.assertNull(manager.getEgKey(endpoint1));
696 public void getEgKeysForEndpointTest() {
697 Endpoint endpoint = mock(Endpoint.class);
700 when(endpoint.getEndpointGroups()).thenReturn(null);
701 egKeys = manager.getEgKeysForEndpoint(endpoint);
702 Assert.assertTrue(egKeys.isEmpty());
704 EndpointGroupId endpointGroupId = mock(EndpointGroupId.class);
705 when(endpoint.getEndpointGroup()).thenReturn(endpointGroupId);
706 egKeys = manager.getEgKeysForEndpoint(endpoint);
707 Assert.assertEquals(1, egKeys.size());
709 EndpointGroupId epgId = mock(EndpointGroupId.class);
710 List<EndpointGroupId> endpointGroups = Collections.singletonList(epgId);
711 when(endpoint.getEndpointGroups()).thenReturn(endpointGroups);
712 egKeys = manager.getEgKeysForEndpoint(endpoint);
713 Assert.assertEquals(2, egKeys.size());
717 public void isExternalIsInternalTest() {
718 Endpoint endpoint = mock(Endpoint.class);
719 when(endpoint.getAugmentation(OfOverlayContext.class)).thenReturn(null);
720 Assert.assertFalse(manager.isExternal(endpoint));
721 Assert.assertTrue(manager.isInternal(endpoint));
723 OfOverlayContext ofc = mock(OfOverlayContext.class);
724 when(endpoint.getAugmentation(OfOverlayContext.class)).thenReturn(ofc);
725 when(ofc.getLocationType()).thenReturn(null);
726 Assert.assertFalse(manager.isExternal(endpoint));
727 Assert.assertTrue(manager.isInternal(endpoint));
729 when(ofc.getLocationType()).thenReturn(LocationType.Internal);
730 Assert.assertFalse(manager.isExternal(endpoint));
731 Assert.assertTrue(manager.isInternal(endpoint));
733 when(ofc.getLocationType()).thenReturn(LocationType.External);
734 Assert.assertTrue(manager.isExternal(endpoint));
735 Assert.assertFalse(manager.isInternal(endpoint));