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