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