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

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