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