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.NetworkDomainId;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.EndpointService;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.Endpoints;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.Endpoint;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointKey;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3Key;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3Prefix;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.l3endpoint.rev151217.NatAddress;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayContext;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayL3Context;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.Tenant;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.ForwardingContext;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.L2BridgeDomain;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
  71 import org.opendaylight.yangtools.concepts.ListenerRegistration;
  72 import org.opendaylight.yangtools.yang.binding.DataObject;
  73 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  74 import org.opendaylight.yangtools.yang.binding.RpcService;
  75
  76 import com.google.common.base.Optional;
  77 import com.google.common.util.concurrent.CheckedFuture;
  78
  79 public class EndpointManagerTest {
  80
  81     private EndpointManager manager;
  82     private DataBroker dataProvider;
  83     private RpcProviderRegistry rpcRegistry;
  84     private NotificationService notificationService;
  85     private ScheduledExecutorService executor;
  86     private SwitchManager switchManager;
  87     private ListenerRegistration<DataChangeListener> listenerReg;
  88     private EndpointListener endpointListener;
  89     private Endpoint endpoint1;
  90     private Endpoint endpoint2;
  91     private TenantId tenantId;
  92     private EndpointGroupId endpointGroupId;
  93     private L2BridgeDomainId l2BridgeDomainId;
  94     private OfOverlayContext context1;
  95     private OfOverlayContext context2;
  96     private NodeId nodeId1;
  97     private NodeId nodeId2;
  98     private EndpointL3 oldL3Ep;
  99     private EndpointL3 newL3Ep;
 100     private Optional<Endpoints> optionalRead;
 101
 102     @SuppressWarnings("unchecked")
 103     @Before
 104     public void initialisation() throws Exception {
 105         dataProvider = mock(DataBroker.class);
 106         rpcRegistry = mock(RpcProviderRegistry.class);
 107         notificationService = mock(NotificationService.class);
 108         executor = mock(ScheduledExecutorService.class);
 109         switchManager = mock(SwitchManager.class);
 110         WriteTransaction writeTransaction = mock(WriteTransaction.class);
 111         when(dataProvider.newWriteOnlyTransaction()).thenReturn(writeTransaction);
 112         CheckedFuture<Void, TransactionCommitFailedException> checkedFutureWrite = mock(CheckedFuture.class);
 113         when(writeTransaction.submit()).thenReturn(checkedFutureWrite);
 114         BindingAwareBroker.RpcRegistration<EndpointService> rpcRegistration = mock(BindingAwareBroker.RpcRegistration.class);
 115         listenerReg = mock(ListenerRegistration.class);
 116         when(
 117                 dataProvider.registerDataChangeListener(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
 118                         any(DataChangeListener.class), any(DataChangeScope.class))).thenReturn(listenerReg);
 119         when(rpcRegistry.addRpcImplementation(any(Class.class), any(RpcService.class))).thenReturn(rpcRegistration);
 120
 121         manager = spy(new EndpointManager(dataProvider, rpcRegistry, notificationService, executor, switchManager));
 122         endpointListener = mock(EndpointListener.class);
 123         manager.registerListener(endpointListener);
 124
 125         endpoint1 = mock(Endpoint.class);
 126         endpoint2 = mock(Endpoint.class);
 127         tenantId = mock(TenantId.class);
 128         endpointGroupId = mock(EndpointGroupId.class);
 129         l2BridgeDomainId = mock(L2BridgeDomainId.class);
 130         MacAddress macAddress = mock(MacAddress.class);
 131         when(endpoint1.getTenant()).thenReturn(tenantId);
 132         when(endpoint1.getEndpointGroup()).thenReturn(endpointGroupId);
 133         when(endpoint1.getL2Context()).thenReturn(l2BridgeDomainId);
 134         when(endpoint1.getMacAddress()).thenReturn(macAddress);
 135         when(endpoint2.getTenant()).thenReturn(tenantId);
 136         when(endpoint2.getEndpointGroup()).thenReturn(endpointGroupId);
 137         when(endpoint2.getL2Context()).thenReturn(l2BridgeDomainId);
 138         when(endpoint2.getMacAddress()).thenReturn(macAddress);
 139         context1 = mock(OfOverlayContext.class);
 140         context2 = mock(OfOverlayContext.class);
 141         when(endpoint1.getAugmentation(OfOverlayContext.class)).thenReturn(context1);
 142         when(endpoint2.getAugmentation(OfOverlayContext.class)).thenReturn(context2);
 143         nodeId1 = mock(NodeId.class);
 144         nodeId2 = mock(NodeId.class);
 145         when(context1.getNodeId()).thenReturn(nodeId1);
 146         when(context2.getNodeId()).thenReturn(nodeId2);
 147         when(nodeId1.getValue()).thenReturn("nodeValue1");
 148         when(nodeId2.getValue()).thenReturn("nodeValue2");
 149
 150         // onDataChanged
 151         AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change = mock(AsyncDataChangeEvent.class);
 152         InstanceIdentifier<DataObject> endpointId = mock(InstanceIdentifier.class);
 153         Set<InstanceIdentifier<?>> removedPaths = new HashSet<>();
 154         removedPaths.add(endpointId);
 155         when(change.getRemovedPaths()).thenReturn(removedPaths);
 156
 157         // updateEndpointL3
 158         oldL3Ep = mock(EndpointL3.class);
 159         newL3Ep = mock(EndpointL3.class);
 160
 161         // getEndpointsFromDataStore
 162         ReadOnlyTransaction readTransaction = mock(ReadOnlyTransaction.class);
 163         when(dataProvider.newReadOnlyTransaction()).thenReturn(readTransaction);
 164         CheckedFuture<Optional<Endpoints>, ReadFailedException> checkedFutureRead = mock(CheckedFuture.class);
 165         when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(
 166                 checkedFutureRead);
 167         optionalRead = mock(Optional.class);
 168         when(checkedFutureRead.checkedGet()).thenReturn(optionalRead);
 169         when(optionalRead.isPresent()).thenReturn(false);
 170
 171     }
 172
 173     // ***************
 174     // EndpointManager
 175     // ***************
 176
 177     @Test
 178     public void getGroupsForNodeTest() {
 179         Assert.assertTrue(manager.getGroupsForNode(nodeId1).isEmpty());
 180         manager.processEndpoint(null, endpoint1);
 181         Assert.assertFalse(manager.getGroupsForNode(nodeId1).isEmpty());
 182     }
 183
 184     @Test
 185     public void getNodesForGroupTest() {
 186         EgKey egKey = mock(EgKey.class);
 187         Set<NodeId> nodesForGroup = manager.getNodesForGroup(egKey);
 188         Assert.assertNotNull(nodesForGroup);
 189         Assert.assertTrue(nodesForGroup.isEmpty());
 190     }
 191
 192     @Test
 193     public void getEndpointsForNodeTestNodeIdEgKey() {
 194         EgKey egKey = new EgKey(tenantId, endpointGroupId);
 195         Assert.assertTrue(manager.getEndpointsForNode(nodeId1, egKey).isEmpty());
 196         manager.processEndpoint(null, endpoint1);
 197         Assert.assertFalse(manager.getEndpointsForNode(nodeId1, egKey).isEmpty());
 198     }
 199
 200     @Test
 201     public void getEndpointsForNodeTestNodeId() {
 202         Assert.assertTrue(manager.getEndpointsForNode(nodeId1).isEmpty());
 203         manager.processEndpoint(null, endpoint1);
 204         Assert.assertFalse(manager.getEndpointsForNode(nodeId1).isEmpty());
 205     }
 206
 207     @Test
 208     public void getEndpoint() {
 209         EpKey epKey = new EpKey(endpoint1.getL2Context(), endpoint1.getMacAddress());
 210         manager.processEndpoint(null, endpoint1);
 211         Assert.assertEquals(endpoint1, manager.getEndpoint(epKey));
 212     }
 213
 214     @SuppressWarnings("unchecked")
 215     @Test
 216     public void getEndpointsL3PrefixForTenantTest() throws Exception {
 217         ReadOnlyTransaction readTransaction = mock(ReadOnlyTransaction.class);
 218         when(dataProvider.newReadOnlyTransaction()).thenReturn(readTransaction);
 219         CheckedFuture<Optional<Endpoints>, ReadFailedException> resultFuture = mock(CheckedFuture.class);
 220         when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(
 221                 resultFuture);
 222         Optional<Endpoints> optional = mock(Optional.class);
 223         when(resultFuture.checkedGet()).thenReturn(optional);
 224         when(optional.isPresent()).thenReturn(true);
 225         Endpoints endpoints = mock(Endpoints.class);
 226         when(optional.get()).thenReturn(endpoints);
 227         EndpointL3Prefix endpointL3Prefix = mock(EndpointL3Prefix.class);
 228         when(endpoints.getEndpointL3Prefix()).thenReturn(Collections.singletonList(endpointL3Prefix));
 229         when(endpointL3Prefix.getTenant()).thenReturn(tenantId);
 230
 231         Collection<EndpointL3Prefix> result = manager.getEndpointsL3PrefixForTenant(tenantId);
 232         Assert.assertTrue(result.contains(endpointL3Prefix));
 233     }
 234
 235     @SuppressWarnings("unchecked")
 236     @Test
 237     public void getEndpointsFromDataStoreTest() throws Exception {
 238         ReadOnlyTransaction transaction = mock(ReadOnlyTransaction.class);
 239         when(dataProvider.newReadOnlyTransaction()).thenReturn(transaction);
 240         CheckedFuture<Optional<Endpoints>, ReadFailedException> checkedFuture = mock(CheckedFuture.class);
 241         when(transaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(checkedFuture);
 242         Optional<Endpoints> optional = mock(Optional.class);
 243         when(checkedFuture.checkedGet()).thenReturn(optional);
 244         when(optional.isPresent()).thenReturn(false);
 245         Assert.assertNull(manager.getEndpointsFromDataStore());
 246
 247         when(optional.isPresent()).thenReturn(true);
 248         Endpoints endpoints = mock(Endpoints.class);
 249         when(optional.get()).thenReturn(endpoints);
 250         Assert.assertEquals(endpoints, manager.getEndpointsFromDataStore());
 251
 252         manager = new EndpointManager(null, rpcRegistry, notificationService, executor, switchManager);
 253         Assert.assertNull(manager.getEndpointsFromDataStore());
 254     }
 255
 256     @Test
 257     public void getL3EndpointsTestEndpointsNull() throws Exception {
 258         Assert.assertNull(manager.getL3Endpoints());
 259     }
 260
 261     @Test
 262     public void getL3EndpointsTestEndpointL3Null() throws Exception {
 263         when(optionalRead.isPresent()).thenReturn(true);
 264         Endpoints endpoints = mock(Endpoints.class);
 265         when(optionalRead.get()).thenReturn(endpoints);
 266         when(endpoints.getEndpointL3()).thenReturn(null);
 267
 268         Assert.assertNull(manager.getL3Endpoints());
 269     }
 270
 271     @Test
 272     public void getL3EndpointsTest() throws Exception {
 273         when(optionalRead.isPresent()).thenReturn(true);
 274         Endpoints endpoints = mock(Endpoints.class);
 275         when(optionalRead.get()).thenReturn(endpoints);
 276         List<EndpointL3> endpointL3List = Collections.singletonList(mock(EndpointL3.class));
 277         when(endpoints.getEndpointL3()).thenReturn(endpointL3List);
 278
 279         Assert.assertEquals(endpointL3List, manager.getL3Endpoints());
 280     }
 281
 282     @Test
 283     public void getL3EpWithNatByL2KeyTest() {
 284         when(optionalRead.isPresent()).thenReturn(true);
 285         Endpoints endpoints = mock(Endpoints.class);
 286         when(optionalRead.get()).thenReturn(endpoints);
 287         EndpointL3 endpointL3 = mock(EndpointL3.class);
 288         List<EndpointL3> endpointL3List = Collections.singletonList(endpointL3);
 289         when(endpoints.getEndpointL3()).thenReturn(endpointL3List);
 290
 291         NatAddress overlayL3Nat = mock(NatAddress.class);
 292         when(endpointL3.getAugmentation(NatAddress.class)).thenReturn(overlayL3Nat);
 293         when(overlayL3Nat.getNatAddress()).thenReturn(mock(IpAddress.class));
 294
 295         when(endpointL3.getL2Context()).thenReturn(mock(L2BridgeDomainId.class));
 296         when(endpointL3.getMacAddress()).thenReturn(mock(MacAddress.class));
 297
 298         Map<EndpointKey, EndpointL3> result = manager.getL3EpWithNatByL2Key();
 299         Assert.assertTrue(result.containsValue(endpointL3));
 300     }
 301
 302     @Test
 303     public void getL3EpWithNatByL2KeyTestL3EpsNull() {
 304         Map<EndpointKey, EndpointL3> result = manager.getL3EpWithNatByL2Key();
 305         Assert.assertTrue(result.isEmpty());
 306     }
 307
 308     @Test
 309     public void getL3EpWithNatByL2KeyTestGetMacAddressNull() {
 310         when(optionalRead.isPresent()).thenReturn(true);
 311         Endpoints endpoints = mock(Endpoints.class);
 312         when(optionalRead.get()).thenReturn(endpoints);
 313         EndpointL3 endpointL3 = mock(EndpointL3.class);
 314         List<EndpointL3> endpointL3List = Collections.singletonList(endpointL3);
 315         when(endpoints.getEndpointL3()).thenReturn(endpointL3List);
 316
 317         NatAddress overlayL3Nat = mock(NatAddress.class);
 318         when(endpointL3.getAugmentation(NatAddress.class)).thenReturn(overlayL3Nat);
 319
 320         when(endpointL3.getL2Context()).thenReturn(mock(L2BridgeDomainId.class));
 321         when(endpointL3.getMacAddress()).thenReturn(null);
 322
 323         Map<EndpointKey, EndpointL3> result = manager.getL3EpWithNatByL2Key();
 324         Assert.assertTrue(result.isEmpty());
 325     }
 326
 327     @Test
 328     public void getL3EpWithNatByL2KeyTestGetL2ContextNull() {
 329         when(optionalRead.isPresent()).thenReturn(true);
 330         Endpoints endpoints = mock(Endpoints.class);
 331         when(optionalRead.get()).thenReturn(endpoints);
 332         EndpointL3 endpointL3 = mock(EndpointL3.class);
 333         List<EndpointL3> endpointL3List = Collections.singletonList(endpointL3);
 334         when(endpoints.getEndpointL3()).thenReturn(endpointL3List);
 335
 336         NatAddress overlayL3Nat = mock(NatAddress.class);
 337         when(endpointL3.getAugmentation(NatAddress.class)).thenReturn(overlayL3Nat);
 338
 339         when(endpointL3.getL2Context()).thenReturn(null);
 340         when(endpointL3.getMacAddress()).thenReturn(mock(MacAddress.class));
 341
 342         Map<EndpointKey, EndpointL3> result = manager.getL3EpWithNatByL2Key();
 343         Assert.assertTrue(result.isEmpty());
 344     }
 345
 346     @Test
 347     public void getEndpointsForGroupTest() {
 348         EgKey newEgKey = new EgKey(tenantId, endpointGroupId);
 349         Assert.assertTrue(manager.getEndpointsForGroup(newEgKey).isEmpty());
 350         manager.processEndpoint(null, endpoint1);
 351         Assert.assertFalse(manager.getEndpointsForGroup(newEgKey).isEmpty());
 352     }
 353
 354     @Test
 355     public void getConditionsForEndpoint() {
 356         Endpoint endpoint = mock(Endpoint.class);
 357         when(endpoint.getCondition()).thenReturn(null);
 358         Assert.assertTrue(manager.getConditionsForEndpoint(endpoint).isEmpty());
 359
 360         List<ConditionName> conditionNameList = Collections.singletonList(mock(ConditionName.class));
 361         when(endpoint.getCondition()).thenReturn(conditionNameList);
 362         Assert.assertEquals(conditionNameList, manager.getConditionsForEndpoint(endpoint));
 363     }
 364
 365     @Test
 366     public void updateEndpointL3TestNewL3EpValidExternalTrue() throws Exception {
 367         when(newL3Ep.getTenant()).thenReturn(mock(TenantId.class));
 368         when(newL3Ep.getEndpointGroup()).thenReturn(mock(EndpointGroupId.class));
 369         when(newL3Ep.getL3Context()).thenReturn(mock(L3ContextId.class));
 370         when(newL3Ep.getIpAddress()).thenReturn(mock(IpAddress.class));
 371
 372         OfOverlayL3Context ofOverlayL3Context = mock(OfOverlayL3Context.class);
 373         when(newL3Ep.getAugmentation(OfOverlayL3Context.class)).thenReturn(ofOverlayL3Context);
 374
 375         NetworkDomainId networkDomainId = mock(NetworkDomainId.class);
 376         when(newL3Ep.getNetworkContainment()).thenReturn(networkDomainId);
 377
 378         EndpointL3Key endpointL3Key = mock(EndpointL3Key.class);
 379         when(newL3Ep.getKey()).thenReturn(endpointL3Key);
 380         IpAddress ipAddress = mock(IpAddress.class);
 381         when(endpointL3Key.getIpAddress()).thenReturn(ipAddress);
 382
 383         manager.processL3Endpoint(null, newL3Ep);
 384         verify(endpointListener,never()).endpointUpdated(any(EpKey.class));
 385     }
 386
 387     @Test
 388     public void updateEndpointL3TestNewL3EpValidExternalTrueNetworkContainmentNull() throws Exception {
 389         when(newL3Ep.getTenant()).thenReturn(mock(TenantId.class));
 390         when(newL3Ep.getEndpointGroup()).thenReturn(mock(EndpointGroupId.class));
 391         when(newL3Ep.getL3Context()).thenReturn(mock(L3ContextId.class));
 392         when(newL3Ep.getIpAddress()).thenReturn(mock(IpAddress.class));
 393
 394         OfOverlayL3Context ofOverlayL3Context = mock(OfOverlayL3Context.class);
 395         when(newL3Ep.getAugmentation(OfOverlayL3Context.class)).thenReturn(ofOverlayL3Context);
 396
 397         when(newL3Ep.getNetworkContainment()).thenReturn(null);
 398
 399         EndpointL3Key endpointL3Key = mock(EndpointL3Key.class);
 400         when(newL3Ep.getKey()).thenReturn(endpointL3Key);
 401         IpAddress ipAddress = mock(IpAddress.class);
 402         when(endpointL3Key.getIpAddress()).thenReturn(ipAddress);
 403
 404         manager.processL3Endpoint(null, newL3Ep);
 405         verify(endpointListener,never()).endpointUpdated(any(EpKey.class));
 406     }
 407
 408     @Test
 409     public void updateEndpointL3TestNewL3EpValidInternal() throws Exception {
 410         when(newL3Ep.getTenant()).thenReturn(mock(TenantId.class));
 411         when(newL3Ep.getEndpointGroup()).thenReturn(mock(EndpointGroupId.class));
 412         when(newL3Ep.getL3Context()).thenReturn(mock(L3ContextId.class));
 413         when(newL3Ep.getIpAddress()).thenReturn(mock(IpAddress.class));
 414
 415         OfOverlayL3Context ofOverlayL3Context = mock(OfOverlayL3Context.class);
 416         when(newL3Ep.getAugmentation(OfOverlayL3Context.class)).thenReturn(ofOverlayL3Context);
 417
 418         when(newL3Ep.getNetworkContainment()).thenReturn(null);
 419
 420         when(newL3Ep.getL2Context()).thenReturn(mock(L2BridgeDomainId.class));
 421         when(newL3Ep.getMacAddress()).thenReturn(mock(MacAddress.class));
 422
 423         manager.processL3Endpoint(null, newL3Ep);
 424         verify(endpointListener).endpointUpdated(any(EpKey.class));
 425     }
 426
 427     @Test
 428     public void updateEndpointL3TestNewL3EpValidFalse() throws Exception {
 429         when(newL3Ep.getTenant()).thenReturn(mock(TenantId.class));
 430         when(newL3Ep.getEndpointGroup()).thenReturn(mock(EndpointGroupId.class));
 431         when(newL3Ep.getL3Context()).thenReturn(mock(L3ContextId.class));
 432         when(newL3Ep.getIpAddress()).thenReturn(null);
 433
 434         manager.processL3Endpoint(null, newL3Ep);
 435         verify(endpointListener,never()).endpointUpdated(any(EpKey.class));
 436     }
 437
 438     @Test
 439     public void updateEndpointL3TestDelete() throws Exception {
 440         manager.processL3Endpoint(oldL3Ep, null);
 441         verify(endpointListener).endpointUpdated(any(EpKey.class));
 442     }
 443
 444     @Test
 445     public void updateEndpointTestNewEndpointRemove() {
 446         Collection<Endpoint> collection;
 447         manager.processEndpoint(null, endpoint2);
 448         verify(endpointListener).endpointUpdated(any(EpKey.class));
 449         verify(endpointListener).nodeEndpointUpdated(any(NodeId.class), any(EpKey.class));
 450         collection = manager.getEndpointsForGroup(new EgKey(tenantId, endpointGroupId));
 451         Assert.assertFalse(collection.isEmpty());
 452
 453         manager.processEndpoint(endpoint2, null);
 454         verify(endpointListener, times(2)).endpointUpdated(any(EpKey.class));
 455         verify(endpointListener, times(2)).nodeEndpointUpdated(any(NodeId.class), any(EpKey.class));
 456         collection = manager.getEndpointsForGroup(new EgKey(tenantId, endpointGroupId));
 457         Assert.assertTrue(collection.isEmpty());
 458     }
 459
 460     @Test
 461     public void updateEndpointTestNewLocNullOldLocNullOfOverlayContextAugmentationNull() {
 462         when(endpoint1.getAugmentation(OfOverlayContext.class)).thenReturn(null);
 463         when(endpoint2.getAugmentation(OfOverlayContext.class)).thenReturn(null);
 464
 465         manager.processEndpoint(endpoint1, endpoint2);
 466         verify(endpointListener, never()).endpointUpdated(any(EpKey.class));
 467         verify(endpointListener, never()).nodeEndpointUpdated(any(NodeId.class), any(EpKey.class));
 468     }
 469
 470     @Test
 471     public void updateEndpointTestNewLocNullOldLocNull() {
 472         when(context1.getNodeId()).thenReturn(null);
 473         when(context2.getNodeId()).thenReturn(null);
 474
 475         manager.processEndpoint(endpoint1, endpoint2);
 476         verify(endpointListener, never()).endpointUpdated(any(EpKey.class));
 477         verify(endpointListener, never()).nodeEndpointUpdated(any(NodeId.class), any(EpKey.class));
 478     }
 479
 480     @Test
 481     public void updateEndpointTestNewLocNullOldLocNullExternalPut() {
 482         when(endpoint1.getAugmentation(OfOverlayContext.class)).thenReturn(null);
 483         when(endpoint2.getAugmentation(OfOverlayContext.class)).thenReturn(null);
 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 updateEndpointTestNewLocNullOldLocNullExternalRemove() {
 492         when(context1.getNodeId()).thenReturn(null);
 493         manager.processEndpoint(null, endpoint1);
 494
 495         manager.processEndpoint(endpoint1, null);
 496         verify(endpointListener, never()).endpointUpdated(any(EpKey.class));
 497         verify(endpointListener, never()).nodeEndpointUpdated(any(NodeId.class), any(EpKey.class));
 498     }
 499
 500     /**
 501      * Endpoint changes it's location
 502      */
 503     @Test
 504     public void updateEndpointLocationTestUpdate() {
 505         Collection<Endpoint> collection;
 506         manager.processEndpoint(null, endpoint1);
 507
 508         manager.processEndpoint(endpoint1, endpoint2);
 509         verify(endpointListener, times(2)).endpointUpdated(any(EpKey.class));
 510         // create: node1, update: node1 -> node2
 511         verify(endpointListener, times(3)).nodeEndpointUpdated(any(NodeId.class), any(EpKey.class));
 512         collection = manager.getEndpointsForGroup(new EgKey(tenantId, endpointGroupId));
 513         Assert.assertFalse(collection.isEmpty());
 514     }
 515
 516     /**
 517      * Endpoint changes it's EPG
 518      */
 519     @Test
 520     public void updateEndpointGroupTestUpdate() {
 521         Collection<Endpoint> collection;
 522         EndpointGroupId otherEndpointGroupId = mock(EndpointGroupId.class);
 523         when(endpoint2.getEndpointGroup()).thenReturn(otherEndpointGroupId);
 524         when(endpoint2.getAugmentation(OfOverlayContext.class)).thenReturn(context1);
 525         manager.processEndpoint(null, endpoint1);
 526
 527         manager.processEndpoint(endpoint1, endpoint2);
 528         verify(endpointListener, times(2)).endpointUpdated(any(EpKey.class));
 529         verify(endpointListener, times(1)).nodeEndpointUpdated(any(NodeId.class), any(EpKey.class));
 530         collection = manager.getEndpointsForGroup(new EgKey(tenantId, endpointGroupId));
 531         Assert.assertTrue(collection.isEmpty());
 532         collection = manager.getEndpointsForGroup(new EgKey(tenantId, otherEndpointGroupId));
 533         Assert.assertFalse(collection.isEmpty());
 534     }
 535
 536     /**
 537      * Endpoint changes it's location and EPGs
 538      */
 539     @Test
 540     public void updateEndpointLocationAndGroupTestUpdate() {
 541         Collection<Endpoint> collection;
 542         EndpointGroupId otherEndpointGroupId = mock(EndpointGroupId.class);
 543         when(endpoint2.getEndpointGroup()).thenReturn(otherEndpointGroupId);
 544         manager.processEndpoint(null, endpoint1);
 545
 546         manager.processEndpoint(endpoint1, endpoint2);
 547         verify(endpointListener, times(2)).endpointUpdated(any(EpKey.class));
 548         // create: node1, update: node1 -> node2
 549         verify(endpointListener, times(3)).nodeEndpointUpdated(any(NodeId.class), any(EpKey.class));
 550         collection = manager.getEndpointsForGroup(new EgKey(tenantId, endpointGroupId));
 551         Assert.assertTrue(collection.isEmpty());
 552         collection = manager.getEndpointsForGroup(new EgKey(tenantId, otherEndpointGroupId));
 553         Assert.assertFalse(collection.isEmpty());
 554     }
 555
 556     /**
 557      * Endpoint becomes external when removing it's location augmentation.
 558      * This might happen when an endpoint is removed from a device.
 559      */
 560     @Test
 561     public void updateEndpointLocationRemovedTestUpdate() {
 562         Collection<Endpoint> collection;
 563         when(endpoint2.getAugmentation(OfOverlayContext.class)).thenReturn(null);
 564         manager.processEndpoint(null, endpoint1);
 565
 566         manager.processEndpoint(endpoint1, endpoint2);
 567         verify(endpointListener, times(2)).endpointUpdated(any(EpKey.class));
 568         verify(endpointListener, times(2)).nodeEndpointUpdated(any(NodeId.class), any(EpKey.class));
 569         collection = manager.getEndpointsForGroup(new EgKey(tenantId, endpointGroupId));
 570         Assert.assertTrue(collection.isEmpty());
 571     }
 572
 573     /**
 574      * Endpoint is created when adding location augmentation.
 575      * Endpoint is not external anymore.
 576      */
 577     @Test
 578     public void updateEndpointLocationAddedTestUpdate() {
 579         Collection<Endpoint> collection;
 580         when(endpoint1.getAugmentation(OfOverlayContext.class)).thenReturn(null);
 581         manager.processEndpoint(null, endpoint1);
 582
 583         manager.processEndpoint(endpoint1, endpoint2);
 584         verify(endpointListener).endpointUpdated(any(EpKey.class));
 585         verify(endpointListener).nodeEndpointUpdated(any(NodeId.class), any(EpKey.class));
 586         collection = manager.getEndpointsForGroup(new EgKey(tenantId, endpointGroupId));
 587         Assert.assertFalse(collection.isEmpty());
 588     }
 589
 590     @SuppressWarnings({"unchecked"})
 591     @Test
 592     public void addEndpointFromL3EndpointTest() throws Exception {
 593         EndpointL3 l3Ep = mock(EndpointL3.class);
 594         ReadWriteTransaction rwTx = mock(ReadWriteTransaction.class);
 595         OfOverlayL3Context ofL3Ctx = mock(OfOverlayL3Context.class);
 596         when(l3Ep.getAugmentation(OfOverlayL3Context.class)).thenReturn(ofL3Ctx);
 597
 598         CheckedFuture<Optional<Tenant>, ReadFailedException> checkedFuture = mock(CheckedFuture.class);
 599         when(rwTx.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(checkedFuture);
 600         Optional<Tenant> optional = mock(Optional.class);
 601         when(checkedFuture.checkedGet()).thenReturn(optional);
 602         Tenant tenant = mock(Tenant.class);
 603         ForwardingContext fwCtx = mock(ForwardingContext.class);
 604         when(tenant.getForwardingContext()).thenReturn(fwCtx);
 605         when(optional.isPresent()).thenReturn(true);
 606         when(optional.get()).thenReturn(tenant);
 607
 608         L2BridgeDomain l2BridgeDomain = mock(L2BridgeDomain.class);
 609         when(fwCtx.getL2BridgeDomain()).thenReturn(Collections.singletonList(l2BridgeDomain));
 610         L2BridgeDomainId l2BridgeDomainId = mock(L2BridgeDomainId.class);
 611         when(l2BridgeDomain.getId()).thenReturn(l2BridgeDomainId);
 612         String l2bdValue = UUID.randomUUID().toString();
 613         when(l2BridgeDomainId.getValue()).thenReturn(l2bdValue);
 614
 615         NetworkDomainId networkDomainId = mock(NetworkDomainId.class);
 616         when(l3Ep.getNetworkContainment()).thenReturn(networkDomainId);
 617         when(networkDomainId.getValue()).thenReturn(l2bdValue);
 618
 619         Method method = EndpointManager.class.getDeclaredMethod("addEndpointFromL3Endpoint", EndpointL3.class,
 620                 ReadWriteTransaction.class);
 621         method.setAccessible(true);
 622         method.invoke(manager, l3Ep, rwTx);
 623         verify(rwTx).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Endpoint.class));
 624     }
 625
 626     @SuppressWarnings({"unchecked"})
 627     @Test
 628     public void addEndpointFromL3EndpointTestTenantPresentFalse() throws Exception {
 629         EndpointL3 l3Ep = mock(EndpointL3.class);
 630         ReadWriteTransaction rwTx = mock(ReadWriteTransaction.class);
 631         OfOverlayL3Context ofL3Ctx = mock(OfOverlayL3Context.class);
 632         when(l3Ep.getAugmentation(OfOverlayL3Context.class)).thenReturn(ofL3Ctx);
 633
 634         CheckedFuture<Optional<Tenant>, ReadFailedException> checkedFuture = mock(CheckedFuture.class);
 635         when(rwTx.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(checkedFuture);
 636         Optional<Tenant> optional = mock(Optional.class);
 637         when(checkedFuture.checkedGet()).thenReturn(optional);
 638         when(optional.isPresent()).thenReturn(false);
 639
 640         Method method = EndpointManager.class.getDeclaredMethod("addEndpointFromL3Endpoint", EndpointL3.class,
 641                 ReadWriteTransaction.class);
 642         method.setAccessible(true);
 643         method.invoke(manager, l3Ep, rwTx);
 644         verify(rwTx).cancel();
 645     }
 646
 647     @Test
 648     public void closeTest() throws Exception {
 649         manager.close();
 650         verify(listenerReg).close();
 651         manager = new EndpointManager(null, rpcRegistry, notificationService, executor, switchManager);
 652         manager.close();
 653         verify(listenerReg, times(1)).close();
 654     }
 655
 656      //**************
 657      //Helper Functions
 658      //**************
 659
 660     @Test
 661     public void getEgKeyTest() {
 662         Assert.assertNotNull(manager.getEgKey(endpoint1));
 663         Assert.assertNull(manager.getEgKey(null));
 664
 665         when(endpoint1.getTenant()).thenReturn(null);
 666         Assert.assertNull(manager.getEgKey(endpoint1));
 667
 668         when(endpoint1.getTenant()).thenReturn(tenantId);
 669         when(endpoint1.getEndpointGroup()).thenReturn(null);
 670         Assert.assertNotNull(manager.getEgKey(endpoint1));
 671
 672         when(endpoint1.getEndpointGroup()).thenReturn(endpointGroupId);
 673         when(endpoint1.getEndpointGroups()).thenReturn(null);
 674         Assert.assertNotNull(manager.getEgKey(endpoint1));
 675
 676         when(endpoint1.getEndpointGroup()).thenReturn(null);
 677         Assert.assertNull(manager.getEgKey(endpoint1));
 678
 679         when(endpoint1.getEndpointGroup()).thenReturn(endpointGroupId);
 680         when(endpoint1.getL2Context()).thenReturn(null);
 681         Assert.assertNull(manager.getEgKey(endpoint1));
 682
 683         when(endpoint1.getL2Context()).thenReturn(l2BridgeDomainId);
 684         when(endpoint1.getMacAddress()).thenReturn(null);
 685         Assert.assertNull(manager.getEgKey(endpoint1));
 686     }
 687
 688     @Test
 689     public void getEgKeysForEndpointTest() {
 690         Endpoint endpoint = mock(Endpoint.class);
 691         Set<EgKey> egKeys;
 692
 693         when(endpoint.getEndpointGroups()).thenReturn(null);
 694         egKeys = manager.getEgKeysForEndpoint(endpoint);
 695         Assert.assertTrue(egKeys.isEmpty());
 696
 697         EndpointGroupId endpointGroupId = mock(EndpointGroupId.class);
 698         when(endpoint.getEndpointGroup()).thenReturn(endpointGroupId);
 699         egKeys = manager.getEgKeysForEndpoint(endpoint);
 700         Assert.assertEquals(1, egKeys.size());
 701
 702         EndpointGroupId epgId = mock(EndpointGroupId.class);
 703         List<EndpointGroupId> endpointGroups = Collections.singletonList(epgId);
 704         when(endpoint.getEndpointGroups()).thenReturn(endpointGroups);
 705         egKeys = manager.getEgKeysForEndpoint(endpoint);
 706         Assert.assertEquals(2, egKeys.size());
 707     }
 708
 709     @Test
 710     public void isExternalIsInternalTest() {
 711         Endpoint endpoint = mock(Endpoint.class);
 712         when(endpoint.getAugmentation(OfOverlayContext.class)).thenReturn(null);
 713         // TODO
 714 //        Assert.assertFalse(manager.isExternal(endpoint));
 715 //        Assert.assertTrue(manager.isInternal(endpoint));
 716 //
 717 //        OfOverlayContext ofc = mock(OfOverlayContext.class);
 718 //        when(endpoint.getAugmentation(OfOverlayContext.class)).thenReturn(ofc);
 719 //        when(ofc.getLocationType()).thenReturn(null);
 720 //        Assert.assertFalse(manager.isExternal(endpoint));
 721 //        Assert.assertTrue(manager.isInternal(endpoint));
 722 //
 723 //        when(ofc.getLocationType()).thenReturn(LocationType.Internal);
 724 //        Assert.assertFalse(manager.isExternal(endpoint));
 725 //        Assert.assertTrue(manager.isInternal(endpoint));
 726 //
 727 //        when(ofc.getLocationType()).thenReturn(LocationType.External);
 728 //        Assert.assertTrue(manager.isExternal(endpoint));
 729 //        Assert.assertFalse(manager.isInternal(endpoint));
 730     }
 731 }