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.util.concurrent.FluentFuture;
25 import java.util.AbstractMap.SimpleEntry;
26 import java.util.ArrayList;
27 import java.util.HashMap;
28 import java.util.HashSet;
29 import java.util.List;
31 import java.util.Map.Entry;
32 import java.util.Optional;
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.mdsal.binding.api.ReadWriteTransaction;
43 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
44 import org.opendaylight.ovsdb.lib.message.TableUpdates;
45 import org.opendaylight.ovsdb.lib.notation.Column;
46 import org.opendaylight.ovsdb.lib.notation.UUID;
47 import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
48 import org.opendaylight.ovsdb.lib.schema.GenericTableSchema;
49 import org.opendaylight.ovsdb.lib.schema.typed.TyperUtils;
50 import org.opendaylight.ovsdb.schema.openvswitch.Bridge;
51 import org.opendaylight.ovsdb.schema.openvswitch.Interface;
52 import org.opendaylight.ovsdb.schema.openvswitch.Port;
53 import org.opendaylight.ovsdb.southbound.InstanceIdentifierCodec;
54 import org.opendaylight.ovsdb.southbound.OvsdbConnectionInstance;
55 import org.opendaylight.ovsdb.southbound.SouthboundConstants;
56 import org.opendaylight.ovsdb.southbound.SouthboundMapper;
57 import org.opendaylight.ovsdb.southbound.SouthboundUtil;
58 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
59 import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId;
60 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeBase;
61 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeInternal;
62 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
63 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeRef;
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.OvsdbPortInterfaceAttributes;
66 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbPortInterfaceAttributes.VlanMode;
67 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
68 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentationBuilder;
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.port._interface.attributes.InterfaceExternalIds;
71 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIdsBuilder;
72 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceOtherConfigs;
73 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceOtherConfigsBuilder;
74 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortExternalIds;
75 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortExternalIdsBuilder;
76 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortOtherConfigs;
77 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.PortOtherConfigsBuilder;
78 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.TrunksBuilder;
79 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
80 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
81 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TpId;
82 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
83 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
84 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
85 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
86 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
87 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointBuilder;
88 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
89 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
90 import org.powermock.api.mockito.PowerMockito;
91 import org.powermock.api.support.membermodification.MemberMatcher;
92 import org.powermock.api.support.membermodification.MemberModifier;
93 import org.powermock.core.classloader.annotations.PrepareForTest;
94 import org.powermock.modules.junit4.PowerMockRunner;
95 import org.powermock.reflect.Whitebox;
97 @RunWith(PowerMockRunner.class)
98 @PrepareForTest({TyperUtils.class, OvsdbPortUpdateCommand.class, SouthboundUtil.class, SouthboundMapper.class})
99 public class OvsdbPortUpdateCommandTest {
101 private static final String OTHER_CONFIG_KEY = "key";
102 private static final String OTHER_CONFIG_VALUE = "value";
103 private static final String EXTERNAL_ID_KEY = "key";
104 private static final String EXTERNAL_ID_VALUE = "value";
105 private static final String INTERFACE_NAME = "interface_name";
106 private static final String VLAN_MODE_ACCESS = "access";
107 private static final String OVSDB_INTERFACE_TYPE = "internal";
108 private static final String PORT_NAME = "port_name";
109 private static final String TP_NAME = "tp_name";
110 private static final String TERMINATION_POINT_NAME = "termination_point_name";
112 private Map<UUID, Port> portUpdatedRows;
113 private Map<UUID, Port> portOldRows;
114 private Map<UUID, Interface> ifUpdatedRows;
115 private Map<UUID, Interface> interfaceOldRows;
116 private Map<UUID, Bridge> bridgeUpdatedRows;
117 private OvsdbPortUpdateCommand ovsdbPortUpdateCommand;
120 public void setUp() throws Exception {
121 ovsdbPortUpdateCommand = PowerMockito.mock(OvsdbPortUpdateCommand.class, Mockito.CALLS_REAL_METHODS);
125 public void testOvsdbPortUpdateCommand() throws Exception {
126 TableUpdates updates = mock(TableUpdates.class);
127 DatabaseSchema dbSchema = mock(DatabaseSchema.class);
129 PowerMockito.mockStatic(TyperUtils.class);
130 PowerMockito.when(TyperUtils.extractRowsUpdated(Port.class, updates, dbSchema)).thenReturn(portUpdatedRows);
131 PowerMockito.when(TyperUtils.extractRowsOld(Port.class, updates, dbSchema)).thenReturn(portOldRows);
132 PowerMockito.when(TyperUtils.extractRowsUpdated(Interface.class, updates, dbSchema)).thenReturn(ifUpdatedRows);
133 PowerMockito.when(TyperUtils.extractRowsOld(Interface.class, updates, dbSchema)).thenReturn(interfaceOldRows);
134 PowerMockito.when(TyperUtils.extractRowsUpdated(Bridge.class, updates, dbSchema)).thenReturn(bridgeUpdatedRows);
136 OvsdbConnectionInstance key = mock(OvsdbConnectionInstance.class);
137 OvsdbPortUpdateCommand ovsdbPortUpdateCommand1 =
138 new OvsdbPortUpdateCommand(mock(InstanceIdentifierCodec.class), key, updates, dbSchema);
139 assertEquals(portUpdatedRows, Whitebox.getInternalState(ovsdbPortUpdateCommand1, "portUpdatedRows"));
140 assertEquals(portOldRows, Whitebox.getInternalState(ovsdbPortUpdateCommand1, "portOldRows"));
141 assertEquals(dbSchema, Whitebox.getInternalState(ovsdbPortUpdateCommand1, "dbSchema"));
144 @SuppressWarnings("unchecked")
146 public void testExecute() throws Exception {
147 portUpdatedRows = new HashMap<>();
148 interfaceOldRows = new HashMap<>();
149 portUpdatedRows.put(mock(UUID.class), mock(Port.class));
150 interfaceOldRows.put(mock(UUID.class), mock(Interface.class));
151 field(OvsdbPortUpdateCommand.class, "portUpdatedRows").set(ovsdbPortUpdateCommand, portUpdatedRows);
152 field(OvsdbPortUpdateCommand.class, "interfaceOldRows").set(ovsdbPortUpdateCommand, interfaceOldRows);
154 OvsdbConnectionInstance ovsdbConnectionInstance = mock(OvsdbConnectionInstance.class);
155 when(ovsdbPortUpdateCommand.getOvsdbConnectionInstance()).thenReturn(ovsdbConnectionInstance);
156 InstanceIdentifier<Node> connectionIId = mock(InstanceIdentifier.class);
157 when(ovsdbConnectionInstance.getInstanceIdentifier()).thenReturn(connectionIId);
159 //case 1: portUpdatedRows & interfaceOldRows not null, not empty
160 Optional<Node> node = Optional.of(mock(Node.class));
161 PowerMockito.doReturn(node).when(ovsdbPortUpdateCommand, "readNode", any(ReadWriteTransaction.class),
162 any(InstanceIdentifier.class));
163 doNothing().when(ovsdbPortUpdateCommand).updateTerminationPoints(any(ReadWriteTransaction.class),
165 ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
166 PowerMockito.mockStatic(SouthboundUtil.class);
167 PowerMockito.when(SouthboundUtil.readNode(any(ReadWriteTransaction.class), any(InstanceIdentifier.class)))
169 ovsdbPortUpdateCommand.execute(transaction);
170 verify(ovsdbConnectionInstance).getInstanceIdentifier();
171 verify(ovsdbPortUpdateCommand).updateTerminationPoints(any(ReadWriteTransaction.class), any(Node.class));
175 @SuppressWarnings("unchecked")
176 public void testUpdateTerminationPoints() throws Exception {
177 portUpdatedRows = new HashMap<>();
178 Port port = mock(Port.class);
179 UUID uuid = mock(UUID.class);
180 portUpdatedRows.put(uuid, port);
181 field(OvsdbPortUpdateCommand.class, "portUpdatedRows").set(ovsdbPortUpdateCommand, portUpdatedRows);
182 Column<GenericTableSchema, String> bridgeColumn = mock(Column.class);
183 when(port.getNameColumn()).thenReturn(bridgeColumn);
184 when(bridgeColumn.getData()).thenReturn(TERMINATION_POINT_NAME);
186 InstanceIdentifier<Node> nodeIid = InstanceIdentifier.create(NetworkTopology.class)
187 .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
188 .child(Node.class, new NodeKey(new NodeId("nodeId")));
190 Optional<InstanceIdentifier<Node>> bridgeIid = Optional.of(nodeIid);
191 PowerMockito.doReturn(bridgeIid).when(ovsdbPortUpdateCommand, "getTerminationPointBridge", any(UUID.class));
193 NodeId bridgeId = mock(NodeId.class);
194 PowerMockito.mockStatic(SouthboundMapper.class);
195 PowerMockito.when(SouthboundMapper.createManagedNodeId(any(InstanceIdentifier.class))).thenReturn(bridgeId);
197 PowerMockito.whenNew(TpId.class).withAnyArguments().thenReturn(mock(TpId.class));
198 TerminationPointKey tpKey = mock(TerminationPointKey.class);
199 PowerMockito.whenNew(TerminationPointKey.class).withAnyArguments().thenReturn(tpKey);
200 TerminationPointBuilder tpBuilder = mock(TerminationPointBuilder.class);
201 PowerMockito.whenNew(TerminationPointBuilder.class).withNoArguments().thenReturn(tpBuilder);
202 when(tpBuilder.withKey(any(TerminationPointKey.class))).thenReturn(tpBuilder);
203 when(tpKey.getTpId()).thenReturn(mock(TpId.class));
204 when(tpBuilder.setTpId(any(TpId.class))).thenReturn(tpBuilder);
205 InstanceIdentifier<TerminationPoint> tpPath = mock(InstanceIdentifier.class);
206 PowerMockito.doReturn(tpPath).when(ovsdbPortUpdateCommand, "getInstanceIdentifier",
207 any(InstanceIdentifier.class), any(Port.class));
209 OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder = mock(
210 OvsdbTerminationPointAugmentationBuilder.class);
211 PowerMockito.whenNew(OvsdbTerminationPointAugmentationBuilder.class).withNoArguments()
212 .thenReturn(tpAugmentationBuilder);
213 PowerMockito.suppress(MemberMatcher.method(OvsdbPortUpdateCommand.class, "buildTerminationPoint",
214 ReadWriteTransaction.class, InstanceIdentifier.class, OvsdbTerminationPointAugmentationBuilder.class,
215 Node.class, Entry.class));
217 Column<GenericTableSchema, Set<UUID>> interfacesColumn = mock(Column.class);
218 when(port.getInterfacesColumn()).thenReturn(interfacesColumn);
219 Set<UUID> uuids = new HashSet<>();
220 UUID uuid2 = mock(UUID.class);
222 when(interfacesColumn.getData()).thenReturn(uuids);
224 ifUpdatedRows = new HashMap<>();
225 interfaceOldRows = new HashMap<>();
226 Interface iface = mock(Interface.class);
227 ifUpdatedRows.put(uuid2, iface);
228 Interface interfaceUpdate = mock(Interface.class);
229 ifUpdatedRows.put(uuid, interfaceUpdate);
230 interfaceOldRows.put(uuid2, iface);
231 field(OvsdbPortUpdateCommand.class, "interfaceUpdatedRows").set(ovsdbPortUpdateCommand, ifUpdatedRows);
232 field(OvsdbPortUpdateCommand.class, "interfaceOldRows").set(ovsdbPortUpdateCommand, interfaceOldRows);
233 PowerMockito.suppress(MemberMatcher.method(OvsdbPortUpdateCommand.class, "buildTerminationPoint",
234 OvsdbTerminationPointAugmentationBuilder.class, Interface.class));
236 when(tpAugmentationBuilder.build()).thenReturn(mock(OvsdbTerminationPointAugmentation.class));
237 when(tpBuilder.addAugmentation(eq(OvsdbTerminationPointAugmentation.class),
238 any(OvsdbTerminationPointAugmentation.class))).thenReturn(tpBuilder);
239 when(tpBuilder.build()).thenReturn(mock(TerminationPoint.class));
240 portOldRows = new HashMap<>();
241 portOldRows.put(uuid, port);
242 MemberModifier.field(OvsdbPortUpdateCommand.class, "portOldRows").set(ovsdbPortUpdateCommand, portOldRows);
243 ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
244 doNothing().when(transaction).merge(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
245 any(TerminationPoint.class));
246 doNothing().when(transaction).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
247 any(TerminationPoint.class));
249 Column<GenericTableSchema, String> interfaceColumn = mock(Column.class);
250 when(interfaceUpdate.getNameColumn()).thenReturn(interfaceColumn);
251 when(interfaceColumn.getData()).thenReturn(INTERFACE_NAME);
252 when(ovsdbPortUpdateCommand.getOvsdbConnectionInstance()).thenReturn(mock(OvsdbConnectionInstance.class));
254 PowerMockito.doReturn(bridgeIid).when(ovsdbPortUpdateCommand, "getTerminationPointBridge",
255 any(ReadWriteTransaction.class), any(Node.class), anyString());
256 PowerMockito.when(SouthboundMapper.createManagedNodeId(any(InstanceIdentifier.class))).thenReturn(bridgeId);
257 PowerMockito.whenNew(TopologyKey.class).withAnyArguments().thenReturn(mock(TopologyKey.class));
258 PowerMockito.whenNew(NodeKey.class).withAnyArguments().thenReturn(mock(NodeKey.class));
260 Node node = mock(Node.class);
261 Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updateTerminationPoints", transaction, node);
262 verify(ovsdbPortUpdateCommand).getInstanceIdentifier(any(InstanceIdentifier.class),
264 verify(transaction, times(2)).merge(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
265 any(TerminationPoint.class));
269 @SuppressWarnings("unchecked")
270 public void testBuildTerminationPoint() throws Exception {
271 Port portUpdate = mock(Port.class);
272 Entry<UUID,Port> portEntry = mock(Entry.class);
273 when(portEntry.getValue()).thenReturn(mock(Port.class));
274 when(portEntry.getValue().getName()).thenReturn(PORT_NAME);
275 when(portEntry.getValue().getUuid()).thenReturn(mock(UUID.class));
276 when(portUpdate.getName()).thenReturn(PORT_NAME);
277 when(portUpdate.getUuid()).thenReturn(mock(UUID.class));
278 PowerMockito.whenNew(Uuid.class).withAnyArguments().thenReturn(mock(Uuid.class));
280 OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder = mock(
281 OvsdbTerminationPointAugmentationBuilder.class);
283 when(tpAugmentationBuilder.setName(anyString())).thenReturn(tpAugmentationBuilder);
284 when(tpAugmentationBuilder.setPortUuid(any(Uuid.class))).thenReturn(tpAugmentationBuilder);
285 doNothing().when(ovsdbPortUpdateCommand).updatePort(any(ReadWriteTransaction.class),
286 any(Node.class), any(InstanceIdentifier.class), any(Entry.class),
287 any(OvsdbTerminationPointAugmentationBuilder.class));
289 Node node = mock(Node.class);
290 ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
291 InstanceIdentifier<TerminationPoint> tpPath = mock(InstanceIdentifier.class);
293 Whitebox.invokeMethod(ovsdbPortUpdateCommand, "buildTerminationPoint", transaction, tpPath,
294 tpAugmentationBuilder, node, portEntry);
295 verify(tpAugmentationBuilder).setName(anyString());
296 verify(tpAugmentationBuilder).setPortUuid(any(Uuid.class));
297 verify(ovsdbPortUpdateCommand).updatePort(any(ReadWriteTransaction.class),
298 any(Node.class), any(InstanceIdentifier.class), any(Entry.class),
299 any(OvsdbTerminationPointAugmentationBuilder.class));
303 public void testBuildTerminationPoint1() throws Exception {
304 Interface interfaceUpdate = mock(Interface.class);
305 when(interfaceUpdate.getName()).thenReturn(INTERFACE_NAME);
306 when(interfaceUpdate.getUuid()).thenReturn(mock(UUID.class));
307 PowerMockito.whenNew(Uuid.class).withAnyArguments().thenReturn(mock(Uuid.class));
308 OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder = mock(
309 OvsdbTerminationPointAugmentationBuilder.class);
310 when(tpAugmentationBuilder.setName(anyString())).thenReturn(tpAugmentationBuilder);
311 when(tpAugmentationBuilder.setInterfaceUuid(any(Uuid.class))).thenReturn(tpAugmentationBuilder);
313 doNothing().when(ovsdbPortUpdateCommand).updateInterfaces(any(Interface.class),
314 any(OvsdbTerminationPointAugmentationBuilder.class));
316 Whitebox.invokeMethod(ovsdbPortUpdateCommand, "buildTerminationPoint", tpAugmentationBuilder, interfaceUpdate);
317 verify(tpAugmentationBuilder).setName(anyString());
318 verify(tpAugmentationBuilder).setInterfaceUuid(any(Uuid.class));
319 verify(ovsdbPortUpdateCommand).updateInterfaces(any(Interface.class),
320 any(OvsdbTerminationPointAugmentationBuilder.class));
323 @SuppressWarnings("unchecked")
325 public void testReadNode() throws Exception {
326 ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
327 InstanceIdentifier<Node> nodePath = mock(InstanceIdentifier.class);
328 Optional<Node> node = Optional.of(mock(Node.class));
329 FluentFuture<Optional<Node>> fluentFuture = mock(FluentFuture.class);
330 when(transaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class)))
331 .thenReturn(fluentFuture);
332 when(fluentFuture.get()).thenReturn(node);
333 assertEquals(node, Whitebox.invokeMethod(ovsdbPortUpdateCommand, "readNode", transaction, nodePath));
336 @SuppressWarnings("unchecked")
338 public void testGetTerminationPointBridge1() throws Exception {
339 Node node = mock(Node.class);
340 OvsdbNodeAugmentation ovsdbNode = mock(OvsdbNodeAugmentation.class);
341 when(node.augmentation(OvsdbNodeAugmentation.class)).thenReturn(ovsdbNode);
342 List<ManagedNodeEntry> managedNodes = new ArrayList<>();
343 ManagedNodeEntry managedNodeEntry = mock(ManagedNodeEntry.class);
344 managedNodes.add(managedNodeEntry);
345 when(ovsdbNode.getManagedNodeEntry()).thenReturn(managedNodes);
347 Node managedNode = mock(Node.class);
348 OvsdbBridgeRef ovsdbBridgeRef = mock(OvsdbBridgeRef.class);
349 when(managedNodeEntry.getBridgeRef()).thenReturn(ovsdbBridgeRef);
350 InstanceIdentifier<Node> iidNode = mock(InstanceIdentifier.class);
351 when((InstanceIdentifier<Node>) ovsdbBridgeRef.getValue()).thenReturn(iidNode);
352 Optional<Node> optionalNode = Optional.of(managedNode);
353 PowerMockito.doReturn(optionalNode).when(ovsdbPortUpdateCommand, "readNode", any(ReadWriteTransaction.class),
354 any(InstanceIdentifier.class));
356 PowerMockito.mockStatic(SouthboundUtil.class);
357 PowerMockito.when(SouthboundUtil.readNode(Matchers.any(ReadWriteTransaction.class),
358 Matchers.any(InstanceIdentifier.class)))
359 .thenReturn(optionalNode);
360 TerminationPointBuilder tpBuilder = mock(TerminationPointBuilder.class);
361 PowerMockito.whenNew(TerminationPointBuilder.class).withNoArguments().thenReturn(tpBuilder);
362 PowerMockito.whenNew(TpId.class).withAnyArguments().thenReturn(mock(TpId.class));
363 PowerMockito.whenNew(TerminationPointKey.class).withAnyArguments().thenReturn(mock(TerminationPointKey.class));
364 when(tpBuilder.withKey(any(TerminationPointKey.class))).thenReturn(tpBuilder);
366 List<TerminationPoint> terminationPointList = new ArrayList<>();
367 TerminationPoint terminationPoint = mock(TerminationPoint.class);
368 terminationPointList.add(terminationPoint);
369 when(tpBuilder.build()).thenReturn(terminationPoint);
370 when(managedNode.getTerminationPoint()).thenReturn(terminationPointList);
372 when(managedNode.augmentation(OvsdbBridgeAugmentation.class))
373 .thenReturn(mock(OvsdbBridgeAugmentation.class));
374 TpId tpId = new TpId(TP_NAME);
375 when(terminationPoint.getTpId()).thenReturn(tpId);
377 Optional<InstanceIdentifier<Node>> testResult = Optional.of(iidNode);
378 ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
379 Optional<InstanceIdentifier<Node>> result = Whitebox.invokeMethod(ovsdbPortUpdateCommand,
380 "getTerminationPointBridge", transaction, node, TP_NAME);
382 assertEquals(testResult, result);
385 @SuppressWarnings("unchecked")
387 public void testUpdateInterfaces() throws Exception {
388 Interface interfaceUpdate = mock(Interface.class);
389 Column<GenericTableSchema, String> typeColumn = mock(Column.class);
390 when(interfaceUpdate.getTypeColumn()).thenReturn(typeColumn);
391 when(typeColumn.getData()).thenReturn(OVSDB_INTERFACE_TYPE);
392 doNothing().when(ovsdbPortUpdateCommand).updateInterface(any(Interface.class), anyString(),
393 any(OvsdbTerminationPointAugmentationBuilder.class));
395 OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder = mock(
396 OvsdbTerminationPointAugmentationBuilder.class);
397 Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updateInterfaces", interfaceUpdate,
398 ovsdbTerminationPointBuilder);
399 verify(ovsdbPortUpdateCommand).updateInterface(any(Interface.class), anyString(),
400 any(OvsdbTerminationPointAugmentationBuilder.class));
404 @SuppressWarnings("unchecked")
405 public void testUpdateInterface() throws Exception {
406 Interface interf = mock(Interface.class);
407 OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder = mock(
408 OvsdbTerminationPointAugmentationBuilder.class);
409 when(interf.getUuid()).thenReturn(mock(UUID.class));
410 PowerMockito.whenNew(Uuid.class).withAnyArguments().thenReturn(mock(Uuid.class));
411 when(ovsdbTerminationPointBuilder.setInterfaceUuid(any(Uuid.class))).thenReturn(ovsdbTerminationPointBuilder);
412 PowerMockito.mockStatic(SouthboundMapper.class);
413 PowerMockito.when(SouthboundMapper.createInterfaceType(Matchers.anyString()))
414 .thenAnswer(new Answer<Class<? extends InterfaceTypeBase>>() {
415 public Class<? extends InterfaceTypeBase> answer(InvocationOnMock invocation) throws Exception {
416 return InterfaceTypeInternal.class;
419 when(ovsdbTerminationPointBuilder.setInterfaceType(any(Class.class))).thenReturn(ovsdbTerminationPointBuilder);
420 suppress(method(OvsdbPortUpdateCommand.class, "updateOfPort", Interface.class,
421 OvsdbTerminationPointAugmentationBuilder.class));
422 suppress(method(OvsdbPortUpdateCommand.class, "updateOfPortRequest", Interface.class,
423 OvsdbTerminationPointAugmentationBuilder.class));
424 suppress(method(OvsdbPortUpdateCommand.class, "updateInterfaceExternalIds", Interface.class,
425 OvsdbTerminationPointAugmentationBuilder.class));
426 suppress(method(OvsdbPortUpdateCommand.class, "updateOptions", Interface.class,
427 OvsdbTerminationPointAugmentationBuilder.class));
428 suppress(method(OvsdbPortUpdateCommand.class, "updateInterfaceOtherConfig", Interface.class,
429 OvsdbTerminationPointAugmentationBuilder.class));
430 suppress(method(OvsdbPortUpdateCommand.class, "updateInterfaceLldp", Interface.class,
431 OvsdbTerminationPointAugmentationBuilder.class));
432 suppress(method(OvsdbPortUpdateCommand.class, "updateInterfaceBfd", Interface.class,
433 OvsdbTerminationPointAugmentationBuilder.class));
434 suppress(method(OvsdbPortUpdateCommand.class, "updateInterfaceBfdStatus", Interface.class,
435 OvsdbTerminationPointAugmentationBuilder.class));
436 suppress(method(OvsdbPortUpdateCommand.class, "updateIfIndex", Interface.class,
437 OvsdbTerminationPointAugmentationBuilder.class));
439 Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updateInterface", interf, OVSDB_INTERFACE_TYPE,
440 ovsdbTerminationPointBuilder);
441 verify(ovsdbTerminationPointBuilder).setInterfaceUuid(any(Uuid.class));
442 verify(ovsdbTerminationPointBuilder).setInterfaceType(any(Class.class));
443 verify(ovsdbPortUpdateCommand).updateOfPort(any(Interface.class),
444 any(OvsdbTerminationPointAugmentationBuilder.class));
445 verify(ovsdbPortUpdateCommand).updateOfPortRequest(any(Interface.class),
446 any(OvsdbTerminationPointAugmentationBuilder.class));
447 verify(ovsdbPortUpdateCommand).updateInterfaceExternalIds(any(Interface.class),
448 any(OvsdbTerminationPointAugmentationBuilder.class));
449 verify(ovsdbPortUpdateCommand).updateOptions(any(Interface.class),
450 any(OvsdbTerminationPointAugmentationBuilder.class));
451 verify(ovsdbPortUpdateCommand).updateInterfaceOtherConfig(any(Interface.class),
452 any(OvsdbTerminationPointAugmentationBuilder.class));
456 @SuppressWarnings("unchecked")
457 public void testUpdatePort() throws Exception {
458 suppress(method(OvsdbPortUpdateCommand.class, "updateVlan", Port.class,
459 OvsdbTerminationPointAugmentationBuilder.class));
460 suppress(method(OvsdbPortUpdateCommand.class, "updateVlanTrunks", Port.class,
461 OvsdbTerminationPointAugmentationBuilder.class));
462 suppress(method(OvsdbPortUpdateCommand.class, "updateVlanMode", Port.class,
463 OvsdbTerminationPointAugmentationBuilder.class));
464 suppress(method(OvsdbPortUpdateCommand.class, "updatePortExternalIds", Port.class,
465 OvsdbTerminationPointAugmentationBuilder.class));
466 suppress(method(OvsdbPortUpdateCommand.class, "updatePortOtherConfig", Port.class,
467 OvsdbTerminationPointAugmentationBuilder.class));
468 suppress(method(OvsdbPortUpdateCommand.class, "updatePortOtherConfig", Port.class,
469 OvsdbTerminationPointAugmentationBuilder.class));
470 suppress(method(OvsdbPortUpdateCommand.class, "updateQos", ReadWriteTransaction.class, Node.class,
471 InstanceIdentifier.class, Entry.class, OvsdbTerminationPointAugmentationBuilder.class));
473 Node node = mock(Node.class);
474 Entry<UUID, Port> port = new SimpleEntry<>(mock(UUID.class), mock(Port.class));
475 OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder = mock(
476 OvsdbTerminationPointAugmentationBuilder.class);
477 ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
478 InstanceIdentifier<TerminationPoint> tpPath = mock(InstanceIdentifier.class);
479 Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updatePort", transaction, node, tpPath, port,
480 ovsdbTerminationPointBuilder);
482 verify(ovsdbPortUpdateCommand).updateVlan(any(Port.class),
483 any(OvsdbTerminationPointAugmentationBuilder.class));
484 verify(ovsdbPortUpdateCommand).updateVlanTrunks(any(Port.class),
485 any(OvsdbTerminationPointAugmentationBuilder.class));
486 verify(ovsdbPortUpdateCommand).updateVlanMode(any(Port.class),
487 any(OvsdbTerminationPointAugmentationBuilder.class));
488 verify(ovsdbPortUpdateCommand).updatePortExternalIds(any(Port.class),
489 any(OvsdbTerminationPointAugmentationBuilder.class));
490 verify(ovsdbPortUpdateCommand).updatePortOtherConfig(any(Port.class),
491 any(OvsdbTerminationPointAugmentationBuilder.class));
494 @SuppressWarnings("unchecked")
496 public void testUpdateVlan() throws Exception {
497 Port port = mock(Port.class);
498 Column<GenericTableSchema, Set<Long>> column = mock(Column.class);
499 when(port.getTagColumn()).thenReturn(column);
500 Set<Long> vlanId = new HashSet<>();
501 vlanId.add((long) 808);
502 when(column.getData()).thenReturn(vlanId);
503 PowerMockito.whenNew(VlanId.class).withAnyArguments().thenReturn(mock(VlanId.class));
504 OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder = mock(
505 OvsdbTerminationPointAugmentationBuilder.class);
506 when(ovsdbTerminationPointBuilder.setVlanTag(any(VlanId.class))).thenReturn(ovsdbTerminationPointBuilder);
507 Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updateVlan", port, ovsdbTerminationPointBuilder);
508 verify(ovsdbTerminationPointBuilder).setVlanTag(any(VlanId.class));
511 @SuppressWarnings("unchecked")
513 public void testUpdateVlanTrunks() throws Exception {
514 Port port = mock(Port.class);
515 Column<GenericTableSchema, Set<Long>> column = mock(Column.class);
516 when(port.getTrunksColumn()).thenReturn(column);
517 Set<Long> portTrunks = new HashSet<>();
518 portTrunks.add((long) 300);
519 when(column.getData()).thenReturn(portTrunks);
521 TrunksBuilder trunksBuilder = mock(TrunksBuilder.class);
522 PowerMockito.whenNew(TrunksBuilder.class).withNoArguments().thenReturn(trunksBuilder);
523 PowerMockito.whenNew(VlanId.class).withAnyArguments().thenReturn(mock(VlanId.class));
524 when(trunksBuilder.setTrunk(any(VlanId.class))).thenReturn(trunksBuilder);
525 OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder = mock(
526 OvsdbTerminationPointAugmentationBuilder.class);
527 when(ovsdbTerminationPointBuilder.setTrunks(any(List.class))).thenReturn(ovsdbTerminationPointBuilder);
528 Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updateVlanTrunks", port, ovsdbTerminationPointBuilder);
529 verify(trunksBuilder).setTrunk(any(VlanId.class));
530 verify(ovsdbTerminationPointBuilder).setTrunks(any(List.class));
533 @SuppressWarnings("unchecked")
535 public void testUpdateVlanMode() throws Exception {
536 Port port = mock(Port.class);
537 Column<GenericTableSchema, Set<String>> column = mock(Column.class);
538 when(port.getVlanModeColumn()).thenReturn(column);
539 Set<String> set = new HashSet<>();
540 set.add(VLAN_MODE_ACCESS);
541 when(column.getData()).thenReturn(set);
542 OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder = mock(
543 OvsdbTerminationPointAugmentationBuilder.class);
544 when(ovsdbTerminationPointBuilder.setVlanMode(OvsdbPortInterfaceAttributes.VlanMode.Access))
545 .thenReturn(ovsdbTerminationPointBuilder);
546 Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updateVlanMode", port, ovsdbTerminationPointBuilder);
547 verify(ovsdbTerminationPointBuilder).setVlanMode(any(VlanMode.class));
550 @SuppressWarnings("unchecked")
552 public void testUpdateOfPort() throws Exception {
553 Interface interf = mock(Interface.class);
554 Set<Long> ofPorts = new HashSet<>();
555 ofPorts.add((long) 10000);
556 Column<GenericTableSchema, Set<Long>> column = mock(Column.class);
557 when(interf.getOpenFlowPortColumn()).thenReturn(column);
558 when(column.getData()).thenReturn(ofPorts);
559 OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder = mock(
560 OvsdbTerminationPointAugmentationBuilder.class);
561 when(ovsdbTerminationPointBuilder.setOfport(any(Long.class))).thenReturn(ovsdbTerminationPointBuilder);
562 when(interf.getName()).thenReturn(INTERFACE_NAME);
563 Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updateOfPort", interf, ovsdbTerminationPointBuilder);
564 verify(ovsdbTerminationPointBuilder).setOfport(any(Long.class));
567 @SuppressWarnings("unchecked")
569 public void testUpdateOfPortRequest() throws Exception {
570 Interface interf = mock(Interface.class);
571 Set<Long> ofPortRequests = new HashSet<>();
572 ofPortRequests.add((long) 10000);
573 Column<GenericTableSchema, Set<Long>> column = mock(Column.class);
574 when(interf.getOpenFlowPortRequestColumn()).thenReturn(column);
575 when(column.getData()).thenReturn(ofPortRequests);
576 OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder = mock(
577 OvsdbTerminationPointAugmentationBuilder.class);
578 when(ovsdbTerminationPointBuilder.setOfportRequest(any(Integer.class)))
579 .thenReturn(ovsdbTerminationPointBuilder);
580 when(interf.getName()).thenReturn(INTERFACE_NAME);
581 Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updateOfPortRequest", interf, ovsdbTerminationPointBuilder);
582 verify(ovsdbTerminationPointBuilder).setOfportRequest(any(Integer.class));
585 @SuppressWarnings("unchecked")
587 public void testUpdateInterfaceExternalIds() throws Exception {
588 Interface interf = mock(Interface.class);
589 Column<GenericTableSchema, Map<String, String>> column = mock(Column.class);
590 when(interf.getExternalIdsColumn()).thenReturn(column);
591 Map<String, String> map = new HashMap<>();
592 when(column.getData()).thenReturn(map);
593 map.put(EXTERNAL_ID_KEY, EXTERNAL_ID_VALUE);
594 when(column.getData()).thenReturn(map);
596 InterfaceExternalIdsBuilder interfaceExternalIdsBuilder = mock(InterfaceExternalIdsBuilder.class);
597 PowerMockito.whenNew(InterfaceExternalIdsBuilder.class).withNoArguments()
598 .thenReturn(interfaceExternalIdsBuilder);
600 when(interfaceExternalIdsBuilder.setExternalIdKey(anyString())).thenReturn(interfaceExternalIdsBuilder);
601 when(interfaceExternalIdsBuilder.setExternalIdValue(anyString())).thenReturn(interfaceExternalIdsBuilder);
602 when(interfaceExternalIdsBuilder.build()).thenReturn(mock(InterfaceExternalIds.class));
603 OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBldr = mock(
604 OvsdbTerminationPointAugmentationBuilder.class);
605 when(ovsdbTerminationPointBldr.setInterfaceExternalIds(any(List.class))).thenReturn(ovsdbTerminationPointBldr);
607 Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updateInterfaceExternalIds", interf, ovsdbTerminationPointBldr);
608 verify(interfaceExternalIdsBuilder).setExternalIdKey(anyString());
609 verify(interfaceExternalIdsBuilder).setExternalIdValue(anyString());
613 @SuppressWarnings("unchecked")
615 public void testUpdatePortExternalIds() throws Exception {
616 Port port = mock(Port.class);
617 Column<GenericTableSchema, Map<String, String>> column = mock(Column.class);
618 when(port.getExternalIdsColumn()).thenReturn(column);
619 Map<String, String> map = new HashMap<>();
620 when(column.getData()).thenReturn(map);
621 map.put(EXTERNAL_ID_KEY, EXTERNAL_ID_VALUE);
622 when(column.getData()).thenReturn(map);
624 PortExternalIdsBuilder portExternalIdsBuilder = mock(PortExternalIdsBuilder.class);
625 PowerMockito.whenNew(PortExternalIdsBuilder.class).withNoArguments().thenReturn(portExternalIdsBuilder);
627 when(portExternalIdsBuilder.setExternalIdKey(anyString())).thenReturn(portExternalIdsBuilder);
628 when(portExternalIdsBuilder.setExternalIdValue(anyString())).thenReturn(portExternalIdsBuilder);
629 when(portExternalIdsBuilder.build()).thenReturn(mock(PortExternalIds.class));
630 OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder = mock(
631 OvsdbTerminationPointAugmentationBuilder.class);
632 when(ovsdbTerminationPointBuilder.setPortExternalIds(any(List.class))).thenReturn(ovsdbTerminationPointBuilder);
634 Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updatePortExternalIds", port, ovsdbTerminationPointBuilder);
635 verify(portExternalIdsBuilder).setExternalIdKey(anyString());
636 verify(portExternalIdsBuilder).setExternalIdValue(anyString());
639 @SuppressWarnings("unchecked")
641 public void testUpdatePortOtherConfig() throws Exception {
642 Port port = mock(Port.class);
643 Column<GenericTableSchema, Map<String, String>> column = mock(Column.class);
644 when(port.getOtherConfigColumn()).thenReturn(column);
645 Map<String, String> map = new HashMap<>();
646 map.put(OTHER_CONFIG_KEY, OTHER_CONFIG_VALUE);
647 when(column.getData()).thenReturn(map);
649 PortOtherConfigsBuilder portOtherConfigsBuilder = mock(PortOtherConfigsBuilder.class);
650 PowerMockito.whenNew(PortOtherConfigsBuilder.class).withNoArguments().thenReturn(portOtherConfigsBuilder);
652 when(portOtherConfigsBuilder.setOtherConfigKey(anyString())).thenReturn(portOtherConfigsBuilder);
653 when(portOtherConfigsBuilder.setOtherConfigValue(anyString())).thenReturn(portOtherConfigsBuilder);
654 when(portOtherConfigsBuilder.build()).thenReturn(mock(PortOtherConfigs.class));
655 OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder = mock(
656 OvsdbTerminationPointAugmentationBuilder.class);
657 when(ovsdbTerminationPointBuilder.setInterfaceOtherConfigs(any(List.class)))
658 .thenReturn(ovsdbTerminationPointBuilder);
660 Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updatePortOtherConfig", port, ovsdbTerminationPointBuilder);
661 verify(portOtherConfigsBuilder).setOtherConfigKey(anyString());
662 verify(portOtherConfigsBuilder).setOtherConfigValue(anyString());
665 @SuppressWarnings("unchecked")
667 public void testUpdateInterfaceOtherConfig() throws Exception {
668 Interface interf = mock(Interface.class);
669 Map<String, String> interfaceOtherConfigMap = new HashMap<>();
670 interfaceOtherConfigMap.put(OTHER_CONFIG_KEY, OTHER_CONFIG_VALUE);
671 Column<GenericTableSchema, Map<String, String>> column = mock(Column.class);
672 when(interf.getOtherConfigColumn()).thenReturn(column);
673 when(column.getData()).thenReturn(interfaceOtherConfigMap);
675 InterfaceOtherConfigsBuilder interfaceOtherConfigsBuilder = mock(InterfaceOtherConfigsBuilder.class);
676 PowerMockito.whenNew(InterfaceOtherConfigsBuilder.class).withNoArguments()
677 .thenReturn(interfaceOtherConfigsBuilder);
679 when(interfaceOtherConfigsBuilder.setOtherConfigKey(anyString())).thenReturn(interfaceOtherConfigsBuilder);
680 when(interfaceOtherConfigsBuilder.setOtherConfigValue(anyString())).thenReturn(interfaceOtherConfigsBuilder);
681 when(interfaceOtherConfigsBuilder.build()).thenReturn(mock(InterfaceOtherConfigs.class));
682 OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder = mock(
683 OvsdbTerminationPointAugmentationBuilder.class);
684 when(ovsdbTerminationPointBuilder.setInterfaceOtherConfigs(any(List.class)))
685 .thenReturn(ovsdbTerminationPointBuilder);
687 Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updateInterfaceOtherConfig", interf,
688 ovsdbTerminationPointBuilder);
689 verify(interfaceOtherConfigsBuilder).setOtherConfigKey(anyString());
690 verify(interfaceOtherConfigsBuilder).setOtherConfigValue(anyString());
693 @SuppressWarnings("unchecked")
695 // TODO This test needs to be re-done
696 @Ignore("Broken mock-based test")
697 public void testGetInstanceIdentifier() throws Exception {
698 Port port = mock(Port.class);
699 Column<GenericTableSchema, Map<String, String>> column = mock(Column.class);
700 when(port.getExternalIdsColumn()).thenReturn(column);
701 Map<String, String> map = new HashMap<>();
702 map.put(SouthboundConstants.IID_EXTERNAL_ID_KEY, "opendaylight-iid");
703 when(column.getData()).thenReturn(map);
705 PowerMockito.mockStatic(SouthboundUtil.class);
706 InstanceIdentifier<TerminationPoint> terminationPointIId = mock(InstanceIdentifier.class);
708 // .when((InstanceIdentifier<TerminationPoint>) SouthboundUtil.deserializeInstanceIdentifier(
709 // any(InstanceIdentifierCodec.class), anyString()))
710 // .thenReturn(terminationPointIId);
711 InstanceIdentifier<Node> bridgeIid = mock(InstanceIdentifier.class);
712 assertEquals(terminationPointIId,
713 Whitebox.invokeMethod(ovsdbPortUpdateCommand, "getInstanceIdentifier", bridgeIid, port));