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