2 * Copyright © 2015, 2017 Inocybe Technologies and others. All rights reserved.
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
9 package org.opendaylight.ovsdb.southbound.transactions.md;
11 import static org.junit.Assert.assertEquals;
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;
21 import com.google.common.base.Optional;
22 import com.google.common.collect.Iterators;
23 import com.google.common.net.InetAddresses;
24 import java.net.NetworkInterface;
25 import java.util.ArrayList;
26 import java.util.HashMap;
27 import java.util.HashSet;
28 import java.util.List;
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.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.OvsdbBridgeRef;
59 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbFailModeStandalone;
60 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
61 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentationBuilder;
62 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeRef;
63 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.BridgeExternalIds;
64 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.BridgeExternalIdsBuilder;
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.BridgeOtherConfigsBuilder;
67 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntry;
68 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ProtocolEntry;
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;
83 @RunWith(PowerMockRunner.class)
84 @PrepareForTest({ TyperUtils.class, OvsdbBridgeUpdateCommand.class, SouthboundUtil.class, InstanceIdentifier.class,
85 SouthboundMapper.class, NetworkInterface.class })
86 public class OvsdbBridgeUpdateCommandTest {
87 private final Map<UUID,Bridge> updatedBridgeRows = new HashMap<>();
88 private final Map<UUID, Bridge> oldBridgeRows = new HashMap<>();
89 private OvsdbBridgeUpdateCommand ovsdbBridgeUpdateCommand;
92 public void setUp() throws Exception {
93 ovsdbBridgeUpdateCommand = PowerMockito.mock(OvsdbBridgeUpdateCommand.class, Mockito.CALLS_REAL_METHODS);
94 MemberModifier.field(OvsdbBridgeUpdateCommand.class, "updatedBridges")
95 .set(ovsdbBridgeUpdateCommand, new ArrayList<>());
96 MemberModifier.field(OvsdbBridgeUpdateCommand.class, "updatedBridgeRows").set(ovsdbBridgeUpdateCommand,
101 public void testOvsdbBridgeUpdateCommand() {
102 OvsdbConnectionInstance key = mock(OvsdbConnectionInstance.class);
103 TableUpdates updates = mock(TableUpdates.class);
104 DatabaseSchema dbSchema = mock(DatabaseSchema.class);
105 OvsdbBridgeUpdateCommand ovsdbBridgeUpdateCommand1 =
106 new OvsdbBridgeUpdateCommand(mock(InstanceIdentifierCodec.class), key, updates, dbSchema);
107 assertEquals(key, Whitebox.getInternalState(ovsdbBridgeUpdateCommand1, "key"));
108 assertEquals(updates, Whitebox.getInternalState(ovsdbBridgeUpdateCommand1, "updates"));
109 assertEquals(dbSchema, Whitebox.getInternalState(ovsdbBridgeUpdateCommand1, "dbSchema"));
113 public void testExecute() throws Exception {
114 updatedBridgeRows.put(mock(UUID.class), mock(Bridge.class));
116 OvsdbConnectionInstance ovsdbConnectionInstance = mock(OvsdbConnectionInstance.class);
117 when(ovsdbBridgeUpdateCommand.getOvsdbConnectionInstance()).thenReturn(ovsdbConnectionInstance);
118 InstanceIdentifier<Node> connectionIId = mock(InstanceIdentifier.class);
119 when(ovsdbConnectionInstance.getInstanceIdentifier()).thenReturn(connectionIId);
120 Optional<Node> connection = Optional.of(mock(Node.class));
121 PowerMockito.mockStatic(SouthboundUtil.class);
122 when(SouthboundUtil.readNode(any(ReadWriteTransaction.class), any(InstanceIdentifier.class)))
123 .thenReturn(connection);
124 ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
125 MemberModifier.suppress(MemberMatcher.method(OvsdbBridgeUpdateCommand.class, "updateBridge",
126 ReadWriteTransaction.class, Bridge.class, InstanceIdentifier.class));
127 ovsdbBridgeUpdateCommand.execute(transaction);
128 verify(ovsdbBridgeUpdateCommand).updateBridge(any(ReadWriteTransaction.class),
129 any(Bridge.class), any(InstanceIdentifier.class));
132 @SuppressWarnings("unchecked")
134 public void testUpdateBridge() throws Exception {
136 .suppress(MemberMatcher.method(OvsdbBridgeUpdateCommand.class, "buildConnectionNode", Bridge.class));
137 ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
138 doNothing().when(transaction).merge(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
141 // suppress calls to private methods
143 .suppress(MemberMatcher.method(OvsdbBridgeUpdateCommand.class, "getInstanceIdentifier", Bridge.class));
144 MemberModifier.suppress(MemberMatcher.method(OvsdbBridgeUpdateCommand.class, "buildBridgeNode", Bridge.class));
145 MemberModifier.suppress(MemberMatcher.method(OvsdbBridgeUpdateCommand.class, "deleteEntries",
146 ReadWriteTransaction.class, List.class));
147 MemberModifier.suppress(MemberMatcher.method(OvsdbBridgeUpdateCommand.class, "protocolEntriesToRemove",
148 InstanceIdentifier.class, Bridge.class));
149 MemberModifier.suppress(MemberMatcher.method(OvsdbBridgeUpdateCommand.class, "externalIdsToRemove",
150 InstanceIdentifier.class, Bridge.class));
151 MemberModifier.suppress(MemberMatcher.method(OvsdbBridgeUpdateCommand.class, "bridgeOtherConfigsToRemove",
152 InstanceIdentifier.class, Bridge.class));
154 Bridge bridge = mock(Bridge.class);
155 InstanceIdentifier<Node> connectionIId = mock(InstanceIdentifier.class);
156 Whitebox.invokeMethod(ovsdbBridgeUpdateCommand, "updateBridge", transaction, bridge, connectionIId);
157 verify(ovsdbBridgeUpdateCommand, times(3)).deleteEntries(any(ReadWriteTransaction.class), eq(null));
160 @SuppressWarnings("unchecked")
162 public void testDeleteEntries() throws Exception {
163 ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
164 List<InstanceIdentifier<DataObject>> entryIids = new ArrayList<>();
165 InstanceIdentifier<DataObject> iid = mock(InstanceIdentifier.class);
167 doNothing().when(transaction).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
168 Whitebox.invokeMethod(ovsdbBridgeUpdateCommand, "deleteEntries", transaction, entryIids);
169 verify(transaction).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
172 @SuppressWarnings("unchecked")
174 public void testToRemoveMethods() throws Exception {
175 Bridge bridge = mock(Bridge.class);
176 UUID uuid = mock(UUID.class);
177 Bridge oldBridge = mock(Bridge.class);
178 oldBridgeRows.put(uuid, oldBridge);
179 when(bridge.getUuid()).thenReturn(uuid);
180 MemberModifier.field(OvsdbBridgeUpdateCommand.class, "oldBridgeRows").set(ovsdbBridgeUpdateCommand,
182 Column<GenericTableSchema, Map<String, String>> column = mock(Column.class);
183 Map<String, String> map = new HashMap<>();
184 map.put("key", "value");
185 when(column.getData()).thenReturn(map);
187 //test bridgeOtherConfigsToRemove()
188 when(oldBridge.getOtherConfigColumn()).thenReturn(column);
189 when(bridge.getOtherConfigColumn()).thenReturn(column);
190 InstanceIdentifier<Node> bridgeIid = PowerMockito.mock(InstanceIdentifier.class);
191 List<InstanceIdentifier<BridgeOtherConfigs>> resultBridgeOtherConfigs = Whitebox
192 .invokeMethod(ovsdbBridgeUpdateCommand, "bridgeOtherConfigsToRemove", bridgeIid, bridge);
193 assertEquals(ArrayList.class, resultBridgeOtherConfigs.getClass());
194 verify(oldBridge, times(2)).getOtherConfigColumn();
196 //test externalIdsToRemove()
197 when(oldBridge.getExternalIdsColumn()).thenReturn(column);
198 when(column.getData()).thenReturn(map);
199 when(bridge.getExternalIdsColumn()).thenReturn(column);
200 List<InstanceIdentifier<BridgeExternalIds>> resultBridgeExternalIds = Whitebox
201 .invokeMethod(ovsdbBridgeUpdateCommand, "externalIdsToRemove", bridgeIid, bridge);
202 assertEquals(ArrayList.class, resultBridgeExternalIds.getClass());
203 verify(oldBridge, times(2)).getExternalIdsColumn();
205 //test protocolEntriesToRemove()
206 Column<GenericTableSchema, Set<String>> column1 = mock(Column.class);
207 Set<String> set = new HashSet<>();
209 when(column1.getData()).thenReturn(set);
210 when(oldBridge.getProtocolsColumn()).thenReturn(column1);
211 when(column.getData()).thenReturn(map);
212 when(bridge.getProtocolsColumn()).thenReturn(column1);
213 List<InstanceIdentifier<ProtocolEntry>> resultProtocolEntry = Whitebox.invokeMethod(ovsdbBridgeUpdateCommand,
214 "protocolEntriesToRemove", bridgeIid, bridge);
215 assertEquals(ArrayList.class, resultProtocolEntry.getClass());
216 verify(oldBridge, times(2)).getProtocolsColumn();
219 @SuppressWarnings("unchecked")
221 public void testBuildConnectionNode() throws Exception {
222 NodeBuilder connectionNode = mock(NodeBuilder.class);
223 PowerMockito.whenNew(NodeBuilder.class).withNoArguments().thenReturn(connectionNode);
224 OvsdbConnectionInstance ovsdbConnectionInstance = mock(OvsdbConnectionInstance.class);
225 when(ovsdbBridgeUpdateCommand.getOvsdbConnectionInstance()).thenReturn(ovsdbConnectionInstance);
226 when(ovsdbConnectionInstance.getNodeId()).thenReturn(mock(NodeId.class));
227 when(connectionNode.setNodeId(any(NodeId.class))).thenReturn(connectionNode);
229 OvsdbNodeAugmentationBuilder ovsdbConnectionAugmentationBuilder = mock(OvsdbNodeAugmentationBuilder.class);
230 PowerMockito.whenNew(OvsdbNodeAugmentationBuilder.class).withNoArguments()
231 .thenReturn(ovsdbConnectionAugmentationBuilder);
232 PowerMockito.mockStatic(SouthboundMapper.class);
233 InstanceIdentifier<Node> bridgeIid = mock(InstanceIdentifier.class);
234 when(SouthboundMapper.createInstanceIdentifier(any(InstanceIdentifierCodec.class),
235 any(OvsdbConnectionInstance.class), any(Bridge.class)))
236 .thenReturn(bridgeIid);
237 ManagedNodeEntry managedBridge = mock(ManagedNodeEntry.class);
238 ManagedNodeEntryBuilder managedNodeEntryBuilder = mock(ManagedNodeEntryBuilder.class);
239 PowerMockito.whenNew(ManagedNodeEntryBuilder.class).withNoArguments().thenReturn(managedNodeEntryBuilder);
240 PowerMockito.whenNew(OvsdbBridgeRef.class).withAnyArguments().thenReturn(mock(OvsdbBridgeRef.class));
241 when(managedNodeEntryBuilder.setBridgeRef(any(OvsdbBridgeRef.class))).thenReturn(managedNodeEntryBuilder);
242 when(managedNodeEntryBuilder.build()).thenReturn(managedBridge);
243 when(ovsdbConnectionAugmentationBuilder.setManagedNodeEntry(any(List.class)))
244 .thenReturn(ovsdbConnectionAugmentationBuilder);
246 when(ovsdbConnectionAugmentationBuilder.build()).thenReturn(mock(OvsdbNodeAugmentation.class));
247 when(connectionNode.addAugmentation(eq(OvsdbNodeAugmentation.class), any(OvsdbNodeAugmentation.class)))
248 .thenReturn(connectionNode);
251 List<ManagedNodeEntry> value = new ArrayList<>();
252 value.add(managedBridge);
253 when(ovsdbConnectionAugmentationBuilder.getManagedNodeEntry()).thenReturn(value);
255 Node node = mock(Node.class);
256 when(connectionNode.build()).thenReturn(node);
257 Bridge bridge = mock(Bridge.class);
258 assertEquals(node, Whitebox.invokeMethod(ovsdbBridgeUpdateCommand, "buildConnectionNode", bridge));
262 public void testBuildBridgeNode() throws Exception {
263 NodeBuilder bridgeNodeBuilder = mock(NodeBuilder.class);
264 PowerMockito.whenNew(NodeBuilder.class).withNoArguments().thenReturn(bridgeNodeBuilder);
265 //suppress call to getNodeId()
266 MemberModifier.suppress(MemberMatcher.method(OvsdbBridgeUpdateCommand.class, "getNodeId", Bridge.class));
267 when(bridgeNodeBuilder.setNodeId(any(NodeId.class))).thenReturn(bridgeNodeBuilder);
268 OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder = mock(OvsdbBridgeAugmentationBuilder.class);
269 PowerMockito.whenNew(OvsdbBridgeAugmentationBuilder.class).withNoArguments()
270 .thenReturn(ovsdbBridgeAugmentationBuilder);
271 Bridge bridge = mock(Bridge.class);
272 when(bridge.getName()).thenReturn("bridge name");
273 PowerMockito.whenNew(OvsdbBridgeName.class).withAnyArguments().thenReturn(mock(OvsdbBridgeName.class));
274 when(ovsdbBridgeAugmentationBuilder.setBridgeName(any(OvsdbBridgeName.class)))
275 .thenReturn(ovsdbBridgeAugmentationBuilder);
276 when(bridge.getUuid()).thenReturn(mock(UUID.class));
277 PowerMockito.whenNew(Uuid.class).withAnyArguments().thenReturn(mock(Uuid.class));
278 when(ovsdbBridgeAugmentationBuilder.setBridgeUuid(any(Uuid.class))).thenReturn(ovsdbBridgeAugmentationBuilder);
280 //suppress calls to the set methods
281 MemberModifier.suppress(MemberMatcher.method(OvsdbBridgeUpdateCommand.class, "setDataPath",
282 OvsdbBridgeAugmentationBuilder.class, Bridge.class));
283 MemberModifier.suppress(MemberMatcher.method(OvsdbBridgeUpdateCommand.class, "setDataPathType",
284 OvsdbBridgeAugmentationBuilder.class, Bridge.class));
285 MemberModifier.suppress(MemberMatcher.method(OvsdbBridgeUpdateCommand.class, "setProtocol",
286 OvsdbBridgeAugmentationBuilder.class, Bridge.class));
287 MemberModifier.suppress(MemberMatcher.method(OvsdbBridgeUpdateCommand.class, "setExternalIds",
288 OvsdbBridgeAugmentationBuilder.class, Bridge.class));
289 MemberModifier.suppress(MemberMatcher.method(OvsdbBridgeUpdateCommand.class, "setOtherConfig",
290 OvsdbBridgeAugmentationBuilder.class, Bridge.class));
291 MemberModifier.suppress(MemberMatcher.method(OvsdbBridgeUpdateCommand.class, "setFailMode",
292 OvsdbBridgeAugmentationBuilder.class, Bridge.class));
293 MemberModifier.suppress(MemberMatcher.method(OvsdbBridgeUpdateCommand.class, "setOpenFlowNodeRef",
294 OvsdbBridgeAugmentationBuilder.class, Bridge.class));
295 MemberModifier.suppress(MemberMatcher.method(OvsdbBridgeUpdateCommand.class, "setManagedBy",
296 OvsdbBridgeAugmentationBuilder.class));
298 when(ovsdbBridgeAugmentationBuilder.build()).thenReturn(mock(OvsdbBridgeAugmentation.class));
299 when(bridgeNodeBuilder.addAugmentation(eq(OvsdbBridgeAugmentation.class), any(OvsdbBridgeAugmentation.class)))
300 .thenReturn(bridgeNodeBuilder);
301 Node node = mock(Node.class);
302 when(bridgeNodeBuilder.build()).thenReturn(node);
303 assertEquals(node, Whitebox.invokeMethod(ovsdbBridgeUpdateCommand, "buildBridgeNode", bridge));
306 @SuppressWarnings("unchecked")
308 public void testSetManagedByAndSetDataPathType() throws Exception {
309 OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder = mock(OvsdbBridgeAugmentationBuilder.class);
311 OvsdbConnectionInstance ovsdbConnectionInstance = mock(OvsdbConnectionInstance.class);
312 when(ovsdbBridgeUpdateCommand.getOvsdbConnectionInstance()).thenReturn(ovsdbConnectionInstance);
313 when(ovsdbConnectionInstance.getInstanceIdentifier()).thenReturn(mock(InstanceIdentifier.class));
314 PowerMockito.whenNew(OvsdbNodeRef.class).withAnyArguments().thenReturn(mock(OvsdbNodeRef.class));
315 when(ovsdbBridgeAugmentationBuilder.setManagedBy(any(OvsdbNodeRef.class)))
316 .thenReturn(ovsdbBridgeAugmentationBuilder);
317 Whitebox.invokeMethod(ovsdbBridgeUpdateCommand, "setManagedBy", ovsdbBridgeAugmentationBuilder);
318 verify(ovsdbBridgeAugmentationBuilder).setManagedBy(any(OvsdbNodeRef.class));
319 verify(ovsdbConnectionInstance).getInstanceIdentifier();
322 @SuppressWarnings("unchecked")
324 public void testSetDataPathType() throws Exception {
325 Bridge bridge = mock(Bridge.class);
326 Column<GenericTableSchema, String> column = mock(Column.class);
327 when(bridge.getDatapathTypeColumn()).thenReturn(column);
328 when(column.getData()).thenReturn("system");
329 PowerMockito.mockStatic(SouthboundMapper.class);
330 when(SouthboundMapper.createDatapathType(anyString()))
331 .thenAnswer((Answer<Class<? extends DatapathTypeBase>>) invocation -> DatapathTypeSystem.class);
332 OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder = mock(OvsdbBridgeAugmentationBuilder.class);
333 when(ovsdbBridgeAugmentationBuilder.setDatapathType(any(Class.class)))
334 .thenReturn(ovsdbBridgeAugmentationBuilder);
335 Whitebox.invokeMethod(ovsdbBridgeUpdateCommand, "setDataPathType", ovsdbBridgeAugmentationBuilder, bridge);
336 verify(bridge).getDatapathTypeColumn();
337 verify(column).getData();
338 verify(ovsdbBridgeAugmentationBuilder).setDatapathType(any(Class.class));
341 @SuppressWarnings("unchecked")
343 public void testSetFailMode() throws Exception {
344 Bridge bridge = mock(Bridge.class);
345 Column<GenericTableSchema, Set<String>> column = mock(Column.class);
346 when(bridge.getFailModeColumn()).thenReturn(column);
347 Set<String> set = new HashSet<>();
348 set.add("standalone");
349 when(column.getData()).thenReturn(set);
350 OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder = mock(OvsdbBridgeAugmentationBuilder.class);
351 when(ovsdbBridgeAugmentationBuilder.setFailMode(OvsdbFailModeStandalone.class))
352 .thenReturn(ovsdbBridgeAugmentationBuilder);
353 Whitebox.invokeMethod(ovsdbBridgeUpdateCommand, "setFailMode", ovsdbBridgeAugmentationBuilder, bridge);
354 verify(bridge, times(5)).getFailModeColumn();
355 verify(ovsdbBridgeAugmentationBuilder).setFailMode(OvsdbFailModeStandalone.class);
358 @SuppressWarnings("unchecked")
360 public void testSetOtherConfig() throws Exception {
361 Bridge bridge = mock(Bridge.class);
362 Column<GenericTableSchema, Map<String, String>> column = mock(Column.class);
363 when(bridge.getOtherConfigColumn()).thenReturn(column);
364 Map<String, String> map = new HashMap<>();
365 map.put("key", "value");
366 when(column.getData()).thenReturn(map);
368 BridgeOtherConfigsBuilder bridgeOtherConfigsBuilder = mock(BridgeOtherConfigsBuilder.class);
369 PowerMockito.whenNew(BridgeOtherConfigsBuilder.class).withNoArguments().thenReturn(bridgeOtherConfigsBuilder);
370 when(bridgeOtherConfigsBuilder.setBridgeOtherConfigKey(anyString())).thenReturn(bridgeOtherConfigsBuilder);
371 when(bridgeOtherConfigsBuilder.setBridgeOtherConfigValue(anyString())).thenReturn(bridgeOtherConfigsBuilder);
372 when(bridgeOtherConfigsBuilder.build()).thenReturn(mock(BridgeOtherConfigs.class));
374 OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder = mock(OvsdbBridgeAugmentationBuilder.class);
375 when(ovsdbBridgeAugmentationBuilder.setBridgeOtherConfigs(any(List.class)))
376 .thenReturn(ovsdbBridgeAugmentationBuilder);
377 Whitebox.invokeMethod(ovsdbBridgeUpdateCommand, "setOtherConfig", ovsdbBridgeAugmentationBuilder, bridge);
378 verify(bridge).getOtherConfigColumn();
379 verify(bridgeOtherConfigsBuilder).setBridgeOtherConfigKey(anyString());
380 verify(bridgeOtherConfigsBuilder).setBridgeOtherConfigValue(anyString());
383 @SuppressWarnings("unchecked")
385 public void testSetExternalIds() throws Exception {
386 Bridge bridge = mock(Bridge.class);
387 Column<GenericTableSchema, Map<String, String>> column = mock(Column.class);
388 when(bridge.getExternalIdsColumn()).thenReturn(column);
389 Map<String, String> map = new HashMap<>();
390 map.put("key", "value");
391 when(column.getData()).thenReturn(map);
393 BridgeExternalIdsBuilder bridgeExternalIdsBuilder = mock(BridgeExternalIdsBuilder.class);
394 PowerMockito.whenNew(BridgeExternalIdsBuilder.class).withNoArguments().thenReturn(bridgeExternalIdsBuilder);
395 when(bridgeExternalIdsBuilder.setBridgeExternalIdKey(anyString())).thenReturn(bridgeExternalIdsBuilder);
396 when(bridgeExternalIdsBuilder.setBridgeExternalIdValue(anyString())).thenReturn(bridgeExternalIdsBuilder);
397 when(bridgeExternalIdsBuilder.build()).thenReturn(mock(BridgeExternalIds.class));
399 OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder = mock(OvsdbBridgeAugmentationBuilder.class);
400 when(ovsdbBridgeAugmentationBuilder.setBridgeOtherConfigs(any(List.class)))
401 .thenReturn(ovsdbBridgeAugmentationBuilder);
402 Whitebox.invokeMethod(ovsdbBridgeUpdateCommand, "setExternalIds", ovsdbBridgeAugmentationBuilder, bridge);
403 verify(bridge).getExternalIdsColumn();
404 verify(bridgeExternalIdsBuilder).setBridgeExternalIdKey(anyString());
405 verify(bridgeExternalIdsBuilder).setBridgeExternalIdValue(anyString());
408 @SuppressWarnings("unchecked")
410 public void testSetProtocolAndSetDataPath() throws Exception {
411 PowerMockito.mockStatic(SouthboundMapper.class);
414 List<ProtocolEntry> listProtocolEntry = new ArrayList<>();
415 listProtocolEntry.add(mock(ProtocolEntry.class));
416 when(SouthboundMapper.createMdsalProtocols(any(Bridge.class))).thenReturn(listProtocolEntry);
417 OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder = mock(OvsdbBridgeAugmentationBuilder.class);
418 Bridge bridge = mock(Bridge.class);
419 when(ovsdbBridgeAugmentationBuilder.setProtocolEntry(any(List.class)))
420 .thenReturn(ovsdbBridgeAugmentationBuilder);
421 Whitebox.invokeMethod(ovsdbBridgeUpdateCommand, "setProtocol", ovsdbBridgeAugmentationBuilder, bridge);
422 verify(ovsdbBridgeAugmentationBuilder).setProtocolEntry(any(List.class));
426 DatapathId dpid = mock(DatapathId.class);
427 when(SouthboundMapper.createDatapathId(any(Bridge.class))).thenReturn(dpid);
428 when(ovsdbBridgeAugmentationBuilder.setDatapathId(any(DatapathId.class)))
429 .thenReturn(ovsdbBridgeAugmentationBuilder);
430 Whitebox.invokeMethod(ovsdbBridgeUpdateCommand, "setDataPath", ovsdbBridgeAugmentationBuilder, bridge);
431 verify(ovsdbBridgeAugmentationBuilder).setDatapathId(any(DatapathId.class));
434 @SuppressWarnings("unchecked")
436 public void testSetOpenFlowNodeRef() throws Exception {
437 PowerMockito.mockStatic(SouthboundMapper.class);
439 when(ovsdbBridgeUpdateCommand.getUpdates()).thenReturn(mock(TableUpdates.class));
440 when(ovsdbBridgeUpdateCommand.getDbSchema()).thenReturn(mock(DatabaseSchema.class));
441 PowerMockito.mockStatic(TyperUtils.class);
442 Map<UUID, Controller> updatedControllerRows = new HashMap<>();
443 when(TyperUtils.extractRowsUpdated(eq(Controller.class), any(TableUpdates.class), any(DatabaseSchema.class)))
444 .thenReturn(updatedControllerRows);
446 List<ControllerEntry> controllerEntryList = new ArrayList<>();
447 ControllerEntry controllerEntry = mock(ControllerEntry.class);
448 controllerEntryList.add(controllerEntry);
449 when(SouthboundMapper.createControllerEntries(any(Bridge.class), any(Map.class)))
450 .thenReturn(controllerEntryList);
451 when(controllerEntry.isIsConnected()).thenReturn(true);
452 Uri uri = mock(Uri.class);
453 when(controllerEntry.getTarget()).thenReturn(uri);
454 when(uri.getValue()).thenReturn("tcp:192.168.12.56:6633");
456 PowerMockito.mockStatic(NetworkInterface.class);
457 NetworkInterface networkInterface = PowerMockito.mock(NetworkInterface.class);
458 when(networkInterface.getInetAddresses()).thenReturn(Iterators.asEnumeration(
459 Iterators.singletonIterator(InetAddresses.forString("192.168.12.56"))));
460 when(NetworkInterface.getNetworkInterfaces()).thenReturn(Iterators.asEnumeration(
461 Iterators.singletonIterator(networkInterface)));
463 OvsdbConnectionInstance ovsdbConnectionInstance = mock(OvsdbConnectionInstance.class);
464 when(ovsdbBridgeUpdateCommand.getOvsdbConnectionInstance()).thenReturn(ovsdbConnectionInstance);
465 when(ovsdbConnectionInstance.getInstanceIdentifier()).thenReturn(mock(InstanceIdentifier.class));
466 OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder = mock(OvsdbBridgeAugmentationBuilder.class);
467 Bridge bridge = mock(Bridge.class);
468 when(ovsdbBridgeAugmentationBuilder.setBridgeOpenflowNodeRef(any(InstanceIdentifier.class)))
469 .thenReturn(ovsdbBridgeAugmentationBuilder);
471 Whitebox.invokeMethod(ovsdbBridgeUpdateCommand, "setOpenFlowNodeRef", ovsdbBridgeAugmentationBuilder, bridge);
472 verify(controllerEntry, times(2)).isIsConnected();
473 verify(ovsdbBridgeAugmentationBuilder).setBridgeOpenflowNodeRef(any(InstanceIdentifier.class));