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.rev130715.IpPrefix;
  37 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.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(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(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(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.CONFIGURATION, 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(CONNECTOR_ID_1)
 390                                                     .build())
 391                                             .build())
 392                                     .build()))
 393                             .build()))
 394                     .build();
 395         assertEquals(locationReference, locations);
 396     }
 397
 398     @Test
 399     public void test_CreateLocationForAddrEndpoint_NEWriteFirst() throws Exception {
 400         NetworkElements nes = createNetworkElements(NODE_ID_1, CONNECTOR_ID_1, L3_CONTEXT_ID, IPv4_NETWORK_ADDRESS_1);
 401         InstanceIdentifier<NetworkElements> neIid = InstanceIdentifier.builder(NetworkElements.class).build();
 402         WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
 403         wtx.put(LogicalDatastoreType.CONFIGURATION, neIid, nes);
 404
 405         AddressEndpoint endpoint =
 406                 createAddressEndpoint(IPv4_HOST_ADDRESS_1, IpPrefixType.class, L3_CONTEXT_ID, L3Context.class);
 407         InstanceIdentifier<AddressEndpoint> iid = IidFactory.addressEndpointIid(endpoint.getKey());
 408         wtx.put(LogicalDatastoreType.OPERATIONAL, iid, endpoint, true);
 409         wtx.submit().get();
 410
 411         ReadOnlyTransaction rtx = dataBroker.newReadOnlyTransaction();
 412         InstanceIdentifier<LocationProviders> locationIid = InstanceIdentifier.builder(LocationProviders.class).build();
 413         CheckedFuture<Optional<LocationProviders>, ReadFailedException> read =
 414                 rtx.read(LogicalDatastoreType.CONFIGURATION, locationIid);
 415         assertTrue(read.get().isPresent());
 416         rtx.close();
 417         LocationProviders locations = read.get().get();
 418         LocationProviders locationReference =
 419                 new LocationProvidersBuilder()
 420                     .setLocationProvider(Collections.singletonList(new LocationProviderBuilder()
 421                             .setProvider(new ProviderName(NeLocationProvider.NE_LOCATION_PROVIDER_NAME))
 422                             .setProviderAddressEndpointLocation(Collections.singletonList(
 423                                     new ProviderAddressEndpointLocationBuilder()
 424                                     .setAddress(IPv4_HOST_ADDRESS_1)
 425                                     .setAddressType(IpPrefixType.class)
 426                                     .setContextId(new ContextId(L3_CONTEXT_ID))
 427                                     .setContextType(L3Context.class)
 428                                     .setAbsoluteLocation(new AbsoluteLocationBuilder()
 429                                             .setLocationType(new ExternalLocationCaseBuilder()
 430                                                     .setExternalNodeMountPoint(createNetworkElementIid(NODE_ID_1))
 431                                                     .setExternalNodeConnector(CONNECTOR_ID_1)
 432                                                     .build())
 433                                             .build())
 434                                     .build()))
 435                             .build()))
 436                     .build();
 437         assertEquals(locationReference, locations);
 438     }
 439
 440     @Test
 441     public void test_CreateLocationForAddrEndpoint_SimultaneousWrite() throws Exception {
 442         NetworkElements nes = createNetworkElements(NODE_ID_1, CONNECTOR_ID_1, L3_CONTEXT_ID, IPv4_NETWORK_ADDRESS_1);
 443         InstanceIdentifier<NetworkElements> neIid = InstanceIdentifier.builder(NetworkElements.class).build();
 444         WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
 445         wtx.put(LogicalDatastoreType.CONFIGURATION, neIid, nes);
 446         wtx.submit().get();
 447
 448         AddressEndpoint endpoint =
 449                 createAddressEndpoint(IPv4_HOST_ADDRESS_1, IpPrefixType.class, L3_CONTEXT_ID, L3Context.class);
 450         InstanceIdentifier<AddressEndpoint> iid = IidFactory.addressEndpointIid(endpoint.getKey());
 451         wtx = dataBroker.newWriteOnlyTransaction();
 452         wtx.put(LogicalDatastoreType.OPERATIONAL, iid, endpoint, true);
 453         wtx.submit().get();
 454
 455         ReadOnlyTransaction rtx = dataBroker.newReadOnlyTransaction();
 456         InstanceIdentifier<LocationProviders> locationIid = InstanceIdentifier.builder(LocationProviders.class).build();
 457         CheckedFuture<Optional<LocationProviders>, ReadFailedException> read =
 458                 rtx.read(LogicalDatastoreType.CONFIGURATION, locationIid);
 459         assertTrue(read.get().isPresent());
 460         rtx.close();
 461         LocationProviders locations = read.get().get();
 462         LocationProviders locationReference =
 463                 new LocationProvidersBuilder()
 464                     .setLocationProvider(Collections.singletonList(new LocationProviderBuilder()
 465                             .setProvider(new ProviderName(NeLocationProvider.NE_LOCATION_PROVIDER_NAME))
 466                             .setProviderAddressEndpointLocation(Collections.singletonList(
 467                                     new ProviderAddressEndpointLocationBuilder()
 468                                     .setAddress(IPv4_HOST_ADDRESS_1)
 469                                     .setAddressType(IpPrefixType.class)
 470                                     .setContextId(new ContextId(L3_CONTEXT_ID))
 471                                     .setContextType(L3Context.class)
 472                                     .setAbsoluteLocation(new AbsoluteLocationBuilder()
 473                                             .setLocationType(new ExternalLocationCaseBuilder()
 474                                                     .setExternalNodeMountPoint(createNetworkElementIid(NODE_ID_1))
 475                                                     .setExternalNodeConnector(CONNECTOR_ID_1)
 476                                                     .build())
 477                                             .build())
 478                                     .build()))
 479                             .build()))
 480                     .build();
 481         assertEquals(locationReference, locations);
 482     }
 483
 484     private AddressEndpoint writeBaseAddrEndpoint () throws Exception {
 485         AddressEndpoint endpoint =
 486                 createAddressEndpoint(IPv4_HOST_ADDRESS_1, IpPrefixType.class, L3_CONTEXT_ID, L3Context.class);
 487         InstanceIdentifier<AddressEndpoint> iid = IidFactory.addressEndpointIid(endpoint.getKey());
 488         WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
 489         wtx.put(LogicalDatastoreType.OPERATIONAL, iid, endpoint, true);
 490         wtx.submit().get();
 491         return endpoint;
 492     }
 493
 494     private NetworkElements writeBaseNetworkElements () throws Exception {
 495         NetworkElements nes = createNetworkElements(NODE_ID_1, CONNECTOR_ID_1, L3_CONTEXT_ID, IPv4_NETWORK_ADDRESS_1);
 496         InstanceIdentifier<NetworkElements> iid = InstanceIdentifier.builder(NetworkElements.class).build();
 497         WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
 498         wtx.put(LogicalDatastoreType.CONFIGURATION, iid, nes);
 499         wtx.submit().get();
 500         return nes;
 501     }
 502
 503     private AddressEndpoint createAddressEndpoint(String ipAddr, Class<? extends AddressType> addrType,
 504             String context, Class<? extends ContextType> cType) {
 505         return new AddressEndpointBuilder().setAddress(ipAddr).setAddressType(addrType)
 506                 .setContextId(new ContextId(context)).setContextType(cType).build();
 507     }
 508
 509     private NetworkElements createNetworkElements(String node, String iface, String l3c, String prefix) {
 510         return new NetworkElementsBuilder()
 511             .setNetworkElement(Collections.singletonList(createNetworkElement(node, iface, l3c, prefix))).build();
 512     }
 513
 514     private NetworkElement createNetworkElement(String node, String iface, String l3c, String prefix) {
 515         return new NetworkElementBuilder().setIid(createNetworkElementIid(node))
 516             .setInterface(Collections.singletonList(createInterface(node, iface, l3c, prefix)))
 517             .build();
 518     }
 519
 520     private Interface createInterface(String node, String iface, String l3c, String prefix) {
 521         return new InterfaceBuilder().setIid(iface)
 522             .setEndpointNetwork(Collections.singletonList(createEndpointNetwork(l3c, prefix)))
 523             .build();
 524     }
 525
 526     private EndpointNetwork createEndpointNetwork(String l3c, String prefix) {
 527         return new EndpointNetworkBuilder().setIpPrefix(new IpPrefix(new Ipv4Prefix(prefix)))
 528             .setL3ContextId(new ContextId(l3c))
 529             .build();
 530     }
 531
 532     private InstanceIdentifier<?> createNetworkElementIid(String node) {
 533         return InstanceIdentifier.builder(Nodes.class).child(Node.class, new NodeKey(new NodeId(node))).build();
 534     }
 535
 536     private InstanceIdentifier<?> createInterfaceIid(String node, String connector) {
 537         return InstanceIdentifier.builder(Nodes.class)
 538             .child(Node.class, new NodeKey(new NodeId(node)))
 539             .child(NodeConnector.class, new NodeConnectorKey(new NodeConnectorId(connector)))
 540             .build();
 541     }
 542
 543     private void verifyEmptyLocations() throws Exception {
 544         ReadOnlyTransaction rtx = dataBroker.newReadOnlyTransaction();
 545         InstanceIdentifier<LocationProviders> locationIid = InstanceIdentifier.builder(LocationProviders.class).build();
 546         CheckedFuture<Optional<LocationProviders>, ReadFailedException> read =
 547                 rtx.read(LogicalDatastoreType.OPERATIONAL, locationIid);
 548         assertFalse(read.get().isPresent());
 549         rtx.close();
 550     }
 551 }