southbound/southbound-impl/src/test/java/org/opendaylight/ovsdb/southbound/transactions/md/OvsdbBridgeUpdateCommandTest.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.junit.Assert.assertSame;
  12 import static org.mockito.ArgumentMatchers.any;
  13 import static org.mockito.ArgumentMatchers.anyString;
  14 import static org.mockito.ArgumentMatchers.eq;
  15 import static org.mockito.Mockito.doNothing;
  16 import static org.mockito.Mockito.mock;
  17 import static org.mockito.Mockito.times;
  18 import static org.mockito.Mockito.verify;
  19 import static org.mockito.Mockito.when;
  20
  21 import com.google.common.collect.Iterators;
  22 import com.google.common.net.InetAddresses;
  23 import java.net.NetworkInterface;
  24 import java.util.ArrayList;
  25 import java.util.HashMap;
  26 import java.util.HashSet;
  27 import java.util.List;
  28 import java.util.Map;
  29 import java.util.Optional;
  30 import java.util.Set;
  31 import org.junit.Before;
  32 import org.junit.Test;
  33 import org.junit.runner.RunWith;
  34 import org.mockito.Mockito;
  35 import org.mockito.stubbing.Answer;
  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.Controller;
  46 import org.opendaylight.ovsdb.southbound.InstanceIdentifierCodec;
  47 import org.opendaylight.ovsdb.southbound.OvsdbConnectionInstance;
  48 import org.opendaylight.ovsdb.southbound.SouthboundMapper;
  49 import org.opendaylight.ovsdb.southbound.SouthboundUtil;
  50 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
  51 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.DatapathId;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.DatapathTypeBase;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.DatapathTypeSystem;
  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.OvsdbBridgeAugmentationBuilder;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeName;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeProtocolBase;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeRef;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbFailModeStandalone;
  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.OvsdbNodeAugmentationBuilder;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeRef;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.BridgeExternalIds;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.BridgeOtherConfigs;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntry;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ProtocolEntry;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ProtocolEntryBuilder;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntry;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntryBuilder;
  71 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
  72 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
  73 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder;
  74 import org.opendaylight.yangtools.yang.binding.DataObject;
  75 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  76 import org.powermock.api.mockito.PowerMockito;
  77 import org.powermock.api.support.membermodification.MemberMatcher;
  78 import org.powermock.api.support.membermodification.MemberModifier;
  79 import org.powermock.core.classloader.annotations.PrepareForTest;
  80 import org.powermock.modules.junit4.PowerMockRunner;
  81 import org.powermock.reflect.Whitebox;
  82
  83 @RunWith(PowerMockRunner.class)
  84 @PrepareForTest({
  85     TyperUtils.class, OvsdbBridgeUpdateCommand.class, SouthboundUtil.class, InstanceIdentifier.class,
  86     SouthboundMapper.class, NetworkInterface.class
  87 })
  88 public class OvsdbBridgeUpdateCommandTest {
  89     private final Map<UUID,Bridge> updatedBridgeRows = new HashMap<>();
  90     private final Map<UUID, Bridge> oldBridgeRows = new HashMap<>();
  91     private OvsdbBridgeUpdateCommand ovsdbBridgeUpdateCommand;
  92     private final Map<NodeId, Node> updatedBridgeNodes = new HashMap<>();
  93
  94     @Before
  95     public void setUp() throws Exception {
  96         ovsdbBridgeUpdateCommand = PowerMockito.mock(OvsdbBridgeUpdateCommand.class, Mockito.CALLS_REAL_METHODS);
  97         MemberModifier.field(OvsdbBridgeUpdateCommand.class, "updatedBridges")
  98                 .set(ovsdbBridgeUpdateCommand, new ArrayList<>());
  99         MemberModifier.field(OvsdbBridgeUpdateCommand.class, "updatedBridgeRows").set(ovsdbBridgeUpdateCommand,
 100                 updatedBridgeRows);
 101         MemberModifier.field(OvsdbBridgeUpdateCommand.class, "updatedBridgeNodes").set(
 102                 ovsdbBridgeUpdateCommand,updatedBridgeNodes);
 103     }
 104
 105     @Test
 106     public void testOvsdbBridgeUpdateCommand() {
 107         OvsdbConnectionInstance key = mock(OvsdbConnectionInstance.class);
 108         TableUpdates updates = mock(TableUpdates.class);
 109         DatabaseSchema dbSchema = mock(DatabaseSchema.class);
 110         OvsdbBridgeUpdateCommand ovsdbBridgeUpdateCommand1 =
 111                 new OvsdbBridgeUpdateCommand(mock(InstanceIdentifierCodec.class), key, updates, dbSchema,
 112                         updatedBridgeNodes);
 113         assertEquals(key, Whitebox.getInternalState(ovsdbBridgeUpdateCommand1, "key"));
 114         assertEquals(updates, Whitebox.getInternalState(ovsdbBridgeUpdateCommand1, "updates"));
 115         assertEquals(dbSchema, Whitebox.getInternalState(ovsdbBridgeUpdateCommand1, "dbSchema"));
 116     }
 117
 118     @Test
 119     public void testExecute() throws Exception {
 120         updatedBridgeRows.put(mock(UUID.class), mock(Bridge.class));
 121
 122         OvsdbConnectionInstance ovsdbConnectionInstance = mock(OvsdbConnectionInstance.class);
 123         when(ovsdbBridgeUpdateCommand.getOvsdbConnectionInstance()).thenReturn(ovsdbConnectionInstance);
 124         InstanceIdentifier<Node> connectionIId = mock(InstanceIdentifier.class);
 125         when(ovsdbConnectionInstance.getInstanceIdentifier()).thenReturn(connectionIId);
 126         Optional<Node> connection = Optional.of(mock(Node.class));
 127         PowerMockito.mockStatic(SouthboundUtil.class);
 128         when(SouthboundUtil.readNode(any(ReadWriteTransaction.class), any(InstanceIdentifier.class)))
 129                 .thenReturn(connection);
 130         ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
 131         MemberModifier.suppress(MemberMatcher.method(OvsdbBridgeUpdateCommand.class, "updateBridge",
 132                 ReadWriteTransaction.class, Bridge.class, InstanceIdentifier.class));
 133         ovsdbBridgeUpdateCommand.execute(transaction);
 134         verify(ovsdbBridgeUpdateCommand).updateBridge(any(ReadWriteTransaction.class),
 135                 any(Bridge.class), any(InstanceIdentifier.class));
 136     }
 137
 138     @SuppressWarnings("unchecked")
 139     @Test
 140     public void testUpdateBridge() throws Exception {
 141         MemberModifier
 142                 .suppress(MemberMatcher.method(OvsdbBridgeUpdateCommand.class, "buildConnectionNode", Bridge.class));
 143         ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
 144         doNothing().when(transaction).merge(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
 145                 any(Node.class));
 146
 147         // suppress calls to private methods
 148         MemberModifier
 149                 .suppress(MemberMatcher.method(OvsdbBridgeUpdateCommand.class, "getInstanceIdentifier", Bridge.class));
 150         MemberModifier.suppress(MemberMatcher.method(OvsdbBridgeUpdateCommand.class, "buildBridgeNode", Bridge.class));
 151         MemberModifier.suppress(MemberMatcher.method(OvsdbBridgeUpdateCommand.class, "deleteEntries",
 152                 ReadWriteTransaction.class, List.class));
 153         MemberModifier.suppress(MemberMatcher.method(OvsdbBridgeUpdateCommand.class, "protocolEntriesToRemove",
 154                 InstanceIdentifier.class, Bridge.class));
 155         MemberModifier.suppress(MemberMatcher.method(OvsdbBridgeUpdateCommand.class, "externalIdsToRemove",
 156                 InstanceIdentifier.class, Bridge.class));
 157         MemberModifier.suppress(MemberMatcher.method(OvsdbBridgeUpdateCommand.class, "bridgeOtherConfigsToRemove",
 158                 InstanceIdentifier.class, Bridge.class));
 159         MemberModifier.suppress(MemberMatcher.method(OvsdbBridgeUpdateCommand.class, "getNodeId",
 160                 Bridge.class));
 161
 162         Bridge bridge = mock(Bridge.class);
 163         InstanceIdentifier<Node> connectionIId = mock(InstanceIdentifier.class);
 164         Whitebox.invokeMethod(ovsdbBridgeUpdateCommand, "updateBridge", transaction, bridge, connectionIId);
 165         verify(ovsdbBridgeUpdateCommand, times(3)).deleteEntries(any(ReadWriteTransaction.class), eq(null));
 166     }
 167
 168     @SuppressWarnings("unchecked")
 169     @Test
 170     public void testDeleteEntries() throws Exception {
 171         ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
 172         List<InstanceIdentifier<DataObject>> entryIids = new ArrayList<>();
 173         InstanceIdentifier<DataObject> iid = mock(InstanceIdentifier.class);
 174         entryIids.add(iid);
 175         doNothing().when(transaction).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
 176         Whitebox.invokeMethod(ovsdbBridgeUpdateCommand, "deleteEntries", transaction, entryIids);
 177         verify(transaction).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
 178     }
 179
 180     @SuppressWarnings("unchecked")
 181     @Test
 182     public void testToRemoveMethods() throws Exception {
 183         Bridge bridge = mock(Bridge.class);
 184         UUID uuid = mock(UUID.class);
 185         Bridge oldBridge = mock(Bridge.class);
 186         oldBridgeRows.put(uuid, oldBridge);
 187         when(bridge.getUuid()).thenReturn(uuid);
 188         MemberModifier.field(OvsdbBridgeUpdateCommand.class, "oldBridgeRows").set(ovsdbBridgeUpdateCommand,
 189                 oldBridgeRows);
 190         Column<GenericTableSchema, Map<String, String>> column = mock(Column.class);
 191         Map<String, String> map = new HashMap<>();
 192         map.put("key", "value");
 193         when(column.getData()).thenReturn(map);
 194
 195         //test bridgeOtherConfigsToRemove()
 196         when(oldBridge.getOtherConfigColumn()).thenReturn(column);
 197         when(bridge.getOtherConfigColumn()).thenReturn(column);
 198         InstanceIdentifier<Node> bridgeIid = PowerMockito.mock(InstanceIdentifier.class);
 199         List<InstanceIdentifier<BridgeOtherConfigs>> resultBridgeOtherConfigs = Whitebox
 200                 .invokeMethod(ovsdbBridgeUpdateCommand, "bridgeOtherConfigsToRemove", bridgeIid, bridge);
 201         assertEquals(ArrayList.class, resultBridgeOtherConfigs.getClass());
 202         verify(oldBridge, times(2)).getOtherConfigColumn();
 203
 204         //test externalIdsToRemove()
 205         when(oldBridge.getExternalIdsColumn()).thenReturn(column);
 206         when(column.getData()).thenReturn(map);
 207         when(bridge.getExternalIdsColumn()).thenReturn(column);
 208         List<InstanceIdentifier<BridgeExternalIds>> resultBridgeExternalIds = Whitebox
 209                 .invokeMethod(ovsdbBridgeUpdateCommand, "externalIdsToRemove", bridgeIid, bridge);
 210         assertEquals(ArrayList.class, resultBridgeExternalIds.getClass());
 211         verify(oldBridge, times(2)).getExternalIdsColumn();
 212
 213         //test protocolEntriesToRemove()
 214         Column<GenericTableSchema, Set<String>> column1 = mock(Column.class);
 215         Set<String> set = new HashSet<>();
 216         set.add("element");
 217         when(column1.getData()).thenReturn(set);
 218         when(oldBridge.getProtocolsColumn()).thenReturn(column1);
 219         when(column.getData()).thenReturn(map);
 220         when(bridge.getProtocolsColumn()).thenReturn(column1);
 221         List<InstanceIdentifier<ProtocolEntry>> resultProtocolEntry = Whitebox.invokeMethod(ovsdbBridgeUpdateCommand,
 222                 "protocolEntriesToRemove", bridgeIid, bridge);
 223         assertEquals(ArrayList.class, resultProtocolEntry.getClass());
 224         verify(oldBridge, times(2)).getProtocolsColumn();
 225     }
 226
 227     @SuppressWarnings("unchecked")
 228     @Test
 229     public void testBuildConnectionNode() throws Exception {
 230         NodeBuilder connectionNode = mock(NodeBuilder.class);
 231         PowerMockito.whenNew(NodeBuilder.class).withNoArguments().thenReturn(connectionNode);
 232         OvsdbConnectionInstance ovsdbConnectionInstance = mock(OvsdbConnectionInstance.class);
 233         when(ovsdbBridgeUpdateCommand.getOvsdbConnectionInstance()).thenReturn(ovsdbConnectionInstance);
 234         when(ovsdbConnectionInstance.getNodeId()).thenReturn(mock(NodeId.class));
 235         when(connectionNode.setNodeId(any(NodeId.class))).thenReturn(connectionNode);
 236
 237         OvsdbNodeAugmentationBuilder ovsdbConnectionAugmentationBuilder = mock(OvsdbNodeAugmentationBuilder.class);
 238         PowerMockito.whenNew(OvsdbNodeAugmentationBuilder.class).withNoArguments()
 239                 .thenReturn(ovsdbConnectionAugmentationBuilder);
 240         PowerMockito.mockStatic(SouthboundMapper.class);
 241         InstanceIdentifier<Node> bridgeIid = mock(InstanceIdentifier.class);
 242         when(SouthboundMapper.createInstanceIdentifier(any(InstanceIdentifierCodec.class),
 243                 any(OvsdbConnectionInstance.class), any(Bridge.class)))
 244                 .thenReturn(bridgeIid);
 245
 246         ManagedNodeEntry managedBridge = new ManagedNodeEntryBuilder()
 247                 .setBridgeRef(new OvsdbBridgeRef(mock(InstanceIdentifier.class)))
 248                 .build();
 249
 250         ManagedNodeEntryBuilder managedNodeEntryBuilder = mock(ManagedNodeEntryBuilder.class);
 251         PowerMockito.whenNew(ManagedNodeEntryBuilder.class).withNoArguments().thenReturn(managedNodeEntryBuilder);
 252         PowerMockito.whenNew(OvsdbBridgeRef.class).withAnyArguments().thenReturn(mock(OvsdbBridgeRef.class));
 253         when(managedNodeEntryBuilder.setBridgeRef(any(OvsdbBridgeRef.class))).thenReturn(managedNodeEntryBuilder);
 254         when(managedNodeEntryBuilder.build()).thenReturn(managedBridge);
 255         when(ovsdbConnectionAugmentationBuilder.setManagedNodeEntry(any(Map.class)))
 256                 .thenReturn(ovsdbConnectionAugmentationBuilder);
 257
 258         when(ovsdbConnectionAugmentationBuilder.build()).thenReturn(mock(OvsdbNodeAugmentation.class));
 259         when(connectionNode.addAugmentation(any(OvsdbNodeAugmentation.class))).thenReturn(connectionNode);
 260
 261         //for logger
 262         when(ovsdbConnectionAugmentationBuilder.getManagedNodeEntry())
 263             .thenReturn(Map.of(managedBridge.key(), managedBridge));
 264
 265         Node node = mock(Node.class);
 266         when(connectionNode.build()).thenReturn(node);
 267         Bridge bridge = mock(Bridge.class);
 268         assertEquals(node, Whitebox.invokeMethod(ovsdbBridgeUpdateCommand, "buildConnectionNode", bridge));
 269     }
 270
 271     @Test
 272     public void testBuildBridgeNode() throws Exception {
 273         NodeBuilder bridgeNodeBuilder = mock(NodeBuilder.class);
 274         PowerMockito.whenNew(NodeBuilder.class).withNoArguments().thenReturn(bridgeNodeBuilder);
 275         //suppress call to getNodeId()
 276         MemberModifier.suppress(MemberMatcher.method(OvsdbBridgeUpdateCommand.class, "getNodeId", Bridge.class));
 277         when(bridgeNodeBuilder.setNodeId(any(NodeId.class))).thenReturn(bridgeNodeBuilder);
 278         OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder = mock(OvsdbBridgeAugmentationBuilder.class);
 279         PowerMockito.whenNew(OvsdbBridgeAugmentationBuilder.class).withNoArguments()
 280                 .thenReturn(ovsdbBridgeAugmentationBuilder);
 281         Bridge bridge = mock(Bridge.class);
 282         when(bridge.getName()).thenReturn("bridge name");
 283         PowerMockito.whenNew(OvsdbBridgeName.class).withAnyArguments().thenReturn(mock(OvsdbBridgeName.class));
 284         when(ovsdbBridgeAugmentationBuilder.setBridgeName(any(OvsdbBridgeName.class)))
 285                 .thenReturn(ovsdbBridgeAugmentationBuilder);
 286         when(bridge.getUuid()).thenReturn(mock(UUID.class));
 287         PowerMockito.whenNew(Uuid.class).withAnyArguments().thenReturn(mock(Uuid.class));
 288         when(ovsdbBridgeAugmentationBuilder.setBridgeUuid(any(Uuid.class))).thenReturn(ovsdbBridgeAugmentationBuilder);
 289
 290         //suppress calls to the set methods
 291         MemberModifier.suppress(MemberMatcher.method(OvsdbBridgeUpdateCommand.class, "setDataPath",
 292                 OvsdbBridgeAugmentationBuilder.class, Bridge.class));
 293         MemberModifier.suppress(MemberMatcher.method(OvsdbBridgeUpdateCommand.class, "setDataPathType",
 294                 OvsdbBridgeAugmentationBuilder.class, Bridge.class));
 295         MemberModifier.suppress(MemberMatcher.method(OvsdbBridgeUpdateCommand.class, "setProtocol",
 296                 OvsdbBridgeAugmentationBuilder.class, Bridge.class));
 297         MemberModifier.suppress(MemberMatcher.method(OvsdbBridgeUpdateCommand.class, "setExternalIds",
 298                 OvsdbBridgeAugmentationBuilder.class, Bridge.class));
 299         MemberModifier.suppress(MemberMatcher.method(OvsdbBridgeUpdateCommand.class, "setOtherConfig",
 300                 OvsdbBridgeAugmentationBuilder.class, Bridge.class));
 301         MemberModifier.suppress(MemberMatcher.method(OvsdbBridgeUpdateCommand.class, "setFailMode",
 302                 OvsdbBridgeAugmentationBuilder.class, Bridge.class));
 303         MemberModifier.suppress(MemberMatcher.method(OvsdbBridgeUpdateCommand.class, "setOpenFlowNodeRef",
 304                 OvsdbBridgeAugmentationBuilder.class, Bridge.class));
 305         MemberModifier.suppress(MemberMatcher.method(OvsdbBridgeUpdateCommand.class, "setManagedBy",
 306                 OvsdbBridgeAugmentationBuilder.class));
 307
 308         when(ovsdbBridgeAugmentationBuilder.build()).thenReturn(mock(OvsdbBridgeAugmentation.class));
 309         when(bridgeNodeBuilder.addAugmentation(any(OvsdbBridgeAugmentation.class))).thenReturn(bridgeNodeBuilder);
 310         Node node = mock(Node.class);
 311         when(bridgeNodeBuilder.build()).thenReturn(node);
 312         assertEquals(node, Whitebox.invokeMethod(ovsdbBridgeUpdateCommand, "buildBridgeNode", bridge));
 313     }
 314
 315     @SuppressWarnings("unchecked")
 316     @Test
 317     public void testSetManagedByAndSetDataPathType() throws Exception {
 318         OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder = mock(OvsdbBridgeAugmentationBuilder.class);
 319
 320         OvsdbConnectionInstance ovsdbConnectionInstance = mock(OvsdbConnectionInstance.class);
 321         when(ovsdbBridgeUpdateCommand.getOvsdbConnectionInstance()).thenReturn(ovsdbConnectionInstance);
 322         when(ovsdbConnectionInstance.getInstanceIdentifier()).thenReturn(mock(InstanceIdentifier.class));
 323         PowerMockito.whenNew(OvsdbNodeRef.class).withAnyArguments().thenReturn(mock(OvsdbNodeRef.class));
 324         when(ovsdbBridgeAugmentationBuilder.setManagedBy(any(OvsdbNodeRef.class)))
 325                 .thenReturn(ovsdbBridgeAugmentationBuilder);
 326         Whitebox.invokeMethod(ovsdbBridgeUpdateCommand, "setManagedBy", ovsdbBridgeAugmentationBuilder);
 327         verify(ovsdbBridgeAugmentationBuilder).setManagedBy(any(OvsdbNodeRef.class));
 328         verify(ovsdbConnectionInstance).getInstanceIdentifier();
 329     }
 330
 331     @SuppressWarnings("unchecked")
 332     @Test
 333     public void testSetDataPathType() throws Exception {
 334         Bridge bridge = mock(Bridge.class);
 335         Column<GenericTableSchema, String> column = mock(Column.class);
 336         when(bridge.getDatapathTypeColumn()).thenReturn(column);
 337         when(column.getData()).thenReturn("system");
 338         PowerMockito.mockStatic(SouthboundMapper.class);
 339         when(SouthboundMapper.createDatapathType(anyString()))
 340                 .thenAnswer((Answer<Class<? extends DatapathTypeBase>>) invocation -> DatapathTypeSystem.class);
 341         OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder = mock(OvsdbBridgeAugmentationBuilder.class);
 342         when(ovsdbBridgeAugmentationBuilder.setDatapathType(any(Class.class)))
 343                 .thenReturn(ovsdbBridgeAugmentationBuilder);
 344         Whitebox.invokeMethod(ovsdbBridgeUpdateCommand, "setDataPathType", ovsdbBridgeAugmentationBuilder, bridge);
 345         verify(bridge).getDatapathTypeColumn();
 346         verify(column).getData();
 347         verify(ovsdbBridgeAugmentationBuilder).setDatapathType(any(Class.class));
 348     }
 349
 350     @SuppressWarnings("unchecked")
 351     @Test
 352     public void testSetFailMode() throws Exception {
 353         Bridge bridge = mock(Bridge.class);
 354         Column<GenericTableSchema, Set<String>> column = mock(Column.class);
 355         when(bridge.getFailModeColumn()).thenReturn(column);
 356         Set<String> set = new HashSet<>();
 357         set.add("standalone");
 358         when(column.getData()).thenReturn(set);
 359         OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder = mock(OvsdbBridgeAugmentationBuilder.class);
 360         when(ovsdbBridgeAugmentationBuilder.setFailMode(OvsdbFailModeStandalone.class))
 361                 .thenReturn(ovsdbBridgeAugmentationBuilder);
 362         Whitebox.invokeMethod(ovsdbBridgeUpdateCommand, "setFailMode", ovsdbBridgeAugmentationBuilder, bridge);
 363         verify(bridge, times(5)).getFailModeColumn();
 364         verify(ovsdbBridgeAugmentationBuilder).setFailMode(OvsdbFailModeStandalone.class);
 365     }
 366
 367     @SuppressWarnings("unchecked")
 368     @Test
 369     public void testSetOtherConfig() throws Exception {
 370         Bridge bridge = mock(Bridge.class);
 371         Column<GenericTableSchema, Map<String, String>> column = mock(Column.class);
 372         when(bridge.getOtherConfigColumn()).thenReturn(column);
 373         Map<String, String> map = new HashMap<>();
 374         map.put("key", "value");
 375         when(column.getData()).thenReturn(map);
 376
 377         var builder = new OvsdbBridgeAugmentationBuilder();
 378         OvsdbBridgeUpdateCommand.setOtherConfig(builder, bridge);
 379         var list = builder.build().nonnullBridgeOtherConfigs().values();
 380         assertEquals(1, list.size());
 381         var result = list.iterator().next();
 382         assertEquals("key", result.getBridgeOtherConfigKey());
 383         assertEquals("value", result.getBridgeOtherConfigValue());
 384     }
 385
 386     @SuppressWarnings("unchecked")
 387     @Test
 388     public void testSetExternalIds() throws Exception {
 389         Bridge bridge = mock(Bridge.class);
 390         Column<GenericTableSchema, Map<String, String>> column = mock(Column.class);
 391         when(bridge.getExternalIdsColumn()).thenReturn(column);
 392         Map<String, String> map = new HashMap<>();
 393         map.put("key", "value");
 394         when(column.getData()).thenReturn(map);
 395
 396         var builder = new OvsdbBridgeAugmentationBuilder();
 397         OvsdbBridgeUpdateCommand.setExternalIds(builder, bridge);
 398         var list = builder.build().nonnullBridgeExternalIds().values();
 399         assertEquals(1, list.size());
 400         var result = list.iterator().next();
 401         assertEquals("key", result.getBridgeExternalIdKey());
 402         assertEquals("value", result.getBridgeExternalIdValue());
 403     }
 404
 405     @Test
 406     public void testSetProtocolAndSetDataPath() throws Exception {
 407         PowerMockito.mockStatic(SouthboundMapper.class);
 408
 409         var builder = new OvsdbBridgeAugmentationBuilder();
 410         var bridge = mock(Bridge.class);
 411
 412         // Call setProtocol()
 413         when(SouthboundMapper.createMdsalProtocols(any(Bridge.class)))
 414                 .thenReturn(List.of(new ProtocolEntryBuilder().setProtocol(OvsdbBridgeProtocolBase.class).build()));
 415         OvsdbBridgeUpdateCommand.setProtocol(builder, bridge);
 416
 417         // Call setDataPath()
 418         var dpid = new DatapathId("00:11:22:33:44:55:66:77");
 419         when(SouthboundMapper.createDatapathId(any(Bridge.class))).thenReturn(dpid);
 420         OvsdbBridgeUpdateCommand.setDataPath(builder, bridge);
 421
 422         // Get result
 423         var result = builder.build();
 424
 425         // Assert setProtocol()
 426         var protocols = result.nonnullProtocolEntry().values();
 427         assertEquals(1, protocols.size());
 428         var protocol = protocols.iterator().next();
 429         assertEquals(OvsdbBridgeProtocolBase.class, protocol.getProtocol());
 430
 431         // Assert setDataPath()
 432         assertSame(dpid, result.getDatapathId());
 433     }
 434
 435     @SuppressWarnings("unchecked")
 436     @Test
 437     public void testSetOpenFlowNodeRef() throws Exception {
 438         PowerMockito.mockStatic(SouthboundMapper.class);
 439
 440         when(ovsdbBridgeUpdateCommand.getUpdates()).thenReturn(mock(TableUpdates.class));
 441         when(ovsdbBridgeUpdateCommand.getDbSchema()).thenReturn(mock(DatabaseSchema.class));
 442         PowerMockito.mockStatic(TyperUtils.class);
 443         Map<UUID, Controller> updatedControllerRows = new HashMap<>();
 444         when(TyperUtils.extractRowsUpdated(eq(Controller.class), any(TableUpdates.class), any(DatabaseSchema.class)))
 445                 .thenReturn(updatedControllerRows);
 446
 447         List<ControllerEntry> controllerEntryList = new ArrayList<>();
 448         ControllerEntry controllerEntry = mock(ControllerEntry.class);
 449         controllerEntryList.add(controllerEntry);
 450         when(SouthboundMapper.createControllerEntries(any(Bridge.class), any(Map.class)))
 451                 .thenReturn(controllerEntryList);
 452         when(controllerEntry.getIsConnected()).thenReturn(true);
 453         Uri uri = mock(Uri.class);
 454         when(controllerEntry.getTarget()).thenReturn(uri);
 455         when(uri.getValue()).thenReturn("tcp:192.168.12.56:6633");
 456
 457         PowerMockito.mockStatic(NetworkInterface.class);
 458         NetworkInterface networkInterface = PowerMockito.mock(NetworkInterface.class);
 459         when(networkInterface.getInetAddresses()).thenReturn(Iterators.asEnumeration(
 460             Iterators.singletonIterator(InetAddresses.forString("192.168.12.56"))));
 461         when(NetworkInterface.getNetworkInterfaces()).thenReturn(Iterators.asEnumeration(
 462             Iterators.singletonIterator(networkInterface)));
 463
 464         OvsdbConnectionInstance ovsdbConnectionInstance = mock(OvsdbConnectionInstance.class);
 465         when(ovsdbBridgeUpdateCommand.getOvsdbConnectionInstance()).thenReturn(ovsdbConnectionInstance);
 466         when(ovsdbConnectionInstance.getInstanceIdentifier()).thenReturn(mock(InstanceIdentifier.class));
 467         OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder = mock(OvsdbBridgeAugmentationBuilder.class);
 468         Bridge bridge = mock(Bridge.class);
 469         when(ovsdbBridgeAugmentationBuilder.setBridgeOpenflowNodeRef(any(InstanceIdentifier.class)))
 470                 .thenReturn(ovsdbBridgeAugmentationBuilder);
 471
 472         Whitebox.invokeMethod(ovsdbBridgeUpdateCommand, "setOpenFlowNodeRef", ovsdbBridgeAugmentationBuilder, bridge);
 473         verify(controllerEntry, times(2)).getIsConnected();
 474         verify(ovsdbBridgeAugmentationBuilder).setBridgeOpenflowNodeRef(any(InstanceIdentifier.class));
 475     }
 476 }