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