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