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;
20 import static org.powermock.api.support.membermodification.MemberMatcher.field;
21 import static org.powermock.api.support.membermodification.MemberMatcher.method;
22 import static org.powermock.api.support.membermodification.MemberModifier.suppress;
24 import com.google.common.base.Optional;
25 import com.google.common.util.concurrent.CheckedFuture;
26 import java.util.AbstractMap.SimpleEntry;
27 import java.util.ArrayList;
28 import java.util.HashMap;
29 import java.util.HashSet;
30 import java.util.List;
32 import java.util.Map.Entry;
34 import org.junit.Before;
35 import org.junit.Ignore;
36 import org.junit.Test;
37 import org.junit.runner.RunWith;
38 import org.mockito.Matchers;
39 import org.mockito.Mockito;
40 import org.mockito.invocation.InvocationOnMock;
41 import org.mockito.stubbing.Answer;
42 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
43 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
44 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
45 import org.opendaylight.ovsdb.lib.message.TableUpdates;
46 import org.opendaylight.ovsdb.lib.notation.Column;
47 import org.opendaylight.ovsdb.lib.notation.UUID;
48 import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
49 import org.opendaylight.ovsdb.lib.schema.GenericTableSchema;
50 import org.opendaylight.ovsdb.lib.schema.typed.TyperUtils;
51 import org.opendaylight.ovsdb.schema.openvswitch.Bridge;
52 import org.opendaylight.ovsdb.schema.openvswitch.Interface;
53 import org.opendaylight.ovsdb.schema.openvswitch.Port;
54 import org.opendaylight.ovsdb.southbound.InstanceIdentifierCodec;
55 import org.opendaylight.ovsdb.southbound.OvsdbConnectionInstance;
56 import org.opendaylight.ovsdb.southbound.SouthboundConstants;
57 import org.opendaylight.ovsdb.southbound.SouthboundMapper;
58 import org.opendaylight.ovsdb.southbound.SouthboundUtil;
59 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
60 import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId;
61 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeBase;
62 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeInternal;
63 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
64 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeRef;
65 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
66 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbPortInterfaceAttributes;
67 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbPortInterfaceAttributes.VlanMode;
68 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
69 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentationBuilder;
70 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntry;
71 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIds;
72 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIdsBuilder;
73 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceOtherConfigs;
74 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceOtherConfigsBuilder;
75 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortExternalIds;
76 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortExternalIdsBuilder;
77 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortOtherConfigs;
78 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortOtherConfigsBuilder;
79 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.TrunksBuilder;
80 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
81 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
82 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TpId;
83 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
84 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
85 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
86 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
87 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
88 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointBuilder;
89 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
90 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
91 import org.powermock.api.mockito.PowerMockito;
92 import org.powermock.api.support.membermodification.MemberMatcher;
93 import org.powermock.api.support.membermodification.MemberModifier;
94 import org.powermock.core.classloader.annotations.PrepareForTest;
95 import org.powermock.modules.junit4.PowerMockRunner;
96 import org.powermock.reflect.Whitebox;
98 @RunWith(PowerMockRunner.class)
99 @PrepareForTest({TyperUtils.class, OvsdbPortUpdateCommand.class, SouthboundUtil.class, SouthboundMapper.class})
100 public class OvsdbPortUpdateCommandTest {
102 private static final String OTHER_CONFIG_KEY = "key";
103 private static final String OTHER_CONFIG_VALUE = "value";
104 private static final String EXTERNAL_ID_KEY = "key";
105 private static final String EXTERNAL_ID_VALUE = "value";
106 private static final String INTERFACE_NAME = "interface_name";
107 private static final String VLAN_MODE_ACCESS = "access";
108 private static final String OVSDB_INTERFACE_TYPE = "internal";
109 private static final String PORT_NAME = "port_name";
110 private static final String TP_NAME = "tp_name";
111 private static final String TERMINATION_POINT_NAME = "termination_point_name";
113 private Map<UUID, Port> portUpdatedRows;
114 private Map<UUID, Port> portOldRows;
115 private Map<UUID, Interface> ifUpdatedRows;
116 private Map<UUID, Interface> interfaceOldRows;
117 private Map<UUID, Bridge> bridgeUpdatedRows;
118 private OvsdbPortUpdateCommand ovsdbPortUpdateCommand;
121 public void setUp() throws Exception {
122 ovsdbPortUpdateCommand = PowerMockito.mock(OvsdbPortUpdateCommand.class, Mockito.CALLS_REAL_METHODS);
126 public void testOvsdbPortUpdateCommand() throws Exception {
127 TableUpdates updates = mock(TableUpdates.class);
128 DatabaseSchema dbSchema = mock(DatabaseSchema.class);
130 PowerMockito.mockStatic(TyperUtils.class);
131 PowerMockito.when(TyperUtils.extractRowsUpdated(Port.class, updates, dbSchema)).thenReturn(portUpdatedRows);
132 PowerMockito.when(TyperUtils.extractRowsOld(Port.class, updates, dbSchema)).thenReturn(portOldRows);
133 PowerMockito.when(TyperUtils.extractRowsUpdated(Interface.class, updates, dbSchema)).thenReturn(ifUpdatedRows);
134 PowerMockito.when(TyperUtils.extractRowsOld(Interface.class, updates, dbSchema)).thenReturn(interfaceOldRows);
135 PowerMockito.when(TyperUtils.extractRowsUpdated(Bridge.class, updates, dbSchema)).thenReturn(bridgeUpdatedRows);
137 OvsdbConnectionInstance key = mock(OvsdbConnectionInstance.class);
138 OvsdbPortUpdateCommand ovsdbPortUpdateCommand1 =
139 new OvsdbPortUpdateCommand(mock(InstanceIdentifierCodec.class), key, updates, dbSchema);
140 assertEquals(portUpdatedRows, Whitebox.getInternalState(ovsdbPortUpdateCommand1, "portUpdatedRows"));
141 assertEquals(portOldRows, Whitebox.getInternalState(ovsdbPortUpdateCommand1, "portOldRows"));
142 assertEquals(dbSchema, Whitebox.getInternalState(ovsdbPortUpdateCommand1, "dbSchema"));
145 @SuppressWarnings("unchecked")
147 public void testExecute() throws Exception {
148 portUpdatedRows = new HashMap<>();
149 interfaceOldRows = new HashMap<>();
150 portUpdatedRows.put(mock(UUID.class), mock(Port.class));
151 interfaceOldRows.put(mock(UUID.class), mock(Interface.class));
152 field(OvsdbPortUpdateCommand.class, "portUpdatedRows").set(ovsdbPortUpdateCommand, portUpdatedRows);
153 field(OvsdbPortUpdateCommand.class, "interfaceOldRows").set(ovsdbPortUpdateCommand, interfaceOldRows);
155 OvsdbConnectionInstance ovsdbConnectionInstance = mock(OvsdbConnectionInstance.class);
156 when(ovsdbPortUpdateCommand.getOvsdbConnectionInstance()).thenReturn(ovsdbConnectionInstance);
157 InstanceIdentifier<Node> connectionIId = mock(InstanceIdentifier.class);
158 when(ovsdbConnectionInstance.getInstanceIdentifier()).thenReturn(connectionIId);
160 //case 1: portUpdatedRows & interfaceOldRows not null, not empty
161 Optional<Node> node = Optional.of(mock(Node.class));
162 PowerMockito.doReturn(node).when(ovsdbPortUpdateCommand, "readNode", any(ReadWriteTransaction.class),
163 any(InstanceIdentifier.class));
164 doNothing().when(ovsdbPortUpdateCommand).updateTerminationPoints(any(ReadWriteTransaction.class),
166 ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
167 ovsdbPortUpdateCommand.execute(transaction);
168 verify(ovsdbConnectionInstance).getInstanceIdentifier();
169 verify(ovsdbPortUpdateCommand).updateTerminationPoints(any(ReadWriteTransaction.class), any(Node.class));
173 @SuppressWarnings("unchecked")
174 public void testUpdateTerminationPoints() throws Exception {
175 portUpdatedRows = new HashMap<>();
176 Port port = mock(Port.class);
177 UUID uuid = mock(UUID.class);
178 portUpdatedRows.put(uuid, port);
179 field(OvsdbPortUpdateCommand.class, "portUpdatedRows").set(ovsdbPortUpdateCommand, portUpdatedRows);
180 Column<GenericTableSchema, String> bridgeColumn = mock(Column.class);
181 when(port.getNameColumn()).thenReturn(bridgeColumn);
182 when(bridgeColumn.getData()).thenReturn(TERMINATION_POINT_NAME);
184 InstanceIdentifier<Node> nodeIid = InstanceIdentifier.create(NetworkTopology.class)
185 .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
186 .child(Node.class, new NodeKey(new NodeId("nodeId")));
188 Optional<InstanceIdentifier<Node>> bridgeIid = Optional.of(nodeIid);
189 PowerMockito.doReturn(bridgeIid).when(ovsdbPortUpdateCommand, "getTerminationPointBridge", any(UUID.class));
191 NodeId bridgeId = mock(NodeId.class);
192 PowerMockito.mockStatic(SouthboundMapper.class);
193 PowerMockito.when(SouthboundMapper.createManagedNodeId(any(InstanceIdentifier.class))).thenReturn(bridgeId);
195 PowerMockito.whenNew(TpId.class).withAnyArguments().thenReturn(mock(TpId.class));
196 TerminationPointKey tpKey = mock(TerminationPointKey.class);
197 PowerMockito.whenNew(TerminationPointKey.class).withAnyArguments().thenReturn(tpKey);
198 TerminationPointBuilder tpBuilder = mock(TerminationPointBuilder.class);
199 PowerMockito.whenNew(TerminationPointBuilder.class).withNoArguments().thenReturn(tpBuilder);
200 when(tpBuilder.withKey(any(TerminationPointKey.class))).thenReturn(tpBuilder);
201 when(tpKey.getTpId()).thenReturn(mock(TpId.class));
202 when(tpBuilder.setTpId(any(TpId.class))).thenReturn(tpBuilder);
203 InstanceIdentifier<TerminationPoint> tpPath = mock(InstanceIdentifier.class);
204 PowerMockito.doReturn(tpPath).when(ovsdbPortUpdateCommand, "getInstanceIdentifier",
205 any(InstanceIdentifier.class), any(Port.class));
207 OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder = mock(
208 OvsdbTerminationPointAugmentationBuilder.class);
209 PowerMockito.whenNew(OvsdbTerminationPointAugmentationBuilder.class).withNoArguments()
210 .thenReturn(tpAugmentationBuilder);
211 PowerMockito.suppress(MemberMatcher.method(OvsdbPortUpdateCommand.class, "buildTerminationPoint",
212 ReadWriteTransaction.class, InstanceIdentifier.class, OvsdbTerminationPointAugmentationBuilder.class,
213 Node.class, Entry.class));
215 Column<GenericTableSchema, Set<UUID>> interfacesColumn = mock(Column.class);
216 when(port.getInterfacesColumn()).thenReturn(interfacesColumn);
217 Set<UUID> uuids = new HashSet<>();
218 UUID uuid2 = mock(UUID.class);
220 when(interfacesColumn.getData()).thenReturn(uuids);
222 ifUpdatedRows = new HashMap<>();
223 interfaceOldRows = new HashMap<>();
224 Interface iface = mock(Interface.class);
225 ifUpdatedRows.put(uuid2, iface);
226 Interface interfaceUpdate = mock(Interface.class);
227 ifUpdatedRows.put(uuid, interfaceUpdate);
228 interfaceOldRows.put(uuid2, iface);
229 field(OvsdbPortUpdateCommand.class, "interfaceUpdatedRows").set(ovsdbPortUpdateCommand, ifUpdatedRows);
230 field(OvsdbPortUpdateCommand.class, "interfaceOldRows").set(ovsdbPortUpdateCommand, interfaceOldRows);
231 PowerMockito.suppress(MemberMatcher.method(OvsdbPortUpdateCommand.class, "buildTerminationPoint",
232 OvsdbTerminationPointAugmentationBuilder.class, Interface.class));
234 when(tpAugmentationBuilder.build()).thenReturn(mock(OvsdbTerminationPointAugmentation.class));
235 when(tpBuilder.addAugmentation(eq(OvsdbTerminationPointAugmentation.class),
236 any(OvsdbTerminationPointAugmentation.class))).thenReturn(tpBuilder);
237 when(tpBuilder.build()).thenReturn(mock(TerminationPoint.class));
238 portOldRows = new HashMap<>();
239 portOldRows.put(uuid, port);
240 MemberModifier.field(OvsdbPortUpdateCommand.class, "portOldRows").set(ovsdbPortUpdateCommand, portOldRows);
241 ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
242 doNothing().when(transaction).merge(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
243 any(TerminationPoint.class));
244 doNothing().when(transaction).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
245 any(TerminationPoint.class));
247 Column<GenericTableSchema, String> interfaceColumn = mock(Column.class);
248 when(interfaceUpdate.getNameColumn()).thenReturn(interfaceColumn);
249 when(interfaceColumn.getData()).thenReturn(INTERFACE_NAME);
251 PowerMockito.doReturn(bridgeIid).when(ovsdbPortUpdateCommand, "getTerminationPointBridge",
252 any(ReadWriteTransaction.class), any(Node.class), anyString());
253 PowerMockito.when(SouthboundMapper.createManagedNodeId(any(InstanceIdentifier.class))).thenReturn(bridgeId);
254 PowerMockito.whenNew(TopologyKey.class).withAnyArguments().thenReturn(mock(TopologyKey.class));
255 PowerMockito.whenNew(NodeKey.class).withAnyArguments().thenReturn(mock(NodeKey.class));
257 Node node = mock(Node.class);
258 Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updateTerminationPoints", transaction, node);
259 verify(ovsdbPortUpdateCommand).getInstanceIdentifier(any(InstanceIdentifier.class),
261 verify(transaction, times(2)).merge(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
262 any(TerminationPoint.class));
266 @SuppressWarnings("unchecked")
267 public void testBuildTerminationPoint() throws Exception {
268 Port portUpdate = mock(Port.class);
269 Entry<UUID,Port> portEntry = mock(Entry.class);
270 when(portEntry.getValue()).thenReturn(mock(Port.class));
271 when(portEntry.getValue().getName()).thenReturn(PORT_NAME);
272 when(portEntry.getValue().getUuid()).thenReturn(mock(UUID.class));
273 when(portUpdate.getName()).thenReturn(PORT_NAME);
274 when(portUpdate.getUuid()).thenReturn(mock(UUID.class));
275 PowerMockito.whenNew(Uuid.class).withAnyArguments().thenReturn(mock(Uuid.class));
277 OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder = mock(
278 OvsdbTerminationPointAugmentationBuilder.class);
280 when(tpAugmentationBuilder.setName(anyString())).thenReturn(tpAugmentationBuilder);
281 when(tpAugmentationBuilder.setPortUuid(any(Uuid.class))).thenReturn(tpAugmentationBuilder);
282 doNothing().when(ovsdbPortUpdateCommand).updatePort(any(ReadWriteTransaction.class),
283 any(Node.class), any(InstanceIdentifier.class), any(Entry.class),
284 any(OvsdbTerminationPointAugmentationBuilder.class));
286 Node node = mock(Node.class);
287 ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
288 InstanceIdentifier<TerminationPoint> tpPath = mock(InstanceIdentifier.class);
290 Whitebox.invokeMethod(ovsdbPortUpdateCommand, "buildTerminationPoint", transaction, tpPath,
291 tpAugmentationBuilder, node, portEntry);
292 verify(tpAugmentationBuilder).setName(anyString());
293 verify(tpAugmentationBuilder).setPortUuid(any(Uuid.class));
294 verify(ovsdbPortUpdateCommand).updatePort(any(ReadWriteTransaction.class),
295 any(Node.class), any(InstanceIdentifier.class), any(Entry.class),
296 any(OvsdbTerminationPointAugmentationBuilder.class));
300 public void testBuildTerminationPoint1() throws Exception {
301 Interface interfaceUpdate = mock(Interface.class);
302 when(interfaceUpdate.getName()).thenReturn(INTERFACE_NAME);
303 when(interfaceUpdate.getUuid()).thenReturn(mock(UUID.class));
304 PowerMockito.whenNew(Uuid.class).withAnyArguments().thenReturn(mock(Uuid.class));
305 OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder = mock(
306 OvsdbTerminationPointAugmentationBuilder.class);
307 when(tpAugmentationBuilder.setName(anyString())).thenReturn(tpAugmentationBuilder);
308 when(tpAugmentationBuilder.setInterfaceUuid(any(Uuid.class))).thenReturn(tpAugmentationBuilder);
310 doNothing().when(ovsdbPortUpdateCommand).updateInterfaces(any(Interface.class),
311 any(OvsdbTerminationPointAugmentationBuilder.class));
313 Whitebox.invokeMethod(ovsdbPortUpdateCommand, "buildTerminationPoint", tpAugmentationBuilder, interfaceUpdate);
314 verify(tpAugmentationBuilder).setName(anyString());
315 verify(tpAugmentationBuilder).setInterfaceUuid(any(Uuid.class));
316 verify(ovsdbPortUpdateCommand).updateInterfaces(any(Interface.class),
317 any(OvsdbTerminationPointAugmentationBuilder.class));
320 @SuppressWarnings("unchecked")
322 public void testReadNode() throws Exception {
323 ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
324 InstanceIdentifier<Node> nodePath = mock(InstanceIdentifier.class);
325 Optional<Node> node = Optional.of(mock(Node.class));
326 CheckedFuture<Optional<Node>, ReadFailedException> checkedFuture = mock(CheckedFuture.class);
327 when(transaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class)))
328 .thenReturn(checkedFuture);
329 when(checkedFuture.checkedGet()).thenReturn(node);
330 assertEquals(node, Whitebox.invokeMethod(ovsdbPortUpdateCommand, "readNode", transaction, nodePath));
333 @SuppressWarnings("unchecked")
335 public void testGetTerminationPointBridge1() throws Exception {
336 Node node = mock(Node.class);
337 OvsdbNodeAugmentation ovsdbNode = mock(OvsdbNodeAugmentation.class);
338 when(node.augmentation(OvsdbNodeAugmentation.class)).thenReturn(ovsdbNode);
339 List<ManagedNodeEntry> managedNodes = new ArrayList<>();
340 ManagedNodeEntry managedNodeEntry = mock(ManagedNodeEntry.class);
341 managedNodes.add(managedNodeEntry);
342 when(ovsdbNode.getManagedNodeEntry()).thenReturn(managedNodes);
344 Node managedNode = mock(Node.class);
345 OvsdbBridgeRef ovsdbBridgeRef = mock(OvsdbBridgeRef.class);
346 when(managedNodeEntry.getBridgeRef()).thenReturn(ovsdbBridgeRef);
347 InstanceIdentifier<Node> iidNode = mock(InstanceIdentifier.class);
348 when((InstanceIdentifier<Node>) ovsdbBridgeRef.getValue()).thenReturn(iidNode);
349 Optional<Node> optionalNode = Optional.of(managedNode);
350 PowerMockito.doReturn(optionalNode).when(ovsdbPortUpdateCommand, "readNode", any(ReadWriteTransaction.class),
351 any(InstanceIdentifier.class));
353 PowerMockito.mockStatic(SouthboundUtil.class);
354 PowerMockito.when(SouthboundUtil.readNode(Matchers.any(ReadWriteTransaction.class),
355 Matchers.any(InstanceIdentifier.class)))
356 .thenReturn(optionalNode);
357 TerminationPointBuilder tpBuilder = mock(TerminationPointBuilder.class);
358 PowerMockito.whenNew(TerminationPointBuilder.class).withNoArguments().thenReturn(tpBuilder);
359 PowerMockito.whenNew(TpId.class).withAnyArguments().thenReturn(mock(TpId.class));
360 PowerMockito.whenNew(TerminationPointKey.class).withAnyArguments().thenReturn(mock(TerminationPointKey.class));
361 when(tpBuilder.withKey(any(TerminationPointKey.class))).thenReturn(tpBuilder);
363 List<TerminationPoint> terminationPointList = new ArrayList<>();
364 TerminationPoint terminationPoint = mock(TerminationPoint.class);
365 terminationPointList.add(terminationPoint);
366 when(tpBuilder.build()).thenReturn(terminationPoint);
367 when(managedNode.getTerminationPoint()).thenReturn(terminationPointList);
369 when(managedNode.augmentation(OvsdbBridgeAugmentation.class))
370 .thenReturn(mock(OvsdbBridgeAugmentation.class));
371 TpId tpId = new TpId(TP_NAME);
372 when(terminationPoint.getTpId()).thenReturn(tpId);
374 Optional<InstanceIdentifier<Node>> testResult = Optional.of(iidNode);
375 ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
376 Optional<InstanceIdentifier<Node>> result = Whitebox.invokeMethod(ovsdbPortUpdateCommand,
377 "getTerminationPointBridge", transaction, node, TP_NAME);
379 assertEquals(testResult, result);
382 @SuppressWarnings("unchecked")
384 public void testUpdateInterfaces() throws Exception {
385 Interface interfaceUpdate = mock(Interface.class);
386 Column<GenericTableSchema, String> typeColumn = mock(Column.class);
387 when(interfaceUpdate.getTypeColumn()).thenReturn(typeColumn);
388 when(typeColumn.getData()).thenReturn(OVSDB_INTERFACE_TYPE);
389 doNothing().when(ovsdbPortUpdateCommand).updateInterface(any(Interface.class), anyString(),
390 any(OvsdbTerminationPointAugmentationBuilder.class));
392 OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder = mock(
393 OvsdbTerminationPointAugmentationBuilder.class);
394 Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updateInterfaces", interfaceUpdate,
395 ovsdbTerminationPointBuilder);
396 verify(ovsdbPortUpdateCommand).updateInterface(any(Interface.class), anyString(),
397 any(OvsdbTerminationPointAugmentationBuilder.class));
401 @SuppressWarnings("unchecked")
402 public void testUpdateInterface() throws Exception {
403 Interface interf = mock(Interface.class);
404 OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder = mock(
405 OvsdbTerminationPointAugmentationBuilder.class);
406 when(interf.getUuid()).thenReturn(mock(UUID.class));
407 PowerMockito.whenNew(Uuid.class).withAnyArguments().thenReturn(mock(Uuid.class));
408 when(ovsdbTerminationPointBuilder.setInterfaceUuid(any(Uuid.class))).thenReturn(ovsdbTerminationPointBuilder);
409 PowerMockito.mockStatic(SouthboundMapper.class);
410 PowerMockito.when(SouthboundMapper.createInterfaceType(Matchers.anyString()))
411 .thenAnswer(new Answer<Class<? extends InterfaceTypeBase>>() {
412 public Class<? extends InterfaceTypeBase> answer(InvocationOnMock invocation) throws Exception {
413 return InterfaceTypeInternal.class;
416 when(ovsdbTerminationPointBuilder.setInterfaceType(any(Class.class))).thenReturn(ovsdbTerminationPointBuilder);
417 suppress(method(OvsdbPortUpdateCommand.class, "updateOfPort", Interface.class,
418 OvsdbTerminationPointAugmentationBuilder.class));
419 suppress(method(OvsdbPortUpdateCommand.class, "updateOfPortRequest", Interface.class,
420 OvsdbTerminationPointAugmentationBuilder.class));
421 suppress(method(OvsdbPortUpdateCommand.class, "updateInterfaceExternalIds", Interface.class,
422 OvsdbTerminationPointAugmentationBuilder.class));
423 suppress(method(OvsdbPortUpdateCommand.class, "updateOptions", Interface.class,
424 OvsdbTerminationPointAugmentationBuilder.class));
425 suppress(method(OvsdbPortUpdateCommand.class, "updateInterfaceOtherConfig", Interface.class,
426 OvsdbTerminationPointAugmentationBuilder.class));
427 suppress(method(OvsdbPortUpdateCommand.class, "updateInterfaceLldp", Interface.class,
428 OvsdbTerminationPointAugmentationBuilder.class));
429 suppress(method(OvsdbPortUpdateCommand.class, "updateInterfaceBfd", Interface.class,
430 OvsdbTerminationPointAugmentationBuilder.class));
431 suppress(method(OvsdbPortUpdateCommand.class, "updateInterfaceBfdStatus", Interface.class,
432 OvsdbTerminationPointAugmentationBuilder.class));
433 suppress(method(OvsdbPortUpdateCommand.class, "updateIfIndex", Interface.class,
434 OvsdbTerminationPointAugmentationBuilder.class));
436 Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updateInterface", interf, OVSDB_INTERFACE_TYPE,
437 ovsdbTerminationPointBuilder);
438 verify(ovsdbTerminationPointBuilder).setInterfaceUuid(any(Uuid.class));
439 verify(ovsdbTerminationPointBuilder).setInterfaceType(any(Class.class));
440 verify(ovsdbPortUpdateCommand).updateOfPort(any(Interface.class),
441 any(OvsdbTerminationPointAugmentationBuilder.class));
442 verify(ovsdbPortUpdateCommand).updateOfPortRequest(any(Interface.class),
443 any(OvsdbTerminationPointAugmentationBuilder.class));
444 verify(ovsdbPortUpdateCommand).updateInterfaceExternalIds(any(Interface.class),
445 any(OvsdbTerminationPointAugmentationBuilder.class));
446 verify(ovsdbPortUpdateCommand).updateOptions(any(Interface.class),
447 any(OvsdbTerminationPointAugmentationBuilder.class));
448 verify(ovsdbPortUpdateCommand).updateInterfaceOtherConfig(any(Interface.class),
449 any(OvsdbTerminationPointAugmentationBuilder.class));
453 @SuppressWarnings("unchecked")
454 public void testUpdatePort() throws Exception {
455 suppress(method(OvsdbPortUpdateCommand.class, "updateVlan", Port.class,
456 OvsdbTerminationPointAugmentationBuilder.class));
457 suppress(method(OvsdbPortUpdateCommand.class, "updateVlanTrunks", Port.class,
458 OvsdbTerminationPointAugmentationBuilder.class));
459 suppress(method(OvsdbPortUpdateCommand.class, "updateVlanMode", Port.class,
460 OvsdbTerminationPointAugmentationBuilder.class));
461 suppress(method(OvsdbPortUpdateCommand.class, "updatePortExternalIds", Port.class,
462 OvsdbTerminationPointAugmentationBuilder.class));
463 suppress(method(OvsdbPortUpdateCommand.class, "updatePortOtherConfig", Port.class,
464 OvsdbTerminationPointAugmentationBuilder.class));
465 suppress(method(OvsdbPortUpdateCommand.class, "updatePortOtherConfig", Port.class,
466 OvsdbTerminationPointAugmentationBuilder.class));
467 suppress(method(OvsdbPortUpdateCommand.class, "updateQos", ReadWriteTransaction.class, Node.class,
468 InstanceIdentifier.class, Entry.class, OvsdbTerminationPointAugmentationBuilder.class));
470 Node node = mock(Node.class);
471 Entry<UUID, Port> port = new SimpleEntry<>(mock(UUID.class), mock(Port.class));
472 OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder = mock(
473 OvsdbTerminationPointAugmentationBuilder.class);
474 ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
475 InstanceIdentifier<TerminationPoint> tpPath = mock(InstanceIdentifier.class);
476 Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updatePort", transaction, node, tpPath, port,
477 ovsdbTerminationPointBuilder);
479 verify(ovsdbPortUpdateCommand).updateVlan(any(Port.class),
480 any(OvsdbTerminationPointAugmentationBuilder.class));
481 verify(ovsdbPortUpdateCommand).updateVlanTrunks(any(Port.class),
482 any(OvsdbTerminationPointAugmentationBuilder.class));
483 verify(ovsdbPortUpdateCommand).updateVlanMode(any(Port.class),
484 any(OvsdbTerminationPointAugmentationBuilder.class));
485 verify(ovsdbPortUpdateCommand).updatePortExternalIds(any(Port.class),
486 any(OvsdbTerminationPointAugmentationBuilder.class));
487 verify(ovsdbPortUpdateCommand).updatePortOtherConfig(any(Port.class),
488 any(OvsdbTerminationPointAugmentationBuilder.class));
491 @SuppressWarnings("unchecked")
493 public void testUpdateVlan() throws Exception {
494 Port port = mock(Port.class);
495 Column<GenericTableSchema, Set<Long>> column = mock(Column.class);
496 when(port.getTagColumn()).thenReturn(column);
497 Set<Long> vlanId = new HashSet<>();
498 vlanId.add((long) 808);
499 when(column.getData()).thenReturn(vlanId);
500 PowerMockito.whenNew(VlanId.class).withAnyArguments().thenReturn(mock(VlanId.class));
501 OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder = mock(
502 OvsdbTerminationPointAugmentationBuilder.class);
503 when(ovsdbTerminationPointBuilder.setVlanTag(any(VlanId.class))).thenReturn(ovsdbTerminationPointBuilder);
504 Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updateVlan", port, ovsdbTerminationPointBuilder);
505 verify(ovsdbTerminationPointBuilder).setVlanTag(any(VlanId.class));
508 @SuppressWarnings("unchecked")
510 public void testUpdateVlanTrunks() throws Exception {
511 Port port = mock(Port.class);
512 Column<GenericTableSchema, Set<Long>> column = mock(Column.class);
513 when(port.getTrunksColumn()).thenReturn(column);
514 Set<Long> portTrunks = new HashSet<>();
515 portTrunks.add((long) 300);
516 when(column.getData()).thenReturn(portTrunks);
518 TrunksBuilder trunksBuilder = mock(TrunksBuilder.class);
519 PowerMockito.whenNew(TrunksBuilder.class).withNoArguments().thenReturn(trunksBuilder);
520 PowerMockito.whenNew(VlanId.class).withAnyArguments().thenReturn(mock(VlanId.class));
521 when(trunksBuilder.setTrunk(any(VlanId.class))).thenReturn(trunksBuilder);
522 OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder = mock(
523 OvsdbTerminationPointAugmentationBuilder.class);
524 when(ovsdbTerminationPointBuilder.setTrunks(any(List.class))).thenReturn(ovsdbTerminationPointBuilder);
525 Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updateVlanTrunks", port, ovsdbTerminationPointBuilder);
526 verify(trunksBuilder).setTrunk(any(VlanId.class));
527 verify(ovsdbTerminationPointBuilder).setTrunks(any(List.class));
530 @SuppressWarnings("unchecked")
532 public void testUpdateVlanMode() throws Exception {
533 Port port = mock(Port.class);
534 Column<GenericTableSchema, Set<String>> column = mock(Column.class);
535 when(port.getVlanModeColumn()).thenReturn(column);
536 Set<String> set = new HashSet<>();
537 set.add(VLAN_MODE_ACCESS);
538 when(column.getData()).thenReturn(set);
539 OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder = mock(
540 OvsdbTerminationPointAugmentationBuilder.class);
541 when(ovsdbTerminationPointBuilder.setVlanMode(OvsdbPortInterfaceAttributes.VlanMode.Access))
542 .thenReturn(ovsdbTerminationPointBuilder);
543 Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updateVlanMode", port, ovsdbTerminationPointBuilder);
544 verify(ovsdbTerminationPointBuilder).setVlanMode(any(VlanMode.class));
547 @SuppressWarnings("unchecked")
549 public void testUpdateOfPort() throws Exception {
550 Interface interf = mock(Interface.class);
551 Set<Long> ofPorts = new HashSet<>();
552 ofPorts.add((long) 10000);
553 Column<GenericTableSchema, Set<Long>> column = mock(Column.class);
554 when(interf.getOpenFlowPortColumn()).thenReturn(column);
555 when(column.getData()).thenReturn(ofPorts);
556 OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder = mock(
557 OvsdbTerminationPointAugmentationBuilder.class);
558 when(ovsdbTerminationPointBuilder.setOfport(any(Long.class))).thenReturn(ovsdbTerminationPointBuilder);
559 when(interf.getName()).thenReturn(INTERFACE_NAME);
560 Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updateOfPort", interf, ovsdbTerminationPointBuilder);
561 verify(ovsdbTerminationPointBuilder).setOfport(any(Long.class));
564 @SuppressWarnings("unchecked")
566 public void testUpdateOfPortRequest() throws Exception {
567 Interface interf = mock(Interface.class);
568 Set<Long> ofPortRequests = new HashSet<>();
569 ofPortRequests.add((long) 10000);
570 Column<GenericTableSchema, Set<Long>> column = mock(Column.class);
571 when(interf.getOpenFlowPortRequestColumn()).thenReturn(column);
572 when(column.getData()).thenReturn(ofPortRequests);
573 OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder = mock(
574 OvsdbTerminationPointAugmentationBuilder.class);
575 when(ovsdbTerminationPointBuilder.setOfportRequest(any(Integer.class)))
576 .thenReturn(ovsdbTerminationPointBuilder);
577 when(interf.getName()).thenReturn(INTERFACE_NAME);
578 Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updateOfPortRequest", interf, ovsdbTerminationPointBuilder);
579 verify(ovsdbTerminationPointBuilder).setOfportRequest(any(Integer.class));
582 @SuppressWarnings("unchecked")
584 public void testUpdateInterfaceExternalIds() throws Exception {
585 Interface interf = mock(Interface.class);
586 Column<GenericTableSchema, Map<String, String>> column = mock(Column.class);
587 when(interf.getExternalIdsColumn()).thenReturn(column);
588 Map<String, String> map = new HashMap<>();
589 when(column.getData()).thenReturn(map);
590 map.put(EXTERNAL_ID_KEY, EXTERNAL_ID_VALUE);
591 when(column.getData()).thenReturn(map);
593 InterfaceExternalIdsBuilder interfaceExternalIdsBuilder = mock(InterfaceExternalIdsBuilder.class);
594 PowerMockito.whenNew(InterfaceExternalIdsBuilder.class).withNoArguments()
595 .thenReturn(interfaceExternalIdsBuilder);
597 when(interfaceExternalIdsBuilder.setExternalIdKey(anyString())).thenReturn(interfaceExternalIdsBuilder);
598 when(interfaceExternalIdsBuilder.setExternalIdValue(anyString())).thenReturn(interfaceExternalIdsBuilder);
599 when(interfaceExternalIdsBuilder.build()).thenReturn(mock(InterfaceExternalIds.class));
600 OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBldr = mock(
601 OvsdbTerminationPointAugmentationBuilder.class);
602 when(ovsdbTerminationPointBldr.setInterfaceExternalIds(any(List.class))).thenReturn(ovsdbTerminationPointBldr);
604 Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updateInterfaceExternalIds", interf, ovsdbTerminationPointBldr);
605 verify(interfaceExternalIdsBuilder).setExternalIdKey(anyString());
606 verify(interfaceExternalIdsBuilder).setExternalIdValue(anyString());
610 @SuppressWarnings("unchecked")
612 public void testUpdatePortExternalIds() throws Exception {
613 Port port = mock(Port.class);
614 Column<GenericTableSchema, Map<String, String>> column = mock(Column.class);
615 when(port.getExternalIdsColumn()).thenReturn(column);
616 Map<String, String> map = new HashMap<>();
617 when(column.getData()).thenReturn(map);
618 map.put(EXTERNAL_ID_KEY, EXTERNAL_ID_VALUE);
619 when(column.getData()).thenReturn(map);
621 PortExternalIdsBuilder portExternalIdsBuilder = mock(PortExternalIdsBuilder.class);
622 PowerMockito.whenNew(PortExternalIdsBuilder.class).withNoArguments().thenReturn(portExternalIdsBuilder);
624 when(portExternalIdsBuilder.setExternalIdKey(anyString())).thenReturn(portExternalIdsBuilder);
625 when(portExternalIdsBuilder.setExternalIdValue(anyString())).thenReturn(portExternalIdsBuilder);
626 when(portExternalIdsBuilder.build()).thenReturn(mock(PortExternalIds.class));
627 OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder = mock(
628 OvsdbTerminationPointAugmentationBuilder.class);
629 when(ovsdbTerminationPointBuilder.setPortExternalIds(any(List.class))).thenReturn(ovsdbTerminationPointBuilder);
631 Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updatePortExternalIds", port, ovsdbTerminationPointBuilder);
632 verify(portExternalIdsBuilder).setExternalIdKey(anyString());
633 verify(portExternalIdsBuilder).setExternalIdValue(anyString());
636 @SuppressWarnings("unchecked")
638 public void testUpdatePortOtherConfig() throws Exception {
639 Port port = mock(Port.class);
640 Column<GenericTableSchema, Map<String, String>> column = mock(Column.class);
641 when(port.getOtherConfigColumn()).thenReturn(column);
642 Map<String, String> map = new HashMap<>();
643 map.put(OTHER_CONFIG_KEY, OTHER_CONFIG_VALUE);
644 when(column.getData()).thenReturn(map);
646 PortOtherConfigsBuilder portOtherConfigsBuilder = mock(PortOtherConfigsBuilder.class);
647 PowerMockito.whenNew(PortOtherConfigsBuilder.class).withNoArguments().thenReturn(portOtherConfigsBuilder);
649 when(portOtherConfigsBuilder.setOtherConfigKey(anyString())).thenReturn(portOtherConfigsBuilder);
650 when(portOtherConfigsBuilder.setOtherConfigValue(anyString())).thenReturn(portOtherConfigsBuilder);
651 when(portOtherConfigsBuilder.build()).thenReturn(mock(PortOtherConfigs.class));
652 OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder = mock(
653 OvsdbTerminationPointAugmentationBuilder.class);
654 when(ovsdbTerminationPointBuilder.setInterfaceOtherConfigs(any(List.class)))
655 .thenReturn(ovsdbTerminationPointBuilder);
657 Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updatePortOtherConfig", port, ovsdbTerminationPointBuilder);
658 verify(portOtherConfigsBuilder).setOtherConfigKey(anyString());
659 verify(portOtherConfigsBuilder).setOtherConfigValue(anyString());
662 @SuppressWarnings("unchecked")
664 public void testUpdateInterfaceOtherConfig() throws Exception {
665 Interface interf = mock(Interface.class);
666 Map<String, String> interfaceOtherConfigMap = new HashMap<>();
667 interfaceOtherConfigMap.put(OTHER_CONFIG_KEY, OTHER_CONFIG_VALUE);
668 Column<GenericTableSchema, Map<String, String>> column = mock(Column.class);
669 when(interf.getOtherConfigColumn()).thenReturn(column);
670 when(column.getData()).thenReturn(interfaceOtherConfigMap);
672 InterfaceOtherConfigsBuilder interfaceOtherConfigsBuilder = mock(InterfaceOtherConfigsBuilder.class);
673 PowerMockito.whenNew(InterfaceOtherConfigsBuilder.class).withNoArguments()
674 .thenReturn(interfaceOtherConfigsBuilder);
676 when(interfaceOtherConfigsBuilder.setOtherConfigKey(anyString())).thenReturn(interfaceOtherConfigsBuilder);
677 when(interfaceOtherConfigsBuilder.setOtherConfigValue(anyString())).thenReturn(interfaceOtherConfigsBuilder);
678 when(interfaceOtherConfigsBuilder.build()).thenReturn(mock(InterfaceOtherConfigs.class));
679 OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder = mock(
680 OvsdbTerminationPointAugmentationBuilder.class);
681 when(ovsdbTerminationPointBuilder.setInterfaceOtherConfigs(any(List.class)))
682 .thenReturn(ovsdbTerminationPointBuilder);
684 Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updateInterfaceOtherConfig", interf,
685 ovsdbTerminationPointBuilder);
686 verify(interfaceOtherConfigsBuilder).setOtherConfigKey(anyString());
687 verify(interfaceOtherConfigsBuilder).setOtherConfigValue(anyString());
690 @SuppressWarnings("unchecked")
692 // TODO This test needs to be re-done
693 @Ignore("Broken mock-based test")
694 public void testGetInstanceIdentifier() throws Exception {
695 Port port = mock(Port.class);
696 Column<GenericTableSchema, Map<String, String>> column = mock(Column.class);
697 when(port.getExternalIdsColumn()).thenReturn(column);
698 Map<String, String> map = new HashMap<>();
699 map.put(SouthboundConstants.IID_EXTERNAL_ID_KEY, "opendaylight-iid");
700 when(column.getData()).thenReturn(map);
702 PowerMockito.mockStatic(SouthboundUtil.class);
703 InstanceIdentifier<TerminationPoint> terminationPointIId = mock(InstanceIdentifier.class);
705 // .when((InstanceIdentifier<TerminationPoint>) SouthboundUtil.deserializeInstanceIdentifier(
706 // any(InstanceIdentifierCodec.class), anyString()))
707 // .thenReturn(terminationPointIId);
708 InstanceIdentifier<Node> bridgeIid = mock(InstanceIdentifier.class);
709 assertEquals(terminationPointIId,
710 Whitebox.invokeMethod(ovsdbPortUpdateCommand, "getInstanceIdentifier", bridgeIid, port));