neutron-ovsdb/src/test/java/org/opendaylight/groupbasedpolicy/neutron/ovsdb/util/OvsdbHelperTest.java

   1 /*
   2  * Copyright (c) 2015 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.neutron.ovsdb.util;
  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.assertNull;
  15 import static org.mockito.Matchers.any;
  16 import static org.mockito.Mockito.mock;
  17 import static org.mockito.Mockito.never;
  18 import static org.mockito.Mockito.verify;
  19 import static org.mockito.Mockito.when;
  20
  21 import java.util.ArrayList;
  22 import java.util.Arrays;
  23 import java.util.List;
  24
  25 import org.junit.Before;
  26 import org.junit.Test;
  27 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  28 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  29 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
  30 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  31 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
  32 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  33 import org.opendaylight.groupbasedpolicy.neutron.ovsdb.AbstractTunnelType;
  34 import org.opendaylight.ovsdb.southbound.SouthboundConstants;
  35 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
  36 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Address;
  37 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
  38 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
  39 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  40 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeVxlan;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentationBuilder;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeName;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeRef;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentationBuilder;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeRef;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntry;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfoBuilder;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.Options;
  53 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointBuilder;
  54 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
  55 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
  56 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TpId;
  57 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
  58 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
  59 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
  60 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  61
  62 import com.google.common.base.Optional;
  63 import com.google.common.util.concurrent.CheckedFuture;
  64
  65 public class OvsdbHelperTest {
  66
  67     private static final String TUNNEL_PREFIX = "tunnelPrefix";
  68
  69     private DataBroker dataBroker;
  70     private InstanceIdentifier<OvsdbTerminationPointAugmentation> tpIid;
  71     private OvsdbBridgeAugmentation ovsdbBridgeAugmentation;
  72     private OvsdbNodeAugmentation ovsdbNodeAugmentation;
  73     private Optional<OvsdbBridgeAugmentation> ovsdbBridgeOptional;
  74     private Optional<OvsdbTerminationPointAugmentation> ovsdbTerminationPointOptional;
  75     private Optional<Node> nodeOptional;
  76     private Node node;
  77     private AbstractTunnelType abstractTunnelType;
  78     private ReadOnlyTransaction readTransaction;
  79     private ReadWriteTransaction readWriteTransaction;
  80     private CheckedFuture<Optional<OvsdbBridgeAugmentation>, ReadFailedException> ovsdbBridgeFuture;
  81     private CheckedFuture<Optional<Node>, ReadFailedException> nodeFuture;
  82     private CheckedFuture<Optional<OvsdbTerminationPointAugmentation>, ReadFailedException> ovsdbTerminationPointFuture;
  83
  84     @SuppressWarnings({"unchecked", "rawtypes"})
  85     @Before
  86     public void setUp() throws Exception {
  87         dataBroker = mock(DataBroker.class);
  88         tpIid = InstanceIdentifier.create(NetworkTopology.class)
  89             .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
  90             .child(Node.class)
  91             .child(TerminationPoint.class)
  92             .augmentation(OvsdbTerminationPointAugmentation.class);
  93
  94         readTransaction = mock(ReadOnlyTransaction.class);
  95         when(dataBroker.newReadOnlyTransaction()).thenReturn(readTransaction);
  96         readWriteTransaction = mock(ReadWriteTransaction.class);
  97         when(dataBroker.newReadWriteTransaction()).thenReturn(readWriteTransaction);
  98         CheckedFuture<Void, TransactionCommitFailedException> submitFuture = mock(CheckedFuture.class);
  99         when(readWriteTransaction.submit()).thenReturn(submitFuture);
 100
 101         ovsdbBridgeFuture = mock(CheckedFuture.class);
 102         ovsdbBridgeOptional = mock(Optional.class);
 103         when(ovsdbBridgeFuture.checkedGet()).thenReturn(ovsdbBridgeOptional);
 104         when(ovsdbBridgeOptional.isPresent()).thenReturn(true);
 105         ovsdbBridgeAugmentation = mock(OvsdbBridgeAugmentation.class);
 106         when(ovsdbBridgeOptional.get()).thenReturn(ovsdbBridgeAugmentation);
 107         OvsdbBridgeName bridgeName = mock(OvsdbBridgeName.class);
 108         when(ovsdbBridgeAugmentation.getBridgeName()).thenReturn(bridgeName);
 109
 110         OvsdbNodeRef bareIid = mock(OvsdbNodeRef.class);
 111         when(ovsdbBridgeAugmentation.getManagedBy()).thenReturn(bareIid);
 112         when(bareIid.getValue()).thenReturn((InstanceIdentifier) InstanceIdentifier.create(Node.class));
 113
 114         nodeFuture = mock(CheckedFuture.class);
 115         nodeOptional = mock(Optional.class);
 116         when(nodeFuture.checkedGet()).thenReturn(nodeOptional);
 117         when(nodeOptional.isPresent()).thenReturn(true);
 118         node = mock(Node.class);
 119         when(nodeOptional.get()).thenReturn(node);
 120         when(node.getAugmentation(OvsdbBridgeAugmentation.class)).thenReturn(ovsdbBridgeAugmentation);
 121
 122         ovsdbTerminationPointFuture = mock(CheckedFuture.class);
 123         ovsdbTerminationPointOptional = mock(Optional.class);
 124         when(ovsdbTerminationPointFuture.checkedGet()).thenReturn(ovsdbTerminationPointOptional);
 125         when(ovsdbTerminationPointOptional.isPresent()).thenReturn(true);
 126         OvsdbTerminationPointAugmentation ovsdbTp = mock(OvsdbTerminationPointAugmentation.class);
 127         when(ovsdbTerminationPointOptional.get()).thenReturn(ovsdbTp);
 128
 129         abstractTunnelType = mock(AbstractTunnelType.class);
 130         when(abstractTunnelType.getTunnelPrefix()).thenReturn(TUNNEL_PREFIX);
 131
 132         ovsdbNodeAugmentation = mock(OvsdbNodeAugmentation.class);
 133         when(node.getAugmentation(OvsdbNodeAugmentation.class)).thenReturn(ovsdbNodeAugmentation);
 134     }
 135
 136     @SuppressWarnings("unchecked")
 137     @Test
 138     public void getOvsdbBridgeFromTerminationPointTest() {
 139         when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(
 140                 ovsdbBridgeFuture);
 141         assertNotNull(OvsdbHelper.getOvsdbBridgeFromTerminationPoint(tpIid, dataBroker));
 142         verify(readTransaction).read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
 143     }
 144
 145     @SuppressWarnings("unchecked")
 146     @Test
 147     public void getOvsdbBridgeFromTerminationPointTestPresentFalse() {
 148         when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(
 149                 ovsdbBridgeFuture);
 150         when(ovsdbBridgeOptional.isPresent()).thenReturn(false);
 151         assertNull(OvsdbHelper.getOvsdbBridgeFromTerminationPoint(tpIid, dataBroker));
 152         verify(readTransaction).read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
 153     }
 154
 155     @SuppressWarnings("unchecked")
 156     @Test
 157     public void getOvsdbBridgeFromTerminationPointTestInvalidIid() {
 158         InstanceIdentifier<OvsdbTerminationPointAugmentation> invalidIid = InstanceIdentifier.create(OvsdbTerminationPointAugmentation.class);
 159         assertNull(OvsdbHelper.getOvsdbBridgeFromTerminationPoint(invalidIid, dataBroker));
 160         verify(readTransaction, never()).read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
 161     }
 162
 163     @SuppressWarnings({"unchecked", "rawtypes"})
 164     @Test
 165     public void getNodeFromBridgeRefTest() {
 166         OvsdbBridgeRef bridgeRef = mock(OvsdbBridgeRef.class);
 167         when(bridgeRef.getValue()).thenReturn((InstanceIdentifier) tpIid);
 168         when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(nodeFuture);
 169         assertNotNull(OvsdbHelper.getNodeFromBridgeRef(bridgeRef, dataBroker));
 170         verify(readTransaction).read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
 171     }
 172
 173     @SuppressWarnings({"unchecked", "rawtypes"})
 174     @Test
 175     public void getNodeFromBridgeRefTestPresentFalse() {
 176         OvsdbBridgeRef bridgeRef = mock(OvsdbBridgeRef.class);
 177         when(bridgeRef.getValue()).thenReturn((InstanceIdentifier) tpIid);
 178         when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(nodeFuture);
 179         when(nodeOptional.isPresent()).thenReturn(false);
 180         assertNull(OvsdbHelper.getNodeFromBridgeRef(bridgeRef, dataBroker));
 181         verify(readTransaction).read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
 182     }
 183
 184     @SuppressWarnings("unchecked")
 185     @Test
 186     public void getOvsdbTerminationPointTest() {
 187         when(readTransaction.read(any(LogicalDatastoreType.class),
 188                 any(InstanceIdentifier.class))).thenReturn(ovsdbTerminationPointFuture);
 189         assertNotNull(OvsdbHelper.getOvsdbTerminationPoint(tpIid, dataBroker));
 190         verify(readTransaction).read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
 191     }
 192
 193     @SuppressWarnings("unchecked")
 194     @Test
 195     public void getOvsdbTerminationPointTestPresentFalse() {
 196         when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(
 197                 ovsdbTerminationPointFuture);
 198         when(ovsdbTerminationPointOptional.isPresent()).thenReturn(false);
 199         assertNull(OvsdbHelper.getOvsdbTerminationPoint(tpIid, dataBroker));
 200         verify(readTransaction).read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
 201     }
 202
 203     @Test
 204     public void getNodeTest() {
 205         NodeBuilder nodeBuilder = new NodeBuilder();
 206         nodeBuilder.setKey(new NodeKey(new NodeId("nodeId")));
 207
 208         TerminationPointBuilder tpBuilder = new TerminationPointBuilder();
 209         tpBuilder.setKey(new TerminationPointKey(new TpId("tpId")));
 210
 211         OvsdbBridgeAugmentationBuilder augmentationBuilder = new OvsdbBridgeAugmentationBuilder();
 212         augmentationBuilder.setBridgeName(new OvsdbBridgeName("bridgeName"));
 213
 214         Node node = OvsdbHelper.getNode(nodeBuilder.build(), Arrays.asList(tpBuilder.build()), augmentationBuilder.build());
 215         assertNotNull(node);
 216         assertEquals("nodeId", node.getKey().getNodeId().getValue());
 217         assertEquals(1, node.getTerminationPoint().size());
 218         TerminationPoint terminationPoint = node.getTerminationPoint().get(0);
 219         assertNotNull(terminationPoint);
 220         assertEquals("tpId", terminationPoint.getKey().getTpId().getValue());
 221         assertEquals("bridgeName", node.getAugmentation(OvsdbBridgeAugmentation.class).getBridgeName().getValue());
 222     }
 223
 224     @Test
 225     public void buildOvsdbBridgeAugmentationTest() {
 226         final InstanceIdentifier<Node> nodeIid = InstanceIdentifier.builder(NetworkTopology.class)
 227                 .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
 228                 .child(Node.class).build();
 229
 230         OvsdbBridgeAugmentationBuilder bridgeAugmentationBuilder = new OvsdbBridgeAugmentationBuilder();
 231         bridgeAugmentationBuilder.setBridgeName(new OvsdbBridgeName("bridgeName"));
 232         bridgeAugmentationBuilder.setManagedBy(new OvsdbNodeRef(nodeIid));
 233
 234         OvsdbNodeAugmentationBuilder nodeAugmentationBuilder = new OvsdbNodeAugmentationBuilder();
 235
 236         ConnectionInfoBuilder ciBuilder = new ConnectionInfoBuilder();
 237         ciBuilder.setLocalIp(new IpAddress(new Ipv4Address("127.0.0.1")));
 238         nodeAugmentationBuilder.setConnectionInfo(ciBuilder.build());
 239
 240         OvsdbBridgeAugmentation augmentation = OvsdbHelper.buildOvsdbBridgeAugmentation(
 241                 bridgeAugmentationBuilder.build(), nodeAugmentationBuilder.build());
 242         assertNotNull(augmentation);
 243         assertNotNull("bridgeName", augmentation.getBridgeName().getValue());
 244         assertEquals(nodeIid, augmentation.getManagedBy().getValue());
 245         assertEquals(1, augmentation.getControllerEntry().size());
 246         ControllerEntry controllerEntry = augmentation.getControllerEntry().get(0);
 247         assertNotNull(controllerEntry);
 248         assertFalse(controllerEntry.getTarget().getValue().isEmpty());
 249     }
 250
 251     @Test
 252     public void buildOvsdbBridgeAugmentationTestManagerIpNull() {
 253         final InstanceIdentifier<Node> nodeIid = InstanceIdentifier.builder(NetworkTopology.class)
 254                 .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
 255                 .child(Node.class).build();
 256
 257         OvsdbBridgeAugmentationBuilder bridgeAugmentationBuilder = new OvsdbBridgeAugmentationBuilder();
 258         bridgeAugmentationBuilder.setBridgeName(new OvsdbBridgeName("bridgeName"));
 259         bridgeAugmentationBuilder.setManagedBy(new OvsdbNodeRef(nodeIid));
 260
 261         OvsdbNodeAugmentationBuilder nodeAugmentationBuilder = new OvsdbNodeAugmentationBuilder();
 262
 263         OvsdbBridgeAugmentation augmentation = OvsdbHelper.buildOvsdbBridgeAugmentation(
 264                 bridgeAugmentationBuilder.build(), nodeAugmentationBuilder.build());
 265         assertNotNull(augmentation);
 266         assertNotNull("bridgeName", augmentation.getBridgeName().getValue());
 267         assertEquals(nodeIid, augmentation.getManagedBy().getValue());
 268         assertNull(augmentation.getControllerEntry());
 269     }
 270
 271     @Test
 272     public void buildTerminationPointsTest() {
 273         OvsdbBridgeAugmentationBuilder bridgeAugmentationBuilder = new OvsdbBridgeAugmentationBuilder();
 274         bridgeAugmentationBuilder.setBridgeName(new OvsdbBridgeName("bridgeName"));
 275
 276         List<Options> options = new ArrayList<Options>();
 277         OvsdbHelper.setOption(options, "optionKey", "optionValue");
 278
 279         OvsdbTerminationPointAugmentation terminationPointAugmentation =
 280                 OvsdbHelper.buildOvsdbTerminationPointAugmentation(bridgeAugmentationBuilder.build(),
 281                         options, abstractTunnelType);
 282
 283         List<TerminationPoint> terminationPoints = OvsdbHelper.buildTerminationPoints(
 284                 bridgeAugmentationBuilder.build(), terminationPointAugmentation, abstractTunnelType);
 285         assertNotNull(terminationPoints);
 286         assertEquals(1, terminationPoints.size());
 287         TerminationPoint terminationPoint = terminationPoints.get(0);
 288         assertNotNull(terminationPoint);
 289         assertEquals(TUNNEL_PREFIX + "bridgeName", terminationPoint.getTpId().getValue());
 290         OvsdbTerminationPointAugmentation tpAugmentation = terminationPoint.getAugmentation(
 291                 OvsdbTerminationPointAugmentation.class);
 292         assertNotNull(tpAugmentation);
 293         assertEquals(TUNNEL_PREFIX + "bridgeName", tpAugmentation.getName());
 294         assertEquals(1, tpAugmentation.getOptions().size());
 295         Options tpOption = tpAugmentation.getOptions().get(0);
 296         assertNotNull(tpOption);
 297         assertEquals("optionKey", tpOption.getOption());
 298         assertEquals("optionValue", tpOption.getValue());
 299         assertEquals(TerminationPoint.class, terminationPoint.getImplementedInterface());
 300     }
 301
 302     @Test
 303     public void buildOvsdbTerminationPointAugmentationTest() {
 304         OvsdbBridgeAugmentationBuilder bridgeAugmentationBuilder = new OvsdbBridgeAugmentationBuilder();
 305         bridgeAugmentationBuilder.setBridgeName(new OvsdbBridgeName("bridgeName"));
 306         List<Options> expectedOptions = new ArrayList<Options>();
 307         OvsdbHelper.setOption(expectedOptions, "optionKey", "optionValue");
 308         OvsdbTerminationPointAugmentation augmentation = OvsdbHelper.buildOvsdbTerminationPointAugmentation(
 309                 bridgeAugmentationBuilder.build(), expectedOptions, abstractTunnelType);
 310         assertNotNull(augmentation);
 311         assertEquals(TUNNEL_PREFIX + "bridgeName", augmentation.getName());
 312         assertEquals(1, augmentation.getOptions().size());
 313         Options option = augmentation.getOptions().get(0);
 314         assertNotNull(option);
 315         assertEquals("optionKey", option.getOption());
 316         assertEquals("optionValue", option.getValue());
 317         assertEquals(InterfaceTypeVxlan.class, augmentation.getInterfaceType());
 318     }
 319
 320     @Test
 321     public void setOptionTest() {
 322         List<Options> options = new ArrayList<Options>();
 323         OvsdbHelper.setOption(options, "key1", "value1");
 324         assertEquals(1, options.size());
 325         Options option = options.get(0);
 326         assertNotNull(option);
 327         assertEquals("key1", option.getOption());
 328         assertEquals("key1", option.getKey().getOption());
 329         assertEquals("value1", option.getValue());
 330         OvsdbHelper.setOption(options, "key2", "value2");
 331         assertEquals(2, options.size());
 332         option = options.get(0);
 333         assertNotNull(option);
 334         assertEquals("key1", option.getOption());
 335         assertEquals("key1", option.getKey().getOption());
 336         assertEquals("value1", option.getValue());
 337         option = options.get(1);
 338         assertNotNull(option);
 339         assertEquals("key2", option.getOption());
 340         assertEquals("key2", option.getKey().getOption());
 341         assertEquals("value2", option.getValue());
 342     }
 343
 344     @Test
 345     public void getNodeIpTest() {
 346         OvsdbNodeAugmentationBuilder nodeAugmentationBuilder = new OvsdbNodeAugmentationBuilder();
 347         ConnectionInfoBuilder ciBuilder = new ConnectionInfoBuilder();
 348         ciBuilder.setRemoteIp(new IpAddress(new Ipv4Address("192.168.50.10")));
 349         nodeAugmentationBuilder.setConnectionInfo(ciBuilder.build());
 350
 351         IpAddress nodeIpAddress = OvsdbHelper.getNodeIp(nodeAugmentationBuilder.build());
 352         assertNotNull(nodeIpAddress);
 353         assertEquals("192.168.50.10", nodeIpAddress.getIpv4Address().getValue());
 354     }
 355
 356     @Test
 357     public void getNodeIpTestIpNotSet() {
 358         OvsdbNodeAugmentationBuilder nodeAugmentationBuilder = new OvsdbNodeAugmentationBuilder();
 359         nodeAugmentationBuilder.setConnectionInfo(new ConnectionInfoBuilder().build());
 360         assertNull(OvsdbHelper.getNodeIp(nodeAugmentationBuilder.build()));
 361     }
 362
 363     @Test
 364     public void getNodeIpTestConnectionInfoNull() {
 365         assertNull(OvsdbHelper.getNodeIp(new OvsdbNodeAugmentationBuilder().build()));
 366     }
 367
 368     @Test
 369     public void getManagedNodeTestManagedByNotSet() {
 370         assertNull(OvsdbHelper.getManagerNode(new OvsdbBridgeAugmentationBuilder().build(), dataBroker));
 371     }
 372
 373     @SuppressWarnings("unchecked")
 374     @Test
 375     public void getManagedNodeTestInvalidTargetTypeForManagedBy() {
 376         final InstanceIdentifier<NetworkTopology> nodeIid = InstanceIdentifier.builder(NetworkTopology.class).build();
 377         OvsdbBridgeAugmentationBuilder bridgeAugmentationBuilder = new OvsdbBridgeAugmentationBuilder();
 378         bridgeAugmentationBuilder.setManagedBy(new OvsdbNodeRef(nodeIid));
 379         assertNull(OvsdbHelper.getManagerNode(bridgeAugmentationBuilder.build(), dataBroker));
 380         verify(readTransaction, never()).read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
 381     }
 382
 383     @SuppressWarnings("unchecked")
 384     @Test
 385     public void getTopologyNodeTest() {
 386         InstanceIdentifier<Node> nodeIid = InstanceIdentifier.create(Node.class);
 387         when(readTransaction.read(any(LogicalDatastoreType.class),
 388                 any(InstanceIdentifier.class))).thenReturn(nodeFuture);
 389         assertEquals(node, OvsdbHelper.getTopologyNode(nodeIid, dataBroker));
 390         verify(readTransaction).read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
 391     }
 392
 393     @SuppressWarnings("unchecked")
 394     @Test
 395     public void getTopologyNodeTestPresentFalse() {
 396         InstanceIdentifier<Node> nodeIid = InstanceIdentifier.create(Node.class);
 397         when(readTransaction.read(any(LogicalDatastoreType.class),
 398                 any(InstanceIdentifier.class))).thenReturn(nodeFuture);
 399         when(nodeOptional.isPresent()).thenReturn(false);
 400         assertNull(OvsdbHelper.getTopologyNode(nodeIid, dataBroker));
 401         verify(readTransaction).read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
 402     }
 403
 404     @SuppressWarnings("unchecked")
 405     @Test
 406     public void createTunnelPortTest() {
 407         InstanceIdentifier<Node> nodeIid = InstanceIdentifier.create(Node.class);
 408         when(readWriteTransaction.read(any(LogicalDatastoreType.class),
 409                 any(InstanceIdentifier.class))).thenReturn(nodeFuture);
 410         OvsdbHelper.createTunnelPort(nodeIid, node, abstractTunnelType, dataBroker);
 411         verify(readWriteTransaction).read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
 412         verify(readWriteTransaction).submit();
 413     }
 414
 415     @Test
 416     public void createTunnelPortTestBridgeNull() {
 417         InstanceIdentifier<Node> nodeIid = InstanceIdentifier.create(Node.class);
 418         when(node.getAugmentation(OvsdbBridgeAugmentation.class)).thenReturn(null);
 419         OvsdbHelper.createTunnelPort(nodeIid, node, abstractTunnelType, dataBroker);
 420         verify(readWriteTransaction, never()).submit();
 421     }
 422
 423     @SuppressWarnings("unchecked")
 424     @Test
 425     public void createTunnelPortTestManagerNodeNull() {
 426         InstanceIdentifier<Node> nodeIid = InstanceIdentifier.create(Node.class);
 427         when(readWriteTransaction.read(any(LogicalDatastoreType.class),
 428                 any(InstanceIdentifier.class))).thenReturn(nodeFuture);
 429         when(nodeOptional.isPresent()).thenReturn(false);
 430         OvsdbHelper.createTunnelPort(nodeIid, node, abstractTunnelType, dataBroker);
 431         verify(readWriteTransaction).read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
 432         verify(readWriteTransaction, never()).submit();
 433     }
 434 }