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
8 package org.opendaylight.ovsdb.southbound.transactions.md;
10 import static org.junit.Assert.assertEquals;
11 import static org.mockito.ArgumentMatchers.any;
12 import static org.mockito.ArgumentMatchers.anyString;
13 import static org.mockito.Mockito.doNothing;
14 import static org.mockito.Mockito.mock;
15 import static org.mockito.Mockito.times;
16 import static org.mockito.Mockito.verify;
17 import static org.mockito.Mockito.when;
18 import static org.powermock.api.support.membermodification.MemberMatcher.field;
19 import static org.powermock.api.support.membermodification.MemberMatcher.method;
20 import static org.powermock.api.support.membermodification.MemberModifier.suppress;
22 import com.google.common.util.concurrent.FluentFuture;
23 import java.util.AbstractMap.SimpleEntry;
24 import java.util.HashMap;
25 import java.util.HashSet;
26 import java.util.List;
28 import java.util.Map.Entry;
29 import java.util.Optional;
31 import org.junit.Before;
32 import org.junit.Ignore;
33 import org.junit.Test;
34 import org.junit.runner.RunWith;
35 import org.mockito.Mockito;
36 import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
37 import org.opendaylight.mdsal.common.api.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.Interface;
46 import org.opendaylight.ovsdb.schema.openvswitch.Port;
47 import org.opendaylight.ovsdb.southbound.InstanceIdentifierCodec;
48 import org.opendaylight.ovsdb.southbound.OvsdbConnectionInstance;
49 import org.opendaylight.ovsdb.southbound.SouthboundConstants;
50 import org.opendaylight.ovsdb.southbound.SouthboundMapper;
51 import org.opendaylight.ovsdb.southbound.SouthboundUtil;
52 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
53 import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId;
54 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeInternal;
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.OvsdbBridgeRef;
57 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
58 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbPortInterfaceAttributes;
59 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbPortInterfaceAttributes.VlanMode;
60 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
61 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentationBuilder;
62 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntry;
63 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagedNodeEntryBuilder;
64 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.TrunksBuilder;
65 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
66 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
67 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TpId;
68 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
69 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
70 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
71 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
72 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
73 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointBuilder;
74 import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
75 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
76 import org.opendaylight.yangtools.yang.common.Uint16;
77 import org.opendaylight.yangtools.yang.common.Uint32;
78 import org.powermock.api.mockito.PowerMockito;
79 import org.powermock.api.support.membermodification.MemberMatcher;
80 import org.powermock.api.support.membermodification.MemberModifier;
81 import org.powermock.core.classloader.annotations.PrepareForTest;
82 import org.powermock.modules.junit4.PowerMockRunner;
83 import org.powermock.reflect.Whitebox;
85 @RunWith(PowerMockRunner.class)
86 @PrepareForTest({TyperUtils.class, OvsdbPortUpdateCommand.class, SouthboundUtil.class, SouthboundMapper.class})
87 public class OvsdbPortUpdateCommandTest {
89 private static final String OTHER_CONFIG_KEY = "key";
90 private static final String OTHER_CONFIG_VALUE = "value";
91 private static final String EXTERNAL_ID_KEY = "key";
92 private static final String EXTERNAL_ID_VALUE = "value";
93 private static final String INTERFACE_NAME = "interface_name";
94 private static final String VLAN_MODE_ACCESS = "access";
95 private static final String OVSDB_INTERFACE_TYPE = "internal";
96 private static final String PORT_NAME = "port_name";
97 private static final String TP_NAME = "tp_name";
98 private static final String TERMINATION_POINT_NAME = "termination_point_name";
100 private Map<UUID, Port> portUpdatedRows;
101 private Map<UUID, Port> portOldRows;
102 private Map<UUID, Interface> ifUpdatedRows;
103 private Map<UUID, Interface> interfaceOldRows;
104 private Map<UUID, Bridge> bridgeUpdatedRows;
105 private OvsdbPortUpdateCommand ovsdbPortUpdateCommand;
108 public void setUp() throws Exception {
109 ovsdbPortUpdateCommand = PowerMockito.mock(OvsdbPortUpdateCommand.class, Mockito.CALLS_REAL_METHODS);
113 public void testOvsdbPortUpdateCommand() throws Exception {
114 TableUpdates updates = mock(TableUpdates.class);
115 DatabaseSchema dbSchema = mock(DatabaseSchema.class);
117 PowerMockito.mockStatic(TyperUtils.class);
118 PowerMockito.when(TyperUtils.extractRowsUpdated(Port.class, updates, dbSchema)).thenReturn(portUpdatedRows);
119 PowerMockito.when(TyperUtils.extractRowsOld(Port.class, updates, dbSchema)).thenReturn(portOldRows);
120 PowerMockito.when(TyperUtils.extractRowsUpdated(Interface.class, updates, dbSchema)).thenReturn(ifUpdatedRows);
121 PowerMockito.when(TyperUtils.extractRowsOld(Interface.class, updates, dbSchema)).thenReturn(interfaceOldRows);
122 PowerMockito.when(TyperUtils.extractRowsUpdated(Bridge.class, updates, dbSchema)).thenReturn(bridgeUpdatedRows);
124 OvsdbConnectionInstance key = mock(OvsdbConnectionInstance.class);
125 OvsdbPortUpdateCommand ovsdbPortUpdateCommand1 =
126 new OvsdbPortUpdateCommand(mock(InstanceIdentifierCodec.class), key, updates, dbSchema);
127 assertEquals(portUpdatedRows, Whitebox.getInternalState(ovsdbPortUpdateCommand1, "portUpdatedRows"));
128 assertEquals(portOldRows, Whitebox.getInternalState(ovsdbPortUpdateCommand1, "portOldRows"));
129 assertEquals(dbSchema, Whitebox.getInternalState(ovsdbPortUpdateCommand1, "dbSchema"));
132 @SuppressWarnings("unchecked")
134 public void testExecute() throws Exception {
135 portUpdatedRows = new HashMap<>();
136 interfaceOldRows = new HashMap<>();
137 portUpdatedRows.put(mock(UUID.class), mock(Port.class));
138 interfaceOldRows.put(mock(UUID.class), mock(Interface.class));
139 field(OvsdbPortUpdateCommand.class, "portUpdatedRows").set(ovsdbPortUpdateCommand, portUpdatedRows);
140 field(OvsdbPortUpdateCommand.class, "interfaceOldRows").set(ovsdbPortUpdateCommand, interfaceOldRows);
142 OvsdbConnectionInstance ovsdbConnectionInstance = mock(OvsdbConnectionInstance.class);
143 when(ovsdbPortUpdateCommand.getOvsdbConnectionInstance()).thenReturn(ovsdbConnectionInstance);
144 InstanceIdentifier<Node> connectionIId = mock(InstanceIdentifier.class);
145 when(ovsdbConnectionInstance.getInstanceIdentifier()).thenReturn(connectionIId);
147 //case 1: portUpdatedRows & interfaceOldRows not null, not empty
148 Optional<Node> node = Optional.of(mock(Node.class));
149 PowerMockito.doReturn(node).when(ovsdbPortUpdateCommand, "readNode", any(ReadWriteTransaction.class),
150 any(InstanceIdentifier.class));
151 doNothing().when(ovsdbPortUpdateCommand).updateTerminationPoints(any(ReadWriteTransaction.class),
153 ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
154 PowerMockito.mockStatic(SouthboundUtil.class);
155 PowerMockito.when(SouthboundUtil.readNode(any(ReadWriteTransaction.class), any(InstanceIdentifier.class)))
157 ovsdbPortUpdateCommand.execute(transaction);
158 verify(ovsdbConnectionInstance).getInstanceIdentifier();
159 verify(ovsdbPortUpdateCommand).updateTerminationPoints(any(ReadWriteTransaction.class), any(Node.class));
163 @SuppressWarnings("unchecked")
164 public void testUpdateTerminationPoints() throws Exception {
165 portUpdatedRows = new HashMap<>();
166 Port port = mock(Port.class);
167 UUID uuid = mock(UUID.class);
168 portUpdatedRows.put(uuid, port);
169 field(OvsdbPortUpdateCommand.class, "portUpdatedRows").set(ovsdbPortUpdateCommand, portUpdatedRows);
170 Column<GenericTableSchema, String> bridgeColumn = mock(Column.class);
171 when(port.getNameColumn()).thenReturn(bridgeColumn);
172 when(bridgeColumn.getData()).thenReturn(TERMINATION_POINT_NAME);
174 InstanceIdentifier<Node> nodeIid = InstanceIdentifier.create(NetworkTopology.class)
175 .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
176 .child(Node.class, new NodeKey(new NodeId("nodeId")));
178 Optional<InstanceIdentifier<Node>> bridgeIid = Optional.of(nodeIid);
179 PowerMockito.doReturn(bridgeIid).when(ovsdbPortUpdateCommand, "getTerminationPointBridge", any(UUID.class));
181 NodeId bridgeId = mock(NodeId.class);
182 PowerMockito.mockStatic(SouthboundMapper.class);
183 PowerMockito.when(SouthboundMapper.createManagedNodeId(any(InstanceIdentifier.class))).thenReturn(bridgeId);
185 PowerMockito.whenNew(TpId.class).withAnyArguments().thenReturn(mock(TpId.class));
186 TerminationPointKey tpKey = mock(TerminationPointKey.class);
187 PowerMockito.whenNew(TerminationPointKey.class).withAnyArguments().thenReturn(tpKey);
188 TerminationPointBuilder tpBuilder = mock(TerminationPointBuilder.class);
189 PowerMockito.whenNew(TerminationPointBuilder.class).withNoArguments().thenReturn(tpBuilder);
190 when(tpBuilder.withKey(any(TerminationPointKey.class))).thenReturn(tpBuilder);
191 when(tpKey.getTpId()).thenReturn(mock(TpId.class));
192 when(tpBuilder.setTpId(any(TpId.class))).thenReturn(tpBuilder);
193 InstanceIdentifier<TerminationPoint> tpPath = mock(InstanceIdentifier.class);
194 PowerMockito.doReturn(tpPath).when(ovsdbPortUpdateCommand, "getInstanceIdentifier",
195 any(InstanceIdentifier.class), any(Port.class));
197 OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder = mock(
198 OvsdbTerminationPointAugmentationBuilder.class);
199 PowerMockito.whenNew(OvsdbTerminationPointAugmentationBuilder.class).withNoArguments()
200 .thenReturn(tpAugmentationBuilder);
201 PowerMockito.suppress(MemberMatcher.method(OvsdbPortUpdateCommand.class, "buildTerminationPoint",
202 ReadWriteTransaction.class, InstanceIdentifier.class, OvsdbTerminationPointAugmentationBuilder.class,
203 Node.class, Entry.class));
205 Column<GenericTableSchema, Set<UUID>> interfacesColumn = mock(Column.class);
206 when(port.getInterfacesColumn()).thenReturn(interfacesColumn);
207 Set<UUID> uuids = new HashSet<>();
208 UUID uuid2 = mock(UUID.class);
210 when(interfacesColumn.getData()).thenReturn(uuids);
212 ifUpdatedRows = new HashMap<>();
213 interfaceOldRows = new HashMap<>();
214 Interface iface = mock(Interface.class);
215 ifUpdatedRows.put(uuid2, iface);
216 Interface interfaceUpdate = mock(Interface.class);
217 ifUpdatedRows.put(uuid, interfaceUpdate);
218 interfaceOldRows.put(uuid2, iface);
219 field(OvsdbPortUpdateCommand.class, "interfaceUpdatedRows").set(ovsdbPortUpdateCommand, ifUpdatedRows);
220 field(OvsdbPortUpdateCommand.class, "interfaceOldRows").set(ovsdbPortUpdateCommand, interfaceOldRows);
221 PowerMockito.suppress(MemberMatcher.method(OvsdbPortUpdateCommand.class, "buildTerminationPoint",
222 OvsdbTerminationPointAugmentationBuilder.class, Interface.class));
224 when(tpAugmentationBuilder.build()).thenReturn(mock(OvsdbTerminationPointAugmentation.class));
225 when(tpBuilder.addAugmentation(any(OvsdbTerminationPointAugmentation.class))).thenReturn(tpBuilder);
226 when(tpBuilder.build()).thenReturn(mock(TerminationPoint.class));
227 portOldRows = new HashMap<>();
228 portOldRows.put(uuid, port);
229 MemberModifier.field(OvsdbPortUpdateCommand.class, "portOldRows").set(ovsdbPortUpdateCommand, portOldRows);
230 ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
231 doNothing().when(transaction).merge(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
232 any(TerminationPoint.class));
233 doNothing().when(transaction).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
234 any(TerminationPoint.class));
236 Column<GenericTableSchema, String> interfaceColumn = mock(Column.class);
237 when(interfaceUpdate.getNameColumn()).thenReturn(interfaceColumn);
238 when(interfaceColumn.getData()).thenReturn(INTERFACE_NAME);
239 when(ovsdbPortUpdateCommand.getOvsdbConnectionInstance()).thenReturn(mock(OvsdbConnectionInstance.class));
241 PowerMockito.doReturn(bridgeIid).when(ovsdbPortUpdateCommand, "getTerminationPointBridge",
242 any(ReadWriteTransaction.class), any(Node.class), anyString());
243 PowerMockito.when(SouthboundMapper.createManagedNodeId(any(InstanceIdentifier.class))).thenReturn(bridgeId);
244 PowerMockito.whenNew(TopologyKey.class).withAnyArguments().thenReturn(mock(TopologyKey.class));
245 PowerMockito.whenNew(NodeKey.class).withAnyArguments().thenReturn(mock(NodeKey.class));
247 Node node = mock(Node.class);
248 Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updateTerminationPoints", transaction, node);
249 verify(ovsdbPortUpdateCommand).getInstanceIdentifier(any(InstanceIdentifier.class),
251 verify(transaction, times(2)).merge(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
252 any(TerminationPoint.class));
256 @SuppressWarnings("unchecked")
257 public void testBuildTerminationPoint() throws Exception {
258 Port portUpdate = mock(Port.class);
259 Entry<UUID,Port> portEntry = mock(Entry.class);
260 when(portEntry.getValue()).thenReturn(mock(Port.class));
261 when(portEntry.getValue().getName()).thenReturn(PORT_NAME);
262 when(portEntry.getValue().getUuid()).thenReturn(mock(UUID.class));
263 when(portUpdate.getName()).thenReturn(PORT_NAME);
264 when(portUpdate.getUuid()).thenReturn(mock(UUID.class));
265 PowerMockito.whenNew(Uuid.class).withAnyArguments().thenReturn(mock(Uuid.class));
267 OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder = mock(
268 OvsdbTerminationPointAugmentationBuilder.class);
270 when(tpAugmentationBuilder.setName(anyString())).thenReturn(tpAugmentationBuilder);
271 when(tpAugmentationBuilder.setPortUuid(any(Uuid.class))).thenReturn(tpAugmentationBuilder);
272 doNothing().when(ovsdbPortUpdateCommand).updatePort(any(ReadWriteTransaction.class),
273 any(Node.class), any(InstanceIdentifier.class), any(Entry.class),
274 any(OvsdbTerminationPointAugmentationBuilder.class));
276 Node node = mock(Node.class);
277 ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
278 InstanceIdentifier<TerminationPoint> tpPath = mock(InstanceIdentifier.class);
280 Whitebox.invokeMethod(ovsdbPortUpdateCommand, "buildTerminationPoint", transaction, tpPath,
281 tpAugmentationBuilder, node, portEntry);
282 verify(tpAugmentationBuilder).setName(anyString());
283 verify(tpAugmentationBuilder).setPortUuid(any(Uuid.class));
284 verify(ovsdbPortUpdateCommand).updatePort(any(ReadWriteTransaction.class),
285 any(Node.class), any(InstanceIdentifier.class), any(Entry.class),
286 any(OvsdbTerminationPointAugmentationBuilder.class));
290 public void testBuildTerminationPoint1() throws Exception {
291 Interface interfaceUpdate = mock(Interface.class);
292 when(interfaceUpdate.getName()).thenReturn(INTERFACE_NAME);
293 when(interfaceUpdate.getUuid()).thenReturn(mock(UUID.class));
294 PowerMockito.whenNew(Uuid.class).withAnyArguments().thenReturn(mock(Uuid.class));
295 OvsdbTerminationPointAugmentationBuilder tpAugmentationBuilder = mock(
296 OvsdbTerminationPointAugmentationBuilder.class);
297 when(tpAugmentationBuilder.setName(anyString())).thenReturn(tpAugmentationBuilder);
298 when(tpAugmentationBuilder.setInterfaceUuid(any(Uuid.class))).thenReturn(tpAugmentationBuilder);
300 doNothing().when(ovsdbPortUpdateCommand).updateInterfaces(any(Interface.class),
301 any(OvsdbTerminationPointAugmentationBuilder.class));
303 Whitebox.invokeMethod(ovsdbPortUpdateCommand, "buildTerminationPoint", tpAugmentationBuilder, interfaceUpdate);
304 verify(tpAugmentationBuilder).setName(anyString());
305 verify(tpAugmentationBuilder).setInterfaceUuid(any(Uuid.class));
306 verify(ovsdbPortUpdateCommand).updateInterfaces(any(Interface.class),
307 any(OvsdbTerminationPointAugmentationBuilder.class));
310 @SuppressWarnings("unchecked")
312 public void testReadNode() throws Exception {
313 ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
314 InstanceIdentifier<Node> nodePath = mock(InstanceIdentifier.class);
315 Optional<Node> node = Optional.of(mock(Node.class));
316 FluentFuture<Optional<Node>> fluentFuture = mock(FluentFuture.class);
317 when(transaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class)))
318 .thenReturn(fluentFuture);
319 when(fluentFuture.get()).thenReturn(node);
320 assertEquals(node, Whitebox.invokeMethod(ovsdbPortUpdateCommand, "readNode", transaction, nodePath));
323 @SuppressWarnings("unchecked")
325 public void testGetTerminationPointBridge1() throws Exception {
326 Node node = mock(Node.class);
327 OvsdbNodeAugmentation ovsdbNode = mock(OvsdbNodeAugmentation.class);
328 when(node.augmentation(OvsdbNodeAugmentation.class)).thenReturn(ovsdbNode);
330 InstanceIdentifier<Node> iidNode = mock(InstanceIdentifier.class);
332 ManagedNodeEntry managedNodeEntry = new ManagedNodeEntryBuilder()
333 .setBridgeRef(new OvsdbBridgeRef(iidNode))
335 when(ovsdbNode.nonnullManagedNodeEntry()).thenCallRealMethod();
336 when(ovsdbNode.getManagedNodeEntry()).thenReturn(Map.of(managedNodeEntry.key(), managedNodeEntry));
338 Node managedNode = mock(Node.class);
339 Optional<Node> optionalNode = Optional.of(managedNode);
340 PowerMockito.doReturn(optionalNode).when(ovsdbPortUpdateCommand, "readNode", any(ReadWriteTransaction.class),
341 any(InstanceIdentifier.class));
343 PowerMockito.mockStatic(SouthboundUtil.class);
344 PowerMockito.when(SouthboundUtil.readNode(any(ReadWriteTransaction.class),
345 any(InstanceIdentifier.class)))
346 .thenReturn(optionalNode);
348 TerminationPoint terminationPoint = new TerminationPointBuilder().setTpId(new TpId(TP_NAME)).build();
350 TerminationPointBuilder tpBuilder = mock(TerminationPointBuilder.class);
351 when(tpBuilder.withKey(any(TerminationPointKey.class))).thenReturn(tpBuilder);
352 when(tpBuilder.build()).thenReturn(terminationPoint);
354 PowerMockito.whenNew(TerminationPointBuilder.class).withNoArguments().thenReturn(tpBuilder);
356 when(managedNode.nonnullTerminationPoint()).thenCallRealMethod();
357 when(managedNode.getTerminationPoint()).thenReturn(Map.of(terminationPoint.key(), terminationPoint));
359 when(managedNode.augmentation(OvsdbBridgeAugmentation.class))
360 .thenReturn(mock(OvsdbBridgeAugmentation.class));
362 Optional<InstanceIdentifier<Node>> testResult = Optional.of(iidNode);
363 ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
364 Optional<InstanceIdentifier<Node>> result = Whitebox.invokeMethod(ovsdbPortUpdateCommand,
365 "getTerminationPointBridge", transaction, node, TP_NAME);
367 assertEquals(testResult, result);
370 @SuppressWarnings("unchecked")
372 public void testUpdateInterfaces() throws Exception {
373 Interface interfaceUpdate = mock(Interface.class);
374 Column<GenericTableSchema, String> typeColumn = mock(Column.class);
375 when(interfaceUpdate.getTypeColumn()).thenReturn(typeColumn);
376 when(typeColumn.getData()).thenReturn(OVSDB_INTERFACE_TYPE);
377 doNothing().when(ovsdbPortUpdateCommand).updateInterface(any(Interface.class), anyString(),
378 any(OvsdbTerminationPointAugmentationBuilder.class));
380 OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder = mock(
381 OvsdbTerminationPointAugmentationBuilder.class);
382 Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updateInterfaces", interfaceUpdate,
383 ovsdbTerminationPointBuilder);
384 verify(ovsdbPortUpdateCommand).updateInterface(any(Interface.class), anyString(),
385 any(OvsdbTerminationPointAugmentationBuilder.class));
389 public void testUpdateInterface() throws Exception {
390 Interface interf = mock(Interface.class);
391 OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder = mock(
392 OvsdbTerminationPointAugmentationBuilder.class);
393 when(interf.getUuid()).thenReturn(mock(UUID.class));
394 PowerMockito.whenNew(Uuid.class).withAnyArguments().thenReturn(mock(Uuid.class));
395 when(ovsdbTerminationPointBuilder.setInterfaceUuid(any(Uuid.class))).thenReturn(ovsdbTerminationPointBuilder);
396 PowerMockito.mockStatic(SouthboundMapper.class);
397 PowerMockito.when(SouthboundMapper.createInterfaceType(anyString())).thenReturn(InterfaceTypeInternal.VALUE);
398 when(ovsdbTerminationPointBuilder.setInterfaceType(any())).thenReturn(ovsdbTerminationPointBuilder);
399 suppress(method(OvsdbPortUpdateCommand.class, "updateOfPort", Interface.class,
400 OvsdbTerminationPointAugmentationBuilder.class));
401 suppress(method(OvsdbPortUpdateCommand.class, "updateOfPortRequest", Interface.class,
402 OvsdbTerminationPointAugmentationBuilder.class));
403 suppress(method(OvsdbPortUpdateCommand.class, "updateInterfaceExternalIds", Interface.class,
404 OvsdbTerminationPointAugmentationBuilder.class));
405 suppress(method(OvsdbPortUpdateCommand.class, "updateOptions", Interface.class,
406 OvsdbTerminationPointAugmentationBuilder.class));
407 suppress(method(OvsdbPortUpdateCommand.class, "updateInterfaceOtherConfig", Interface.class,
408 OvsdbTerminationPointAugmentationBuilder.class));
409 suppress(method(OvsdbPortUpdateCommand.class, "updateInterfaceLldp", Interface.class,
410 OvsdbTerminationPointAugmentationBuilder.class));
411 suppress(method(OvsdbPortUpdateCommand.class, "updateInterfaceBfd", Interface.class,
412 OvsdbTerminationPointAugmentationBuilder.class));
413 suppress(method(OvsdbPortUpdateCommand.class, "updateInterfaceBfdStatus", Interface.class,
414 OvsdbTerminationPointAugmentationBuilder.class));
415 suppress(method(OvsdbPortUpdateCommand.class, "updateIfIndex", Interface.class,
416 OvsdbTerminationPointAugmentationBuilder.class));
418 Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updateInterface", interf, OVSDB_INTERFACE_TYPE,
419 ovsdbTerminationPointBuilder);
420 verify(ovsdbTerminationPointBuilder).setInterfaceUuid(any(Uuid.class));
421 verify(ovsdbTerminationPointBuilder).setInterfaceType(any());
422 verify(ovsdbPortUpdateCommand).updateOfPort(any(Interface.class),
423 any(OvsdbTerminationPointAugmentationBuilder.class));
424 verify(ovsdbPortUpdateCommand).updateOfPortRequest(any(Interface.class),
425 any(OvsdbTerminationPointAugmentationBuilder.class));
426 verify(ovsdbPortUpdateCommand).updateInterfaceExternalIds(any(Interface.class),
427 any(OvsdbTerminationPointAugmentationBuilder.class));
428 verify(ovsdbPortUpdateCommand).updateOptions(any(Interface.class),
429 any(OvsdbTerminationPointAugmentationBuilder.class));
430 verify(ovsdbPortUpdateCommand).updateInterfaceOtherConfig(any(Interface.class),
431 any(OvsdbTerminationPointAugmentationBuilder.class));
435 @SuppressWarnings("unchecked")
436 public void testUpdatePort() throws Exception {
437 suppress(method(OvsdbPortUpdateCommand.class, "updateVlan", Port.class,
438 OvsdbTerminationPointAugmentationBuilder.class));
439 suppress(method(OvsdbPortUpdateCommand.class, "updateVlanTrunks", Port.class,
440 OvsdbTerminationPointAugmentationBuilder.class));
441 suppress(method(OvsdbPortUpdateCommand.class, "updateVlanMode", Port.class,
442 OvsdbTerminationPointAugmentationBuilder.class));
443 suppress(method(OvsdbPortUpdateCommand.class, "updatePortExternalIds", Port.class,
444 OvsdbTerminationPointAugmentationBuilder.class));
445 suppress(method(OvsdbPortUpdateCommand.class, "updatePortOtherConfig", Port.class,
446 OvsdbTerminationPointAugmentationBuilder.class));
447 suppress(method(OvsdbPortUpdateCommand.class, "updatePortOtherConfig", Port.class,
448 OvsdbTerminationPointAugmentationBuilder.class));
449 suppress(method(OvsdbPortUpdateCommand.class, "updateQos", ReadWriteTransaction.class, Node.class,
450 InstanceIdentifier.class, Entry.class, OvsdbTerminationPointAugmentationBuilder.class));
452 Node node = mock(Node.class);
453 Entry<UUID, Port> port = new SimpleEntry<>(mock(UUID.class), mock(Port.class));
454 OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder = mock(
455 OvsdbTerminationPointAugmentationBuilder.class);
456 ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
457 InstanceIdentifier<TerminationPoint> tpPath = mock(InstanceIdentifier.class);
458 Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updatePort", transaction, node, tpPath, port,
459 ovsdbTerminationPointBuilder);
461 verify(ovsdbPortUpdateCommand).updateVlan(any(Port.class),
462 any(OvsdbTerminationPointAugmentationBuilder.class));
463 verify(ovsdbPortUpdateCommand).updateVlanTrunks(any(Port.class),
464 any(OvsdbTerminationPointAugmentationBuilder.class));
465 verify(ovsdbPortUpdateCommand).updateVlanMode(any(Port.class),
466 any(OvsdbTerminationPointAugmentationBuilder.class));
467 verify(ovsdbPortUpdateCommand).updatePortExternalIds(any(Port.class),
468 any(OvsdbTerminationPointAugmentationBuilder.class));
469 verify(ovsdbPortUpdateCommand).updatePortOtherConfig(any(Port.class),
470 any(OvsdbTerminationPointAugmentationBuilder.class));
473 @SuppressWarnings("unchecked")
475 public void testUpdateVlan() throws Exception {
476 Port port = mock(Port.class);
477 Column<GenericTableSchema, Set<Long>> column = mock(Column.class);
478 when(port.getTagColumn()).thenReturn(column);
479 Set<Long> vlanId = new HashSet<>();
480 vlanId.add((long) 808);
481 when(column.getData()).thenReturn(vlanId);
482 PowerMockito.whenNew(VlanId.class).withAnyArguments().thenReturn(mock(VlanId.class));
483 OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder = mock(
484 OvsdbTerminationPointAugmentationBuilder.class);
485 when(ovsdbTerminationPointBuilder.setVlanTag(any(VlanId.class))).thenReturn(ovsdbTerminationPointBuilder);
486 Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updateVlan", port, ovsdbTerminationPointBuilder);
487 verify(ovsdbTerminationPointBuilder).setVlanTag(any(VlanId.class));
490 @SuppressWarnings("unchecked")
492 public void testUpdateVlanTrunks() throws Exception {
493 Port port = mock(Port.class);
494 Column<GenericTableSchema, Set<Long>> column = mock(Column.class);
495 when(port.getTrunksColumn()).thenReturn(column);
496 Set<Long> portTrunks = new HashSet<>();
497 portTrunks.add((long) 300);
498 when(column.getData()).thenReturn(portTrunks);
500 TrunksBuilder trunksBuilder = mock(TrunksBuilder.class);
501 PowerMockito.whenNew(TrunksBuilder.class).withNoArguments().thenReturn(trunksBuilder);
502 PowerMockito.whenNew(VlanId.class).withAnyArguments().thenReturn(mock(VlanId.class));
503 when(trunksBuilder.setTrunk(any(VlanId.class))).thenReturn(trunksBuilder);
504 OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder = mock(
505 OvsdbTerminationPointAugmentationBuilder.class);
506 when(ovsdbTerminationPointBuilder.setTrunks(any(List.class))).thenReturn(ovsdbTerminationPointBuilder);
507 Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updateVlanTrunks", port, ovsdbTerminationPointBuilder);
508 verify(trunksBuilder).setTrunk(any(VlanId.class));
509 verify(ovsdbTerminationPointBuilder).setTrunks(any(List.class));
512 @SuppressWarnings("unchecked")
514 public void testUpdateVlanMode() throws Exception {
515 Port port = mock(Port.class);
516 Column<GenericTableSchema, Set<String>> column = mock(Column.class);
517 when(port.getVlanModeColumn()).thenReturn(column);
518 Set<String> set = new HashSet<>();
519 set.add(VLAN_MODE_ACCESS);
520 when(column.getData()).thenReturn(set);
521 OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder = mock(
522 OvsdbTerminationPointAugmentationBuilder.class);
523 when(ovsdbTerminationPointBuilder.setVlanMode(OvsdbPortInterfaceAttributes.VlanMode.Access))
524 .thenReturn(ovsdbTerminationPointBuilder);
525 Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updateVlanMode", port, ovsdbTerminationPointBuilder);
526 verify(ovsdbTerminationPointBuilder).setVlanMode(any(VlanMode.class));
529 @SuppressWarnings("unchecked")
531 public void testUpdateOfPort() throws Exception {
532 Interface interf = mock(Interface.class);
533 Set<Long> ofPorts = new HashSet<>();
534 ofPorts.add((long) 10000);
535 Column<GenericTableSchema, Set<Long>> column = mock(Column.class);
536 when(interf.getOpenFlowPortColumn()).thenReturn(column);
537 when(column.getData()).thenReturn(ofPorts);
538 OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder = mock(
539 OvsdbTerminationPointAugmentationBuilder.class);
540 when(ovsdbTerminationPointBuilder.setOfport(any(Uint32.class))).thenReturn(ovsdbTerminationPointBuilder);
541 when(interf.getName()).thenReturn(INTERFACE_NAME);
542 Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updateOfPort", interf, ovsdbTerminationPointBuilder);
543 verify(ovsdbTerminationPointBuilder).setOfport(any(Uint32.class));
546 @SuppressWarnings("unchecked")
548 public void testUpdateOfPortRequest() throws Exception {
549 Interface interf = mock(Interface.class);
550 Set<Long> ofPortRequests = new HashSet<>();
551 ofPortRequests.add((long) 10000);
552 Column<GenericTableSchema, Set<Long>> column = mock(Column.class);
553 when(interf.getOpenFlowPortRequestColumn()).thenReturn(column);
554 when(column.getData()).thenReturn(ofPortRequests);
555 OvsdbTerminationPointAugmentationBuilder ovsdbTerminationPointBuilder = mock(
556 OvsdbTerminationPointAugmentationBuilder.class);
557 when(ovsdbTerminationPointBuilder.setOfportRequest(any(Uint16.class)))
558 .thenReturn(ovsdbTerminationPointBuilder);
559 when(interf.getName()).thenReturn(INTERFACE_NAME);
560 Whitebox.invokeMethod(ovsdbPortUpdateCommand, "updateOfPortRequest", interf, ovsdbTerminationPointBuilder);
561 verify(ovsdbTerminationPointBuilder).setOfportRequest(any(Uint16.class));
564 @SuppressWarnings("unchecked")
566 public void testUpdateInterfaceExternalIds() throws Exception {
567 Interface interf = mock(Interface.class);
568 Column<GenericTableSchema, Map<String, String>> column = mock(Column.class);
569 when(interf.getExternalIdsColumn()).thenReturn(column);
570 Map<String, String> map = new HashMap<>();
571 when(column.getData()).thenReturn(map);
572 map.put(EXTERNAL_ID_KEY, EXTERNAL_ID_VALUE);
573 when(column.getData()).thenReturn(map);
575 var builder = new OvsdbTerminationPointAugmentationBuilder();
576 ovsdbPortUpdateCommand.updateInterfaceExternalIds(interf, builder);
577 var list = builder.build().nonnullInterfaceExternalIds().values();
578 assertEquals(1, list.size());
579 var result = list.iterator().next();
580 assertEquals(EXTERNAL_ID_KEY, result.getExternalIdKey());
581 assertEquals(EXTERNAL_ID_VALUE, result.getExternalIdValue());
584 @SuppressWarnings("unchecked")
586 public void testUpdatePortExternalIds() throws Exception {
587 Port port = mock(Port.class);
588 Column<GenericTableSchema, Map<String, String>> column = mock(Column.class);
589 when(port.getExternalIdsColumn()).thenReturn(column);
590 Map<String, String> map = new HashMap<>();
591 when(column.getData()).thenReturn(map);
592 map.put(EXTERNAL_ID_KEY, EXTERNAL_ID_VALUE);
593 when(column.getData()).thenReturn(map);
595 var builder = new OvsdbTerminationPointAugmentationBuilder();
596 ovsdbPortUpdateCommand.updatePortExternalIds(port, builder);
597 var list = builder.build().nonnullPortExternalIds().values();
598 assertEquals(1, list.size());
599 var result = list.iterator().next();
600 assertEquals(EXTERNAL_ID_KEY, result.getExternalIdKey());
601 assertEquals(EXTERNAL_ID_VALUE, result.getExternalIdValue());
604 @SuppressWarnings("unchecked")
606 public void testUpdatePortOtherConfig() throws Exception {
607 Port port = mock(Port.class);
608 Column<GenericTableSchema, Map<String, String>> column = mock(Column.class);
609 when(port.getOtherConfigColumn()).thenReturn(column);
610 Map<String, String> map = new HashMap<>();
611 map.put(OTHER_CONFIG_KEY, OTHER_CONFIG_VALUE);
612 when(column.getData()).thenReturn(map);
614 var builder = new OvsdbTerminationPointAugmentationBuilder();
615 ovsdbPortUpdateCommand.updatePortOtherConfig(port, builder);
616 var list = builder.build().nonnullPortOtherConfigs().values();
617 assertEquals(1, list.size());
618 var result = list.iterator().next();
619 assertEquals(OTHER_CONFIG_KEY, result.getOtherConfigKey());
620 assertEquals(OTHER_CONFIG_VALUE, result.getOtherConfigValue());
623 @SuppressWarnings("unchecked")
625 public void testUpdateInterfaceOtherConfig() throws Exception {
626 Interface interf = mock(Interface.class);
627 Map<String, String> interfaceOtherConfigMap = new HashMap<>();
628 interfaceOtherConfigMap.put(OTHER_CONFIG_KEY, OTHER_CONFIG_VALUE);
629 Column<GenericTableSchema, Map<String, String>> column = mock(Column.class);
630 when(interf.getOtherConfigColumn()).thenReturn(column);
631 when(column.getData()).thenReturn(interfaceOtherConfigMap);
633 var builder = new OvsdbTerminationPointAugmentationBuilder();
634 ovsdbPortUpdateCommand.updateInterfaceOtherConfig(interf, builder);
635 var list = builder.build().nonnullInterfaceOtherConfigs().values();
636 assertEquals(1, list.size());
637 var result = list.iterator().next();
638 assertEquals(OTHER_CONFIG_KEY, result.getOtherConfigKey());
639 assertEquals(OTHER_CONFIG_VALUE, result.getOtherConfigValue());
642 @SuppressWarnings("unchecked")
644 // TODO This test needs to be re-done
645 @Ignore("Broken mock-based test")
646 public void testGetInstanceIdentifier() throws Exception {
647 Port port = mock(Port.class);
648 Column<GenericTableSchema, Map<String, String>> column = mock(Column.class);
649 when(port.getExternalIdsColumn()).thenReturn(column);
650 Map<String, String> map = new HashMap<>();
651 map.put(SouthboundConstants.IID_EXTERNAL_ID_KEY, "opendaylight-iid");
652 when(column.getData()).thenReturn(map);
654 PowerMockito.mockStatic(SouthboundUtil.class);
655 InstanceIdentifier<TerminationPoint> terminationPointIId = mock(InstanceIdentifier.class);
657 // .when((InstanceIdentifier<TerminationPoint>) SouthboundUtil.deserializeInstanceIdentifier(
658 // any(InstanceIdentifierCodec.class), anyString()))
659 // .thenReturn(terminationPointIId);
660 InstanceIdentifier<Node> bridgeIid = mock(InstanceIdentifier.class);
661 assertEquals(terminationPointIId,
662 Whitebox.invokeMethod(ovsdbPortUpdateCommand, "getInstanceIdentifier", bridgeIid, port));