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