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

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