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