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