impl/src/test/java/org/opendaylight/unimgr/utils/OvsdbUtilsTest.java

   1 /*
   2  * Copyright (c) 2016 CableLabs 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.unimgr.utils;
  10
  11 import static org.junit.Assert.assertEquals;
  12 import static org.junit.Assert.assertNotNull;
  13 import static org.junit.Assert.assertTrue;
  14 import static org.mockito.Matchers.any;
  15 import static org.mockito.Matchers.argThat;
  16 import static org.mockito.Matchers.eq;
  17 import static org.mockito.Mockito.doNothing;
  18 import static org.mockito.Mockito.mock;
  19 import static org.mockito.Mockito.times;
  20 import static org.mockito.Mockito.verify;
  21 import static org.mockito.Mockito.when;
  22
  23 import java.net.InetAddress;
  24 import java.net.UnknownHostException;
  25 import java.util.ArrayList;
  26 import java.util.HashMap;
  27 import java.util.HashSet;
  28 import java.util.List;
  29 import java.util.Map;
  30 import java.util.UUID;
  31
  32 import org.junit.Before;
  33 import org.junit.Rule;
  34 import org.junit.Test;
  35 import org.junit.rules.ExpectedException;
  36 import org.junit.runner.RunWith;
  37 import org.mockito.ArgumentMatcher;
  38 import org.mockito.Mock;
  39 import org.mockito.Mockito;
  40 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  41 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  42 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
  43 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  44 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  45 import org.opendaylight.ovsdb.southbound.SouthboundConstants;
  46 import org.opendaylight.unimgr.impl.UnimgrConstants;
  47 import org.opendaylight.unimgr.impl.UnimgrMapper;
  48 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
  49 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Address;
  50 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.PortNumber;
  51 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Uri;
  52 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentationBuilder;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeName;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeProtocolBase;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentationBuilder;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeRef;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbPortInterfaceAttributes.VlanMode;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentationBuilder;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntry;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntryBuilder;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ProtocolEntry;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ProtocolEntryBuilder;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfo;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfoBuilder;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.Uni;
  71 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.UniAugmentation;
  72 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.UniAugmentationBuilder;
  73 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
  74 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
  75 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TpId;
  76 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
  77 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
  78 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  79 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder;
  80 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
  81 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
  82 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointBuilder;
  83 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
  84 import org.opendaylight.yangtools.yang.binding.DataObject;
  85 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  86 import org.powermock.api.mockito.PowerMockito;
  87 import org.powermock.api.support.membermodification.MemberMatcher;
  88 import org.powermock.api.support.membermodification.MemberModifier;
  89 import org.powermock.core.classloader.annotations.PrepareForTest;
  90 import org.powermock.modules.junit4.PowerMockRunner;
  91 import org.slf4j.Logger;
  92 import org.slf4j.LoggerFactory;
  93
  94 import com.google.common.base.Optional;
  95 import com.google.common.collect.ImmutableBiMap;
  96 import com.google.common.util.concurrent.CheckedFuture;
  97
  98 import ch.qos.logback.classic.spi.LoggingEvent;
  99 import ch.qos.logback.core.Appender;
 100
 101 @RunWith(PowerMockRunner.class)
 102 @PrepareForTest({LogicalDatastoreType.class, UnimgrMapper.class, OvsdbUtils.class, MdsalUtils.class, UUID.class})
 103 public class OvsdbUtilsTest {
 104
 105     @Rule
 106     public final ExpectedException exception = ExpectedException.none();
 107     @Mock private DataBroker dataBroker;
 108     @Mock private Node bridgeNode;
 109     @Mock private String bridgeName;
 110     @Mock private String portName;
 111     @Mock private String type;
 112     @Mock private WriteTransaction transaction;
 113     @Mock private IpAddress mockIp;
 114     @SuppressWarnings("rawtypes")
 115     @Mock private Appender mockAppender;
 116     @SuppressWarnings({ "rawtypes" })
 117     @Mock private CheckedFuture checkedFuture;
 118     @SuppressWarnings("unchecked")
 119     private static final InstanceIdentifier<TerminationPoint> tpIid = PowerMockito.mock(InstanceIdentifier.class);
 120     private static final IpAddress IP = new IpAddress(new Ipv4Address("192.168.1.2"));
 121     private static final NodeId OVSDB_NODE_ID = new NodeId("ovsdb://7011db35-f44b-4aab-90f6-d89088caf9d8");
 122     @SuppressWarnings("unchecked")
 123     private static final InstanceIdentifier<Node> MOCK_NODE_IID = PowerMockito.mock(InstanceIdentifier.class);
 124     private ch.qos.logback.classic.Logger root;
 125
 126     @SuppressWarnings("unchecked")
 127     @Before
 128     public void setUp() throws Exception {
 129         PowerMockito.mockStatic(OvsdbUtils.class, Mockito.CALLS_REAL_METHODS);
 130         PowerMockito.mockStatic(MdsalUtils.class, Mockito.CALLS_REAL_METHODS);
 131         PowerMockito.mockStatic(UnimgrMapper.class, Mockito.CALLS_REAL_METHODS);
 132         PowerMockito.mockStatic(LogicalDatastoreType.class);
 133         PowerMockito.mockStatic(UUID.class);
 134         root = (ch.qos.logback.classic.Logger)
 135                 LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
 136         // Check logger messages
 137         when(mockAppender.getName()).thenReturn("MOCK");
 138         root.addAppender(mockAppender);
 139     }
 140
 141     /*
 142      *  This test for 2 functions with the
 143      *  same name that take different parameters.
 144      */
 145     @SuppressWarnings({"unchecked", "rawtypes"})
 146     @Test
 147     public void testCreateBridgeNode() throws Exception {
 148         // Function 1
 149         Node ovsdbNode = new NodeBuilder().setNodeId(OVSDB_NODE_ID).build();
 150         InstanceIdentifier<Node> nodeIid = InstanceIdentifier
 151                 .create(NetworkTopology.class)
 152                 .child(Topology.class,
 153                         new TopologyKey(UnimgrConstants.OVSDB_TOPOLOGY_ID))
 154                 .child(Node.class,
 155                         new NodeKey(OVSDB_NODE_ID));
 156         OvsdbNodeRef ovsdbNodeRef = new OvsdbNodeRef(nodeIid);
 157         UniAugmentation uni = new UniAugmentationBuilder()
 158                                       .setIpAddress(new IpAddress(new Ipv4Address("192.168.1.1")))
 159                                       .setOvsdbNodeRef(ovsdbNodeRef)
 160                                       .build();
 161
 162         when(dataBroker.newWriteOnlyTransaction()).thenReturn(transaction);
 163         doNothing().when(transaction).put(any(LogicalDatastoreType.class),
 164                                           any(InstanceIdentifier.class),
 165                                           any(Node.class));
 166         when(transaction.submit()).thenReturn(checkedFuture);
 167         MemberModifier.suppress(MemberMatcher.method(UnimgrMapper.class, "createOvsdbBridgeNodeIid", Node.class, String.class));
 168         when(UnimgrMapper.createOvsdbBridgeNodeIid(any(Node.class),
 169                                                    any(String.class))).thenReturn(MOCK_NODE_IID);
 170         OvsdbUtils.createBridgeNode(dataBroker, ovsdbNode, uni, "br0");
 171         verify(transaction).put(any(LogicalDatastoreType.class),
 172                                 any(InstanceIdentifier.class),
 173                                 any(Node.class));
 174         verify(transaction).submit();
 175
 176         // Function 2
 177         MemberModifier.suppress(MemberMatcher.method(MdsalUtils.class,
 178                                                      "readNode",
 179                                                      DataBroker.class,
 180                                                      LogicalDatastoreType.class,
 181                                                      InstanceIdentifier.class));
 182         Optional<Node> mockOptional = mock(Optional.class);
 183         when(MdsalUtils.readNode(any(DataBroker.class),
 184                                   any(LogicalDatastoreType.class),
 185                                   any(InstanceIdentifier.class))).thenReturn(mockOptional);
 186         OvsdbUtils.createBridgeNode(dataBroker, nodeIid, uni, "br0");
 187         verify(transaction).put(any(LogicalDatastoreType.class),
 188                                 any(InstanceIdentifier.class),
 189                                 any(Node.class));
 190         verify(transaction).submit();
 191
 192         // Ensure correct logging
 193         verify(mockAppender, times(2)).doAppend(argThat(new ArgumentMatcher() {
 194             @Override
 195             public boolean matches(final Object argument) {
 196               return ((LoggingEvent)argument).getFormattedMessage().contains("Creating a bridge on node");
 197             }
 198           }));
 199     }
 200
 201     @Test
 202     public void testCreateControllerEntries() {
 203         String targetString = new String("controllerEntry");
 204         List<ControllerEntry> controllerEntries = new ArrayList<ControllerEntry>();
 205         ControllerEntryBuilder controllerEntryBuilder = new ControllerEntryBuilder();
 206         controllerEntryBuilder.setTarget(new Uri(targetString));
 207         controllerEntries.add(controllerEntryBuilder.build());
 208         assertEquals(controllerEntries, OvsdbUtils.createControllerEntries(targetString));
 209     }
 210
 211     @SuppressWarnings("unchecked")
 212     @Test
 213     public void testCreateGreTunnel() throws Exception {
 214
 215         UniAugmentation sourceUniAug = new UniAugmentationBuilder()
 216                 .setIpAddress(new IpAddress(new Ipv4Address("192.168.1.1")))
 217                 .build();
 218         UniAugmentation destUniAug = new UniAugmentationBuilder()
 219                 .setIpAddress(new IpAddress(new Ipv4Address("192.168.1.2")))
 220                 .build();
 221
 222         when(dataBroker.newWriteOnlyTransaction()).thenReturn(transaction);
 223         doNothing().when(transaction).put(any(LogicalDatastoreType.class),
 224                                           any(InstanceIdentifier.class),
 225                                           any(TerminationPoint.class));
 226         when(transaction.submit()).thenReturn(checkedFuture);
 227
 228         MemberModifier.suppress(MemberMatcher.method(UnimgrMapper.class, "getTerminationPointIid", Node.class, String.class));
 229         MemberModifier.suppress(MemberMatcher.method(OvsdbUtils.class, "createMdsalProtocols"));
 230
 231         Node bNode = new NodeBuilder().setKey(new NodeKey(OVSDB_NODE_ID)).build();
 232         InstanceIdentifier<TerminationPoint> tpIid = InstanceIdentifier
 233                                                         .create(NetworkTopology.class)
 234                                                         .child(Topology.class,
 235                                                                 new TopologyKey(UnimgrConstants.OVSDB_TOPOLOGY_ID))
 236                                                         .child(Node.class, bNode.getKey())
 237                                                         .child(TerminationPoint.class,
 238                                                                 new TerminationPointKey(new TpId(portName)));
 239         when(UnimgrMapper.getTerminationPointIid(any(Node.class), any(String.class))).thenReturn(tpIid);
 240         OvsdbUtils.createGreTunnel(dataBroker,
 241                                     sourceUniAug,
 242                                     destUniAug,
 243                                     bridgeNode,
 244                                     bridgeName,
 245                                     portName);
 246         verify(transaction).put(any(LogicalDatastoreType.class),
 247                                 any(InstanceIdentifier.class),
 248                                 any(TerminationPoint.class));
 249         verify(transaction).submit();
 250     }
 251
 252     @Test
 253     public void testCreateMdsalProtocols() {
 254         List<ProtocolEntry> protocolList = new ArrayList<ProtocolEntry>();
 255         ImmutableBiMap<String, Class<? extends OvsdbBridgeProtocolBase>> mapper =
 256                 SouthboundConstants.OVSDB_PROTOCOL_MAP.inverse();
 257         ProtocolEntry protoEntry = new ProtocolEntryBuilder().setProtocol((Class<? extends OvsdbBridgeProtocolBase>) mapper.get("OpenFlow13")).build();
 258         protocolList.add(protoEntry);
 259         assertEquals(protocolList, OvsdbUtils.createMdsalProtocols());
 260     }
 261
 262     @Test
 263     public void testCreateOvsdbBridgeAugmentation() throws Exception {
 264         OvsdbNodeRef ovsdbNodeRef = new OvsdbNodeRef(PowerMockito.mock(InstanceIdentifier.class));
 265         UniAugmentation uni = new UniAugmentationBuilder().setOvsdbNodeRef(ovsdbNodeRef).build();
 266         UUID bridgeUuid = PowerMockito.mock(UUID.class);
 267         PowerMockito.when(UUID.randomUUID()).thenReturn(bridgeUuid);
 268         OvsdbBridgeAugmentation ovsdbNode = new OvsdbBridgeAugmentationBuilder()
 269                                                     .setBridgeName(new OvsdbBridgeName(UnimgrConstants.DEFAULT_BRIDGE_NAME))
 270                                                     .setManagedBy(ovsdbNodeRef)
 271                                                     .setBridgeUuid(new Uuid(bridgeUuid.toString()))
 272                                                     .build();
 273         assertEquals(ovsdbNode, OvsdbUtils.createOvsdbBridgeAugmentation(uni));
 274         // Force an exception
 275         Uni ovsdbNodeRefNull = new UniAugmentationBuilder().setOvsdbNodeRef(null).build();
 276         exception.expect(Exception.class);
 277         OvsdbUtils.createOvsdbBridgeAugmentation(ovsdbNodeRefNull);
 278     }
 279
 280     /*
 281      *  This test for 2 functions with the
 282      *  same name that take different parameters.
 283      */
 284     @SuppressWarnings({ "unchecked", "rawtypes" })
 285     @Test
 286     public void testCreateOvsdbNode() {
 287         MemberModifier.suppress(MemberMatcher.method(UnimgrMapper.class, "getOvsdbNodeIid", IpAddress.class));
 288         PowerMockito.when(UnimgrMapper.getOvsdbNodeIid(mockIp)).thenReturn(MOCK_NODE_IID);
 289         when(dataBroker.newWriteOnlyTransaction()).thenReturn(transaction);
 290         //when(dataBroker.newWriteOnlyTransaction()).thenReturn(transaction);
 291         Uni uni = new UniAugmentationBuilder().setIpAddress(new IpAddress(new Ipv4Address("192.168.1.2"))).build();
 292         // createOvsdbNode with NodeId and Uni
 293         OvsdbUtils.createOvsdbNode(dataBroker, OVSDB_NODE_ID, uni);
 294         // Ensure correct logging
 295         verify(mockAppender).doAppend(argThat(new ArgumentMatcher() {
 296             @Override
 297             public boolean matches(final Object argument) {
 298               return ((LoggingEvent)argument).getFormattedMessage().contains("Created and submitted a new OVSDB node");
 299             }
 300           }));
 301         doNothing().when(transaction).put(any(LogicalDatastoreType.class),
 302                                           any(InstanceIdentifier.class),
 303                                           any(Node.class));
 304         when(transaction.submit()).thenReturn(checkedFuture);
 305         verify(transaction).put(any(LogicalDatastoreType.class),
 306                                 any(InstanceIdentifier.class),
 307                                 any(Node.class));
 308         verify(transaction).submit();
 309         // Test with a null uni
 310         exception.expect(Exception.class);
 311         OvsdbUtils.createOvsdbNode(dataBroker, OVSDB_NODE_ID, null);
 312         // Ensure correct logging
 313         verify(mockAppender).doAppend(argThat(new ArgumentMatcher() {
 314             @Override
 315             public boolean matches(final Object argument) {
 316               return ((LoggingEvent)argument).getFormattedMessage().contains("Created and submitted a new OVSDB node");
 317             }
 318           }));
 319         // createOvsdbNode with Uni
 320         UniAugmentation uniAug = new UniAugmentationBuilder(uni).build();
 321         OvsdbUtils.createOvsdbNode(dataBroker, uniAug);
 322         MemberModifier.suppress(MemberMatcher.method(UnimgrMapper.class, "getOvsdbNodeIid", NodeId.class));
 323         PowerMockito.when(UnimgrMapper.getOvsdbNodeIid(any(NodeId.class))).thenReturn(MOCK_NODE_IID);
 324         doNothing().when(transaction).put(any(LogicalDatastoreType.class),
 325                                           any(InstanceIdentifier.class),
 326                                           any(Node.class));
 327         when(transaction.submit()).thenReturn(checkedFuture);
 328         verify(transaction).put(any(LogicalDatastoreType.class),
 329                                 any(InstanceIdentifier.class),
 330                                 any(Node.class));
 331         verify(transaction).submit();
 332         // try with a null uni
 333         PowerMockito.when(UnimgrMapper.getOvsdbNodeIid(any(NodeId.class))).thenReturn(null);
 334         OvsdbUtils.createOvsdbNode(dataBroker, null);
 335         exception.expect(Exception.class);
 336         OvsdbUtils.createOvsdbNode(dataBroker, null);
 337     }
 338
 339     @Test
 340     public void testCreateOvsdbNodeAugmentation() {
 341         Uni uni = new UniAugmentationBuilder().setIpAddress(new IpAddress(new Ipv4Address("192.168.1.2"))).build();
 342         ConnectionInfo connectionInfos = new ConnectionInfoBuilder()
 343                 .setRemoteIp(uni.getIpAddress())
 344                 .setRemotePort(new PortNumber(UnimgrConstants.OVSDB_PORT))
 345                 .build();
 346         OvsdbNodeAugmentation ovsdbNode = new OvsdbNodeAugmentationBuilder()
 347                 .setConnectionInfo(connectionInfos).build();
 348         assertEquals(ovsdbNode, OvsdbUtils.createOvsdbNodeAugmentation(uni));
 349     }
 350
 351     @Test
 352     public void testCreateOvsdbNodeId() {
 353         String nodeId = UnimgrConstants.OVSDB_PREFIX
 354                 + IP.getIpv4Address().getValue().toString()
 355                 + ":"
 356                 + UnimgrConstants.OVSDB_PORT;
 357         assertEquals(new NodeId(nodeId), OvsdbUtils.createOvsdbNodeId(IP));
 358     }
 359
 360     @Test
 361     public void testCreateOvsdbTerminationPointAugmentation() {
 362         Uni uni = new UniAugmentationBuilder().build();
 363         VlanId vlanID = new VlanId(1);
 364         OvsdbTerminationPointAugmentation terminationPoint = new OvsdbTerminationPointAugmentationBuilder()
 365                                                                      .setName(UnimgrConstants.DEFAULT_INTERNAL_IFACE)
 366                                                                      .setVlanTag(vlanID)
 367                                                                      .setVlanMode(VlanMode.Access)
 368                                                                      .build();
 369         assertEquals(terminationPoint, OvsdbUtils.createOvsdbTerminationPointAugmentation(uni));
 370     }
 371
 372     /*
 373      *  This test for 2 functions with the
 374      *  same name that take different parameters.
 375      */
 376     @SuppressWarnings("unchecked")
 377     @Test
 378     public void testCreateTerminationPointNode() {
 379         Uni uni = new UniAugmentationBuilder().build();
 380         Node bridgeNode = new NodeBuilder().build();
 381
 382         MemberModifier.suppress(MemberMatcher.method(UnimgrMapper.class,
 383                                                      "getTerminationPointIid",
 384                                                      Node.class,
 385                                                      String.class));
 386         PowerMockito.when(UnimgrMapper.getTerminationPointIid(any(Node.class),
 387                                                               any(String.class))).thenReturn(tpIid);
 388         when(dataBroker.newWriteOnlyTransaction()).thenReturn(transaction);
 389         Node bNode = new NodeBuilder().setKey(new NodeKey(OVSDB_NODE_ID)).build();
 390         InstanceIdentifier<TerminationPoint> tpIid = InstanceIdentifier
 391                                                         .create(NetworkTopology.class)
 392                                                         .child(Topology.class,
 393                                                                 new TopologyKey(UnimgrConstants.OVSDB_TOPOLOGY_ID))
 394                                                         .child(Node.class, bNode.getKey())
 395                                                         .child(TerminationPoint.class,
 396                                                                 new TerminationPointKey(new TpId(portName)));
 397         when(UnimgrMapper.getTerminationPointIid(any(Node.class), any(String.class))).thenReturn(tpIid);
 398         // Function 1
 399         OvsdbUtils.createTerminationPointNode(dataBroker, uni, bNode, bridgeName, portName, type);
 400
 401         //Function 2
 402         doNothing().when(transaction).put(any(LogicalDatastoreType.class),
 403                                           any(InstanceIdentifier.class),
 404                                           any(TerminationPoint.class));
 405         when(transaction.submit()).thenReturn(checkedFuture);
 406         OvsdbUtils.createTerminationPointNode(dataBroker, uni, bridgeNode, bridgeName, portName);
 407         verify(transaction, times(2)).put(any(LogicalDatastoreType.class),
 408                                           any(InstanceIdentifier.class),
 409                                           any(TerminationPoint.class));
 410         verify(transaction,times(2)).submit();
 411     }
 412
 413     @SuppressWarnings("unchecked")
 414     @Test
 415     public void testDeleteTerminationPoint() {
 416         TerminationPointKey tpKey = new TerminationPointKey(new TpId("abcde"));
 417         TerminationPoint terminationPoint = new TerminationPointBuilder().setKey(tpKey).build();
 418         Node ovsdbNode = new NodeBuilder().setKey(new NodeKey(OVSDB_NODE_ID)).build();
 419         when(dataBroker.newWriteOnlyTransaction()).thenReturn(transaction);
 420         doNothing().when(transaction).delete(any(LogicalDatastoreType.class),
 421                                              any(InstanceIdentifier.class));
 422
 423         OvsdbUtils.deleteTerminationPoint(dataBroker, terminationPoint, ovsdbNode);
 424         verify(transaction,times(2)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
 425         verify(transaction,times(1)).submit();
 426         CheckedFuture<Void, TransactionCommitFailedException> mockCheckedFuture = mock(CheckedFuture.class);
 427         when(transaction.submit()).thenReturn(mockCheckedFuture);
 428         assertEquals(mockCheckedFuture, OvsdbUtils.deleteTerminationPoint(dataBroker, terminationPoint, ovsdbNode));
 429     }
 430
 431     @Test
 432     public void testExtract() {
 433         Map<InstanceIdentifier<?>, DataObject> changes = new HashMap<>();
 434         Class<DataObject> klazz = DataObject.class;
 435         assertEquals(HashMap.class, OvsdbUtils.extract(changes, klazz).getClass());
 436     }
 437
 438     @SuppressWarnings("unchecked")
 439     @Test
 440     public void testExtractOriginal() {
 441         AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes = mock(AsyncDataChangeEvent.class);
 442         Class<DataObject> klazz = DataObject.class;
 443         Map<InstanceIdentifier<?>, DataObject> map = new HashMap<>();
 444         when(changes.getOriginalData()).thenReturn(map);
 445         Map<InstanceIdentifier<DataObject>, DataObject> map1 = new HashMap<>();
 446         when(OvsdbUtils.extract(any(Map.class),eq(DataObject.class))).thenReturn(map1);
 447         assertEquals(map1, OvsdbUtils.extractOriginal(changes, klazz));
 448     }
 449
 450     @SuppressWarnings("unchecked")
 451     @Test
 452     public void testExtractRemoved() {
 453         AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes = mock(AsyncDataChangeEvent.class);
 454         Class<DataObject> klazz = DataObject.class;
 455         assertEquals(HashSet.class, OvsdbUtils.extractRemoved(changes, klazz).getClass());
 456     }
 457
 458     @Test
 459     public void testFindOvsdbNode() {
 460         List<Node> ovsdbNodes = new ArrayList<Node>();
 461         UniAugmentation uni = new UniAugmentationBuilder()
 462                                       .setIpAddress(IP)
 463                                       .build();
 464         ConnectionInfo connInfo = new ConnectionInfoBuilder().setRemoteIp(IP).build();
 465         OvsdbNodeAugmentation augmentation = new OvsdbNodeAugmentationBuilder()
 466                                                      .setConnectionInfo(connInfo)
 467                                                      .build();
 468         Node node = new NodeBuilder().addAugmentation(OvsdbNodeAugmentation.class, augmentation).build();
 469         ovsdbNodes.add(node);
 470         MemberModifier.suppress(MemberMatcher.method(OvsdbUtils.class,
 471                                                      "getOvsdbNodes",
 472                                                      DataBroker.class));
 473         when(OvsdbUtils.getOvsdbNodes(any(DataBroker.class))).thenReturn(ovsdbNodes);
 474         Optional<Node> optNode = Optional.of(node);
 475         assertEquals(optNode, OvsdbUtils.findOvsdbNode(dataBroker, uni));
 476     }
 477
 478     @SuppressWarnings("unchecked")
 479     @Test
 480     public void testGetConnectionInfo() {
 481         DataBroker dataBroker = mock(DataBroker.class);
 482         InstanceIdentifier<Node> nodeIid = PowerMockito.mock(InstanceIdentifier.class);
 483         NodeId ovsdbNodeId = mock(NodeId.class);
 484         Optional<Node> optNode = mock(Optional.class);
 485         Node node = mock(Node.class);
 486         OvsdbNodeAugmentation ovsdbNodeAugmentation = mock(OvsdbNodeAugmentation.class);
 487         ConnectionInfo connectionInfo = mock(ConnectionInfo.class);
 488         MemberModifier.suppress(MemberMatcher.method(UnimgrMapper.class, "getOvsdbNodeIid", NodeId.class));
 489         when(UnimgrMapper.getOvsdbNodeIid(any(NodeId.class))).thenReturn(nodeIid);
 490         MemberModifier.suppress(MemberMatcher.method(MdsalUtils.class, "readNode", DataBroker.class, LogicalDatastoreType.class, InstanceIdentifier.class));
 491         when(MdsalUtils.readNode(any(DataBroker.class), any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(optNode);
 492         when(optNode.isPresent()).thenReturn(true);
 493         when(optNode.get()).thenReturn(node);
 494         when(node.getAugmentation(OvsdbNodeAugmentation.class)).thenReturn(ovsdbNodeAugmentation);
 495         when(ovsdbNodeAugmentation.getConnectionInfo()).thenReturn(connectionInfo);
 496         ConnectionInfo expectedConnInfo = OvsdbUtils.getConnectionInfo(dataBroker, ovsdbNodeId);
 497         assertNotNull(expectedConnInfo);
 498         assertEquals(expectedConnInfo, connectionInfo);
 499     }
 500
 501     @Test
 502     public void testGetLocalIp() {
 503         String ip = "";
 504         try {
 505             ip = InetAddress.getLocalHost().getHostAddress();
 506         } catch (UnknownHostException e) {
 507             ip = "127.0.0.1";
 508         }
 509         IpAddress ipAddress = OvsdbUtils.getLocalIp();
 510         assertNotNull(ipAddress);
 511         String expectedIp = new String(ipAddress.getValue());
 512         assertTrue(expectedIp.equals(ip));
 513     }
 514
 515     @SuppressWarnings("unchecked")
 516     @Test
 517     public void testGetOvsdbNodes() {
 518         Node node = mock(Node.class);
 519         List<Node> ndList = new ArrayList<Node>();
 520         ndList.add(node);
 521         Topology topology = mock (Topology.class);
 522         DataBroker dataBroker = mock(DataBroker.class);
 523         OvsdbNodeAugmentation ovsNdAugmentation = mock(OvsdbNodeAugmentation.class, Mockito.RETURNS_MOCKS);
 524         InstanceIdentifier<Topology> topologyInstanceIdentifier = mock(InstanceIdentifier.class);
 525         MemberModifier.suppress(MemberMatcher.method(UnimgrMapper.class, "getOvsdbTopologyIid"));
 526         when(UnimgrMapper.getOvsdbTopologyIid()).thenReturn(topologyInstanceIdentifier);
 527         MemberModifier.suppress(MemberMatcher.method(MdsalUtils.class, "read", DataBroker.class, LogicalDatastoreType.class, InstanceIdentifier.class));
 528         when(MdsalUtils.read(any(DataBroker.class), any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(topology);
 529         when(topology.getNode()).thenReturn(ndList);
 530         when(node.getAugmentation(OvsdbNodeAugmentation.class)).thenReturn(ovsNdAugmentation);
 531         List<Node> expectedListNnList = OvsdbUtils.getOvsdbNodes(dataBroker);
 532         assertNotNull(expectedListNnList);
 533         assertEquals(expectedListNnList.get(0), node);
 534     }
 535
 536 }