location-providers/ne-location-provider/src/test/java/org/opendaylight/groupbasedpolicy/ne/location/provider/NeLocationProviderTest.java

   1 /*
   2  * Copyright (c) 2016 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.ne.location.provider;
  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.assertTrue;
  15 import static org.mockito.Matchers.any;
  16 import static org.mockito.Matchers.eq;
  17 import static org.mockito.Matchers.isA;
  18 import static org.mockito.Mockito.mock;
  19 import static org.mockito.Mockito.verify;
  20 import static org.mockito.Mockito.when;
  21
  22 import com.google.common.base.Optional;
  23 import com.google.common.collect.ImmutableList;
  24 import com.google.common.util.concurrent.CheckedFuture;
  25 import java.util.Collection;
  26 import java.util.Collections;
  27 import java.util.List;
  28 import org.junit.Before;
  29 import org.junit.Test;
  30 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  31 import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
  32 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  33 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  34 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  35 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
  36 import org.opendaylight.groupbasedpolicy.test.CustomDataBrokerTest;
  37 import org.opendaylight.groupbasedpolicy.util.IidFactory;
  38 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpPrefix;
  39 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Prefix;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.Endpoints;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.NetworkContainment;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.NetworkContainmentBuilder;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.network.containment.containment.NetworkDomainContainmentBuilder;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.AddressEndpoints;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpoint;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpointBuilder;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpointKey;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.AbsoluteLocationBuilder;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.absolute.location.location.type.ExternalLocationCaseBuilder;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContextId;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.EndpointGroupId;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.NetworkDomainId;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.network.elements.rev160407.NetworkElements;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.network.elements.rev160407.NetworkElementsBuilder;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.network.elements.rev160407.network.elements.NetworkElement;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.network.elements.rev160407.network.elements.NetworkElementBuilder;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.network.elements.rev160407.network.elements.NetworkElementKey;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.network.elements.rev160407.network.elements.network.element.Interface;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.network.elements.rev160407.network.elements.network.element.InterfaceBuilder;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.network.elements.rev160407.network.elements.network.element.InterfaceKey;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.network.elements.rev160407.network.elements.network.element._interface.EndpointNetwork;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.network.elements.rev160407.network.elements.network.element._interface.EndpointNetworkBuilder;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.network.elements.rev160407.network.elements.network.element._interface.EndpointNetworkKey;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.LocationProviders;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.LocationProvidersBuilder;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.ProviderName;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.location.providers.LocationProviderBuilder;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.location.providers.location.provider.ProviderAddressEndpointLocationBuilder;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev170511.IpPrefixType;
  71 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev170511.L3Context;
  72 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.AddressType;
  73 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.ContextType;
  74 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
  75 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
  76 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
  77 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
  78 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey;
  79 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  80 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
  81 import org.opendaylight.yangtools.concepts.ListenerRegistration;
  82 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  83
  84 public class NeLocationProviderTest extends CustomDataBrokerTest {
  85
  86     private static final TenantId TENANT = new TenantId("Tenant");
  87     private static final List<EndpointGroupId> DEFAULT_EPG =
  88         Collections.singletonList(new EndpointGroupId("defaultEPG"));
  89     private static final String L3_CONTEXT_ID = "l3Context";
  90     private static final String IP_V4_HOST_ADDRESS_1 = "192.168.50.71/24";
  91     private static final String IP_V4_NETWORK_ADDRESS_1 = "192.168.50.0/24";
  92     private static final String IP_V4_NETWORK_ADDRESS_2 = "192.168.51.0/24";
  93     private static final String NODE_ID_1 = "node1";
  94     private static final String NODE_ID_2 = "node2";
  95     private static final String CONNECTOR_ID_1 = "connector:1";
  96     private static final String CONNECTOR_ID_2 = "connector:2";
  97     private DataBroker dataBroker;
  98     private NeLocationProvider neProvider;
  99
 100     @Override
 101     public Collection<Class<?>> getClassesFromModules() {
 102         return ImmutableList.<Class<?>>of(NetworkElements.class, LocationProviders.class, Endpoints.class,
 103             L3Context.class, Nodes.class);
 104     }
 105
 106     @Before
 107     public void init() {
 108         dataBroker = getDataBroker();
 109         neProvider = new NeLocationProvider(dataBroker);
 110     }
 111
 112     @Test
 113     public void test_NetworkElementsListenerRegistration() {
 114         DataBroker mockDataBroker = mock(DataBroker.class);
 115         NeLocationProvider provider = new NeLocationProvider(mockDataBroker);
 116         verify(mockDataBroker).registerDataTreeChangeListener(
 117                 new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
 118                 InstanceIdentifier.builder(NetworkElements.class).build()), provider);
 119     }
 120
 121     @Test
 122     public void test_EndpointsListenerRegistration() {
 123         DataBroker mockDataBroker = mock(DataBroker.class);
 124         new NeLocationProvider(mockDataBroker);
 125         verify(mockDataBroker)
 126             .registerDataTreeChangeListener(eq(new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL,
 127                     InstanceIdentifier.builder(Endpoints.class).child(AddressEndpoints.class)
 128                     .child(AddressEndpoint.class).build())), isA(EndpointsListener.class));
 129     }
 130
 131     @Test
 132     public void test_ListenersUnregistration() {
 133         DataBroker mockDataBroker = mock(DataBroker.class);
 134         ListenerRegistration<EndpointsListener> endpointsListenerRegistration = mock(ListenerRegistration.class);
 135         when(mockDataBroker.registerDataTreeChangeListener(any(), isA(EndpointsListener.class)))
 136             .thenReturn(endpointsListenerRegistration);
 137         ListenerRegistration<NeLocationProvider> nelistenerregistration = mock(ListenerRegistration.class);
 138         when(mockDataBroker.registerDataTreeChangeListener(any(), isA(NeLocationProvider.class)))
 139             .thenReturn(nelistenerregistration);
 140         NeLocationProvider provider = new NeLocationProvider(mockDataBroker);
 141         provider.close();
 142         verify(endpointsListenerRegistration).close();
 143         verify(nelistenerregistration).close();
 144     }
 145
 146     @Test
 147     public void test_AddressEndpointWrite_NoNE_NoOverwrite() throws Exception {
 148         AddressEndpoint endpoint = writeBaseAddrEndpoint();
 149         List<AddressEndpoint> endpoints = neProvider.getEndpoints();
 150         assertEquals(1, endpoints.size());
 151         assertEquals(endpoint, endpoints.get(0));
 152         verifyEmptyLocations();
 153     }
 154
 155     @Test
 156     public void test_AddressEndpointWrite_NoNE_Overwrite() throws Exception {
 157         writeBaseAddrEndpoint();
 158         NetworkContainment nc = new NetworkContainmentBuilder().setContainment(
 159             new NetworkDomainContainmentBuilder().setNetworkDomainId(new NetworkDomainId(L3_CONTEXT_ID)).build())
 160             .build();
 161         AddressEndpoint endpoint = new AddressEndpointBuilder().setKey(
 162                 new AddressEndpointKey(IP_V4_HOST_ADDRESS_1, IpPrefixType.class, new ContextId(L3_CONTEXT_ID),
 163                     L3Context.class)).setNetworkContainment(nc).setTenant(TENANT).setEndpointGroup(DEFAULT_EPG).build();
 164         InstanceIdentifier<AddressEndpoint> iid = IidFactory.addressEndpointIid(endpoint.getKey());
 165         WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
 166         wtx.put(LogicalDatastoreType.OPERATIONAL, iid, endpoint, true);
 167         wtx.submit().get();
 168         List<AddressEndpoint> endpoints = neProvider.getEndpoints();
 169         assertEquals(1, endpoints.size());
 170         assertEquals(endpoint, endpoints.get(0));
 171         verifyEmptyLocations();
 172     }
 173
 174     @Test
 175     public void test_AddressEndpointModified_NoNE() throws Exception {
 176         writeBaseAddrEndpoint();
 177         NetworkContainment nc =
 178             new NetworkContainmentBuilder().setContainment(
 179                 new NetworkDomainContainmentBuilder().setNetworkDomainId(new NetworkDomainId(L3_CONTEXT_ID)).build())
 180                 .build();
 181         InstanceIdentifier<NetworkContainment> iid = InstanceIdentifier
 182                 .builder(Endpoints.class)
 183                 .child(AddressEndpoints.class)
 184                 .child(AddressEndpoint.class, new AddressEndpointKey(IP_V4_HOST_ADDRESS_1, IpPrefixType.class,
 185                         new ContextId(L3_CONTEXT_ID), L3Context.class))
 186                 .child(NetworkContainment.class)
 187                 .build();
 188         WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
 189         wtx.put(LogicalDatastoreType.OPERATIONAL, iid, nc);
 190         wtx.submit().get();
 191         List<AddressEndpoint> l3Endpoint = neProvider.getEndpoints();
 192         assertEquals(1, l3Endpoint.size());
 193         assertNotNull(l3Endpoint.get(0).getNetworkContainment());
 194         assertEquals(nc, l3Endpoint.get(0).getNetworkContainment());
 195         verifyEmptyLocations();
 196     }
 197
 198     @Test
 199     public void test_EndpointsDelete_NoNE() throws Exception {
 200         writeBaseAddrEndpoint();
 201         InstanceIdentifier<Endpoints> iid = InstanceIdentifier.builder(Endpoints.class)
 202                 .build();
 203         WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
 204         wtx.delete(LogicalDatastoreType.OPERATIONAL, iid);
 205         wtx.submit().get();
 206         List<AddressEndpoint> l3Endpoint = neProvider.getEndpoints();
 207         assertEquals(0, l3Endpoint.size());
 208         verifyEmptyLocations();
 209     }
 210
 211     @Test
 212     public void test_EndpointsModify_NoNE() throws Exception {
 213         writeBaseAddrEndpoint();
 214         InstanceIdentifier<Endpoints> iid = InstanceIdentifier.builder(Endpoints.class)
 215                 .build();
 216         WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
 217         wtx.delete(LogicalDatastoreType.OPERATIONAL, iid);
 218         wtx.submit().get();
 219         List<AddressEndpoint> l3Endpoint = neProvider.getEndpoints();
 220         assertEquals(0, l3Endpoint.size());
 221         verifyEmptyLocations();
 222     }
 223
 224     @Test
 225     public void test_NetworkElementsWrite_NoEP_NoOverwrite() throws Exception {
 226         NetworkElements nes = writeBaseNetworkElements();
 227         NetworkElements networkElements = neProvider.getNetworkElements();
 228         assertEquals(nes, networkElements);
 229         verifyEmptyLocations();
 230     }
 231
 232     @Test
 233     public void test_NetworkElementsWrite_NoEP_Overwrite() throws Exception {
 234         writeBaseNetworkElements();
 235         NetworkElements nes = createNetworkElements(NODE_ID_2, CONNECTOR_ID_2, L3_CONTEXT_ID, IP_V4_NETWORK_ADDRESS_1);
 236         InstanceIdentifier<NetworkElements> iid = InstanceIdentifier.builder(NetworkElements.class).build();
 237         WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
 238         wtx.put(LogicalDatastoreType.CONFIGURATION, iid, nes);
 239         wtx.submit().get();
 240         NetworkElements networkElements = neProvider.getNetworkElements();
 241         assertEquals(nes, networkElements);
 242         verifyEmptyLocations();
 243     }
 244
 245     @Test
 246     public void test_NetworkElementWrite_NoEP_Overwrite() throws Exception {
 247         writeBaseNetworkElements();
 248         NetworkElement ne = createNetworkElement(NODE_ID_1, CONNECTOR_ID_1, L3_CONTEXT_ID, IP_V4_NETWORK_ADDRESS_2);
 249         InstanceIdentifier<NetworkElement> iid = InstanceIdentifier.builder(NetworkElements.class)
 250             .child(NetworkElement.class, new NetworkElementKey(ne.getKey()))
 251             .build();
 252         WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
 253         wtx.put(LogicalDatastoreType.CONFIGURATION, iid, ne);
 254         wtx.submit().get();
 255         NetworkElements nes = neProvider.getNetworkElements();
 256         assertNotNull(nes.getNetworkElement());
 257         assertEquals(1, nes.getNetworkElement().size());
 258         assertEquals(ne, nes.getNetworkElement().get(0));
 259         verifyEmptyLocations();
 260     }
 261
 262     @Test
 263     public void test_InterfaceWrite_NoEP_Overwrite() throws Exception {
 264         writeBaseNetworkElements();
 265         Interface iface = createInterface(NODE_ID_1, CONNECTOR_ID_1, L3_CONTEXT_ID, IP_V4_NETWORK_ADDRESS_2);
 266         InstanceIdentifier<Interface> iid = InstanceIdentifier.builder(NetworkElements.class)
 267             .child(NetworkElement.class, new NetworkElementKey(createNetworkElementIid(NODE_ID_1)))
 268             .child(Interface.class, new InterfaceKey(iface.getKey()))
 269             .build();
 270         WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
 271         wtx.put(LogicalDatastoreType.CONFIGURATION, iid, iface);
 272         wtx.submit().get();
 273         NetworkElements nes = neProvider.getNetworkElements();
 274         assertNotNull(nes.getNetworkElement());
 275         assertEquals(1, nes.getNetworkElement().size());
 276         assertNotNull(nes.getNetworkElement().get(0).getInterface());
 277         assertEquals(1, nes.getNetworkElement().get(0).getInterface().size());
 278         assertEquals(iface, nes.getNetworkElement().get(0).getInterface().get(0));
 279         verifyEmptyLocations();
 280     }
 281
 282     @Test
 283     public void test_EndpointNetworkChange_NoEP() throws Exception {
 284         writeBaseNetworkElements();
 285         EndpointNetwork en = createEndpointNetwork(L3_CONTEXT_ID, IP_V4_NETWORK_ADDRESS_2);
 286         InstanceIdentifier<EndpointNetwork> iid = InstanceIdentifier.builder(NetworkElements.class)
 287             .child(NetworkElement.class, new NetworkElementKey(createNetworkElementIid(NODE_ID_1)))
 288             .child(Interface.class, new InterfaceKey(CONNECTOR_ID_1))
 289             .child(EndpointNetwork.class, new EndpointNetworkKey(en.getKey()))
 290             .build();
 291         InstanceIdentifier<EndpointNetwork> removeIid =
 292                 InstanceIdentifier.builder(NetworkElements.class)
 293                     .child(NetworkElement.class, new NetworkElementKey(createNetworkElementIid(NODE_ID_1)))
 294                     .child(Interface.class, new InterfaceKey(CONNECTOR_ID_1))
 295                     .child(EndpointNetwork.class, new EndpointNetworkKey(
 296                             new IpPrefix(new Ipv4Prefix(IP_V4_NETWORK_ADDRESS_1)),new ContextId(L3_CONTEXT_ID)))
 297                     .build();
 298         WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
 299         wtx.delete(LogicalDatastoreType.CONFIGURATION, removeIid);
 300         wtx.put(LogicalDatastoreType.CONFIGURATION, iid, en);
 301         wtx.submit().get();
 302         NetworkElements nes = neProvider.getNetworkElements();
 303         assertNotNull(nes.getNetworkElement());
 304         assertEquals(1, nes.getNetworkElement().size());
 305         assertNotNull(nes.getNetworkElement().get(0).getInterface());
 306         assertEquals(1, nes.getNetworkElement().get(0).getInterface().size());
 307         assertNotNull(nes.getNetworkElement().get(0).getInterface().get(0).getEndpointNetwork());
 308         assertEquals(1, nes.getNetworkElement().get(0).getInterface().get(0).getEndpointNetwork().size());
 309         assertEquals(en, nes.getNetworkElement().get(0).getInterface().get(0).getEndpointNetwork().get(0));
 310         verifyEmptyLocations();
 311     }
 312
 313     @Test
 314     public void test_NetworkElementsDelete() throws Exception {
 315         writeBaseNetworkElements();
 316         InstanceIdentifier<NetworkElements> iid = InstanceIdentifier.builder(NetworkElements.class).build();
 317         WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
 318         wtx.delete(LogicalDatastoreType.CONFIGURATION, iid);
 319         wtx.submit().get();
 320         NetworkElements nes = neProvider.getNetworkElements();
 321         assertEquals(new NetworkElementsBuilder().build(), nes);
 322         verifyEmptyLocations();
 323     }
 324
 325     @Test
 326     public void test_NetworkElementDelete() throws Exception {
 327         writeBaseNetworkElements();
 328         InstanceIdentifier<NetworkElement> iid = InstanceIdentifier.builder(NetworkElements.class)
 329             .child(NetworkElement.class, new NetworkElementKey(createNetworkElementIid(NODE_ID_1)))
 330             .build();
 331         WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
 332         wtx.delete(LogicalDatastoreType.CONFIGURATION, iid);
 333         wtx.submit().get();
 334         NetworkElements nes = neProvider.getNetworkElements();
 335         assertNotNull(nes.getNetworkElement());
 336         assertTrue(nes.getNetworkElement().isEmpty());
 337         verifyEmptyLocations();
 338     }
 339
 340     @Test
 341     public void test_InterfaceDelete() throws Exception {
 342         writeBaseNetworkElements();
 343         InstanceIdentifier<Interface> iid = InstanceIdentifier.builder(NetworkElements.class)
 344             .child(NetworkElement.class, new NetworkElementKey(createNetworkElementIid(NODE_ID_1)))
 345             .child(Interface.class, new InterfaceKey(CONNECTOR_ID_1))
 346             .build();
 347         WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
 348         wtx.delete(LogicalDatastoreType.CONFIGURATION, iid);
 349         wtx.submit().get();
 350         NetworkElements nes = neProvider.getNetworkElements();
 351         assertNotNull(nes.getNetworkElement());
 352         assertEquals(1, nes.getNetworkElement().size());
 353         assertNotNull(nes.getNetworkElement().get(0).getInterface());
 354         assertTrue(nes.getNetworkElement().get(0).getInterface().isEmpty());
 355         verifyEmptyLocations();
 356     }
 357
 358     @Test
 359     public void test_CreateLocationForAddrEndpoint_EndpointWriteFirst() throws Exception {
 360         AddressEndpoint endpoint =
 361                 createAddressEndpoint(IP_V4_HOST_ADDRESS_1, IpPrefixType.class, L3_CONTEXT_ID, L3Context.class);
 362         InstanceIdentifier<AddressEndpoint> iid = IidFactory.addressEndpointIid(endpoint.getKey());
 363         WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
 364         wtx.put(LogicalDatastoreType.OPERATIONAL, iid, endpoint, true);
 365         wtx.submit().get();
 366
 367         NetworkElements nes = createNetworkElements(NODE_ID_1, CONNECTOR_ID_1, L3_CONTEXT_ID, IP_V4_NETWORK_ADDRESS_1);
 368         InstanceIdentifier<NetworkElements> neIid = InstanceIdentifier.builder(NetworkElements.class).build();
 369         wtx = dataBroker.newWriteOnlyTransaction();
 370         wtx.put(LogicalDatastoreType.CONFIGURATION, neIid, nes);
 371         wtx.submit().get();
 372
 373         ReadOnlyTransaction rtx = dataBroker.newReadOnlyTransaction();
 374         InstanceIdentifier<LocationProviders> locationIid = InstanceIdentifier.builder(LocationProviders.class).build();
 375         CheckedFuture<Optional<LocationProviders>, ReadFailedException> read =
 376                 rtx.read(LogicalDatastoreType.CONFIGURATION, locationIid);
 377         assertTrue(read.get().isPresent());
 378         rtx.close();
 379         LocationProviders locations = read.get().get();
 380         LocationProviders locationReference =
 381                 new LocationProvidersBuilder()
 382                     .setLocationProvider(Collections.singletonList(new LocationProviderBuilder()
 383                             .setProvider(new ProviderName(NeLocationProvider.NE_LOCATION_PROVIDER_NAME))
 384                             .setProviderAddressEndpointLocation(Collections.singletonList(
 385                                     new ProviderAddressEndpointLocationBuilder()
 386                                     .setAddress(IP_V4_HOST_ADDRESS_1)
 387                                     .setAddressType(IpPrefixType.class)
 388                                     .setContextId(new ContextId(L3_CONTEXT_ID))
 389                                     .setContextType(L3Context.class)
 390                                     .setAbsoluteLocation(new AbsoluteLocationBuilder()
 391                                             .setLocationType(new ExternalLocationCaseBuilder()
 392                                                     .setExternalNodeMountPoint(createNetworkElementIid(NODE_ID_1))
 393                                                     .setExternalNodeConnector(CONNECTOR_ID_1)
 394                                                     .build())
 395                                             .build())
 396                                     .build()))
 397                             .build()))
 398                     .build();
 399         assertEquals(locationReference, locations);
 400     }
 401
 402     @Test
 403     public void test_CreateLocationForAddrEndpoint_NEWriteFirst() throws Exception {
 404         NetworkElements nes = createNetworkElements(NODE_ID_1, CONNECTOR_ID_1, L3_CONTEXT_ID, IP_V4_NETWORK_ADDRESS_1);
 405         InstanceIdentifier<NetworkElements> neIid = InstanceIdentifier.builder(NetworkElements.class).build();
 406         WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
 407         wtx.put(LogicalDatastoreType.CONFIGURATION, neIid, nes);
 408
 409         AddressEndpoint endpoint =
 410                 createAddressEndpoint(IP_V4_HOST_ADDRESS_1, IpPrefixType.class, L3_CONTEXT_ID, L3Context.class);
 411         InstanceIdentifier<AddressEndpoint> iid = IidFactory.addressEndpointIid(endpoint.getKey());
 412         wtx.put(LogicalDatastoreType.OPERATIONAL, iid, endpoint, true);
 413         wtx.submit().get();
 414
 415         ReadOnlyTransaction rtx = dataBroker.newReadOnlyTransaction();
 416         InstanceIdentifier<LocationProviders> locationIid = InstanceIdentifier.builder(LocationProviders.class).build();
 417         CheckedFuture<Optional<LocationProviders>, ReadFailedException> read =
 418                 rtx.read(LogicalDatastoreType.CONFIGURATION, locationIid);
 419         assertTrue(read.get().isPresent());
 420         rtx.close();
 421         LocationProviders locations = read.get().get();
 422         LocationProviders locationReference =
 423                 new LocationProvidersBuilder()
 424                     .setLocationProvider(Collections.singletonList(new LocationProviderBuilder()
 425                             .setProvider(new ProviderName(NeLocationProvider.NE_LOCATION_PROVIDER_NAME))
 426                             .setProviderAddressEndpointLocation(Collections.singletonList(
 427                                     new ProviderAddressEndpointLocationBuilder()
 428                                     .setAddress(IP_V4_HOST_ADDRESS_1)
 429                                     .setAddressType(IpPrefixType.class)
 430                                     .setContextId(new ContextId(L3_CONTEXT_ID))
 431                                     .setContextType(L3Context.class)
 432                                     .setAbsoluteLocation(new AbsoluteLocationBuilder()
 433                                             .setLocationType(new ExternalLocationCaseBuilder()
 434                                                     .setExternalNodeMountPoint(createNetworkElementIid(NODE_ID_1))
 435                                                     .setExternalNodeConnector(CONNECTOR_ID_1)
 436                                                     .build())
 437                                             .build())
 438                                     .build()))
 439                             .build()))
 440                     .build();
 441         assertEquals(locationReference, locations);
 442     }
 443
 444     @Test
 445     public void test_CreateLocationForAddrEndpoint_SimultaneousWrite() throws Exception {
 446         NetworkElements nes = createNetworkElements(NODE_ID_1, CONNECTOR_ID_1, L3_CONTEXT_ID, IP_V4_NETWORK_ADDRESS_1);
 447         InstanceIdentifier<NetworkElements> neIid = InstanceIdentifier.builder(NetworkElements.class).build();
 448         WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
 449         wtx.put(LogicalDatastoreType.CONFIGURATION, neIid, nes);
 450         wtx.submit().get();
 451
 452         AddressEndpoint endpoint =
 453                 createAddressEndpoint(IP_V4_HOST_ADDRESS_1, IpPrefixType.class, L3_CONTEXT_ID, L3Context.class);
 454         InstanceIdentifier<AddressEndpoint> iid = IidFactory.addressEndpointIid(endpoint.getKey());
 455         wtx = dataBroker.newWriteOnlyTransaction();
 456         wtx.put(LogicalDatastoreType.OPERATIONAL, iid, endpoint, true);
 457         wtx.submit().get();
 458
 459         ReadOnlyTransaction rtx = dataBroker.newReadOnlyTransaction();
 460         InstanceIdentifier<LocationProviders> locationIid = InstanceIdentifier.builder(LocationProviders.class).build();
 461         CheckedFuture<Optional<LocationProviders>, ReadFailedException> read =
 462                 rtx.read(LogicalDatastoreType.CONFIGURATION, locationIid);
 463         assertTrue(read.get().isPresent());
 464         rtx.close();
 465         LocationProviders locations = read.get().get();
 466         LocationProviders locationReference =
 467                 new LocationProvidersBuilder()
 468                     .setLocationProvider(Collections.singletonList(new LocationProviderBuilder()
 469                             .setProvider(new ProviderName(NeLocationProvider.NE_LOCATION_PROVIDER_NAME))
 470                             .setProviderAddressEndpointLocation(Collections.singletonList(
 471                                     new ProviderAddressEndpointLocationBuilder()
 472                                     .setAddress(IP_V4_HOST_ADDRESS_1)
 473                                     .setAddressType(IpPrefixType.class)
 474                                     .setContextId(new ContextId(L3_CONTEXT_ID))
 475                                     .setContextType(L3Context.class)
 476                                     .setAbsoluteLocation(new AbsoluteLocationBuilder()
 477                                             .setLocationType(new ExternalLocationCaseBuilder()
 478                                                     .setExternalNodeMountPoint(createNetworkElementIid(NODE_ID_1))
 479                                                     .setExternalNodeConnector(CONNECTOR_ID_1)
 480                                                     .build())
 481                                             .build())
 482                                     .build()))
 483                             .build()))
 484                     .build();
 485         assertEquals(locationReference, locations);
 486     }
 487
 488     private AddressEndpoint writeBaseAddrEndpoint() throws Exception {
 489         AddressEndpoint endpoint =
 490                 createAddressEndpoint(IP_V4_HOST_ADDRESS_1, IpPrefixType.class, L3_CONTEXT_ID, L3Context.class);
 491         InstanceIdentifier<AddressEndpoint> iid = IidFactory.addressEndpointIid(endpoint.getKey());
 492         WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
 493         wtx.put(LogicalDatastoreType.OPERATIONAL, iid, endpoint, true);
 494         wtx.submit().get();
 495         return endpoint;
 496     }
 497
 498     private NetworkElements writeBaseNetworkElements() throws Exception {
 499         NetworkElements nes = createNetworkElements(NODE_ID_1, CONNECTOR_ID_1, L3_CONTEXT_ID, IP_V4_NETWORK_ADDRESS_1);
 500         InstanceIdentifier<NetworkElements> iid = InstanceIdentifier.builder(NetworkElements.class).build();
 501         WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
 502         wtx.put(LogicalDatastoreType.CONFIGURATION, iid, nes);
 503         wtx.submit().get();
 504         return nes;
 505     }
 506
 507     private AddressEndpoint createAddressEndpoint(String ipAddr, Class<? extends AddressType> addrType,
 508             String context, Class<? extends ContextType> contextType) {
 509         return new AddressEndpointBuilder()
 510             .setAddress(ipAddr)
 511             .setAddressType(addrType)
 512             .setContextId(new ContextId(context))
 513             .setContextType(contextType).setTenant(TENANT)
 514             .setEndpointGroup(DEFAULT_EPG).build();
 515     }
 516
 517     private NetworkElements createNetworkElements(String node, String iface, String l3c, String prefix) {
 518         return new NetworkElementsBuilder()
 519             .setNetworkElement(Collections.singletonList(createNetworkElement(node, iface, l3c, prefix))).build();
 520     }
 521
 522     private NetworkElement createNetworkElement(String node, String iface, String l3c, String prefix) {
 523         return new NetworkElementBuilder().setIid(createNetworkElementIid(node))
 524             .setInterface(Collections.singletonList(createInterface(node, iface, l3c, prefix)))
 525             .build();
 526     }
 527
 528     private Interface createInterface(String node, String iface, String l3c, String prefix) {
 529         return new InterfaceBuilder().setIid(iface)
 530             .setEndpointNetwork(Collections.singletonList(createEndpointNetwork(l3c, prefix)))
 531             .build();
 532     }
 533
 534     private EndpointNetwork createEndpointNetwork(String l3c, String prefix) {
 535         return new EndpointNetworkBuilder().setIpPrefix(new IpPrefix(new Ipv4Prefix(prefix)))
 536             .setL3ContextId(new ContextId(l3c))
 537             .build();
 538     }
 539
 540     private InstanceIdentifier<?> createNetworkElementIid(String node) {
 541         return InstanceIdentifier.builder(Nodes.class).child(Node.class, new NodeKey(new NodeId(node))).build();
 542     }
 543
 544     private InstanceIdentifier<?> createInterfaceIid(String node, String connector) {
 545         return InstanceIdentifier.builder(Nodes.class)
 546             .child(Node.class, new NodeKey(new NodeId(node)))
 547             .child(NodeConnector.class, new NodeConnectorKey(new NodeConnectorId(connector)))
 548             .build();
 549     }
 550
 551     private void verifyEmptyLocations() throws Exception {
 552         ReadOnlyTransaction rtx = dataBroker.newReadOnlyTransaction();
 553         InstanceIdentifier<LocationProviders> locationIid = InstanceIdentifier.builder(LocationProviders.class).build();
 554         CheckedFuture<Optional<LocationProviders>, ReadFailedException> read =
 555                 rtx.read(LogicalDatastoreType.OPERATIONAL, locationIid);
 556         assertFalse(read.get().isPresent());
 557         rtx.close();
 558     }
 559 }