southbound/southbound-impl/src/test/java/org/opendaylight/ovsdb/southbound/transactions/md/OvsdbPortUpdateCommandTest.java

   1 /*
   2  * Copyright © 2015, 2017 Inocybe Technologies and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.ovsdb.southbound.transactions.md;
  10
  11 import static org.junit.Assert.assertEquals;
  12 import static org.mockito.ArgumentMatchers.any;
  13 import static org.mockito.ArgumentMatchers.anyString;
  14 import static org.mockito.ArgumentMatchers.eq;
  15 import static org.mockito.Mockito.doNothing;
  16 import static org.mockito.Mockito.mock;
  17 import static org.mockito.Mockito.times;
  18 import static org.mockito.Mockito.verify;
  19 import static org.mockito.Mockito.when;
  20 import static org.powermock.api.support.membermodification.MemberMatcher.field;
  21 import static org.powermock.api.support.membermodification.MemberMatcher.method;
  22 import static org.powermock.api.support.membermodification.MemberModifier.suppress;
  23
  24 import com.google.common.util.concurrent.FluentFuture;
  25 import java.util.AbstractMap.SimpleEntry;
  26 import java.util.ArrayList;
  27 import java.util.HashMap;
  28 import java.util.HashSet;
  29 import java.util.List;
  30 import java.util.Map;
  31 import java.util.Map.Entry;
  32 import java.util.Optional;
  33 import java.util.Set;
  34 import org.junit.Before;
  35 import org.junit.Ignore;
  36 import org.junit.Test;
  37 import org.junit.runner.RunWith;
  38 import org.mockito.Matchers;
  39 import org.mockito.Mockito;
  40 import org.mockito.invocation.InvocationOnMock;
  41 import org.mockito.stubbing.Answer;
  42 import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
  43 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  44 import org.opendaylight.ovsdb.lib.message.TableUpdates;
  45 import org.opendaylight.ovsdb.lib.notation.Column;
  46 import org.opendaylight.ovsdb.lib.notation.UUID;
  47 import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
  48 import org.opendaylight.ovsdb.lib.schema.GenericTableSchema;
  49 import org.opendaylight.ovsdb.lib.schema.typed.TyperUtils;
  50 import org.opendaylight.ovsdb.schema.openvswitch.Bridge;
  51 import org.opendaylight.ovsdb.schema.openvswitch.Interface;
  52 import org.opendaylight.ovsdb.schema.openvswitch.Port;
  53 import org.opendaylight.ovsdb.southbound.InstanceIdentifierCodec;
  54 import org.opendaylight.ovsdb.southbound.OvsdbConnectionInstance;
  55 import org.opendaylight.ovsdb.southbound.SouthboundConstants;
  56 import org.opendaylight.ovsdb.southbound.SouthboundMapper;
  57 import org.opendaylight.ovsdb.southbound.SouthboundUtil;
  58 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeBase;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeInternal;
  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.OvsdbBridgeRef;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbPortInterfaceAttributes;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbPortInterfaceAttributes.VlanMode;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentationBuilder;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntry;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIds;
  71 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIdsBuilder;
  72 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceOtherConfigs;
  73 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceOtherConfigsBuilder;
  74 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortExternalIds;
  75 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortExternalIdsBuilder;
  76 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortOtherConfigs;
  77 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortOtherConfigsBuilder;
  78 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.TrunksBuilder;
  79 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
  80 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
  81 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TpId;
  82 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
  83 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
  84 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  85 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
  86 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
  87 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointBuilder;
  88 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
  89 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  90 import org.powermock.api.mockito.PowerMockito;
  91 import org.powermock.api.support.membermodification.MemberMatcher;
  92 import org.powermock.api.support.membermodification.MemberModifier;
  93 import org.powermock.core.classloader.annotations.PrepareForTest;
  94 import org.powermock.modules.junit4.PowerMockRunner;
  95 import org.powermock.reflect.Whitebox;
  96
  97 @RunWith(PowerMockRunner.class)
  98 @PrepareForTest({TyperUtils.class, OvsdbPortUpdateCommand.class, SouthboundUtil.class, SouthboundMapper.class})
  99 public class OvsdbPortUpdateCommandTest {
 100
 101     private static final String OTHER_CONFIG_KEY = "key";
 102     private static final String OTHER_CONFIG_VALUE = "value";
 103     private static final String EXTERNAL_ID_KEY = "key";
 104     private static final String EXTERNAL_ID_VALUE = "value";
 105     private static final String INTERFACE_NAME = "interface_name";
 106     private static final String VLAN_MODE_ACCESS = "access";
 107     private static final String OVSDB_INTERFACE_TYPE = "internal";
 108     private static final String PORT_NAME = "port_name";
 109     private static final String TP_NAME = "tp_name";
 110     private static final String TERMINATION_POINT_NAME = "termination_point_name";
 111
 112     private Map<UUID, Port> portUpdatedRows;
 113     private Map<UUID, Port> portOldRows;
 114     private Map<UUID, Interface> ifUpdatedRows;
 115     private Map<UUID, Interface> interfaceOldRows;
 116     private Map<UUID, Bridge> bridgeUpdatedRows;
 117     private OvsdbPortUpdateCommand ovsdbPortUpdateCommand;
 118
 119     @Before
 120     public void setUp() throws Exception {
 121         ovsdbPortUpdateCommand = PowerMockito.mock(OvsdbPortUpdateCommand.class, Mockito.CALLS_REAL_METHODS);
 122     }
 123
 124     @Test
 125     public void testOvsdbPortUpdateCommand() throws Exception {
 126         TableUpdates updates = mock(TableUpdates.class);
 127         DatabaseSchema dbSchema = mock(DatabaseSchema.class);
 128
 129         PowerMockito.mockStatic(TyperUtils.class);
 130         PowerMockito.when(TyperUtils.extractRowsUpdated(Port.class, updates, dbSchema)).thenReturn(portUpdatedRows);
 131         PowerMockito.when(TyperUtils.extractRowsOld(Port.class, updates, dbSchema)).thenReturn(portOldRows);
 132         PowerMockito.when(TyperUtils.extractRowsUpdated(Interface.class, updates, dbSchema)).thenReturn(ifUpdatedRows);
 133         PowerMockito.when(TyperUtils.extractRowsOld(Interface.class, updates, dbSchema)).thenReturn(interfaceOldRows);
 134         PowerMockito.when(TyperUtils.extractRowsUpdated(Bridge.class, updates, dbSchema)).thenReturn(bridgeUpdatedRows);
 135
 136         OvsdbConnectionInstance key = mock(OvsdbConnectionInstance.class);
 137         OvsdbPortUpdateCommand ovsdbPortUpdateCommand1 =
 138                 new OvsdbPortUpdateCommand(mock(InstanceIdentifierCodec.class), key, updates, dbSchema);
 139         assertEquals(portUpdatedRows, Whitebox.getInternalState(ovsdbPortUpdateCommand1, "portUpdatedRows"));
 140         assertEquals(portOldRows, Whitebox.getInternalState(ovsdbPortUpdateCommand1, "portOldRows"));
 141         assertEquals(dbSchema, Whitebox.getInternalState(ovsdbPortUpdateCommand1, "dbSchema"));
 142     }
 143
 144     @SuppressWarnings("unchecked")
 145     @Test
 146     public void testExecute() throws Exception {
 147         portUpdatedRows = new HashMap<>();
 148         interfaceOldRows = new HashMap<>();
 149         portUpdatedRows.put(mock(UUID.class), mock(Port.class));
 150         interfaceOldRows.put(mock(UUID.class), mock(Interface.class));
 151         field(OvsdbPortUpdateCommand.class, "portUpdatedRows").set(ovsdbPortUpdateCommand, portUpdatedRows);
 152         field(OvsdbPortUpdateCommand.class, "interfaceOldRows").set(ovsdbPortUpdateCommand, interfaceOldRows);
 153
 154         OvsdbConnectionInstance ovsdbConnectionInstance = mock(OvsdbConnectionInstance.class);
 155         when(ovsdbPortUpdateCommand.getOvsdbConnectionInstance()).thenReturn(ovsdbConnectionInstance);
 156         InstanceIdentifier<Node> connectionIId = mock(InstanceIdentifier.class);
 157         when(ovsdbConnectionInstance.getInstanceIdentifier()).thenReturn(connectionIId);
 158
 159         //case 1: portUpdatedRows & interfaceOldRows not null, not empty
 160         Optional<Node> node = Optional.of(mock(Node.class));
 161         PowerMockito.doReturn(node).when(ovsdbPortUpdateCommand, "readNode", any(ReadWriteTransaction.class),
 162                 any(InstanceIdentifier.class));
 163         doNothing().when(ovsdbPortUpdateCommand).updateTerminationPoints(any(ReadWriteTransaction.class),
 164             any(Node.class));
 165         ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
 166         PowerMockito.mockStatic(SouthboundUtil.class);
 167         PowerMockito.when(SouthboundUtil.readNode(any(ReadWriteTransaction.class), any(InstanceIdentifier.class)))
 168             .thenReturn(node);
 169         ovsdbPortUpdateCommand.execute(transaction);
 170         verify(ovsdbConnectionInstance).getInstanceIdentifier();
 171         verify(ovsdbPortUpdateCommand).updateTerminationPoints(any(ReadWriteTransaction.class), any(Node.class));
 172     }
 173
 174     @Test
 175     @SuppressWarnings("unchecked")
 176     public void testUpdateTerminationPoints() throws Exception {
 177         portUpdatedRows = new HashMap<>();
 178         Port port = mock(Port.class);
 179         UUID uuid = mock(UUID.class);
 180         portUpdatedRows.put(uuid, port);
 181         field(OvsdbPortUpdateCommand.class, "portUpdatedRows").set(ovsdbPortUpdateCommand, portUpdatedRows);
 182         Column<GenericTableSchema, String> bridgeColumn = mock(Column.class);
 183         when(port.getNameColumn()).thenReturn(bridgeColumn);
 184         when(bridgeColumn.getData()).thenReturn(TERMINATION_POINT_NAME);
 185
 186         InstanceIdentifier<Node> nodeIid = InstanceIdentifier.create(NetworkTopology.class)
 187                 .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
 188                 .child(Node.class, new NodeKey(new NodeId("nodeId")));
 189
 190         Optional<InstanceIdentifier<Node>> bridgeIid = Optional.of(nodeIid);
 191         PowerMockito.doReturn(bridgeIid).when(ovsdbPortUpdateCommand, "getTerminationPointBridge", any(UUID.class));
 192
 193         NodeId bridgeId = mock(NodeId.class);
 194         PowerMockito.mockStatic(SouthboundMapper.class);
 195         PowerMockito.when(SouthboundMapper.createManagedNodeId(any(InstanceIdentifier.class))).thenReturn(bridgeId);
 196
 197         PowerMockito.whenNew(TpId.class).withAnyArguments().thenReturn(mock(TpId.class));
 198         TerminationPointKey tpKey = mock(TerminationPointKey.class);
 199         PowerMockito.whenNew(TerminationPointKey.class).withAnyArguments().thenReturn(tpKey);
 200         TerminationPointBuilder tpBuilder = mock(TerminationPointBuilder.class);
 201         PowerMockito.whenNew(TerminationPointBuilder.class).withNoArguments().thenReturn(tpBuilder);
 202         when(tpBuilder.withKey(any(TerminationPointKey.class))).thenReturn(tpBuilder);
 203         when(tpKey.getTpId()).thenReturn(mock(TpId.class));
 204         when(tpBuilder.setTpId(any(TpId.class))).thenReturn(tpBuilder);
 205         InstanceIdentifier<TerminationPoint> tpPath = mock(InstanceIdentifier.class);
 206         PowerMockito.doReturn(tpPath).when(ovsdbPortUpdateCommand, "getInstanceIdentifier",
 207                 any(InstanceIdentifier.class), any(Port.class));
 208
 209         OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder = mock(
 210                 OvsdbTerminationPointAugmentationBuilder.class);
 211         PowerMockito.whenNew(OvsdbTerminationPointAugmentationBuilder.class).withNoArguments()
 212                 .thenReturn(tpAugmentationBuilder);
 213         PowerMockito.suppress(MemberMatcher.method(OvsdbPortUpdateCommand.class, "buildTerminationPoint",
 214                 ReadWriteTransaction.class, InstanceIdentifier.class, OvsdbTerminationPointAugmentationBuilder.class,
 215                 Node.class, Entry.class));
 216
 217         Column<GenericTableSchema, Set<UUID>> interfacesColumn = mock(Column.class);
 218         when(port.getInterfacesColumn()).thenReturn(interfacesColumn);
 219         Set<UUID> uuids = new HashSet<>();
 220         UUID uuid2 = mock(UUID.class);
 221         uuids.add(uuid2);
 222         when(interfacesColumn.getData()).thenReturn(uuids);
 223
 224         ifUpdatedRows = new HashMap<>();
 225         interfaceOldRows = new HashMap<>();
 226         Interface iface = mock(Interface.class);
 227         ifUpdatedRows.put(uuid2, iface);
 228         Interface interfaceUpdate = mock(Interface.class);
 229         ifUpdatedRows.put(uuid, interfaceUpdate);
 230         interfaceOldRows.put(uuid2, iface);
 231         field(OvsdbPortUpdateCommand.class, "interfaceUpdatedRows").set(ovsdbPortUpdateCommand, ifUpdatedRows);
 232         field(OvsdbPortUpdateCommand.class, "interfaceOldRows").set(ovsdbPortUpdateCommand, interfaceOldRows);
 233         PowerMockito.suppress(MemberMatcher.method(OvsdbPortUpdateCommand.class, "buildTerminationPoint",
 234                 OvsdbTerminationPointAugmentationBuilder.class, Interface.class));
 235
 236         when(tpAugmentationBuilder.build()).thenReturn(mock(OvsdbTerminationPointAugmentation.class));
 237         when(tpBuilder.addAugmentation(eq(OvsdbTerminationPointAugmentation.class),
 238                 any(OvsdbTerminationPointAugmentation.class))).thenReturn(tpBuilder);
 239         when(tpBuilder.build()).thenReturn(mock(TerminationPoint.class));
 240         portOldRows = new HashMap<>();
 241         portOldRows.put(uuid, port);
 242         MemberModifier.field(OvsdbPortUpdateCommand.class, "portOldRows").set(ovsdbPortUpdateCommand, portOldRows);
 243         ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
 244         doNothing().when(transaction).merge(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
 245                 any(TerminationPoint.class));
 246         doNothing().when(transaction).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
 247                 any(TerminationPoint.class));
 248
 249         Column<GenericTableSchema, String> interfaceColumn = mock(Column.class);
 250         when(interfaceUpdate.getNameColumn()).thenReturn(interfaceColumn);
 251         when(interfaceColumn.getData()).thenReturn(INTERFACE_NAME);
 252         when(ovsdbPortUpdateCommand.getOvsdbConnectionInstance()).thenReturn(mock(OvsdbConnectionInstance.class));
 253
 254         PowerMockito.doReturn(bridgeIid).when(ovsdbPortUpdateCommand, "getTerminationPointBridge",
 255                 any(ReadWriteTransaction.class), any(Node.class), anyString());
 256         PowerMockito.when(SouthboundMapper.createManagedNodeId(any(InstanceIdentifier.class))).thenReturn(bridgeId);
 257         PowerMockito.whenNew(TopologyKey.class).withAnyArguments().thenReturn(mock(TopologyKey.class));
 258         PowerMockito.whenNew(NodeKey.class).withAnyArguments().thenReturn(mock(NodeKey.class));
 259
 260         Node node = mock(Node.class);
 261         Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updateTerminationPoints", transaction, node);
 262         verify(ovsdbPortUpdateCommand).getInstanceIdentifier(any(InstanceIdentifier.class),
 263             any(Port.class));
 264         verify(transaction, times(2)).merge(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
 265                 any(TerminationPoint.class));
 266     }
 267
 268     @Test
 269     @SuppressWarnings("unchecked")
 270     public void testBuildTerminationPoint() throws Exception {
 271         Port portUpdate = mock(Port.class);
 272         Entry<UUID,Port> portEntry = mock(Entry.class);
 273         when(portEntry.getValue()).thenReturn(mock(Port.class));
 274         when(portEntry.getValue().getName()).thenReturn(PORT_NAME);
 275         when(portEntry.getValue().getUuid()).thenReturn(mock(UUID.class));
 276         when(portUpdate.getName()).thenReturn(PORT_NAME);
 277         when(portUpdate.getUuid()).thenReturn(mock(UUID.class));
 278         PowerMockito.whenNew(Uuid.class).withAnyArguments().thenReturn(mock(Uuid.class));
 279
 280         OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder = mock(
 281                 OvsdbTerminationPointAugmentationBuilder.class);
 282
 283         when(tpAugmentationBuilder.setName(anyString())).thenReturn(tpAugmentationBuilder);
 284         when(tpAugmentationBuilder.setPortUuid(any(Uuid.class))).thenReturn(tpAugmentationBuilder);
 285         doNothing().when(ovsdbPortUpdateCommand).updatePort(any(ReadWriteTransaction.class),
 286             any(Node.class), any(InstanceIdentifier.class), any(Entry.class),
 287             any(OvsdbTerminationPointAugmentationBuilder.class));
 288
 289         Node node = mock(Node.class);
 290         ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
 291         InstanceIdentifier<TerminationPoint> tpPath = mock(InstanceIdentifier.class);
 292
 293         Whitebox.invokeMethod(ovsdbPortUpdateCommand, "buildTerminationPoint", transaction, tpPath,
 294                 tpAugmentationBuilder, node, portEntry);
 295         verify(tpAugmentationBuilder).setName(anyString());
 296         verify(tpAugmentationBuilder).setPortUuid(any(Uuid.class));
 297         verify(ovsdbPortUpdateCommand).updatePort(any(ReadWriteTransaction.class),
 298                 any(Node.class), any(InstanceIdentifier.class), any(Entry.class),
 299                 any(OvsdbTerminationPointAugmentationBuilder.class));
 300     }
 301
 302     @Test
 303     public void testBuildTerminationPoint1() throws Exception {
 304         Interface interfaceUpdate = mock(Interface.class);
 305         when(interfaceUpdate.getName()).thenReturn(INTERFACE_NAME);
 306         when(interfaceUpdate.getUuid()).thenReturn(mock(UUID.class));
 307         PowerMockito.whenNew(Uuid.class).withAnyArguments().thenReturn(mock(Uuid.class));
 308         OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder = mock(
 309                 OvsdbTerminationPointAugmentationBuilder.class);
 310         when(tpAugmentationBuilder.setName(anyString())).thenReturn(tpAugmentationBuilder);
 311         when(tpAugmentationBuilder.setInterfaceUuid(any(Uuid.class))).thenReturn(tpAugmentationBuilder);
 312
 313         doNothing().when(ovsdbPortUpdateCommand).updateInterfaces(any(Interface.class),
 314             any(OvsdbTerminationPointAugmentationBuilder.class));
 315
 316         Whitebox.invokeMethod(ovsdbPortUpdateCommand, "buildTerminationPoint", tpAugmentationBuilder, interfaceUpdate);
 317         verify(tpAugmentationBuilder).setName(anyString());
 318         verify(tpAugmentationBuilder).setInterfaceUuid(any(Uuid.class));
 319         verify(ovsdbPortUpdateCommand).updateInterfaces(any(Interface.class),
 320                 any(OvsdbTerminationPointAugmentationBuilder.class));
 321     }
 322
 323     @SuppressWarnings("unchecked")
 324     @Test
 325     public void testReadNode() throws Exception {
 326         ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
 327         InstanceIdentifier<Node> nodePath = mock(InstanceIdentifier.class);
 328         Optional<Node> node = Optional.of(mock(Node.class));
 329         FluentFuture<Optional<Node>> fluentFuture = mock(FluentFuture.class);
 330         when(transaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class)))
 331                 .thenReturn(fluentFuture);
 332         when(fluentFuture.get()).thenReturn(node);
 333         assertEquals(node, Whitebox.invokeMethod(ovsdbPortUpdateCommand, "readNode", transaction, nodePath));
 334     }
 335
 336     @SuppressWarnings("unchecked")
 337     @Test
 338     public void testGetTerminationPointBridge1() throws Exception {
 339         Node node = mock(Node.class);
 340         OvsdbNodeAugmentation ovsdbNode = mock(OvsdbNodeAugmentation.class);
 341         when(node.augmentation(OvsdbNodeAugmentation.class)).thenReturn(ovsdbNode);
 342         List<ManagedNodeEntry> managedNodes = new ArrayList<>();
 343         ManagedNodeEntry managedNodeEntry = mock(ManagedNodeEntry.class);
 344         managedNodes.add(managedNodeEntry);
 345         when(ovsdbNode.getManagedNodeEntry()).thenReturn(managedNodes);
 346
 347         Node managedNode = mock(Node.class);
 348         OvsdbBridgeRef ovsdbBridgeRef = mock(OvsdbBridgeRef.class);
 349         when(managedNodeEntry.getBridgeRef()).thenReturn(ovsdbBridgeRef);
 350         InstanceIdentifier<Node> iidNode = mock(InstanceIdentifier.class);
 351         when((InstanceIdentifier<Node>) ovsdbBridgeRef.getValue()).thenReturn(iidNode);
 352         Optional<Node> optionalNode = Optional.of(managedNode);
 353         PowerMockito.doReturn(optionalNode).when(ovsdbPortUpdateCommand, "readNode", any(ReadWriteTransaction.class),
 354                 any(InstanceIdentifier.class));
 355
 356         PowerMockito.mockStatic(SouthboundUtil.class);
 357         PowerMockito.when(SouthboundUtil.readNode(Matchers.any(ReadWriteTransaction.class),
 358                 Matchers.any(InstanceIdentifier.class)))
 359                 .thenReturn(optionalNode);
 360         TerminationPointBuilder tpBuilder = mock(TerminationPointBuilder.class);
 361         PowerMockito.whenNew(TerminationPointBuilder.class).withNoArguments().thenReturn(tpBuilder);
 362         PowerMockito.whenNew(TpId.class).withAnyArguments().thenReturn(mock(TpId.class));
 363         PowerMockito.whenNew(TerminationPointKey.class).withAnyArguments().thenReturn(mock(TerminationPointKey.class));
 364         when(tpBuilder.withKey(any(TerminationPointKey.class))).thenReturn(tpBuilder);
 365
 366         List<TerminationPoint> terminationPointList = new ArrayList<>();
 367         TerminationPoint terminationPoint = mock(TerminationPoint.class);
 368         terminationPointList.add(terminationPoint);
 369         when(tpBuilder.build()).thenReturn(terminationPoint);
 370         when(managedNode.getTerminationPoint()).thenReturn(terminationPointList);
 371
 372         when(managedNode.augmentation(OvsdbBridgeAugmentation.class))
 373                 .thenReturn(mock(OvsdbBridgeAugmentation.class));
 374         TpId tpId = new TpId(TP_NAME);
 375         when(terminationPoint.getTpId()).thenReturn(tpId);
 376
 377         Optional<InstanceIdentifier<Node>> testResult = Optional.of(iidNode);
 378         ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
 379         Optional<InstanceIdentifier<Node>> result = Whitebox.invokeMethod(ovsdbPortUpdateCommand,
 380                 "getTerminationPointBridge", transaction, node, TP_NAME);
 381
 382         assertEquals(testResult, result);
 383     }
 384
 385     @SuppressWarnings("unchecked")
 386     @Test
 387     public void testUpdateInterfaces() throws Exception {
 388         Interface interfaceUpdate = mock(Interface.class);
 389         Column<GenericTableSchema, String> typeColumn = mock(Column.class);
 390         when(interfaceUpdate.getTypeColumn()).thenReturn(typeColumn);
 391         when(typeColumn.getData()).thenReturn(OVSDB_INTERFACE_TYPE);
 392         doNothing().when(ovsdbPortUpdateCommand).updateInterface(any(Interface.class), anyString(),
 393             any(OvsdbTerminationPointAugmentationBuilder.class));
 394
 395         OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder = mock(
 396                 OvsdbTerminationPointAugmentationBuilder.class);
 397         Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updateInterfaces", interfaceUpdate,
 398                 ovsdbTerminationPointBuilder);
 399         verify(ovsdbPortUpdateCommand).updateInterface(any(Interface.class), anyString(),
 400                 any(OvsdbTerminationPointAugmentationBuilder.class));
 401     }
 402
 403     @Test
 404     @SuppressWarnings("unchecked")
 405     public void testUpdateInterface() throws Exception {
 406         Interface interf = mock(Interface.class);
 407         OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder = mock(
 408                 OvsdbTerminationPointAugmentationBuilder.class);
 409         when(interf.getUuid()).thenReturn(mock(UUID.class));
 410         PowerMockito.whenNew(Uuid.class).withAnyArguments().thenReturn(mock(Uuid.class));
 411         when(ovsdbTerminationPointBuilder.setInterfaceUuid(any(Uuid.class))).thenReturn(ovsdbTerminationPointBuilder);
 412         PowerMockito.mockStatic(SouthboundMapper.class);
 413         PowerMockito.when(SouthboundMapper.createInterfaceType(Matchers.anyString()))
 414                 .thenAnswer(new Answer<Class<? extends InterfaceTypeBase>>() {
 415                     public Class<? extends InterfaceTypeBase> answer(InvocationOnMock invocation) throws Exception {
 416                         return InterfaceTypeInternal.class;
 417                     }
 418                 });
 419         when(ovsdbTerminationPointBuilder.setInterfaceType(any(Class.class))).thenReturn(ovsdbTerminationPointBuilder);
 420         suppress(method(OvsdbPortUpdateCommand.class, "updateOfPort", Interface.class,
 421                 OvsdbTerminationPointAugmentationBuilder.class));
 422         suppress(method(OvsdbPortUpdateCommand.class, "updateOfPortRequest", Interface.class,
 423                 OvsdbTerminationPointAugmentationBuilder.class));
 424         suppress(method(OvsdbPortUpdateCommand.class, "updateInterfaceExternalIds", Interface.class,
 425                 OvsdbTerminationPointAugmentationBuilder.class));
 426         suppress(method(OvsdbPortUpdateCommand.class, "updateOptions", Interface.class,
 427                 OvsdbTerminationPointAugmentationBuilder.class));
 428         suppress(method(OvsdbPortUpdateCommand.class, "updateInterfaceOtherConfig", Interface.class,
 429                 OvsdbTerminationPointAugmentationBuilder.class));
 430         suppress(method(OvsdbPortUpdateCommand.class, "updateInterfaceLldp", Interface.class,
 431                 OvsdbTerminationPointAugmentationBuilder.class));
 432         suppress(method(OvsdbPortUpdateCommand.class, "updateInterfaceBfd", Interface.class,
 433                 OvsdbTerminationPointAugmentationBuilder.class));
 434         suppress(method(OvsdbPortUpdateCommand.class, "updateInterfaceBfdStatus", Interface.class,
 435                 OvsdbTerminationPointAugmentationBuilder.class));
 436         suppress(method(OvsdbPortUpdateCommand.class, "updateIfIndex", Interface.class,
 437                 OvsdbTerminationPointAugmentationBuilder.class));
 438
 439         Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updateInterface", interf, OVSDB_INTERFACE_TYPE,
 440                 ovsdbTerminationPointBuilder);
 441         verify(ovsdbTerminationPointBuilder).setInterfaceUuid(any(Uuid.class));
 442         verify(ovsdbTerminationPointBuilder).setInterfaceType(any(Class.class));
 443         verify(ovsdbPortUpdateCommand).updateOfPort(any(Interface.class),
 444                 any(OvsdbTerminationPointAugmentationBuilder.class));
 445         verify(ovsdbPortUpdateCommand).updateOfPortRequest(any(Interface.class),
 446                 any(OvsdbTerminationPointAugmentationBuilder.class));
 447         verify(ovsdbPortUpdateCommand).updateInterfaceExternalIds(any(Interface.class),
 448                 any(OvsdbTerminationPointAugmentationBuilder.class));
 449         verify(ovsdbPortUpdateCommand).updateOptions(any(Interface.class),
 450                 any(OvsdbTerminationPointAugmentationBuilder.class));
 451         verify(ovsdbPortUpdateCommand).updateInterfaceOtherConfig(any(Interface.class),
 452                 any(OvsdbTerminationPointAugmentationBuilder.class));
 453     }
 454
 455     @Test
 456     @SuppressWarnings("unchecked")
 457     public void testUpdatePort() throws Exception {
 458         suppress(method(OvsdbPortUpdateCommand.class, "updateVlan", Port.class,
 459             OvsdbTerminationPointAugmentationBuilder.class));
 460         suppress(method(OvsdbPortUpdateCommand.class, "updateVlanTrunks", Port.class,
 461             OvsdbTerminationPointAugmentationBuilder.class));
 462         suppress(method(OvsdbPortUpdateCommand.class, "updateVlanMode", Port.class,
 463             OvsdbTerminationPointAugmentationBuilder.class));
 464         suppress(method(OvsdbPortUpdateCommand.class, "updatePortExternalIds", Port.class,
 465             OvsdbTerminationPointAugmentationBuilder.class));
 466         suppress(method(OvsdbPortUpdateCommand.class, "updatePortOtherConfig", Port.class,
 467             OvsdbTerminationPointAugmentationBuilder.class));
 468         suppress(method(OvsdbPortUpdateCommand.class, "updatePortOtherConfig", Port.class,
 469             OvsdbTerminationPointAugmentationBuilder.class));
 470         suppress(method(OvsdbPortUpdateCommand.class, "updateQos", ReadWriteTransaction.class, Node.class,
 471                 InstanceIdentifier.class, Entry.class, OvsdbTerminationPointAugmentationBuilder.class));
 472
 473         Node node = mock(Node.class);
 474         Entry<UUID, Port> port = new SimpleEntry<>(mock(UUID.class), mock(Port.class));
 475         OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder = mock(
 476                 OvsdbTerminationPointAugmentationBuilder.class);
 477         ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
 478         InstanceIdentifier<TerminationPoint> tpPath = mock(InstanceIdentifier.class);
 479         Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updatePort", transaction, node, tpPath, port,
 480                 ovsdbTerminationPointBuilder);
 481
 482         verify(ovsdbPortUpdateCommand).updateVlan(any(Port.class),
 483                 any(OvsdbTerminationPointAugmentationBuilder.class));
 484         verify(ovsdbPortUpdateCommand).updateVlanTrunks(any(Port.class),
 485                 any(OvsdbTerminationPointAugmentationBuilder.class));
 486         verify(ovsdbPortUpdateCommand).updateVlanMode(any(Port.class),
 487                 any(OvsdbTerminationPointAugmentationBuilder.class));
 488         verify(ovsdbPortUpdateCommand).updatePortExternalIds(any(Port.class),
 489                 any(OvsdbTerminationPointAugmentationBuilder.class));
 490         verify(ovsdbPortUpdateCommand).updatePortOtherConfig(any(Port.class),
 491                 any(OvsdbTerminationPointAugmentationBuilder.class));
 492     }
 493
 494     @SuppressWarnings("unchecked")
 495     @Test
 496     public void testUpdateVlan() throws Exception {
 497         Port port = mock(Port.class);
 498         Column<GenericTableSchema, Set<Long>> column = mock(Column.class);
 499         when(port.getTagColumn()).thenReturn(column);
 500         Set<Long> vlanId = new HashSet<>();
 501         vlanId.add((long) 808);
 502         when(column.getData()).thenReturn(vlanId);
 503         PowerMockito.whenNew(VlanId.class).withAnyArguments().thenReturn(mock(VlanId.class));
 504         OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder = mock(
 505                 OvsdbTerminationPointAugmentationBuilder.class);
 506         when(ovsdbTerminationPointBuilder.setVlanTag(any(VlanId.class))).thenReturn(ovsdbTerminationPointBuilder);
 507         Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updateVlan", port, ovsdbTerminationPointBuilder);
 508         verify(ovsdbTerminationPointBuilder).setVlanTag(any(VlanId.class));
 509     }
 510
 511     @SuppressWarnings("unchecked")
 512     @Test
 513     public void testUpdateVlanTrunks() throws Exception {
 514         Port port = mock(Port.class);
 515         Column<GenericTableSchema, Set<Long>> column = mock(Column.class);
 516         when(port.getTrunksColumn()).thenReturn(column);
 517         Set<Long> portTrunks = new HashSet<>();
 518         portTrunks.add((long) 300);
 519         when(column.getData()).thenReturn(portTrunks);
 520
 521         TrunksBuilder trunksBuilder = mock(TrunksBuilder.class);
 522         PowerMockito.whenNew(TrunksBuilder.class).withNoArguments().thenReturn(trunksBuilder);
 523         PowerMockito.whenNew(VlanId.class).withAnyArguments().thenReturn(mock(VlanId.class));
 524         when(trunksBuilder.setTrunk(any(VlanId.class))).thenReturn(trunksBuilder);
 525         OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder = mock(
 526                 OvsdbTerminationPointAugmentationBuilder.class);
 527         when(ovsdbTerminationPointBuilder.setTrunks(any(List.class))).thenReturn(ovsdbTerminationPointBuilder);
 528         Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updateVlanTrunks", port, ovsdbTerminationPointBuilder);
 529         verify(trunksBuilder).setTrunk(any(VlanId.class));
 530         verify(ovsdbTerminationPointBuilder).setTrunks(any(List.class));
 531     }
 532
 533     @SuppressWarnings("unchecked")
 534     @Test
 535     public void testUpdateVlanMode() throws Exception {
 536         Port port = mock(Port.class);
 537         Column<GenericTableSchema, Set<String>> column = mock(Column.class);
 538         when(port.getVlanModeColumn()).thenReturn(column);
 539         Set<String> set = new HashSet<>();
 540         set.add(VLAN_MODE_ACCESS);
 541         when(column.getData()).thenReturn(set);
 542         OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder = mock(
 543                 OvsdbTerminationPointAugmentationBuilder.class);
 544         when(ovsdbTerminationPointBuilder.setVlanMode(OvsdbPortInterfaceAttributes.VlanMode.Access))
 545                 .thenReturn(ovsdbTerminationPointBuilder);
 546         Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updateVlanMode", port, ovsdbTerminationPointBuilder);
 547         verify(ovsdbTerminationPointBuilder).setVlanMode(any(VlanMode.class));
 548     }
 549
 550     @SuppressWarnings("unchecked")
 551     @Test
 552     public void testUpdateOfPort() throws Exception {
 553         Interface interf = mock(Interface.class);
 554         Set<Long> ofPorts = new HashSet<>();
 555         ofPorts.add((long) 10000);
 556         Column<GenericTableSchema, Set<Long>> column = mock(Column.class);
 557         when(interf.getOpenFlowPortColumn()).thenReturn(column);
 558         when(column.getData()).thenReturn(ofPorts);
 559         OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder = mock(
 560                 OvsdbTerminationPointAugmentationBuilder.class);
 561         when(ovsdbTerminationPointBuilder.setOfport(any(Long.class))).thenReturn(ovsdbTerminationPointBuilder);
 562         when(interf.getName()).thenReturn(INTERFACE_NAME);
 563         Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updateOfPort", interf, ovsdbTerminationPointBuilder);
 564         verify(ovsdbTerminationPointBuilder).setOfport(any(Long.class));
 565     }
 566
 567     @SuppressWarnings("unchecked")
 568     @Test
 569     public void testUpdateOfPortRequest() throws Exception {
 570         Interface interf = mock(Interface.class);
 571         Set<Long> ofPortRequests = new HashSet<>();
 572         ofPortRequests.add((long) 10000);
 573         Column<GenericTableSchema, Set<Long>> column = mock(Column.class);
 574         when(interf.getOpenFlowPortRequestColumn()).thenReturn(column);
 575         when(column.getData()).thenReturn(ofPortRequests);
 576         OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder = mock(
 577                 OvsdbTerminationPointAugmentationBuilder.class);
 578         when(ovsdbTerminationPointBuilder.setOfportRequest(any(Integer.class)))
 579                 .thenReturn(ovsdbTerminationPointBuilder);
 580         when(interf.getName()).thenReturn(INTERFACE_NAME);
 581         Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updateOfPortRequest", interf, ovsdbTerminationPointBuilder);
 582         verify(ovsdbTerminationPointBuilder).setOfportRequest(any(Integer.class));
 583     }
 584
 585     @SuppressWarnings("unchecked")
 586     @Test
 587     public void testUpdateInterfaceExternalIds() throws Exception {
 588         Interface interf = mock(Interface.class);
 589         Column<GenericTableSchema, Map<String, String>> column = mock(Column.class);
 590         when(interf.getExternalIdsColumn()).thenReturn(column);
 591         Map<String, String> map = new HashMap<>();
 592         when(column.getData()).thenReturn(map);
 593         map.put(EXTERNAL_ID_KEY, EXTERNAL_ID_VALUE);
 594         when(column.getData()).thenReturn(map);
 595
 596         InterfaceExternalIdsBuilder interfaceExternalIdsBuilder = mock(InterfaceExternalIdsBuilder.class);
 597         PowerMockito.whenNew(InterfaceExternalIdsBuilder.class).withNoArguments()
 598                 .thenReturn(interfaceExternalIdsBuilder);
 599
 600         when(interfaceExternalIdsBuilder.setExternalIdKey(anyString())).thenReturn(interfaceExternalIdsBuilder);
 601         when(interfaceExternalIdsBuilder.setExternalIdValue(anyString())).thenReturn(interfaceExternalIdsBuilder);
 602         when(interfaceExternalIdsBuilder.build()).thenReturn(mock(InterfaceExternalIds.class));
 603         OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBldr = mock(
 604                 OvsdbTerminationPointAugmentationBuilder.class);
 605         when(ovsdbTerminationPointBldr.setInterfaceExternalIds(any(List.class))).thenReturn(ovsdbTerminationPointBldr);
 606
 607         Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updateInterfaceExternalIds", interf, ovsdbTerminationPointBldr);
 608         verify(interfaceExternalIdsBuilder).setExternalIdKey(anyString());
 609         verify(interfaceExternalIdsBuilder).setExternalIdValue(anyString());
 610
 611     }
 612
 613     @SuppressWarnings("unchecked")
 614     @Test
 615     public void testUpdatePortExternalIds() throws Exception {
 616         Port port = mock(Port.class);
 617         Column<GenericTableSchema, Map<String, String>> column = mock(Column.class);
 618         when(port.getExternalIdsColumn()).thenReturn(column);
 619         Map<String, String> map = new HashMap<>();
 620         when(column.getData()).thenReturn(map);
 621         map.put(EXTERNAL_ID_KEY, EXTERNAL_ID_VALUE);
 622         when(column.getData()).thenReturn(map);
 623
 624         PortExternalIdsBuilder portExternalIdsBuilder = mock(PortExternalIdsBuilder.class);
 625         PowerMockito.whenNew(PortExternalIdsBuilder.class).withNoArguments().thenReturn(portExternalIdsBuilder);
 626
 627         when(portExternalIdsBuilder.setExternalIdKey(anyString())).thenReturn(portExternalIdsBuilder);
 628         when(portExternalIdsBuilder.setExternalIdValue(anyString())).thenReturn(portExternalIdsBuilder);
 629         when(portExternalIdsBuilder.build()).thenReturn(mock(PortExternalIds.class));
 630         OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder = mock(
 631                 OvsdbTerminationPointAugmentationBuilder.class);
 632         when(ovsdbTerminationPointBuilder.setPortExternalIds(any(List.class))).thenReturn(ovsdbTerminationPointBuilder);
 633
 634         Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updatePortExternalIds", port, ovsdbTerminationPointBuilder);
 635         verify(portExternalIdsBuilder).setExternalIdKey(anyString());
 636         verify(portExternalIdsBuilder).setExternalIdValue(anyString());
 637     }
 638
 639     @SuppressWarnings("unchecked")
 640     @Test
 641     public void testUpdatePortOtherConfig() throws Exception {
 642         Port port = mock(Port.class);
 643         Column<GenericTableSchema, Map<String, String>> column = mock(Column.class);
 644         when(port.getOtherConfigColumn()).thenReturn(column);
 645         Map<String, String> map = new HashMap<>();
 646         map.put(OTHER_CONFIG_KEY, OTHER_CONFIG_VALUE);
 647         when(column.getData()).thenReturn(map);
 648
 649         PortOtherConfigsBuilder portOtherConfigsBuilder = mock(PortOtherConfigsBuilder.class);
 650         PowerMockito.whenNew(PortOtherConfigsBuilder.class).withNoArguments().thenReturn(portOtherConfigsBuilder);
 651
 652         when(portOtherConfigsBuilder.setOtherConfigKey(anyString())).thenReturn(portOtherConfigsBuilder);
 653         when(portOtherConfigsBuilder.setOtherConfigValue(anyString())).thenReturn(portOtherConfigsBuilder);
 654         when(portOtherConfigsBuilder.build()).thenReturn(mock(PortOtherConfigs.class));
 655         OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder = mock(
 656                 OvsdbTerminationPointAugmentationBuilder.class);
 657         when(ovsdbTerminationPointBuilder.setInterfaceOtherConfigs(any(List.class)))
 658                 .thenReturn(ovsdbTerminationPointBuilder);
 659
 660         Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updatePortOtherConfig", port, ovsdbTerminationPointBuilder);
 661         verify(portOtherConfigsBuilder).setOtherConfigKey(anyString());
 662         verify(portOtherConfigsBuilder).setOtherConfigValue(anyString());
 663     }
 664
 665     @SuppressWarnings("unchecked")
 666     @Test
 667     public void testUpdateInterfaceOtherConfig() throws Exception {
 668         Interface interf = mock(Interface.class);
 669         Map<String, String> interfaceOtherConfigMap = new HashMap<>();
 670         interfaceOtherConfigMap.put(OTHER_CONFIG_KEY, OTHER_CONFIG_VALUE);
 671         Column<GenericTableSchema, Map<String, String>> column = mock(Column.class);
 672         when(interf.getOtherConfigColumn()).thenReturn(column);
 673         when(column.getData()).thenReturn(interfaceOtherConfigMap);
 674
 675         InterfaceOtherConfigsBuilder interfaceOtherConfigsBuilder = mock(InterfaceOtherConfigsBuilder.class);
 676         PowerMockito.whenNew(InterfaceOtherConfigsBuilder.class).withNoArguments()
 677                 .thenReturn(interfaceOtherConfigsBuilder);
 678
 679         when(interfaceOtherConfigsBuilder.setOtherConfigKey(anyString())).thenReturn(interfaceOtherConfigsBuilder);
 680         when(interfaceOtherConfigsBuilder.setOtherConfigValue(anyString())).thenReturn(interfaceOtherConfigsBuilder);
 681         when(interfaceOtherConfigsBuilder.build()).thenReturn(mock(InterfaceOtherConfigs.class));
 682         OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder = mock(
 683                 OvsdbTerminationPointAugmentationBuilder.class);
 684         when(ovsdbTerminationPointBuilder.setInterfaceOtherConfigs(any(List.class)))
 685                 .thenReturn(ovsdbTerminationPointBuilder);
 686
 687         Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updateInterfaceOtherConfig", interf,
 688                 ovsdbTerminationPointBuilder);
 689         verify(interfaceOtherConfigsBuilder).setOtherConfigKey(anyString());
 690         verify(interfaceOtherConfigsBuilder).setOtherConfigValue(anyString());
 691     }
 692
 693     @SuppressWarnings("unchecked")
 694     @Test
 695     // TODO This test needs to be re-done
 696     @Ignore("Broken mock-based test")
 697     public void testGetInstanceIdentifier() throws Exception {
 698         Port port = mock(Port.class);
 699         Column<GenericTableSchema, Map<String, String>> column = mock(Column.class);
 700         when(port.getExternalIdsColumn()).thenReturn(column);
 701         Map<String, String> map = new HashMap<>();
 702         map.put(SouthboundConstants.IID_EXTERNAL_ID_KEY, "opendaylight-iid");
 703         when(column.getData()).thenReturn(map);
 704
 705         PowerMockito.mockStatic(SouthboundUtil.class);
 706         InstanceIdentifier<TerminationPoint> terminationPointIId = mock(InstanceIdentifier.class);
 707 //        PowerMockito
 708 //                .when((InstanceIdentifier<TerminationPoint>) SouthboundUtil.deserializeInstanceIdentifier(
 709 //                        any(InstanceIdentifierCodec.class), anyString()))
 710 //                .thenReturn(terminationPointIId);
 711         InstanceIdentifier<Node> bridgeIid = mock(InstanceIdentifier.class);
 712         assertEquals(terminationPointIId,
 713                 Whitebox.invokeMethod(ovsdbPortUpdateCommand, "getInstanceIdentifier", bridgeIid, port));
 714     }
 715 }