renderers/ofoverlay/src/test/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/endpoint/EndpointManagerTest.java

   1 /*
   2  * Copyright (c) 2015 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
   9 package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.endpoint;
  10
  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;
  18
  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;
  24 import java.util.Map;
  25 import java.util.Set;
  26 import java.util.UUID;
  27 import java.util.concurrent.ScheduledExecutorService;
  28
  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;
  80
  81 import com.google.common.base.Optional;
  82 import com.google.common.util.concurrent.CheckedFuture;
  83
  84 public class EndpointManagerTest {
  85
  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;
 106
 107     @SuppressWarnings("unchecked")
 108     @Before
 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);
 121         when(
 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);
 125
 126         manager = spy(new EndpointManager(dataProvider, rpcRegistry, notificationService, executor, switchManager));
 127         endpointListener = mock(EndpointListener.class);
 128         manager.registerListener(endpointListener);
 129
 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");
 154
 155         // onDataChanged
 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);
 161
 162         // updateEndpointL3
 163         oldL3Ep = mock(EndpointL3.class);
 164         newL3Ep = mock(EndpointL3.class);
 165
 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(
 171                 checkedFutureRead);
 172         optionalRead = mock(Optional.class);
 173         when(checkedFutureRead.checkedGet()).thenReturn(optionalRead);
 174         when(optionalRead.isPresent()).thenReturn(false);
 175
 176     }
 177
 178     // ***************
 179     // EndpointManager
 180     // ***************
 181
 182     @Test
 183     public void getGroupsForNodeTest() {
 184         Assert.assertTrue(manager.getGroupsForNode(nodeId1).isEmpty());
 185         manager.processEndpoint(null, endpoint1);
 186         Assert.assertFalse(manager.getGroupsForNode(nodeId1).isEmpty());
 187     }
 188
 189     @Test
 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());
 195     }
 196
 197     @Test
 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());
 203     }
 204
 205     @Test
 206     public void getEndpointsForNodeTestNodeId() {
 207         Assert.assertTrue(manager.getEndpointsForNode(nodeId1).isEmpty());
 208         manager.processEndpoint(null, endpoint1);
 209         Assert.assertFalse(manager.getEndpointsForNode(nodeId1).isEmpty());
 210     }
 211
 212     @Test
 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));
 217     }
 218
 219     @SuppressWarnings("unchecked")
 220     @Test
 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(
 226                 resultFuture);
 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);
 235
 236         Collection<EndpointL3Prefix> result = manager.getEndpointsL3PrefixForTenant(tenantId);
 237         Assert.assertTrue(result.contains(endpointL3Prefix));
 238     }
 239
 240     @SuppressWarnings("unchecked")
 241     @Test
 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());
 251
 252         when(optional.isPresent()).thenReturn(true);
 253         Endpoints endpoints = mock(Endpoints.class);
 254         when(optional.get()).thenReturn(endpoints);
 255         Assert.assertEquals(endpoints, manager.getEndpointsFromDataStore());
 256
 257         manager = new EndpointManager(null, rpcRegistry, notificationService, executor, switchManager);
 258         Assert.assertNull(manager.getEndpointsFromDataStore());
 259     }
 260
 261     @Test
 262     public void getL3EndpointsTestEndpointsNull() throws Exception {
 263         Assert.assertNull(manager.getL3Endpoints());
 264     }
 265
 266     @Test
 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);
 272
 273         Assert.assertNull(manager.getL3Endpoints());
 274     }
 275
 276     @Test
 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);
 283
 284         Assert.assertEquals(endpointL3List, manager.getL3Endpoints());
 285     }
 286
 287     @Test
 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);
 295
 296         NatAddress overlayL3Nat = mock(NatAddress.class);
 297         when(endpointL3.getAugmentation(NatAddress.class)).thenReturn(overlayL3Nat);
 298         when(overlayL3Nat.getNatAddress()).thenReturn(mock(IpAddress.class));
 299
 300         when(endpointL3.getL2Context()).thenReturn(mock(L2BridgeDomainId.class));
 301         when(endpointL3.getMacAddress()).thenReturn(mock(MacAddress.class));
 302
 303         Map<EndpointKey, EndpointL3> result = manager.getL3EpWithNatByL2Key();
 304         Assert.assertTrue(result.containsValue(endpointL3));
 305     }
 306
 307     @Test
 308     public void getL3EpWithNatByL2KeyTestL3EpsNull() {
 309         Map<EndpointKey, EndpointL3> result = manager.getL3EpWithNatByL2Key();
 310         Assert.assertTrue(result.isEmpty());
 311     }
 312
 313     @Test
 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);
 321
 322         NatAddress overlayL3Nat = mock(NatAddress.class);
 323         when(endpointL3.getAugmentation(NatAddress.class)).thenReturn(overlayL3Nat);
 324
 325         when(endpointL3.getL2Context()).thenReturn(mock(L2BridgeDomainId.class));
 326         when(endpointL3.getMacAddress()).thenReturn(null);
 327
 328         Map<EndpointKey, EndpointL3> result = manager.getL3EpWithNatByL2Key();
 329         Assert.assertTrue(result.isEmpty());
 330     }
 331
 332     @Test
 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);
 340
 341         NatAddress overlayL3Nat = mock(NatAddress.class);
 342         when(endpointL3.getAugmentation(NatAddress.class)).thenReturn(overlayL3Nat);
 343
 344         when(endpointL3.getL2Context()).thenReturn(null);
 345         when(endpointL3.getMacAddress()).thenReturn(mock(MacAddress.class));
 346
 347         Map<EndpointKey, EndpointL3> result = manager.getL3EpWithNatByL2Key();
 348         Assert.assertTrue(result.isEmpty());
 349     }
 350
 351     @Test
 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());
 357     }
 358
 359     @Test
 360     public void getConditionsForEndpoint() {
 361         Endpoint endpoint = mock(Endpoint.class);
 362         when(endpoint.getCondition()).thenReturn(null);
 363         Assert.assertTrue(manager.getConditionsForEndpoint(endpoint).isEmpty());
 364
 365         List<ConditionName> conditionNameList = Collections.singletonList(mock(ConditionName.class));
 366         when(endpoint.getCondition()).thenReturn(conditionNameList);
 367         Assert.assertEquals(conditionNameList, manager.getConditionsForEndpoint(endpoint));
 368     }
 369
 370     @Test
 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));
 376
 377         OfOverlayL3Context ofOverlayL3Context = mock(OfOverlayL3Context.class);
 378         when(newL3Ep.getAugmentation(OfOverlayL3Context.class)).thenReturn(ofOverlayL3Context);
 379         when(ofOverlayL3Context.getLocationType()).thenReturn(LocationType.External);
 380
 381         NetworkDomainId networkDomainId = mock(NetworkDomainId.class);
 382         when(newL3Ep.getNetworkContainment()).thenReturn(networkDomainId);
 383
 384         EndpointL3Key endpointL3Key = mock(EndpointL3Key.class);
 385         when(newL3Ep.getKey()).thenReturn(endpointL3Key);
 386         IpAddress ipAddress = mock(IpAddress.class);
 387         when(endpointL3Key.getIpAddress()).thenReturn(ipAddress);
 388
 389         manager.processL3Endpoint(null, newL3Ep);
 390         verify(endpointListener,never()).endpointUpdated(any(EpKey.class));
 391     }
 392
 393     @Test
 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));
 399
 400         OfOverlayL3Context ofOverlayL3Context = mock(OfOverlayL3Context.class);
 401         when(newL3Ep.getAugmentation(OfOverlayL3Context.class)).thenReturn(ofOverlayL3Context);
 402         when(ofOverlayL3Context.getLocationType()).thenReturn(LocationType.External);
 403
 404         when(newL3Ep.getNetworkContainment()).thenReturn(null);
 405
 406         EndpointL3Key endpointL3Key = mock(EndpointL3Key.class);
 407         when(newL3Ep.getKey()).thenReturn(endpointL3Key);
 408         IpAddress ipAddress = mock(IpAddress.class);
 409         when(endpointL3Key.getIpAddress()).thenReturn(ipAddress);
 410
 411         manager.processL3Endpoint(null, newL3Ep);
 412         verify(endpointListener,never()).endpointUpdated(any(EpKey.class));
 413     }
 414
 415     @Test
 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));
 421
 422         OfOverlayL3Context ofOverlayL3Context = mock(OfOverlayL3Context.class);
 423         when(newL3Ep.getAugmentation(OfOverlayL3Context.class)).thenReturn(ofOverlayL3Context);
 424         when(ofOverlayL3Context.getLocationType()).thenReturn(LocationType.External);
 425
 426         when(newL3Ep.getNetworkContainment()).thenReturn(null);
 427
 428         when(newL3Ep.getL2Context()).thenReturn(mock(L2BridgeDomainId.class));
 429         when(newL3Ep.getMacAddress()).thenReturn(mock(MacAddress.class));
 430
 431         manager.processL3Endpoint(null, newL3Ep);
 432         verify(endpointListener).endpointUpdated(any(EpKey.class));
 433     }
 434
 435     @Test
 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);
 441
 442         manager.processL3Endpoint(null, newL3Ep);
 443         verify(endpointListener,never()).endpointUpdated(any(EpKey.class));
 444     }
 445
 446     @Test
 447     public void updateEndpointL3TestDelete() throws Exception {
 448         manager.processL3Endpoint(oldL3Ep, null);
 449         verify(endpointListener).endpointUpdated(any(EpKey.class));
 450     }
 451
 452     @Test
 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());
 460
 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());
 466     }
 467
 468     @Test
 469     public void updateEndpointTestNewLocNullOldLocNullOfOverlayContextAugmentationNull() {
 470         when(endpoint1.getAugmentation(OfOverlayContext.class)).thenReturn(null);
 471         when(endpoint2.getAugmentation(OfOverlayContext.class)).thenReturn(null);
 472
 473         manager.processEndpoint(endpoint1, endpoint2);
 474         verify(endpointListener, never()).endpointUpdated(any(EpKey.class));
 475         verify(endpointListener, never()).nodeEndpointUpdated(any(NodeId.class), any(EpKey.class));
 476     }
 477
 478     @Test
 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);
 484
 485         manager.processEndpoint(endpoint1, endpoint2);
 486         verify(endpointListener, never()).endpointUpdated(any(EpKey.class));
 487         verify(endpointListener, never()).nodeEndpointUpdated(any(NodeId.class), any(EpKey.class));
 488     }
 489
 490     @Test
 491     public void updateEndpointTestNewLocNullOldLocNullExternalPut() {
 492         when(endpoint1.getAugmentation(OfOverlayContext.class)).thenReturn(null);
 493         when(endpoint2.getAugmentation(OfOverlayContext.class)).thenReturn(null);
 494
 495         manager.processEndpoint(endpoint1, endpoint2);
 496         verify(endpointListener, never()).endpointUpdated(any(EpKey.class));
 497         verify(endpointListener, never()).nodeEndpointUpdated(any(NodeId.class), any(EpKey.class));
 498     }
 499
 500     @Test
 501     public void updateEndpointTestNewLocNullOldLocNullExternalRemove() {
 502         when(context1.getNodeId()).thenReturn(null);
 503         when(context1.getLocationType()).thenReturn(LocationType.External);
 504         manager.processEndpoint(null, endpoint1);
 505
 506         manager.processEndpoint(endpoint1, null);
 507         verify(endpointListener, never()).endpointUpdated(any(EpKey.class));
 508         verify(endpointListener, never()).nodeEndpointUpdated(any(NodeId.class), any(EpKey.class));
 509     }
 510
 511     /**
 512      * Endpoint changes it's location
 513      */
 514     @Test
 515     public void updateEndpointLocationTestUpdate() {
 516         Collection<Endpoint> collection;
 517         manager.processEndpoint(null, endpoint1);
 518
 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());
 525     }
 526
 527     /**
 528      * Endpoint changes it's EPG
 529      */
 530     @Test
 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);
 537
 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());
 545     }
 546
 547     /**
 548      * Endpoint changes it's location and EPGs
 549      */
 550     @Test
 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);
 556
 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());
 565     }
 566
 567     /**
 568      * Endpoint becomes external when removing it's location augmentation.
 569      * This might happen when an endpoint is removed from a device.
 570      */
 571     @Test
 572     public void updateEndpointLocationRemovedTestUpdate() {
 573         Collection<Endpoint> collection;
 574         when(endpoint2.getAugmentation(OfOverlayContext.class)).thenReturn(null);
 575         manager.processEndpoint(null, endpoint1);
 576
 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());
 582     }
 583
 584     /**
 585      * Endpoint is created when adding location augmentation.
 586      * Endpoint is not external anymore.
 587      */
 588     @Test
 589     public void updateEndpointLocationAddedTestUpdate() {
 590         Collection<Endpoint> collection;
 591         when(endpoint1.getAugmentation(OfOverlayContext.class)).thenReturn(null);
 592         manager.processEndpoint(null, endpoint1);
 593
 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());
 599     }
 600
 601     @SuppressWarnings({"unchecked"})
 602     @Test
 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);
 608
 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);
 618
 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);
 625
 626         NetworkDomainId networkDomainId = mock(NetworkDomainId.class);
 627         when(l3Ep.getNetworkContainment()).thenReturn(networkDomainId);
 628         when(networkDomainId.getValue()).thenReturn(l2bdValue);
 629
 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));
 635     }
 636
 637     @SuppressWarnings({"unchecked"})
 638     @Test
 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);
 644
 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);
 650
 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();
 656     }
 657
 658     // ************************
 659     // Endpoint Augmentation
 660     // ************************
 661
 662     @Test
 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);
 669
 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());
 676
 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);
 687
 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());
 694     }
 695
 696     @Test
 697     public void closeTest() throws Exception {
 698         manager.close();
 699         verify(listenerReg).close();
 700         manager = new EndpointManager(null, rpcRegistry, notificationService, executor, switchManager);
 701         manager.close();
 702         verify(listenerReg, times(1)).close();
 703     }
 704
 705      //**************
 706      //Helper Functions
 707      //**************
 708
 709     @Test
 710     public void getEgKeyTest() {
 711         Assert.assertNotNull(manager.getEgKey(endpoint1));
 712         Assert.assertNull(manager.getEgKey(null));
 713
 714         when(endpoint1.getTenant()).thenReturn(null);
 715         Assert.assertNull(manager.getEgKey(endpoint1));
 716
 717         when(endpoint1.getTenant()).thenReturn(tenantId);
 718         when(endpoint1.getEndpointGroup()).thenReturn(null);
 719         Assert.assertNotNull(manager.getEgKey(endpoint1));
 720
 721         when(endpoint1.getEndpointGroup()).thenReturn(endpointGroupId);
 722         when(endpoint1.getEndpointGroups()).thenReturn(null);
 723         Assert.assertNotNull(manager.getEgKey(endpoint1));
 724
 725         when(endpoint1.getEndpointGroup()).thenReturn(null);
 726         Assert.assertNull(manager.getEgKey(endpoint1));
 727
 728         when(endpoint1.getEndpointGroup()).thenReturn(endpointGroupId);
 729         when(endpoint1.getL2Context()).thenReturn(null);
 730         Assert.assertNull(manager.getEgKey(endpoint1));
 731
 732         when(endpoint1.getL2Context()).thenReturn(l2BridgeDomainId);
 733         when(endpoint1.getMacAddress()).thenReturn(null);
 734         Assert.assertNull(manager.getEgKey(endpoint1));
 735     }
 736
 737     @Test
 738     public void getEgKeysForEndpointTest() {
 739         Endpoint endpoint = mock(Endpoint.class);
 740         Set<EgKey> egKeys;
 741
 742         when(endpoint.getEndpointGroups()).thenReturn(null);
 743         egKeys = manager.getEgKeysForEndpoint(endpoint);
 744         Assert.assertTrue(egKeys.isEmpty());
 745
 746         EndpointGroupId endpointGroupId = mock(EndpointGroupId.class);
 747         when(endpoint.getEndpointGroup()).thenReturn(endpointGroupId);
 748         egKeys = manager.getEgKeysForEndpoint(endpoint);
 749         Assert.assertEquals(1, egKeys.size());
 750
 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());
 756     }
 757
 758     @Test
 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));
 764
 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));
 770
 771         when(ofc.getLocationType()).thenReturn(LocationType.Internal);
 772         Assert.assertFalse(manager.isExternal(endpoint));
 773         Assert.assertTrue(manager.isInternal(endpoint));
 774
 775         when(ofc.getLocationType()).thenReturn(LocationType.External);
 776         Assert.assertTrue(manager.isExternal(endpoint));
 777         Assert.assertFalse(manager.isInternal(endpoint));
 778     }
 779 }