impl/src/test/java/org/opendaylight/unimgr/impl/UnimgrUtilsTest.java

   1 package org.opendaylight.unimgr.impl;
   2
   3 import static org.junit.Assert.assertEquals;
   4 import static org.junit.Assert.assertNotNull;
   5 import static org.junit.Assert.assertTrue;
   6 import static org.mockito.Matchers.any;
   7 import static org.mockito.Mockito.doNothing;
   8 import static org.mockito.Mockito.mock;
   9 import static org.mockito.Mockito.verify;
  10 import static org.mockito.Mockito.when;
  11 import static org.mockito.Mockito.times;
  12 import static org.mockito.Matchers.argThat;
  13 import static org.mockito.Matchers.eq;
  14
  15 import org.mockito.Mock;
  16 import org.mockito.Mockito;
  17
  18 import org.powermock.core.classloader.annotations.PrepareForTest;
  19 import org.powermock.modules.junit4.PowerMockRunner;
  20 import org.slf4j.LoggerFactory;
  21
  22 import com.google.common.base.Optional;
  23 import com.google.common.collect.ImmutableBiMap;
  24 import com.google.common.util.concurrent.CheckedFuture;
  25
  26 import ch.qos.logback.core.Appender;
  27 import ch.qos.logback.classic.spi.LoggingEvent;
  28 import org.mockito.ArgumentMatcher;
  29
  30 import org.powermock.api.mockito.PowerMockito;
  31 import org.powermock.api.support.membermodification.MemberMatcher;
  32 import org.powermock.api.support.membermodification.MemberModifier;
  33
  34 import java.net.InetAddress;
  35 import java.net.UnknownHostException;
  36 import java.util.ArrayList;
  37 import java.util.HashMap;
  38 import java.util.HashSet;
  39 import java.util.List;
  40 import java.util.Map;
  41 import java.util.UUID;
  42
  43 import org.junit.Before;
  44 import org.junit.Rule;
  45 import org.junit.Test;
  46 import org.junit.rules.ExpectedException;
  47 import org.junit.runner.RunWith;
  48 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  49 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  50 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  51 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
  52 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  53 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
  54 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  55 import org.opendaylight.ovsdb.southbound.SouthboundConstants;
  56 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
  57 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Address;
  58 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.PortNumber;
  59 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Uri;
  60 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentationBuilder;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeName;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeProtocolBase;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentationBuilder;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeRef;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentationBuilder;
  71 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbPortInterfaceAttributes.VlanMode;
  72 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntry;
  73 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntryBuilder;
  74 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ProtocolEntry;
  75 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ProtocolEntryBuilder;
  76 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfo;
  77 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfoBuilder;
  78 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.EvcAugmentation;
  79 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.EvcAugmentationBuilder;
  80 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.Uni;
  81 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.UniAugmentation;
  82 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.UniAugmentationBuilder;
  83 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.evc.EgressBw;
  84 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.evc.IngressBw;
  85 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.evc.UniDest;
  86 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.evc.UniDestBuilder;
  87 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.evc.UniDestKey;
  88 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.evc.UniSource;
  89 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.evc.UniSourceBuilder;
  90 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.unimgr.rev151012.evc.UniSourceKey;
  91 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.LinkId;
  92 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
  93 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
  94 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TpId;
  95 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
  96 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
  97 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Link;
  98 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.LinkKey;
  99 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
 100 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder;
 101 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
 102 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
 103 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointBuilder;
 104 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
 105 import org.opendaylight.yangtools.yang.binding.DataObject;
 106 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 107
 108
 109 @RunWith(PowerMockRunner.class)
 110 @PrepareForTest({LogicalDatastoreType.class, UnimgrMapper.class, UnimgrUtils.class, UUID.class})
 111 public class UnimgrUtilsTest {
 112
 113     @Rule
 114     public final ExpectedException exception = ExpectedException.none();
 115     @Mock private DataBroker dataBroker;
 116     @Mock private Node bridgeNode;
 117     @Mock private String bridgeName;
 118     @Mock private String portName;
 119     @Mock private String type;
 120     @Mock private WriteTransaction transaction;
 121     @Mock private IpAddress mockIp;
 122     @SuppressWarnings("rawtypes")
 123     @Mock private Appender mockAppender;
 124     @SuppressWarnings({ "rawtypes" })
 125     @Mock private CheckedFuture checkedFuture;
 126     @SuppressWarnings("unchecked")
 127     private static final InstanceIdentifier<TerminationPoint> tpIid = PowerMockito.mock(InstanceIdentifier.class);
 128     private static final IpAddress IP = new IpAddress(new Ipv4Address("192.168.1.2"));
 129     private static final NodeId OVSDB_NODE_ID = new NodeId("ovsdb://7011db35-f44b-4aab-90f6-d89088caf9d8");
 130     @SuppressWarnings("unchecked")
 131     private static final InstanceIdentifier<Node> MOCK_NODE_IID = PowerMockito.mock(InstanceIdentifier.class);
 132     private ch.qos.logback.classic.Logger root;
 133
 134     @SuppressWarnings("unchecked")
 135     @Before
 136     public void setUp() throws Exception {
 137         PowerMockito.mockStatic(UnimgrUtils.class, Mockito.CALLS_REAL_METHODS);
 138         PowerMockito.mockStatic(UnimgrMapper.class, Mockito.CALLS_REAL_METHODS);
 139         PowerMockito.mockStatic(LogicalDatastoreType.class);
 140         PowerMockito.mockStatic(UUID.class);
 141         root = (ch.qos.logback.classic.Logger)
 142                 LoggerFactory.getLogger(ch.qos.logback.classic.Logger.ROOT_LOGGER_NAME);
 143         // Check logger messages
 144         when(mockAppender.getName()).thenReturn("MOCK");
 145         root.addAppender(mockAppender);
 146     }
 147
 148     /*
 149      *  This test for 2 functions with the
 150      *  same name that take different parameters.
 151      */
 152     @SuppressWarnings({"unchecked", "rawtypes"})
 153     @Test
 154     public void testCreateBridgeNode() throws Exception {
 155         // Function 1
 156         Node ovsdbNode = new NodeBuilder().setNodeId(OVSDB_NODE_ID).build();
 157         InstanceIdentifier<Node> nodeIid = InstanceIdentifier
 158                 .create(NetworkTopology.class)
 159                 .child(Topology.class,
 160                         new TopologyKey(UnimgrConstants.OVSDB_TOPOLOGY_ID))
 161                 .child(Node.class,
 162                         new NodeKey(OVSDB_NODE_ID));
 163         OvsdbNodeRef ovsdbNodeRef = new OvsdbNodeRef(nodeIid);
 164         UniAugmentation uni = new UniAugmentationBuilder()
 165                                       .setIpAddress(new IpAddress(new Ipv4Address("192.168.1.1")))
 166                                       .setOvsdbNodeRef(ovsdbNodeRef)
 167                                       .build();
 168
 169         when(dataBroker.newWriteOnlyTransaction()).thenReturn(transaction);
 170         doNothing().when(transaction).put(any(LogicalDatastoreType.class),
 171                                           any(InstanceIdentifier.class),
 172                                           any(Node.class));
 173         when(transaction.submit()).thenReturn(checkedFuture);
 174         MemberModifier.suppress(MemberMatcher.method(UnimgrMapper.class, "createOvsdbBridgeNodeIid", Node.class, String.class));
 175         when(UnimgrMapper.createOvsdbBridgeNodeIid(any(Node.class),
 176                                                    any(String.class))).thenReturn(MOCK_NODE_IID);
 177         UnimgrUtils.createBridgeNode(dataBroker, ovsdbNode, uni, "br0");
 178         verify(transaction).put(any(LogicalDatastoreType.class),
 179                                 any(InstanceIdentifier.class),
 180                                 any(Node.class));
 181         verify(transaction).submit();
 182
 183         // Function 2
 184         MemberModifier.suppress(MemberMatcher.method(UnimgrUtils.class,
 185                                                      "readNode",
 186                                                      DataBroker.class,
 187                                                      LogicalDatastoreType.class,
 188                                                      InstanceIdentifier.class));
 189         Optional<Node> mockOptional = mock(Optional.class);
 190         when(UnimgrUtils.readNode(any(DataBroker.class),
 191                                   any(LogicalDatastoreType.class),
 192                                   any(InstanceIdentifier.class))).thenReturn(mockOptional);
 193         UnimgrUtils.createBridgeNode(dataBroker, nodeIid, uni, "br0");
 194         verify(transaction).put(any(LogicalDatastoreType.class),
 195                                 any(InstanceIdentifier.class),
 196                                 any(Node.class));
 197         verify(transaction).submit();
 198
 199         // Ensure correct logging
 200         verify(mockAppender, times(2)).doAppend(argThat(new ArgumentMatcher() {
 201             @Override
 202             public boolean matches(final Object argument) {
 203               return ((LoggingEvent)argument).getFormattedMessage().contains("Creating a bridge on node");
 204             }
 205           }));
 206     }
 207
 208     @Test
 209     public void testCreateControllerEntries() {
 210         String targetString = new String("controllerEntry");
 211         List<ControllerEntry> controllerEntries = new ArrayList<ControllerEntry>();
 212         ControllerEntryBuilder controllerEntryBuilder = new ControllerEntryBuilder();
 213         controllerEntryBuilder.setTarget(new Uri(targetString));
 214         controllerEntries.add(controllerEntryBuilder.build());
 215         assertEquals(controllerEntries, UnimgrUtils.createControllerEntries(targetString));
 216     }
 217
 218     @SuppressWarnings("unchecked")
 219     @Test
 220     public void testCreateGreTunnel() throws Exception {
 221
 222         UniAugmentation sourceUniAug = new UniAugmentationBuilder()
 223                 .setIpAddress(new IpAddress(new Ipv4Address("192.168.1.1")))
 224                 .build();
 225         UniAugmentation destUniAug = new UniAugmentationBuilder()
 226                 .setIpAddress(new IpAddress(new Ipv4Address("192.168.1.2")))
 227                 .build();
 228
 229         when(dataBroker.newWriteOnlyTransaction()).thenReturn(transaction);
 230         doNothing().when(transaction).put(any(LogicalDatastoreType.class),
 231                                           any(InstanceIdentifier.class),
 232                                           any(TerminationPoint.class));
 233         when(transaction.submit()).thenReturn(checkedFuture);
 234
 235         MemberModifier.suppress(MemberMatcher.method(UnimgrMapper.class, "getTerminationPointIid", Node.class, String.class));
 236         MemberModifier.suppress(MemberMatcher.method(UnimgrUtils.class, "createMdsalProtocols"));
 237
 238         Node bNode = new NodeBuilder().setKey(new NodeKey(OVSDB_NODE_ID)).build();
 239         InstanceIdentifier<TerminationPoint> tpIid = InstanceIdentifier
 240                                                         .create(NetworkTopology.class)
 241                                                         .child(Topology.class,
 242                                                                 new TopologyKey(UnimgrConstants.OVSDB_TOPOLOGY_ID))
 243                                                         .child(Node.class, bNode.getKey())
 244                                                         .child(TerminationPoint.class,
 245                                                                 new TerminationPointKey(new TpId(portName)));
 246         when(UnimgrMapper.getTerminationPointIid(any(Node.class), any(String.class))).thenReturn(tpIid);
 247         UnimgrUtils.createGreTunnel(dataBroker,
 248                                     sourceUniAug,
 249                                     destUniAug,
 250                                     bridgeNode,
 251                                     bridgeName,
 252                                     portName);
 253         verify(transaction).put(any(LogicalDatastoreType.class),
 254                                 any(InstanceIdentifier.class),
 255                                 any(TerminationPoint.class));
 256         verify(transaction).submit();
 257     }
 258
 259     @Test
 260     public void testCreateMdsalProtocols() {
 261         List<ProtocolEntry> protocolList = new ArrayList<ProtocolEntry>();
 262         ImmutableBiMap<String, Class<? extends OvsdbBridgeProtocolBase>> mapper =
 263                 SouthboundConstants.OVSDB_PROTOCOL_MAP.inverse();
 264         ProtocolEntry protoEntry = new ProtocolEntryBuilder().setProtocol((Class<? extends OvsdbBridgeProtocolBase>) mapper.get("OpenFlow13")).build();
 265         protocolList.add(protoEntry);
 266         assertEquals(protocolList, UnimgrUtils.createMdsalProtocols());
 267     }
 268
 269     @Test
 270     public void testCreateOvsdbBridgeAugmentation() throws Exception {
 271         OvsdbNodeRef ovsdbNodeRef = new OvsdbNodeRef(PowerMockito.mock(InstanceIdentifier.class));
 272         UniAugmentation uni = new UniAugmentationBuilder().setOvsdbNodeRef(ovsdbNodeRef).build();
 273         UUID bridgeUuid = PowerMockito.mock(UUID.class);
 274         PowerMockito.when(UUID.randomUUID()).thenReturn(bridgeUuid);
 275         OvsdbBridgeAugmentation ovsdbNode = new OvsdbBridgeAugmentationBuilder()
 276                                                     .setBridgeName(new OvsdbBridgeName(UnimgrConstants.DEFAULT_BRIDGE_NAME))
 277                                                     .setManagedBy(ovsdbNodeRef)
 278                                                     .setBridgeUuid(new Uuid(bridgeUuid.toString()))
 279                                                     .build();
 280         assertEquals(ovsdbNode, UnimgrUtils.createOvsdbBridgeAugmentation(uni));
 281         // Force an exception
 282         Uni ovsdbNodeRefNull = new UniAugmentationBuilder().setOvsdbNodeRef(null).build();
 283         exception.expect(Exception.class);
 284         UnimgrUtils.createOvsdbBridgeAugmentation(ovsdbNodeRefNull);
 285     }
 286
 287     /*
 288      *  This test for 2 functions with the
 289      *  same name that take different parameters.
 290      */
 291     @SuppressWarnings({ "unchecked", "rawtypes" })
 292     @Test
 293     public void testCreateOvsdbNode() {
 294         MemberModifier.suppress(MemberMatcher.method(UnimgrMapper.class, "getOvsdbNodeIid", IpAddress.class));
 295         PowerMockito.when(UnimgrMapper.getOvsdbNodeIid(mockIp)).thenReturn(MOCK_NODE_IID);
 296         when(dataBroker.newWriteOnlyTransaction()).thenReturn(transaction);
 297         //when(dataBroker.newWriteOnlyTransaction()).thenReturn(transaction);
 298         Uni uni = new UniAugmentationBuilder().setIpAddress(new IpAddress(new Ipv4Address("192.168.1.2"))).build();
 299         // createOvsdbNode with NodeId and Uni
 300         UnimgrUtils.createOvsdbNode(dataBroker, OVSDB_NODE_ID, uni);
 301         // Ensure correct logging
 302         verify(mockAppender).doAppend(argThat(new ArgumentMatcher() {
 303             @Override
 304             public boolean matches(final Object argument) {
 305               return ((LoggingEvent)argument).getFormattedMessage().contains("Created and submitted a new OVSDB node");
 306             }
 307           }));
 308         doNothing().when(transaction).put(any(LogicalDatastoreType.class),
 309                                           any(InstanceIdentifier.class),
 310                                           any(Node.class));
 311         when(transaction.submit()).thenReturn(checkedFuture);
 312         verify(transaction).put(any(LogicalDatastoreType.class),
 313                                 any(InstanceIdentifier.class),
 314                                 any(Node.class));
 315         verify(transaction).submit();
 316         // Test with a null uni
 317         exception.expect(Exception.class);
 318         UnimgrUtils.createOvsdbNode(dataBroker, OVSDB_NODE_ID, null);
 319         // Ensure correct logging
 320         verify(mockAppender).doAppend(argThat(new ArgumentMatcher() {
 321             @Override
 322             public boolean matches(final Object argument) {
 323               return ((LoggingEvent)argument).getFormattedMessage().contains("Created and submitted a new OVSDB node");
 324             }
 325           }));
 326         // createOvsdbNode with Uni
 327         UniAugmentation uniAug = new UniAugmentationBuilder(uni).build();
 328         UnimgrUtils.createOvsdbNode(dataBroker, uniAug);
 329         MemberModifier.suppress(MemberMatcher.method(UnimgrMapper.class, "getOvsdbNodeIid", NodeId.class));
 330         PowerMockito.when(UnimgrMapper.getOvsdbNodeIid(any(NodeId.class))).thenReturn(MOCK_NODE_IID);
 331         doNothing().when(transaction).put(any(LogicalDatastoreType.class),
 332                                           any(InstanceIdentifier.class),
 333                                           any(Node.class));
 334         when(transaction.submit()).thenReturn(checkedFuture);
 335         verify(transaction).put(any(LogicalDatastoreType.class),
 336                                 any(InstanceIdentifier.class),
 337                                 any(Node.class));
 338         verify(transaction).submit();
 339         // try with a null uni
 340         PowerMockito.when(UnimgrMapper.getOvsdbNodeIid(any(NodeId.class))).thenReturn(null);
 341         UnimgrUtils.createOvsdbNode(dataBroker, null);
 342         exception.expect(Exception.class);
 343         UnimgrUtils.createOvsdbNode(dataBroker, null);
 344     }
 345
 346     @Test
 347     public void testCreateOvsdbNodeAugmentation() {
 348         Uni uni = new UniAugmentationBuilder().setIpAddress(new IpAddress(new Ipv4Address("192.168.1.2"))).build();
 349         ConnectionInfo connectionInfos = new ConnectionInfoBuilder()
 350                 .setRemoteIp(uni.getIpAddress())
 351                 .setRemotePort(new PortNumber(UnimgrConstants.OVSDB_PORT))
 352                 .build();
 353         OvsdbNodeAugmentation ovsdbNode = new OvsdbNodeAugmentationBuilder()
 354                 .setConnectionInfo(connectionInfos).build();
 355         assertEquals(ovsdbNode, UnimgrUtils.createOvsdbNodeAugmentation(uni));
 356     }
 357
 358     @Test
 359     public void testCreateOvsdbNodeId() {
 360         String nodeId = UnimgrConstants.OVSDB_PREFIX
 361                 + IP.getIpv4Address().getValue().toString()
 362                 + ":"
 363                 + UnimgrConstants.OVSDB_PORT;
 364         assertEquals(new NodeId(nodeId), UnimgrUtils.createOvsdbNodeId(IP));
 365     }
 366
 367     @Test
 368     public void testCreateOvsdbTerminationPointAugmentation() {
 369         Uni uni = new UniAugmentationBuilder().build();
 370         VlanId vlanID = new VlanId(1);
 371         OvsdbTerminationPointAugmentation terminationPoint = new OvsdbTerminationPointAugmentationBuilder()
 372                                                                      .setName(UnimgrConstants.DEFAULT_INTERNAL_IFACE)
 373                                                                      .setVlanTag(vlanID)
 374                                                                      .setVlanMode(VlanMode.Access)
 375                                                                      .build();
 376         assertEquals(terminationPoint, UnimgrUtils.createOvsdbTerminationPointAugmentation(uni));
 377     }
 378
 379     @Test
 380     public void testCreateEvc() {
 381         EvcAugmentation evc = mock(EvcAugmentation.class);
 382         assertEquals(false, UnimgrUtils.createEvc(dataBroker, evc));
 383     }
 384
 385     @SuppressWarnings({ "unchecked", "rawtypes" })
 386     @Test
 387     public void testCreateUniNode() {
 388         UniAugmentation uniAug = new UniAugmentationBuilder()
 389                                         .setIpAddress(new IpAddress(new Ipv4Address("192.168.1.2")))
 390                                         .build();
 391         when(UnimgrMapper.getUniNodeIid(any(NodeId.class))).thenReturn(mock(InstanceIdentifier.class));
 392         doNothing().when(transaction).put(any(LogicalDatastoreType.class),
 393                                           any(InstanceIdentifier.class),
 394                                           any(Node.class));
 395         when(transaction.submit()).thenReturn(checkedFuture);
 396         assertEquals(false, UnimgrUtils.createUniNode(dataBroker, uniAug));
 397         verify(mockAppender).doAppend(argThat(new ArgumentMatcher() {
 398             @Override
 399             public boolean matches(final Object argument) {
 400               return ((LoggingEvent)argument).getFormattedMessage().contains("Exception while creating Uni Node");
 401             }
 402           }));
 403         MemberModifier.suppress(MemberMatcher.method(UnimgrMapper.class, "getUniNodeIid", NodeId.class));
 404         PowerMockito.when(UnimgrMapper.getUniNodeIid(any(NodeId.class))).thenReturn(MOCK_NODE_IID);
 405
 406         when(dataBroker.newWriteOnlyTransaction()).thenReturn(transaction);
 407         UnimgrUtils.createUniNode(dataBroker, uniAug);
 408         verify(transaction).put(any(LogicalDatastoreType.class),
 409                                 any(InstanceIdentifier.class),
 410                                 any(Node.class));
 411         verify(transaction).submit();
 412         verify(mockAppender).doAppend(argThat(new ArgumentMatcher() {
 413             @Override
 414             public boolean matches(final Object argument) {
 415               return ((LoggingEvent)argument).getFormattedMessage().contains("Created and submitted a new Uni");
 416             }
 417           }));
 418     }
 419
 420     @Test
 421     public void testCreateUniNodeId() {
 422         NodeId nodeId = new NodeId(UnimgrConstants.UNI_PREFIX + IP.getIpv4Address().getValue().toString());
 423         assertEquals(nodeId, UnimgrUtils.createUniNodeId(IP));
 424     }
 425
 426     /*
 427      *  This test for 2 functions with the
 428      *  same name that take different parameters.
 429      */
 430     @SuppressWarnings("unchecked")
 431     @Test
 432     public void testCreateTerminationPointNode() {
 433         Uni uni = new UniAugmentationBuilder().build();
 434         Node bridgeNode = new NodeBuilder().build();
 435
 436         MemberModifier.suppress(MemberMatcher.method(UnimgrMapper.class,
 437                                                      "getTerminationPointIid",
 438                                                      Node.class,
 439                                                      String.class));
 440         PowerMockito.when(UnimgrMapper.getTerminationPointIid(any(Node.class),
 441                                                               any(String.class))).thenReturn(tpIid);
 442         when(dataBroker.newWriteOnlyTransaction()).thenReturn(transaction);
 443         Node bNode = new NodeBuilder().setKey(new NodeKey(OVSDB_NODE_ID)).build();
 444         InstanceIdentifier<TerminationPoint> tpIid = InstanceIdentifier
 445                                                         .create(NetworkTopology.class)
 446                                                         .child(Topology.class,
 447                                                                 new TopologyKey(UnimgrConstants.OVSDB_TOPOLOGY_ID))
 448                                                         .child(Node.class, bNode.getKey())
 449                                                         .child(TerminationPoint.class,
 450                                                                 new TerminationPointKey(new TpId(portName)));
 451         when(UnimgrMapper.getTerminationPointIid(any(Node.class), any(String.class))).thenReturn(tpIid);
 452         // Function 1
 453         UnimgrUtils.createTerminationPointNode(dataBroker, uni, bNode, bridgeName, portName, type);
 454
 455         //Function 2
 456         doNothing().when(transaction).put(any(LogicalDatastoreType.class),
 457                                           any(InstanceIdentifier.class),
 458                                           any(TerminationPoint.class));
 459         when(transaction.submit()).thenReturn(checkedFuture);
 460         UnimgrUtils.createTerminationPointNode(dataBroker, uni, bridgeNode, bridgeName, portName);
 461         verify(transaction, times(2)).put(any(LogicalDatastoreType.class),
 462                                           any(InstanceIdentifier.class),
 463                                           any(TerminationPoint.class));
 464         verify(transaction,times(2)).submit();
 465     }
 466
 467     @Test
 468     public void testDelete() {
 469         // FIXME this function will be moved into an MdsalUtils class.
 470         // see bug: https://bugs.opendaylight.org/show_bug.cgi?id=5035
 471     }
 472
 473     @SuppressWarnings("unchecked")
 474     @Test
 475     public void testDeleteTerminationPoint() {
 476         TerminationPointKey tpKey = new TerminationPointKey(new TpId("abcde"));
 477         TerminationPoint terminationPoint = new TerminationPointBuilder().setKey(tpKey).build();
 478         Node ovsdbNode = new NodeBuilder().setKey(new NodeKey(OVSDB_NODE_ID)).build();
 479         when(dataBroker.newWriteOnlyTransaction()).thenReturn(transaction);
 480         doNothing().when(transaction).delete(any(LogicalDatastoreType.class),
 481                                              any(InstanceIdentifier.class));
 482
 483         UnimgrUtils.deleteTerminationPoint(dataBroker, terminationPoint, ovsdbNode);
 484         verify(transaction,times(2)).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
 485         verify(transaction,times(2)).submit();
 486         CheckedFuture<Void, TransactionCommitFailedException> mockCheckedFuture = mock(CheckedFuture.class);
 487         when(transaction.submit()).thenReturn(mockCheckedFuture);
 488         assertEquals(mockCheckedFuture, UnimgrUtils.deleteTerminationPoint(dataBroker, terminationPoint, ovsdbNode));
 489     }
 490
 491     @SuppressWarnings({ "unchecked", "rawtypes" })
 492     @Test
 493     public void testDeleteNode() throws Exception {
 494         InstanceIdentifier<Node> genericNode = InstanceIdentifier
 495                                                    .create(NetworkTopology.class)
 496                                                    .child(Topology.class,
 497                                                            new TopologyKey(UnimgrConstants.UNI_TOPOLOGY_ID))
 498                                                    .child(Node.class);
 499         when(dataBroker.newWriteOnlyTransaction()).thenReturn(transaction);
 500         doNothing().when(transaction).delete(any(LogicalDatastoreType.class),
 501                                              any(InstanceIdentifier.class));
 502         when(transaction.submit()).thenReturn(checkedFuture);
 503         assertEquals(true, UnimgrUtils.deleteNode(dataBroker, genericNode, LogicalDatastoreType.CONFIGURATION));
 504         verify(transaction).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
 505         verify(transaction).submit();
 506         verify(mockAppender).doAppend(argThat(new ArgumentMatcher() {
 507             @Override
 508             public boolean matches(final Object argument) {
 509               return ((LoggingEvent)argument).getFormattedMessage().contains("Received a request to delete node");
 510             }
 511           }));
 512     }
 513
 514     @Test
 515     public void testExtract() {
 516         Map<InstanceIdentifier<?>, DataObject> changes = new HashMap<>();
 517         Class<DataObject> klazz = DataObject.class;
 518         assertEquals(HashMap.class, UnimgrUtils.extract(changes, klazz).getClass());
 519     }
 520
 521     @SuppressWarnings("unchecked")
 522     @Test
 523     public void testExtractOriginal() {
 524         AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes = mock(AsyncDataChangeEvent.class);
 525         Class<DataObject> klazz = DataObject.class;
 526         Map<InstanceIdentifier<?>, DataObject> map = new HashMap<>();
 527         when(changes.getOriginalData()).thenReturn(map);
 528         when(UnimgrUtils.extract(any(Map.class),eq(DataObject.class))).thenReturn(map);
 529         assertEquals(map, UnimgrUtils.extractOriginal(changes, klazz));
 530     }
 531
 532     @SuppressWarnings("unchecked")
 533     @Test
 534     public void testExtractRemoved() {
 535         AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes = mock(AsyncDataChangeEvent.class);
 536         Class<DataObject> klazz = DataObject.class;
 537         assertEquals(HashSet.class, UnimgrUtils.extractRemoved(changes, klazz).getClass());
 538     }
 539
 540     @Test
 541     public void testFindOvsdbNode() {
 542         List<Node> ovsdbNodes = new ArrayList<Node>();
 543         UniAugmentation uni = new UniAugmentationBuilder()
 544                                       .setIpAddress(IP)
 545                                       .build();
 546         ConnectionInfo connInfo = new ConnectionInfoBuilder().setRemoteIp(IP).build();
 547         OvsdbNodeAugmentation augmentation = new OvsdbNodeAugmentationBuilder()
 548                                                      .setConnectionInfo(connInfo)
 549                                                      .build();
 550         Node node = new NodeBuilder().addAugmentation(OvsdbNodeAugmentation.class, augmentation).build();
 551         ovsdbNodes.add(node);
 552         MemberModifier.suppress(MemberMatcher.method(UnimgrUtils.class,
 553                                                      "getOvsdbNodes",
 554                                                      DataBroker.class));
 555         when(UnimgrUtils.getOvsdbNodes(any(DataBroker.class))).thenReturn(ovsdbNodes);
 556         Optional<Node> optNode = Optional.of(node);
 557         assertEquals(optNode, UnimgrUtils.findOvsdbNode(dataBroker, uni));
 558     }
 559
 560     @Test
 561     public void testFindUniNode() {
 562         DataBroker dataBroker = mock(DataBroker.class);
 563         IpAddress ipAddress = mock(IpAddress.class);
 564         UniAugmentation uniAugmentation = mock(UniAugmentation.class);
 565         List<Node> uniNodes = new ArrayList<Node>();
 566         Node nd = mock(Node.class);
 567         uniNodes.add(nd);
 568         PowerMockito.suppress(MemberMatcher.method(UnimgrUtils.class, "getUniNodes", DataBroker.class));
 569         when(UnimgrUtils.getUniNodes(any(DataBroker.class))).thenReturn(uniNodes);
 570         when(nd.getAugmentation(UniAugmentation.class)).thenReturn(uniAugmentation);
 571         when(uniAugmentation.getIpAddress()).thenReturn(ipAddress);
 572         Optional<Node> optNode = UnimgrUtils.findUniNode(dataBroker, ipAddress);
 573         assertNotNull(optNode);
 574         assertTrue(optNode.isPresent());
 575         uniNodes.remove(0);
 576         optNode = UnimgrUtils.findUniNode(dataBroker, ipAddress);
 577         assertTrue(optNode.absent() == Optional.absent());
 578     }
 579
 580     @Test
 581     public void testGetConnectionInfo() {
 582         DataBroker dataBroker = mock(DataBroker.class);
 583         InstanceIdentifier<Node> nodeIid = PowerMockito.mock(InstanceIdentifier.class);
 584         NodeId ovsdbNodeId = mock(NodeId.class);
 585         Optional<Node> optNode = mock(Optional.class);
 586         Node node = mock(Node.class);
 587         OvsdbNodeAugmentation ovsdbNodeAugmentation = mock(OvsdbNodeAugmentation.class);
 588         ConnectionInfo connectionInfo = mock(ConnectionInfo.class);
 589         PowerMockito.suppress(MemberMatcher.method(UnimgrMapper.class, "getOvsdbNodeIid", NodeId.class));
 590         when(UnimgrMapper.getOvsdbNodeIid(any(NodeId.class))).thenReturn(nodeIid);
 591         PowerMockito.suppress(MemberMatcher.method(UnimgrUtils.class, "readNode", DataBroker.class, LogicalDatastoreType.class, InstanceIdentifier.class));
 592         when(UnimgrUtils.readNode(any(DataBroker.class), any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(optNode);
 593         when(optNode.isPresent()).thenReturn(true);
 594         when(optNode.get()).thenReturn(node);
 595         when(node.getAugmentation(OvsdbNodeAugmentation.class)).thenReturn(ovsdbNodeAugmentation);
 596         when(ovsdbNodeAugmentation.getConnectionInfo()).thenReturn(connectionInfo);
 597         ConnectionInfo expectedConnInfo = UnimgrUtils.getConnectionInfo(dataBroker, ovsdbNodeId);
 598         assertNotNull(expectedConnInfo);
 599         assertEquals(expectedConnInfo, connectionInfo);
 600     }
 601
 602     @Test
 603     public void testGetEvcLinks() {
 604         Link link = mock(Link.class);
 605         List<Link> lnkList = new ArrayList<Link>();
 606         lnkList.add(link);
 607         Topology topology = mock (Topology.class);
 608         DataBroker dataBroker = mock(DataBroker.class);
 609         EvcAugmentation evcAugmentation = mock(EvcAugmentation.class, Mockito.RETURNS_MOCKS);
 610         InstanceIdentifier<Topology> topologyInstanceIdentifier = mock(InstanceIdentifier.class);
 611         PowerMockito.suppress(MemberMatcher.method(UnimgrMapper.class, "getEvcTopologyIid"));
 612         when(UnimgrMapper.getEvcTopologyIid()).thenReturn(topologyInstanceIdentifier);
 613         PowerMockito.suppress(MemberMatcher.method(UnimgrUtils.class, "read", DataBroker.class, LogicalDatastoreType.class, InstanceIdentifier.class));
 614         when(UnimgrUtils.read(any(DataBroker.class), any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(topology);
 615         when(topology.getLink()).thenReturn(lnkList);
 616         when(link.getAugmentation(EvcAugmentation.class)).thenReturn(evcAugmentation);
 617         List<Link> expectedListLink = UnimgrUtils.getEvcLinks(dataBroker);
 618         assertNotNull(expectedListLink);
 619         assertEquals(expectedListLink.get(0), link);
 620     }
 621
 622     @Test
 623     public void testGetLocalIp() {
 624         String ip = "";
 625         try {
 626             ip = InetAddress.getLocalHost().getHostAddress();
 627         } catch (UnknownHostException e) {
 628             ip = "127.0.0.1";
 629         }
 630         IpAddress ipAddress = UnimgrUtils.getLocalIp();
 631         assertNotNull(ipAddress);
 632         String expectedIp = new String(ipAddress.getValue());
 633         assertTrue(expectedIp.equals(ip));
 634     }
 635
 636     @Test
 637     public void testGetOvsdbNodes() {
 638         Node node = mock(Node.class);
 639         List<Node> ndList = new ArrayList<Node>();
 640         ndList.add(node);
 641         Topology topology = mock (Topology.class);
 642         DataBroker dataBroker = mock(DataBroker.class);
 643         OvsdbNodeAugmentation ovsNdAugmentation = mock(OvsdbNodeAugmentation.class, Mockito.RETURNS_MOCKS);
 644         InstanceIdentifier<Topology> topologyInstanceIdentifier = mock(InstanceIdentifier.class);
 645         PowerMockito.suppress(MemberMatcher.method(UnimgrMapper.class, "getOvsdbTopologyIid"));
 646         when(UnimgrMapper.getOvsdbTopologyIid()).thenReturn(topologyInstanceIdentifier);
 647         PowerMockito.suppress(MemberMatcher.method(UnimgrUtils.class, "read", DataBroker.class, LogicalDatastoreType.class, InstanceIdentifier.class));
 648         when(UnimgrUtils.read(any(DataBroker.class), any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(topology);
 649         when(topology.getNode()).thenReturn(ndList);
 650         when(node.getAugmentation(OvsdbNodeAugmentation.class)).thenReturn(ovsNdAugmentation);
 651         List<Node> expectedListNnList = UnimgrUtils.getOvsdbNodes(dataBroker);
 652         assertNotNull(expectedListNnList);
 653         assertEquals(expectedListNnList.get(0), node);
 654     }
 655
 656     @Test
 657     public void testGetUniNodes() {
 658         Node node = mock(Node.class);
 659         List<Node> ndList = new ArrayList<Node>();
 660         ndList.add(node);
 661         Topology topology = mock (Topology.class);
 662         DataBroker dataBroker = mock(DataBroker.class);
 663         UniAugmentation uniAugmentation = mock(UniAugmentation.class);
 664         InstanceIdentifier<Topology> topologyInstanceIdentifier = mock(InstanceIdentifier.class);
 665         PowerMockito.suppress(MemberMatcher.method(UnimgrMapper.class, "getUniTopologyIid"));
 666         when(UnimgrMapper.getUniTopologyIid()).thenReturn(topologyInstanceIdentifier);
 667         PowerMockito.suppress(MemberMatcher.method(UnimgrUtils.class, "read", DataBroker.class, LogicalDatastoreType.class, InstanceIdentifier.class));
 668         when(UnimgrUtils.read(any(DataBroker.class), any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(topology);
 669         when(topology.getNode()).thenReturn(ndList);
 670         when(node.getAugmentation(UniAugmentation.class)).thenReturn(uniAugmentation);
 671         List<Node> expectedListNnList = UnimgrUtils.getUniNodes(dataBroker);
 672         assertNotNull(expectedListNnList);
 673         assertEquals(expectedListNnList, ndList);
 674     }
 675
 676     @Test
 677     public void testGetUniNodes2() {
 678         Node node = mock(Node.class);
 679         List<Node> ndList = new ArrayList<Node>();
 680         ndList.add(node);
 681         Topology topology = mock (Topology.class);
 682         DataBroker dataBroker = mock(DataBroker.class);
 683         UniAugmentation uniAugmentation = mock(UniAugmentation.class);
 684         InstanceIdentifier<Topology> topologyInstanceIdentifier = mock(InstanceIdentifier.class);
 685         PowerMockito.suppress(MemberMatcher.method(UnimgrMapper.class, "getUniTopologyIid"));
 686         when(UnimgrMapper.getUniTopologyIid()).thenReturn(topologyInstanceIdentifier);
 687         PowerMockito.suppress(MemberMatcher.method(UnimgrUtils.class, "read", DataBroker.class, LogicalDatastoreType.class, InstanceIdentifier.class));
 688         when(UnimgrUtils.read(any(DataBroker.class), any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(topology);
 689         when(topology.getNode()).thenReturn(ndList);
 690         when(node.getAugmentation(UniAugmentation.class)).thenReturn(uniAugmentation);
 691         List<Node> expectedListNnList = UnimgrUtils.getUniNodes(dataBroker, LogicalDatastoreType.OPERATIONAL);
 692         assertNotNull(expectedListNnList);
 693         assertEquals(expectedListNnList, ndList);
 694     }
 695
 696     @Test
 697     public void testGetUnis() {
 698         Node node = mock(Node.class);
 699         List<Node> ndList = new ArrayList<Node>();
 700         ndList.add(node);
 701         Topology topology = mock (Topology.class);
 702         DataBroker dataBroker = mock(DataBroker.class);
 703         UniAugmentation uniAugmentation = mock(UniAugmentation.class);
 704         InstanceIdentifier<Topology> topologyInstanceIdentifier = mock(InstanceIdentifier.class);
 705         PowerMockito.suppress(MemberMatcher.method(UnimgrMapper.class, "getUniTopologyIid"));
 706         when(UnimgrMapper.getUniTopologyIid()).thenReturn(topologyInstanceIdentifier);
 707         PowerMockito.suppress(MemberMatcher.method(UnimgrUtils.class, "read", DataBroker.class, LogicalDatastoreType.class, InstanceIdentifier.class));
 708         when(UnimgrUtils.read(any(DataBroker.class), any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(topology);
 709         when(topology.getNode()).thenReturn(ndList);
 710         when(node.getAugmentation(UniAugmentation.class)).thenReturn(uniAugmentation);
 711         List<UniAugmentation> expectedListUni = UnimgrUtils.getUnis(dataBroker, LogicalDatastoreType.CONFIGURATION);
 712         assertNotNull(expectedListUni);
 713         assertEquals(expectedListUni.iterator().next(), uniAugmentation);
 714     }
 715
 716     @Test
 717     public void testGetUni() {
 718         Node node = mock(Node.class);
 719         List<Node> ndList = new ArrayList<Node>();
 720         ndList.add(node);
 721         Topology topology = mock (Topology.class);
 722         DataBroker dataBroker = mock(DataBroker.class);
 723         UniAugmentation uniAugmentation = mock(UniAugmentation.class);
 724         IpAddress ipAddreDest = new IpAddress("10.10.0.2".toCharArray());
 725         InstanceIdentifier<Topology> topologyInstanceIdentifier = mock(InstanceIdentifier.class);
 726         PowerMockito.suppress(MemberMatcher.method(UnimgrMapper.class, "getUniTopologyIid"));
 727         when(UnimgrMapper.getUniTopologyIid()).thenReturn(topologyInstanceIdentifier);
 728         PowerMockito.suppress(MemberMatcher.method(UnimgrUtils.class, "read", DataBroker.class, LogicalDatastoreType.class, InstanceIdentifier.class));
 729         when(UnimgrUtils.read(any(DataBroker.class), any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(topology);
 730         when(topology.getNode()).thenReturn(ndList);
 731         when(node.getAugmentation(UniAugmentation.class)).thenReturn(uniAugmentation);
 732         when(uniAugmentation.getIpAddress()).thenReturn(ipAddreDest);
 733         PowerMockito.suppress(MemberMatcher.method(UnimgrMapper.class, "getUniTopologyIid"));
 734         when(UnimgrMapper.getUniTopologyIid()).thenReturn(topologyInstanceIdentifier);
 735         UniAugmentation expectedUniAug = UnimgrUtils.getUni(dataBroker, LogicalDatastoreType.CONFIGURATION, ipAddreDest);
 736         assertNotNull(expectedUniAug);
 737         assertEquals(expectedUniAug, uniAugmentation);
 738     }
 739
 740     @Test
 741     public void testRead() throws ReadFailedException {
 742         DataBroker dataBroker = mock(DataBroker.class);
 743         InstanceIdentifier<Node> nodeIid = PowerMockito.mock(InstanceIdentifier.class);
 744         ReadOnlyTransaction transaction = mock(ReadOnlyTransaction.class);
 745         when(dataBroker.newReadOnlyTransaction()).thenReturn(transaction);
 746         Optional<Node> optionalDataObject = mock(Optional.class);
 747         CheckedFuture<Optional<Node>, ReadFailedException> future = mock(CheckedFuture.class);
 748         Node nd = mock(Node.class);
 749         when(transaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(future);
 750         when(future.checkedGet()).thenReturn(optionalDataObject);
 751         when(optionalDataObject.isPresent()).thenReturn(true);
 752         when(optionalDataObject.get()).thenReturn(nd);
 753         Node expectedNode = UnimgrUtils.read(dataBroker, LogicalDatastoreType.CONFIGURATION, nodeIid);
 754         verify(transaction).read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
 755         verify(transaction).close();
 756         assertNotNull(expectedNode);
 757         assertEquals(expectedNode, nd);
 758     }
 759
 760     @SuppressWarnings("unchecked")
 761     @Test
 762     public void testReadLink() throws ReadFailedException {
 763         LinkId linkId = new LinkId("evc://7011db35-f44b-4aab-90f6-d89088caf9d8");
 764         InstanceIdentifier<?> nodeIid = InstanceIdentifier
 765                 .create(NetworkTopology.class)
 766                 .child(Topology.class,
 767                         new TopologyKey(UnimgrConstants.EVC_TOPOLOGY_ID))
 768                 .child(Link.class,
 769                         new LinkKey(linkId));
 770         ReadOnlyTransaction transaction = mock(ReadOnlyTransaction.class);
 771         when(dataBroker.newReadOnlyTransaction()).thenReturn(transaction);
 772         CheckedFuture<Optional<Link>, ReadFailedException> linkFuture = mock(CheckedFuture.class);
 773         Optional<Link> optLink = mock(Optional.class);
 774         when(transaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(linkFuture);
 775         when(linkFuture.checkedGet()).thenReturn(optLink);
 776         Optional<Link> expectedOpt = UnimgrUtils.readLink(dataBroker, LogicalDatastoreType.CONFIGURATION, nodeIid);
 777         verify(transaction).read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
 778         assertNotNull(expectedOpt);
 779         assertEquals(expectedOpt, optLink);
 780     }
 781
 782     @SuppressWarnings("unchecked")
 783     @Test
 784     public void testReadNode() throws ReadFailedException {
 785         InstanceIdentifier<?> nodeIid = InstanceIdentifier
 786                                             .create(NetworkTopology.class)
 787                                             .child(Topology.class,
 788                                                     new TopologyKey(UnimgrConstants.UNI_TOPOLOGY_ID))
 789                                             .child(Node.class,
 790                                                     new NodeKey(OVSDB_NODE_ID));
 791         ReadOnlyTransaction transaction = mock(ReadOnlyTransaction.class);
 792         when(dataBroker.newReadOnlyTransaction()).thenReturn(transaction);
 793         CheckedFuture<Optional<Node>, ReadFailedException> nodeFuture = mock(CheckedFuture.class);
 794         Optional<Node> optNode = mock(Optional.class);
 795         when(transaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(nodeFuture);
 796         when(nodeFuture.checkedGet()).thenReturn(optNode);
 797         Optional<Node> expectedOpt = UnimgrUtils.readNode(dataBroker, LogicalDatastoreType.CONFIGURATION, nodeIid);
 798         verify(transaction).read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
 799         assertNotNull(expectedOpt);
 800         assertEquals(expectedOpt, optNode);
 801     }
 802
 803     @SuppressWarnings("unchecked")
 804     @Test
 805     public void testUpdateUniNode() {
 806         UniAugmentation uni = PowerMockito.mock(UniAugmentation.class);
 807         InstanceIdentifier<?> uniKey = InstanceIdentifier
 808                                            .create(NetworkTopology.class)
 809                                            .child(Topology.class,
 810                                                    new TopologyKey(UnimgrConstants.UNI_TOPOLOGY_ID))//Any node id is fine for tests
 811                                            .child(Node.class,
 812                                                    new NodeKey(OVSDB_NODE_ID));
 813         InstanceIdentifier<Node> ovsdbNodeIid = mock(InstanceIdentifier.class);
 814         Optional<Node> optionalNode = mock(Optional.class);
 815         Node nd = mock(Node.class, Mockito.RETURNS_MOCKS);
 816         when(optionalNode.isPresent()).thenReturn(true);
 817         when(optionalNode.get()).thenReturn(nd);
 818         WriteTransaction transaction = mock(WriteTransaction.class);
 819         when(dataBroker.newWriteOnlyTransaction()).thenReturn(transaction);
 820         doNothing().when(transaction).put(any(LogicalDatastoreType.class),
 821                                           any(InstanceIdentifier.class),
 822                                           any(Node.class));
 823         PowerMockito.suppress(MemberMatcher.method(UnimgrUtils.class, "readNode", DataBroker.class, LogicalDatastoreType.class, InstanceIdentifier.class));
 824         when(UnimgrUtils.readNode(any(DataBroker.class), any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(optionalNode);
 825         UnimgrUtils.updateUniNode(LogicalDatastoreType.OPERATIONAL, uniKey, uni, ovsdbNodeIid, dataBroker);
 826         verify(transaction).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class));
 827         verify(transaction).submit();
 828     }
 829
 830     @SuppressWarnings("unchecked")
 831     @Test
 832     public void testUpdateUniNode2() {
 833         UniAugmentation uni = PowerMockito.mock(UniAugmentation.class);
 834         InstanceIdentifier<?> uniKey = InstanceIdentifier
 835                                            .create(NetworkTopology.class)
 836                                            .child(Topology.class,
 837                                                    new TopologyKey(UnimgrConstants.UNI_TOPOLOGY_ID))
 838                                            .child(Node.class,
 839                                                    new NodeKey(OVSDB_NODE_ID));//Any node id is fine for tests
 840         Node ovsdbNode = mock(Node.class);
 841         InstanceIdentifier<Node> ovsdbNodeIid = mock(InstanceIdentifier.class);
 842         Optional<Node> optionalNode = mock(Optional.class);
 843         Node nd = mock(Node.class);
 844         when(optionalNode.isPresent()).thenReturn(true);
 845         when(optionalNode.get()).thenReturn(nd);
 846         doNothing().when(transaction).put(any(LogicalDatastoreType.class),
 847                                           any(InstanceIdentifier.class),
 848                                           any(Node.class));
 849         when(dataBroker.newWriteOnlyTransaction()).thenReturn(transaction);
 850         PowerMockito.suppress(MemberMatcher.method(UnimgrMapper.class, "getOvsdbNodeIid", NodeId.class));
 851         when(UnimgrMapper.getOvsdbNodeIid(any(NodeId.class))).thenReturn(ovsdbNodeIid);
 852         PowerMockito.suppress(MemberMatcher.method(UnimgrUtils.class, "readNode", DataBroker.class, LogicalDatastoreType.class, InstanceIdentifier.class));
 853         when(UnimgrUtils.readNode(any(DataBroker.class), any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(optionalNode);
 854         UnimgrUtils.updateUniNode(LogicalDatastoreType.OPERATIONAL, uniKey, uni, ovsdbNode, dataBroker);
 855         verify(transaction).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class));
 856         verify(transaction).submit();
 857     }
 858
 859     @SuppressWarnings("unchecked")
 860     @Test
 861     public void testUpdateEvcNode() {
 862         LinkId id = new LinkId("abcde");
 863         InstanceIdentifier<?> evcKey = InstanceIdentifier
 864                                            .create(NetworkTopology.class)
 865                                            .child(Topology.class,
 866                                                    new TopologyKey(UnimgrConstants.EVC_TOPOLOGY_ID))
 867                                            .child(Link.class,
 868                                                    new LinkKey(id));
 869         InstanceIdentifier<?> sourceUniIid = PowerMockito.mock(InstanceIdentifier.class);
 870         InstanceIdentifier<?> destinationUniIid = PowerMockito.mock(InstanceIdentifier.class);
 871         WriteTransaction transaction = mock(WriteTransaction.class);
 872         when(dataBroker.newWriteOnlyTransaction()).thenReturn(transaction);
 873         Short order = new Short("0");
 874         IpAddress ipAddreSource = new IpAddress("10.10.1.1".toCharArray());
 875         UniSource uniSource = new UniSourceBuilder()
 876                                   .setIpAddress(ipAddreSource)
 877                                   .setKey(new UniSourceKey(order))
 878                                   .setOrder(order)
 879                                   .build();
 880         List<UniSource> uniSourceList = new ArrayList<UniSource>();
 881         uniSourceList.add(uniSource);
 882         IpAddress ipAddreDest = new IpAddress("10.10.0.2".toCharArray());
 883         UniDest uniDest = new UniDestBuilder()
 884                           .setOrder(order)
 885                           .setKey(new UniDestKey(order))
 886                           .setIpAddress(ipAddreDest)
 887                           .build();
 888         List<UniDest> uniDestList = new ArrayList<UniDest>();
 889         uniDestList.add(uniDest);
 890         EgressBw egressBw = mock(EgressBw.class);
 891         IngressBw ingressBw = mock(IngressBw.class);
 892         EvcAugmentation evcAug = new EvcAugmentationBuilder()
 893                                      .setCosId(UnimgrConstants.EVC_PREFIX + 1)
 894                                      .setEgressBw(egressBw)
 895                                      .setIngressBw(ingressBw)
 896                                      .setUniDest(uniDestList)
 897                                      .setUniSource(uniSourceList)
 898                                      .build();
 899         Optional<Link> optionalEvcLink = mock(Optional.class);
 900         Link lnk = mock (Link.class);
 901         when(optionalEvcLink.isPresent()).thenReturn(true);
 902         when(optionalEvcLink.get()).thenReturn(lnk);
 903         PowerMockito.suppress(MemberMatcher.method(UnimgrUtils.class, "readLink", DataBroker.class, LogicalDatastoreType.class, InstanceIdentifier.class));
 904         when(UnimgrUtils.readLink(any(DataBroker.class), any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(optionalEvcLink);
 905         doNothing().when(transaction).put(any(LogicalDatastoreType.class),
 906                                           any(InstanceIdentifier.class),
 907                                           any(Node.class));
 908         UnimgrUtils.updateEvcNode(LogicalDatastoreType.OPERATIONAL, evcKey, evcAug,
 909                                         sourceUniIid, destinationUniIid, dataBroker);
 910         verify(transaction).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class), any(Node.class));
 911         verify(transaction).submit();
 912     }
 913
 914 }