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