/*
- * Copyright (c) 2015 Inocybe Technologies and others. All rights reserved.
+ * Copyright © 2015, 2017 Inocybe Technologies and others. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 which accompanies this distribution,
package org.opendaylight.ovsdb.southbound.transactions.md;
import static org.junit.Assert.assertEquals;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyString;
-import static org.mockito.Matchers.eq;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import com.google.common.base.Optional;
+import com.google.common.collect.Iterators;
import com.google.common.net.InetAddresses;
-import java.net.InetAddress;
import java.net.NetworkInterface;
import java.util.ArrayList;
-import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.Set;
-import org.apache.commons.lang3.math.NumberUtils;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
-import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.ReadWriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.notation.Column;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.schema.typed.TyperUtils;
import org.opendaylight.ovsdb.schema.openvswitch.Bridge;
import org.opendaylight.ovsdb.schema.openvswitch.Controller;
+import org.opendaylight.ovsdb.southbound.InstanceIdentifierCodec;
import org.opendaylight.ovsdb.southbound.OvsdbConnectionInstance;
import org.opendaylight.ovsdb.southbound.SouthboundMapper;
import org.opendaylight.ovsdb.southbound.SouthboundUtil;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.IpAddress;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
-import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.PortNumber;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Uri;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.DatapathId;
@RunWith(PowerMockRunner.class)
@PrepareForTest({ TyperUtils.class, OvsdbBridgeUpdateCommand.class, SouthboundUtil.class, InstanceIdentifier.class,
- SouthboundMapper.class, InetAddresses.class, NumberUtils.class, NetworkInterface.class })
+ SouthboundMapper.class, NetworkInterface.class })
public class OvsdbBridgeUpdateCommandTest {
- private Map<UUID,Bridge> updatedBridgeRows = new HashMap<>();
- private Map<UUID, Bridge> oldBridgeRows = new HashMap<>();
+ private final Map<UUID,Bridge> updatedBridgeRows = new HashMap<>();
+ private final Map<UUID, Bridge> oldBridgeRows = new HashMap<>();
private OvsdbBridgeUpdateCommand ovsdbBridgeUpdateCommand;
+ private final Map<NodeId, Node> updatedBridgeNodes = new HashMap<>();
@Before
public void setUp() throws Exception {
ovsdbBridgeUpdateCommand = PowerMockito.mock(OvsdbBridgeUpdateCommand.class, Mockito.CALLS_REAL_METHODS);
+ MemberModifier.field(OvsdbBridgeUpdateCommand.class, "updatedBridges")
+ .set(ovsdbBridgeUpdateCommand, new ArrayList<>());
MemberModifier.field(OvsdbBridgeUpdateCommand.class, "updatedBridgeRows").set(ovsdbBridgeUpdateCommand,
updatedBridgeRows);
+ MemberModifier.field(OvsdbBridgeUpdateCommand.class, "updatedBridgeNodes").set(
+ ovsdbBridgeUpdateCommand,updatedBridgeNodes);
}
@Test
OvsdbConnectionInstance key = mock(OvsdbConnectionInstance.class);
TableUpdates updates = mock(TableUpdates.class);
DatabaseSchema dbSchema = mock(DatabaseSchema.class);
- OvsdbBridgeUpdateCommand ovsdbBridgeUpdateCommand1 = new OvsdbBridgeUpdateCommand(key, updates, dbSchema);
+ OvsdbBridgeUpdateCommand ovsdbBridgeUpdateCommand1 =
+ new OvsdbBridgeUpdateCommand(mock(InstanceIdentifierCodec.class), key, updates, dbSchema,
+ updatedBridgeNodes);
assertEquals(key, Whitebox.getInternalState(ovsdbBridgeUpdateCommand1, "key"));
assertEquals(updates, Whitebox.getInternalState(ovsdbBridgeUpdateCommand1, "updates"));
assertEquals(dbSchema, Whitebox.getInternalState(ovsdbBridgeUpdateCommand1, "dbSchema"));
@Test
public void testExecute() throws Exception {
- ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
updatedBridgeRows.put(mock(UUID.class), mock(Bridge.class));
- MemberModifier.suppress(MemberMatcher.method(OvsdbBridgeUpdateCommand.class, "updateBridge",
- ReadWriteTransaction.class, Bridge.class));
- ovsdbBridgeUpdateCommand.execute(transaction);
- PowerMockito.verifyPrivate(ovsdbBridgeUpdateCommand).invoke("updateBridge", any(ReadWriteTransaction.class),
- any(Bridge.class));
- }
- @SuppressWarnings("unchecked")
- @Test
- public void testUpdateBridge() throws Exception {
OvsdbConnectionInstance ovsdbConnectionInstance = mock(OvsdbConnectionInstance.class);
when(ovsdbBridgeUpdateCommand.getOvsdbConnectionInstance()).thenReturn(ovsdbConnectionInstance);
InstanceIdentifier<Node> connectionIId = mock(InstanceIdentifier.class);
when(ovsdbConnectionInstance.getInstanceIdentifier()).thenReturn(connectionIId);
- Optional<Node> connection = mock(Optional.class);
+ Optional<Node> connection = Optional.of(mock(Node.class));
PowerMockito.mockStatic(SouthboundUtil.class);
when(SouthboundUtil.readNode(any(ReadWriteTransaction.class), any(InstanceIdentifier.class)))
.thenReturn(connection);
- when(connection.isPresent()).thenReturn(true);
+ ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
+ MemberModifier.suppress(MemberMatcher.method(OvsdbBridgeUpdateCommand.class, "updateBridge",
+ ReadWriteTransaction.class, Bridge.class, InstanceIdentifier.class));
+ ovsdbBridgeUpdateCommand.execute(transaction);
+ verify(ovsdbBridgeUpdateCommand).updateBridge(any(ReadWriteTransaction.class),
+ any(Bridge.class), any(InstanceIdentifier.class));
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ public void testUpdateBridge() throws Exception {
MemberModifier
.suppress(MemberMatcher.method(OvsdbBridgeUpdateCommand.class, "buildConnectionNode", Bridge.class));
ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
InstanceIdentifier.class, Bridge.class));
MemberModifier.suppress(MemberMatcher.method(OvsdbBridgeUpdateCommand.class, "bridgeOtherConfigsToRemove",
InstanceIdentifier.class, Bridge.class));
+ MemberModifier.suppress(MemberMatcher.method(OvsdbBridgeUpdateCommand.class, "getNodeId",
+ Bridge.class));
Bridge bridge = mock(Bridge.class);
- Whitebox.invokeMethod(ovsdbBridgeUpdateCommand, "updateBridge", transaction, bridge);
- PowerMockito.verifyPrivate(ovsdbBridgeUpdateCommand, times(3)).invoke("deleteEntries",
- any(ReadWriteTransaction.class), any(Bridge.class));
- verify(ovsdbConnectionInstance).getInstanceIdentifier();
+ InstanceIdentifier<Node> connectionIId = mock(InstanceIdentifier.class);
+ Whitebox.invokeMethod(ovsdbBridgeUpdateCommand, "updateBridge", transaction, bridge, connectionIId);
+ verify(ovsdbBridgeUpdateCommand, times(3)).deleteEntries(any(ReadWriteTransaction.class), eq(null));
}
@SuppressWarnings("unchecked")
List<InstanceIdentifier<DataObject>> entryIids = new ArrayList<>();
InstanceIdentifier<DataObject> iid = mock(InstanceIdentifier.class);
entryIids.add(iid);
- doNothing().when(transaction).delete(any(LogicalDatastoreType.class), (InstanceIdentifier<?>) any(List.class));
+ doNothing().when(transaction).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
Whitebox.invokeMethod(ovsdbBridgeUpdateCommand, "deleteEntries", transaction, entryIids);
- verify(transaction).delete(any(LogicalDatastoreType.class), (InstanceIdentifier<?>) any(List.class));
+ verify(transaction).delete(any(LogicalDatastoreType.class), any(InstanceIdentifier.class));
}
@SuppressWarnings("unchecked")
.thenReturn(ovsdbConnectionAugmentationBuilder);
PowerMockito.mockStatic(SouthboundMapper.class);
InstanceIdentifier<Node> bridgeIid = mock(InstanceIdentifier.class);
- when(SouthboundMapper.createInstanceIdentifier(any(OvsdbConnectionInstance.class), any(Bridge.class)))
+ when(SouthboundMapper.createInstanceIdentifier(any(InstanceIdentifierCodec.class),
+ any(OvsdbConnectionInstance.class), any(Bridge.class)))
.thenReturn(bridgeIid);
- ManagedNodeEntry managedBridge = mock(ManagedNodeEntry.class);
+
+ ManagedNodeEntry managedBridge = new ManagedNodeEntryBuilder()
+ .setBridgeRef(new OvsdbBridgeRef(mock(InstanceIdentifier.class)))
+ .build();
+
ManagedNodeEntryBuilder managedNodeEntryBuilder = mock(ManagedNodeEntryBuilder.class);
PowerMockito.whenNew(ManagedNodeEntryBuilder.class).withNoArguments().thenReturn(managedNodeEntryBuilder);
PowerMockito.whenNew(OvsdbBridgeRef.class).withAnyArguments().thenReturn(mock(OvsdbBridgeRef.class));
when(ovsdbConnectionAugmentationBuilder.setManagedNodeEntry(any(List.class)))
.thenReturn(ovsdbConnectionAugmentationBuilder);
- when(ovsdbConnectionAugmentationBuilder.build()).thenReturn(mock(OvsdbNodeAugmentation.class) );
- when(connectionNode.addAugmentation(eq(OvsdbNodeAugmentation.class), any(OvsdbNodeAugmentation.class)))
- .thenReturn(connectionNode);
+ when(ovsdbConnectionAugmentationBuilder.build()).thenReturn(mock(OvsdbNodeAugmentation.class));
+ when(connectionNode.addAugmentation(any(OvsdbNodeAugmentation.class))).thenReturn(connectionNode);
//for logger
- List<ManagedNodeEntry> value = new ArrayList<>();
- value.add(managedBridge);
- when(ovsdbConnectionAugmentationBuilder.getManagedNodeEntry()).thenReturn(value);
+ when(ovsdbConnectionAugmentationBuilder.getManagedNodeEntry())
+ .thenReturn(Map.of(managedBridge.key(), managedBridge));
Node node = mock(Node.class);
when(connectionNode.build()).thenReturn(node);
OvsdbBridgeAugmentationBuilder.class));
when(ovsdbBridgeAugmentationBuilder.build()).thenReturn(mock(OvsdbBridgeAugmentation.class));
- when(bridgeNodeBuilder.addAugmentation(eq(OvsdbBridgeAugmentation.class), any(OvsdbBridgeAugmentation.class)))
- .thenReturn(bridgeNodeBuilder);
+ when(bridgeNodeBuilder.addAugmentation(any(OvsdbBridgeAugmentation.class))).thenReturn(bridgeNodeBuilder);
Node node = mock(Node.class);
when(bridgeNodeBuilder.build()).thenReturn(node);
assertEquals(node, Whitebox.invokeMethod(ovsdbBridgeUpdateCommand, "buildBridgeNode", bridge));
when(column.getData()).thenReturn("system");
PowerMockito.mockStatic(SouthboundMapper.class);
when(SouthboundMapper.createDatapathType(anyString()))
- .thenAnswer(new Answer<Class<? extends DatapathTypeBase>>() {
- public Class<? extends DatapathTypeBase> answer(InvocationOnMock invocation) throws Throwable {
- return DatapathTypeSystem.class;
- }
- });
+ .thenAnswer((Answer<Class<? extends DatapathTypeBase>>) invocation -> DatapathTypeSystem.class);
OvsdbBridgeAugmentationBuilder ovsdbBridgeAugmentationBuilder = mock(OvsdbBridgeAugmentationBuilder.class);
when(ovsdbBridgeAugmentationBuilder.setDatapathType(any(Class.class)))
.thenReturn(ovsdbBridgeAugmentationBuilder);
when(controllerEntry.getTarget()).thenReturn(uri);
when(uri.getValue()).thenReturn("tcp:192.168.12.56:6633");
- IpAddress bridgeControllerIpAddress = mock(IpAddress.class);
- PowerMockito.mockStatic(InetAddresses.class);
- when(InetAddresses.isInetAddress("192.168.12.56")).thenReturn(true);
- PowerMockito.whenNew(IpAddress.class).withAnyArguments().thenReturn(bridgeControllerIpAddress);
-
-
- PowerMockito.mockStatic(NumberUtils.class);
- when(NumberUtils.isNumber("6633")).thenReturn(true);
- PortNumber bridgeControllerPortNumber = mock(PortNumber.class);
- PowerMockito.whenNew(PortNumber.class).withAnyArguments().thenReturn(bridgeControllerPortNumber);
-
PowerMockito.mockStatic(NetworkInterface.class);
- Enumeration<NetworkInterface> networkInterfaces = mock(Enumeration.class);
- when(NetworkInterface.getNetworkInterfaces()).thenReturn(networkInterfaces);
-
- when(networkInterfaces.hasMoreElements()).thenReturn(true, false);
NetworkInterface networkInterface = PowerMockito.mock(NetworkInterface.class);
- when(networkInterfaces.nextElement()).thenReturn(networkInterface);
-
- Enumeration<InetAddress> networkInterfaceAddresses = mock(Enumeration.class);
- when(networkInterface.getInetAddresses()).thenReturn(networkInterfaceAddresses);
- when(networkInterfaceAddresses.hasMoreElements()).thenReturn(true, false);
- InetAddress networkInterfaceAddress = PowerMockito.mock(InetAddress.class);
- when(networkInterfaceAddresses.nextElement()).thenReturn(networkInterfaceAddress);
-
- Ipv4Address ipv4Address = mock(Ipv4Address.class);
- when(bridgeControllerIpAddress.getIpv4Address()).thenReturn(ipv4Address);
- when(ipv4Address.getValue()).thenReturn("127.0.0.1");
- when(networkInterfaceAddress.getHostAddress()).thenReturn("127.0.0.1");
- assertEquals(bridgeControllerIpAddress.getIpv4Address().getValue(), networkInterfaceAddress.getHostAddress());
+ when(networkInterface.getInetAddresses()).thenReturn(Iterators.asEnumeration(
+ Iterators.singletonIterator(InetAddresses.forString("192.168.12.56"))));
+ when(NetworkInterface.getNetworkInterfaces()).thenReturn(Iterators.asEnumeration(
+ Iterators.singletonIterator(networkInterface)));
+
OvsdbConnectionInstance ovsdbConnectionInstance = mock(OvsdbConnectionInstance.class);
when(ovsdbBridgeUpdateCommand.getOvsdbConnectionInstance()).thenReturn(ovsdbConnectionInstance);
when(ovsdbConnectionInstance.getInstanceIdentifier()).thenReturn(mock(InstanceIdentifier.class));
verify(controllerEntry, times(2)).isIsConnected();
verify(ovsdbBridgeAugmentationBuilder).setBridgeOpenflowNodeRef(any(InstanceIdentifier.class));
}
-
- @SuppressWarnings("unchecked")
- @Test
- public void testGetInstanceIdentifier() throws Exception {
- PowerMockito.mockStatic(SouthboundMapper.class);
- when(ovsdbBridgeUpdateCommand.getOvsdbConnectionInstance()).thenReturn(mock(OvsdbConnectionInstance.class));
- InstanceIdentifier<Node> iid = mock(InstanceIdentifier.class);
- when(SouthboundMapper.createInstanceIdentifier(any(OvsdbConnectionInstance.class), any(Bridge.class)))
- .thenReturn(iid);
-
- assertEquals(iid, Whitebox.invokeMethod(ovsdbBridgeUpdateCommand, "getInstanceIdentifier", mock(Bridge.class)));
- }
}
Code Review / ovsdb.git / blobdiff