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.EndpointLocations;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.Endpoints;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.NetworkContainment;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.NetworkContainmentBuilder;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.network.containment.containment.NetworkDomainContainmentBuilder;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.AddressEndpoints;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpoint;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpointBuilder;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpointKey;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContextId;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.NetworkDomainId;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.network.elements.rev160407.NetworkElements;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.network.elements.rev160407.NetworkElementsBuilder;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.network.elements.rev160407.network.elements.NetworkElement;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.network.elements.rev160407.network.elements.NetworkElementBuilder;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.network.elements.rev160407.network.elements.NetworkElementKey;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.network.elements.rev160407.network.elements.network.element.Interface;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.network.elements.rev160407.network.elements.network.element.InterfaceBuilder;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.network.elements.rev160407.network.elements.network.element.InterfaceKey;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.network.elements.rev160407.network.elements.network.element._interface.EndpointNetwork;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.network.elements.rev160407.network.elements.network.element._interface.EndpointNetworkBuilder;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.network.elements.rev160407.network.elements.network.element._interface.EndpointNetworkKey;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.IpPrefixType;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.AddressType;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.ContextType;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
  71 import org.opendaylight.yangtools.concepts.ListenerRegistration;
  72 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  73
  74 import com.google.common.base.Optional;
  75 import com.google.common.collect.ImmutableList;
  76 import com.google.common.util.concurrent.CheckedFuture;
  77
  78 public class NeLocationProviderTest extends CustomDataBrokerTest {
  79
  80     private DataBroker dataBroker;
  81     private NeLocationProvider neProvider;
  82     private String L3_CONTEXT_ID = "l3Context";
  83     private String IPv4_HOST_ADDRESS_1 = "192.168.50.71";
  84     private String IPv4_HOST_ADDRESS_2 = "192.168.50.72";
  85     private String IPv4_NETWORK_ADDRESS_1 = "192.168.50.0/24";
  86     private String IPv4_NETWORK_ADDRESS_2 = "192.168.51.0/24";
  87     private String NODE_ID_1 = "node1";
  88     private String NODE_ID_2 = "node2";
  89     private String CONNECTOR_ID_1 = "connector:1";
  90     private String CONNECTOR_ID_2 = "connector:2";
  91
  92     @Override
  93     public Collection<Class<?>> getClassesFromModules() {
  94         return ImmutableList.<Class<?>>of(NetworkElements.class, EndpointLocations.class, Endpoints.class, L3Context.class, Nodes.class);
  95     }
  96
  97     @Before
  98     public void init() {
  99         dataBroker = getDataBroker();
 100         neProvider = new NeLocationProvider(dataBroker);
 101     }
 102
 103     @Test
 104     public void test_NetworkElementsListenerRegistration() {
 105         DataBroker dataBroker = mock(DataBroker.class);
 106         NeLocationProvider provider = new NeLocationProvider(dataBroker);
 107         verify(dataBroker).registerDataTreeChangeListener(new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
 108                 InstanceIdentifier.builder(NetworkElements.class).build()), provider);
 109     }
 110
 111     @Test
 112     public void test_EndpointsListenerRegistration() {
 113         DataBroker dataBroker = mock(DataBroker.class);
 114         new NeLocationProvider(dataBroker);
 115         verify(dataBroker)
 116             .registerDataTreeChangeListener(eq(new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL,
 117                     InstanceIdentifier.builder(Endpoints.class).child(AddressEndpoints.class)
 118                     .child(AddressEndpoint.class).build())), isA(EndpointsListener.class));
 119     }
 120
 121     @Test
 122     public void test_ListenersUnregistration() {
 123         DataBroker dataBroker = mock(DataBroker.class);
 124         ListenerRegistration<EndpointsListener> endpointsListenerRegistration = mock(ListenerRegistration.class);
 125         when(dataBroker.registerDataTreeChangeListener(any(), isA(EndpointsListener.class)))
 126             .thenReturn(endpointsListenerRegistration);
 127         ListenerRegistration<NeLocationProvider> NEListenerRegistration = mock(ListenerRegistration.class);
 128         when(dataBroker.registerDataTreeChangeListener(any(), isA(NeLocationProvider.class)))
 129             .thenReturn(NEListenerRegistration);
 130         NeLocationProvider provider = new NeLocationProvider(dataBroker);
 131         provider.close();
 132         verify(endpointsListenerRegistration).close();
 133         verify(NEListenerRegistration).close();
 134     }
 135
 136     @Test
 137     public void test_AddressEndpointWrite_NoNE_NoOverwrite() throws Exception {
 138         AddressEndpoint endpoint =
 139                 createAddressEndpoint(IPv4_HOST_ADDRESS_1, IpPrefixType.class, L3_CONTEXT_ID, L3Context.class);
 140         InstanceIdentifier<AddressEndpoint> iid = IidFactory.addressEndpointIid(endpoint.getKey());
 141         WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
 142         wtx.put(LogicalDatastoreType.OPERATIONAL, iid, endpoint, true);
 143         wtx.submit().get();
 144         List<AddressEndpoint> endpoints = neProvider.getEndpoints();
 145         assertEquals(1, endpoints.size());
 146         assertEquals(endpoint, endpoints.get(0));
 147         verifyEmptyLocations();
 148     }
 149
 150     @Test
 151     public void test_AddressEndpointWrite_NoNE_Overwrite() throws Exception {
 152         test_AddressEndpointWrite_NoNE_NoOverwrite();
 153         NetworkContainment nc = new NetworkContainmentBuilder()
 154         .setContainment(new NetworkDomainContainmentBuilder().setNetworkDomainId(new NetworkDomainId(L3_CONTEXT_ID)).build())
 155                 .build();
 156         InstanceIdentifier<NetworkContainment> iid = InstanceIdentifier
 157                 .builder(Endpoints.class)
 158                 .child(AddressEndpoints.class)
 159                 .child(AddressEndpoint.class, new AddressEndpointKey(IPv4_HOST_ADDRESS_1, IpPrefixType.class,
 160                         new ContextId(L3_CONTEXT_ID), L3Context.class))
 161                 .child(NetworkContainment.class)
 162                 .build();
 163         WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
 164         wtx.put(LogicalDatastoreType.OPERATIONAL, iid, nc);
 165         wtx.submit().get();
 166         List<AddressEndpoint> l3Endpoint = neProvider.getEndpoints();
 167         assertEquals(1, l3Endpoint.size());
 168         assertNotNull(l3Endpoint.get(0).getNetworkContainment());
 169         assertEquals(nc, l3Endpoint.get(0).getNetworkContainment());
 170         verifyEmptyLocations();
 171     }
 172
 173     @Test
 174     public void test_EndpointsDelete_NoNE() throws Exception {
 175         test_AddressEndpointWrite_NoNE_NoOverwrite();
 176         InstanceIdentifier<Endpoints> iid = InstanceIdentifier.builder(Endpoints.class)
 177                 .build();
 178         WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
 179         wtx.delete(LogicalDatastoreType.OPERATIONAL, iid);
 180         wtx.submit().get();
 181         List<AddressEndpoint> l3Endpoint = neProvider.getEndpoints();
 182         assertEquals(0, l3Endpoint.size());
 183         verifyEmptyLocations();
 184     }
 185
 186     @Test
 187     public void test_EndpointsModify_NoNE() throws Exception {
 188         test_AddressEndpointWrite_NoNE_NoOverwrite();
 189         InstanceIdentifier<Endpoints> iid = InstanceIdentifier.builder(Endpoints.class)
 190                 .build();
 191         WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
 192         wtx.delete(LogicalDatastoreType.OPERATIONAL, iid);
 193         wtx.submit().get();
 194         List<AddressEndpoint> l3Endpoint = neProvider.getEndpoints();
 195         assertEquals(0, l3Endpoint.size());
 196         verifyEmptyLocations();
 197     }
 198
 199     @Test
 200     public void test_NetworkElementsWrite_NoEP_NoOverwrite() throws Exception {
 201         NetworkElements nes = createNetworkElements(NODE_ID_1, CONNECTOR_ID_1, L3_CONTEXT_ID, IPv4_NETWORK_ADDRESS_1);
 202         InstanceIdentifier<NetworkElements> iid = InstanceIdentifier.builder(NetworkElements.class).build();
 203         WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
 204         wtx.put(LogicalDatastoreType.CONFIGURATION, iid, nes);
 205         wtx.submit().get();
 206         NetworkElements networkElements = neProvider.getNetworkElements();
 207         assertEquals(nes, networkElements);
 208         verifyEmptyLocations();
 209     }
 210
 211     @Test
 212     public void test_NetworkElementsWrite_NoEP_Overwrite() throws Exception {
 213         test_NetworkElementsWrite_NoEP_NoOverwrite();
 214         NetworkElements nes = createNetworkElements(NODE_ID_2, CONNECTOR_ID_2, L3_CONTEXT_ID, IPv4_NETWORK_ADDRESS_1);
 215         InstanceIdentifier<NetworkElements> iid = InstanceIdentifier.builder(NetworkElements.class).build();
 216         WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
 217         wtx.put(LogicalDatastoreType.CONFIGURATION, iid, nes);
 218         wtx.submit().get();
 219         NetworkElements networkElements = neProvider.getNetworkElements();
 220         assertEquals(nes, networkElements);
 221         verifyEmptyLocations();
 222     }
 223
 224     @Test
 225     public void test_NetworkElementWrite_NoEP_Overwrite() throws Exception {
 226         test_NetworkElementsWrite_NoEP_NoOverwrite();
 227         NetworkElement ne = createNetworkElement(NODE_ID_1, CONNECTOR_ID_1, L3_CONTEXT_ID, IPv4_NETWORK_ADDRESS_2);
 228         InstanceIdentifier<NetworkElement> iid = InstanceIdentifier.builder(NetworkElements.class)
 229             .child(NetworkElement.class, new NetworkElementKey(ne.getKey()))
 230             .build();
 231         WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
 232         wtx.put(LogicalDatastoreType.CONFIGURATION, iid, ne);
 233         wtx.submit().get();
 234         NetworkElements nes = neProvider.getNetworkElements();
 235         assertNotNull(nes.getNetworkElement());
 236         assertEquals(1, nes.getNetworkElement().size());
 237         assertEquals(ne, nes.getNetworkElement().get(0));
 238         verifyEmptyLocations();
 239     }
 240
 241     @Test
 242     public void test_InterfaceWrite_NoEP_Overwrite() throws Exception {
 243         test_NetworkElementsWrite_NoEP_NoOverwrite();
 244         Interface iface = createInterface(NODE_ID_1, CONNECTOR_ID_1, L3_CONTEXT_ID, IPv4_NETWORK_ADDRESS_2);
 245         InstanceIdentifier<Interface> iid = InstanceIdentifier.builder(NetworkElements.class)
 246             .child(NetworkElement.class, new NetworkElementKey(createNetworkElementIid(NODE_ID_1)))
 247             .child(Interface.class, new InterfaceKey(iface.getKey()))
 248             .build();
 249         WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
 250         wtx.put(LogicalDatastoreType.CONFIGURATION, iid, iface);
 251         wtx.submit().get();
 252         NetworkElements nes = neProvider.getNetworkElements();
 253         assertNotNull(nes.getNetworkElement());
 254         assertEquals(1, nes.getNetworkElement().size());
 255         assertNotNull(nes.getNetworkElement().get(0).getInterface());
 256         assertEquals(1, nes.getNetworkElement().get(0).getInterface().size());
 257         assertEquals(iface, nes.getNetworkElement().get(0).getInterface().get(0));
 258         verifyEmptyLocations();
 259     }
 260
 261     @Test
 262     public void test_EndpointNetworkChange_NoEP() throws Exception {
 263         test_NetworkElementsWrite_NoEP_NoOverwrite();
 264         EndpointNetwork en = createEndpointNetwork(L3_CONTEXT_ID, IPv4_NETWORK_ADDRESS_2);
 265         InstanceIdentifier<EndpointNetwork> iid = InstanceIdentifier.builder(NetworkElements.class)
 266             .child(NetworkElement.class, new NetworkElementKey(createNetworkElementIid(NODE_ID_1)))
 267             .child(Interface.class, new InterfaceKey(createInterfaceIid(NODE_ID_1, CONNECTOR_ID_1)))
 268             .child(EndpointNetwork.class, new EndpointNetworkKey(en.getKey()))
 269             .build();
 270         InstanceIdentifier<EndpointNetwork> removeIid =
 271                 InstanceIdentifier.builder(NetworkElements.class)
 272                     .child(NetworkElement.class, new NetworkElementKey(createNetworkElementIid(NODE_ID_1)))
 273                     .child(Interface.class, new InterfaceKey(createInterfaceIid(NODE_ID_1, CONNECTOR_ID_1)))
 274                     .child(EndpointNetwork.class, new EndpointNetworkKey(
 275                             new IpPrefix(new Ipv4Prefix(IPv4_NETWORK_ADDRESS_1)),new ContextId(L3_CONTEXT_ID)))
 276                     .build();
 277         WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
 278         wtx.delete(LogicalDatastoreType.CONFIGURATION, removeIid);
 279         wtx.put(LogicalDatastoreType.CONFIGURATION, iid, en);
 280         wtx.submit().get();
 281         NetworkElements nes = neProvider.getNetworkElements();
 282         assertNotNull(nes.getNetworkElement());
 283         assertEquals(1, nes.getNetworkElement().size());
 284         assertNotNull(nes.getNetworkElement().get(0).getInterface());
 285         assertEquals(1, nes.getNetworkElement().get(0).getInterface().size());
 286         assertNotNull(nes.getNetworkElement().get(0).getInterface().get(0).getEndpointNetwork());
 287         assertEquals(1, nes.getNetworkElement().get(0).getInterface().get(0).getEndpointNetwork().size());
 288         assertEquals(en, nes.getNetworkElement().get(0).getInterface().get(0).getEndpointNetwork().get(0));
 289         verifyEmptyLocations();
 290     }
 291
 292     @Test
 293     public void test_NetworkElementsDelete() throws Exception {
 294         test_NetworkElementsWrite_NoEP_NoOverwrite();
 295         InstanceIdentifier<NetworkElements> iid = InstanceIdentifier.builder(NetworkElements.class).build();
 296         WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
 297         wtx.delete(LogicalDatastoreType.CONFIGURATION, iid);
 298         wtx.submit().get();
 299         NetworkElements nes = neProvider.getNetworkElements();
 300         assertEquals(new NetworkElementsBuilder().build(), nes);
 301         verifyEmptyLocations();
 302     }
 303
 304     @Test
 305     public void test_NetworkElementDelete() throws Exception {
 306         test_NetworkElementsWrite_NoEP_NoOverwrite();
 307         InstanceIdentifier<NetworkElement> iid = InstanceIdentifier.builder(NetworkElements.class)
 308             .child(NetworkElement.class, new NetworkElementKey(createNetworkElementIid(NODE_ID_1)))
 309             .build();
 310         WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
 311         wtx.delete(LogicalDatastoreType.CONFIGURATION, iid);
 312         wtx.submit().get();
 313         NetworkElements nes = neProvider.getNetworkElements();
 314         assertNotNull(nes.getNetworkElement());
 315         assertTrue(nes.getNetworkElement().isEmpty());
 316         verifyEmptyLocations();
 317     }
 318
 319     @Test
 320     public void test_InterfaceDelete() throws Exception {
 321         test_NetworkElementsWrite_NoEP_NoOverwrite();
 322         InstanceIdentifier<Interface> iid = InstanceIdentifier.builder(NetworkElements.class)
 323             .child(NetworkElement.class, new NetworkElementKey(createNetworkElementIid(NODE_ID_1)))
 324             .child(Interface.class, new InterfaceKey(createInterfaceIid(NODE_ID_1, CONNECTOR_ID_1)))
 325             .build();
 326         WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
 327         wtx.delete(LogicalDatastoreType.CONFIGURATION, iid);
 328         wtx.submit().get();
 329         NetworkElements nes = neProvider.getNetworkElements();
 330         assertNotNull(nes.getNetworkElement());
 331         assertEquals(1, nes.getNetworkElement().size());
 332         assertNotNull(nes.getNetworkElement().get(0).getInterface());
 333         assertTrue(nes.getNetworkElement().get(0).getInterface().isEmpty());
 334         verifyEmptyLocations();
 335     }
 336
 337     private AddressEndpoint createAddressEndpoint(String ipAddr, Class<? extends AddressType> addrType,
 338             String context, Class<? extends ContextType> cType) {
 339         return new AddressEndpointBuilder().setAddress(ipAddr).setAddressType(addrType)
 340                 .setContextId(new ContextId(context)).setContextType(cType).build();
 341     }
 342
 343     private NetworkElements createNetworkElements(String node, String iface, String l3c, String prefix) {
 344         return new NetworkElementsBuilder()
 345             .setNetworkElement(Collections.singletonList(createNetworkElement(node, iface, l3c, prefix))).build();
 346     }
 347
 348     private NetworkElement createNetworkElement(String node, String iface, String l3c, String prefix) {
 349         return new NetworkElementBuilder().setIid(createNetworkElementIid(node))
 350             .setInterface(Collections.singletonList(createInterface(node, iface, l3c, prefix)))
 351             .build();
 352     }
 353
 354     private Interface createInterface(String node, String iface, String l3c, String prefix) {
 355         return new InterfaceBuilder().setIid(createInterfaceIid(node, iface))
 356             .setEndpointNetwork(Collections.singletonList(createEndpointNetwork(l3c, prefix)))
 357             .build();
 358     }
 359
 360     private EndpointNetwork createEndpointNetwork(String l3c, String prefix) {
 361         return new EndpointNetworkBuilder().setIpPrefix(new IpPrefix(new Ipv4Prefix(prefix)))
 362             .setL3ContextId(new ContextId(l3c))
 363             .build();
 364     }
 365
 366     private InstanceIdentifier<?> createNetworkElementIid(String node) {
 367         return InstanceIdentifier.builder(Nodes.class).child(Node.class, new NodeKey(new NodeId(node))).build();
 368     }
 369
 370     private InstanceIdentifier<?> createInterfaceIid(String node, String connector) {
 371         return InstanceIdentifier.builder(Nodes.class)
 372             .child(Node.class, new NodeKey(new NodeId(node)))
 373             .child(NodeConnector.class, new NodeConnectorKey(new NodeConnectorId(connector)))
 374             .build();
 375     }
 376
 377     private void verifyEmptyLocations() throws Exception {
 378         ReadOnlyTransaction rtx = dataBroker.newReadOnlyTransaction();
 379         InstanceIdentifier<EndpointLocations> locationIid = InstanceIdentifier.builder(EndpointLocations.class).build();
 380         CheckedFuture<Optional<EndpointLocations>, ReadFailedException> read =
 381                 rtx.read(LogicalDatastoreType.OPERATIONAL, locationIid);
 382         assertFalse(read.get().isPresent());
 383         rtx.close();
 384     }
 385 }