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

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