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

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