import static org.opendaylight.ovsdb.lib.operations.Operations.op;
+import com.google.common.annotations.VisibleForTesting;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import java.util.Collection;
}
}
- private void monitorTables(String database, DatabaseSchema dbSchema) {
+ @VisibleForTesting
+ void monitorTables(String database, DatabaseSchema dbSchema) {
Set<String> tables = dbSchema.getTables();
if (tables != null) {
List<MonitorRequest> monitorRequests = new ArrayList<>();
import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.CONFIGURATION;
+import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Optional;
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.FutureCallback;
return changes;
}
- private void reconcileBridgeConfigurations(final Map<InstanceIdentifier<?>, DataObject> changes) {
+ @VisibleForTesting
+ void reconcileBridgeConfigurations(final Map<InstanceIdentifier<?>, DataObject> changes) {
DataChangeEvent changeEvents = new DataChangeEvent() {
@Override
public Map<InstanceIdentifier<?>, DataObject> getCreatedData() {
import static org.opendaylight.ovsdb.southbound.SouthboundUtil.schemaMismatchLog;
+import com.google.common.annotations.VisibleForTesting;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
}
}
- private void removeOldConfigs(ReadWriteTransaction transaction,
- Map<String, String> oldOtherConfigs, OpenVSwitch ovs) {
+ @VisibleForTesting
+ void removeOldConfigs(ReadWriteTransaction transaction, Map<String, String> oldOtherConfigs, OpenVSwitch ovs) {
InstanceIdentifier<OvsdbNodeAugmentation> nodeAugmentataionIid = InstanceIdentifier
.create(NetworkTopology.class)
.child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
}
}
- private void setNewOtherConfigs(OvsdbNodeAugmentationBuilder ovsdbNodeBuilder,
- Map<String, String> otherConfigs) {
+ @VisibleForTesting
+ void setNewOtherConfigs(OvsdbNodeAugmentationBuilder ovsdbNodeBuilder, Map<String, String> otherConfigs) {
List<OpenvswitchOtherConfigs> otherConfigsList = new ArrayList<>();
for (Entry<String, String> entry : otherConfigs.entrySet()) {
String otherConfigKey = entry.getKey();
}
}
- private void removeExternalIds(ReadWriteTransaction transaction,
- Map<String, String> oldExternalIds, OpenVSwitch ovs) {
+ @VisibleForTesting
+ void removeExternalIds(ReadWriteTransaction transaction, Map<String, String> oldExternalIds, OpenVSwitch ovs) {
InstanceIdentifier<OvsdbNodeAugmentation> nodeAugmentataionIid = InstanceIdentifier
.create(NetworkTopology.class)
.child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
}
}
- private void setNewExternalIds(OvsdbNodeAugmentationBuilder ovsdbNodeBuilder,
- Map<String, String> externalIds) {
+ @VisibleForTesting
+ void setNewExternalIds(OvsdbNodeAugmentationBuilder ovsdbNodeBuilder, Map<String, String> externalIds) {
List<OpenvswitchExternalIds> externalIdsList = new ArrayList<>();
for (Entry<String, String> entry : externalIds.entrySet()) {
String externalIdKey = entry.getKey();
return getOvsdbConnectionInstance().getInstanceIdentifier();
}
- private NodeId getNodeId(OpenVSwitch ovs) {
+ @VisibleForTesting
+ NodeId getNodeId(OpenVSwitch ovs) {
NodeKey nodeKey = getInstanceIdentifier(ovs).firstKeyOf(Node.class);
return nodeKey.getNodeId();
}
package org.opendaylight.ovsdb.southbound.transactions.md;
+import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Optional;
import com.google.common.util.concurrent.CheckedFuture;
import java.util.concurrent.ExecutionException;
}
}
- private boolean checkIfOnlyConnectedManager(OvsdbNodeAugmentation ovsdbNodeAugmentation) {
+ @VisibleForTesting
+ boolean checkIfOnlyConnectedManager(OvsdbNodeAugmentation ovsdbNodeAugmentation) {
ManagerEntry onlyConnectedManager = null;
if (ovsdbNodeAugmentation != null) {
int connectedManager = 0;
package org.opendaylight.ovsdb.southbound.transactions.md;
+import com.google.common.annotations.VisibleForTesting;
import com.google.common.util.concurrent.FutureCallback;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.MoreExecutors;
}
}
- private List<TransactionCommand> extractResubmitCommands() {
+ @VisibleForTesting
+ List<TransactionCommand> extractResubmitCommands() {
AsyncTransaction<?, ?> transaction = failedTransactionQueue.poll();
List<TransactionCommand> commands = new ArrayList<>();
if (transaction != null) {
return commands;
}
- private void resetTransactionQueue() {
+ @VisibleForTesting
+ void resetTransactionQueue() {
chain.close();
chain = db.createTransactionChain(this);
pendingTransactions = new ArrayList<>();
return commands;
}
- private List<TransactionCommand> extractCommandsFromQueue() throws InterruptedException {
+ @VisibleForTesting
+ List<TransactionCommand> extractCommandsFromQueue() throws InterruptedException {
List<TransactionCommand> result = new ArrayList<>();
TransactionCommand command = inputQueue.take();
while (command != null) {
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyString;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import static org.powermock.api.support.membermodification.MemberMatcher.field;
+import static org.powermock.reflect.Whitebox.getField;
import com.google.common.collect.ImmutableSet;
import java.net.URI;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
import org.mockito.stubbing.Answer;
import org.opendaylight.mdsal.binding.dom.codec.api.BindingNormalizedNodeSerializer;
import org.opendaylight.mdsal.dom.api.DOMSchemaService;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
-import org.opendaylight.yangtools.yang.data.util.AbstractModuleStringInstanceIdentifierCodec;
import org.opendaylight.yangtools.yang.data.util.DataSchemaContextTree;
import org.opendaylight.yangtools.yang.model.api.Module;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-import org.powermock.api.mockito.PowerMockito;
-import org.powermock.core.classloader.annotations.PrepareForTest;
-import org.powermock.modules.junit4.PowerMockRunner;
-@RunWith(PowerMockRunner.class)
-@PrepareForTest({ AbstractModuleStringInstanceIdentifierCodec.class, DataSchemaContextTree.class })
+@RunWith(MockitoJUnitRunner.class)
public class InstanceIdentifierCodecTest {
private InstanceIdentifierCodec instanceIdCodec;
- @Mock
private DataSchemaContextTree dataSchemaContextTree;
+
@Mock
private SchemaContext context;
@Mock
@Before
public void setUp() throws IllegalArgumentException, IllegalAccessException {
+ when(context.getQName()).thenReturn(SchemaContext.NAME);
+ dataSchemaContextTree = DataSchemaContextTree.from(context);
+
instanceIdCodec = mock(InstanceIdentifierCodec.class, Mockito.CALLS_REAL_METHODS);
- field(InstanceIdentifierCodec.class, "dataSchemaContextTree").set(instanceIdCodec, dataSchemaContextTree);
- field(InstanceIdentifierCodec.class, "context").set(instanceIdCodec, context);
- field(InstanceIdentifierCodec.class, "bindingNormalizedNodeSerializer").set(instanceIdCodec,
+ getField(InstanceIdentifierCodec.class, "dataSchemaContextTree").set(instanceIdCodec, dataSchemaContextTree);
+ getField(InstanceIdentifierCodec.class, "context").set(instanceIdCodec, context);
+ getField(InstanceIdentifierCodec.class, "bindingNormalizedNodeSerializer").set(instanceIdCodec,
bindingNormalizedNodeSerializer);
}
assertEquals("Found prefix", prefix, instanceIdCodec.prefixForNamespace(namespace));
}
- @Test
- public void testOnGlobalContextUpdated() {
- PowerMockito.mockStatic(DataSchemaContextTree.class);
- when(DataSchemaContextTree.from(any(SchemaContext.class))).thenReturn(dataSchemaContextTree);
- instanceIdCodec.onGlobalContextUpdated(context);
- verify(instanceIdCodec).onGlobalContextUpdated(context);
- }
-
@Test
public void testSerialize() {
InstanceIdentifier<?> iid = mock(InstanceIdentifier.class);
YangInstanceIdentifier yiid = mock(YangInstanceIdentifier.class);
when(bindingNormalizedNodeSerializer.toYangInstanceIdentifier(iid)).thenReturn(yiid);
-
- when(PowerMockito.mock(AbstractModuleStringInstanceIdentifierCodec.class).serialize(yiid))
- .thenReturn("Serialized IID");
- assertEquals("Error, did not return correct string", anyString(), instanceIdCodec.serialize(iid));
+ assertEquals("Error, did not return correct string", "", instanceIdCodec.serialize(iid));
}
@Test
public void testBindingDeserializer() throws Exception {
YangInstanceIdentifier yiid = mock(YangInstanceIdentifier.class);
- when(PowerMockito.mock(AbstractModuleStringInstanceIdentifierCodec.class).deserialize(anyString()))
- .thenReturn(yiid);
-
- mock(InstanceIdentifier.class);
when(bindingNormalizedNodeSerializer.fromYangInstanceIdentifier(yiid)).thenAnswer(
(Answer<InstanceIdentifier<?>>) invocation -> (InstanceIdentifier<?>) invocation.getArguments()[0]);
- assertEquals("Error, did not return correct InstanceIdentifier<?> object", any(InstanceIdentifier.class),
- instanceIdCodec.bindingDeserializer(""));
+ assertNull("Error, did not return correct InstanceIdentifier<?> object",
+ instanceIdCodec.bindingDeserializer(""));
}
}
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import static org.powermock.api.support.membermodification.MemberMatcher.field;
-import static org.powermock.api.support.membermodification.MemberModifier.suppress;
+import static org.powermock.reflect.Whitebox.getField;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.ArrayList;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
import org.opendaylight.ovsdb.lib.LockAquisitionCallback;
import org.opendaylight.ovsdb.lib.LockStolenCallback;
import org.opendaylight.ovsdb.lib.MonitorCallBack;
import org.opendaylight.ovsdb.lib.MonitorHandle;
import org.opendaylight.ovsdb.lib.OvsdbClient;
import org.opendaylight.ovsdb.lib.OvsdbConnectionInfo;
-import org.opendaylight.ovsdb.lib.message.MonitorRequestBuilder;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.operations.OperationResult;
import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.powermock.api.mockito.PowerMockito;
-import org.powermock.api.support.membermodification.MemberMatcher;
-import org.powermock.api.support.membermodification.MemberModifier;
-import org.powermock.core.classloader.annotations.PrepareForTest;
-import org.powermock.modules.junit4.PowerMockRunner;
import org.powermock.reflect.Whitebox;
-@RunWith(PowerMockRunner.class)
-@PrepareForTest({OvsdbConnectionInstance.class, MonitorRequestBuilder.class})
+@RunWith(MockitoJUnitRunner.class)
public class OvsdbConnectionInstanceTest {
@Mock private OvsdbConnectionInstance ovsdbConnectionInstance;
@Before
public void setUp() throws Exception {
- ovsdbConnectionInstance = PowerMockito.mock(OvsdbConnectionInstance.class, Mockito.CALLS_REAL_METHODS);
- field(OvsdbConnectionInstance.class, "txInvoker").set(ovsdbConnectionInstance, txInvoker);
- field(OvsdbConnectionInstance.class, "connectionInfo").set(ovsdbConnectionInstance, key);
- field(OvsdbConnectionInstance.class, "instanceIdentifier").set(ovsdbConnectionInstance, instanceIdentifier);
- field(OvsdbConnectionInstance.class, "hasDeviceOwnership").set(ovsdbConnectionInstance, false);
+ ovsdbConnectionInstance = mock(OvsdbConnectionInstance.class, Mockito.CALLS_REAL_METHODS);
+ getField(OvsdbConnectionInstance.class, "txInvoker").set(ovsdbConnectionInstance, txInvoker);
+ getField(OvsdbConnectionInstance.class, "connectionInfo").set(ovsdbConnectionInstance, key);
+ getField(OvsdbConnectionInstance.class, "instanceIdentifier").set(ovsdbConnectionInstance, instanceIdentifier);
+ getField(OvsdbConnectionInstance.class, "hasDeviceOwnership").set(ovsdbConnectionInstance, false);
}
@Test
TransactInvoker transactInvoker2 = mock(TransactInvoker.class);
transactInvokers.put(mock(DatabaseSchema.class), transactInvoker1);
transactInvokers.put(mock(DatabaseSchema.class), transactInvoker2);
- field(OvsdbConnectionInstance.class, "transactInvokers").set(ovsdbConnectionInstance , transactInvokers);
+ getField(OvsdbConnectionInstance.class, "transactInvokers").set(ovsdbConnectionInstance , transactInvokers);
TransactCommand command = mock(TransactCommand.class);
ovsdbConnectionInstance.transact(command, mock(BridgeOperationalState.class), mock(DataChangeEvent.class),
InstanceIdentifierCodec instanceIdentifierCodec = mock(InstanceIdentifierCodec.class);
// callback not null case
- MemberModifier.field(OvsdbConnectionInstance.class, "callback").set(ovsdbConnectionInstance , callback);
+ getField(OvsdbConnectionInstance.class, "callback").set(ovsdbConnectionInstance , callback);
ovsdbConnectionInstance.registerCallbacks(instanceIdentifierCodec);
verify(ovsdbConnectionInstance, times(0)).getDatabases();
// callback null case
- MemberModifier.field(OvsdbConnectionInstance.class, "callback").set(ovsdbConnectionInstance , null);
+ getField(OvsdbConnectionInstance.class, "callback").set(ovsdbConnectionInstance , null);
ListenableFuture<List<String>> listenableFuture = mock(ListenableFuture.class);
List<String> databases = new ArrayList<>();
databases.add("Open_vSwitch");
doReturn(listenableDbSchema).when(ovsdbConnectionInstance).getSchema(anyString());
when(listenableDbSchema.get()).thenReturn(dbSchema);
- suppress(MemberMatcher.method(OvsdbConnectionInstance.class, "monitorTables", String.class,
- DatabaseSchema.class));
+ doNothing().when(ovsdbConnectionInstance).monitorTables(anyString(), any(DatabaseSchema.class));
ovsdbConnectionInstance.registerCallbacks(instanceIdentifierCodec);
- PowerMockito.verifyPrivate(ovsdbConnectionInstance, times(1)).invoke("monitorTables", anyString(),
- any(DatabaseSchema.class));
+ verify(ovsdbConnectionInstance, times(1)).monitorTables(anyString(), any(DatabaseSchema.class));
}
@Test
public void testCreateTransactInvokers() throws Exception {
// transactInvokers not null case
transactInvokers = new HashMap();
- field(OvsdbConnectionInstance.class, "transactInvokers").set(ovsdbConnectionInstance , transactInvokers);
+ getField(OvsdbConnectionInstance.class, "transactInvokers").set(ovsdbConnectionInstance , transactInvokers);
ovsdbConnectionInstance.createTransactInvokers();
verify(ovsdbConnectionInstance, times(0)).getSchema(anyString());
// transactInvokers null case
- MemberModifier.field(OvsdbConnectionInstance.class, "transactInvokers").set(ovsdbConnectionInstance , null);
+ getField(OvsdbConnectionInstance.class, "transactInvokers").set(ovsdbConnectionInstance , null);
ListenableFuture<DatabaseSchema> listenableDbSchema = mock(ListenableFuture.class);
DatabaseSchema dbSchema = mock(DatabaseSchema.class);
columns.add("statistics");
when(tableSchema.getColumns()).thenReturn(columns);
- suppress(MemberMatcher.method(OvsdbConnectionInstance.class, "monitor", DatabaseSchema.class, List.class,
- MonitorCallBack.class));
TableUpdates tableUpdates = mock(TableUpdates.class);
- when(ovsdbConnectionInstance.monitor(any(DatabaseSchema.class), any(List.class), any(MonitorCallBack.class)))
- .thenReturn(tableUpdates);
- MemberModifier.field(OvsdbConnectionInstance.class, "callback").set(ovsdbConnectionInstance, callback);
+ doReturn(tableUpdates).when(ovsdbConnectionInstance).monitor(any(DatabaseSchema.class), any(List.class),
+ any(MonitorCallBack.class));
+ getField(OvsdbConnectionInstance.class, "callback").set(ovsdbConnectionInstance, callback);
doNothing().when(callback).update(any(TableUpdates.class), any(DatabaseSchema.class));
Whitebox.invokeMethod(ovsdbConnectionInstance, "monitorTables", "database", dbSchema);
- PowerMockito.verifyPrivate(ovsdbConnectionInstance, times(1)).invoke("monitorTables", anyString(),
- any(DatabaseSchema.class));
+ verify(ovsdbConnectionInstance, times(1)).monitorTables(anyString(), any(DatabaseSchema.class));
}
@SuppressWarnings({ "unchecked" })
@Test
public void testOvsdbConnectionInstance() throws Exception {
- MemberModifier.field(OvsdbConnectionInstance.class, "client").set(ovsdbConnectionInstance, client);
+ getField(OvsdbConnectionInstance.class, "client").set(ovsdbConnectionInstance, client);
// test getDatabases()
ListenableFuture<List<String>> listenableFuture = mock(ListenableFuture.class);
ovsdbConnectionInstance.getInstanceIdentifier());
// test getNodeId()
- NodeKey nodeKey = mock(NodeKey.class);
NodeId nodeId = mock(NodeId.class);
- MemberModifier.suppress(MemberMatcher.method(OvsdbConnectionInstance.class, "getNodeKey"));
+ NodeKey nodeKey = new NodeKey(nodeId);
+ doReturn(nodeKey).when(ovsdbConnectionInstance).getNodeKey();
when(ovsdbConnectionInstance.getNodeKey()).thenReturn(nodeKey);
- when(nodeKey.getNodeId()).thenReturn(nodeId);
assertEquals("Error, incorrect NodeId object", nodeId, ovsdbConnectionInstance.getNodeId());
// test setInstanceIdentifier()
Whitebox.getInternalState(ovsdbConnectionInstance, "instanceIdentifier"));
// test monitor()
- suppress(MemberMatcher.method(OvsdbConnectionInstance.class, "monitor", DatabaseSchema.class, List.class,
- MonitorHandle.class, MonitorCallBack.class));
when(ovsdbConnectionInstance.monitor(any(DatabaseSchema.class), any(List.class), any(MonitorHandle.class),
any(MonitorCallBack.class))).thenReturn(null);
assertNull(ovsdbConnectionInstance.monitor(any(DatabaseSchema.class), any(List.class), any(MonitorHandle.class),
package org.opendaylight.ovsdb.southbound.ovsdb.transact;
+import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.doReturn;
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 static org.powermock.api.support.membermodification.MemberModifier.suppress;
+import static org.powermock.reflect.Whitebox.getField;
import com.google.common.base.Optional;
import java.util.ArrayList;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ControllerEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.bridge.attributes.ProtocolEntry;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPoint;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.powermock.api.mockito.PowerMockito;
-import org.powermock.api.support.membermodification.MemberMatcher;
-import org.powermock.api.support.membermodification.MemberModifier;
-import org.powermock.core.classloader.annotations.PrepareForTest;
-import org.powermock.modules.junit4.PowerMockRunner;
-
-@RunWith(PowerMockRunner.class)
-@PrepareForTest({ BridgeOperationalState.class, Optional.class, InstanceIdentifier.class, Node.class,
- OvsdbBridgeAugmentation.class })
+
+@RunWith(MockitoJUnitRunner.class)
public class BridgeOperationalStateTest {
+ private final Node nd = new NodeBuilder().setNodeId(new NodeId("foo")).build();
+ private final InstanceIdentifier<?> iid = InstanceIdentifier.create(Topology.class);
@Mock private BridgeOperationalState briOperationState;
- @Mock private InstanceIdentifier<ProtocolEntry> protocolEntry;
- @Mock private InstanceIdentifier<?> iid;
- @Mock private InstanceIdentifier<Node> iidNode;
- @Mock private Node nd;
+ private InstanceIdentifier<ProtocolEntry> protocolEntry;
+ private InstanceIdentifier<Node> iidNode;
private Map<InstanceIdentifier<Node>, Node> operationalNodes;
@Before
public void setUp() throws Exception {
+ iidNode = InstanceIdentifier.create(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(new TopologyId("foo")))
+ .child(Node.class, new NodeKey(nd.getNodeId()));
+ protocolEntry = InstanceIdentifier.create(NetworkTopology.class).child(Topology.class).child(Node.class)
+ .augmentation(OvsdbBridgeAugmentation.class).child(ProtocolEntry.class);
+
briOperationState = mock(BridgeOperationalState.class, Mockito.CALLS_REAL_METHODS);
- iid = mock(InstanceIdentifier.class, Mockito.RETURNS_MOCKS);
- protocolEntry = mock(InstanceIdentifier.class, Mockito.RETURNS_MOCKS);
- iidNode = mock(InstanceIdentifier.class, Mockito.RETURNS_MOCKS);
- nd = mock(Node.class, Mockito.RETURNS_MOCKS);
operationalNodes = new HashMap<>();
operationalNodes.put(iidNode, nd);
- MemberModifier.field(BridgeOperationalState.class,"operationalNodes").set(briOperationState, operationalNodes);
- PowerMockito.suppress(MemberMatcher.methodsDeclaredIn(InstanceIdentifier.class));
+ getField(BridgeOperationalState.class,"operationalNodes").set(briOperationState, operationalNodes);
}
@Test
- public void testGetBridgeNode() throws Exception {
+ public void testGetBridgeNode() {
Optional<Node> optNodes = briOperationState.getBridgeNode(iid);
- verify(iid, times(1)).firstIdentifierOf(Node.class);
- assertNotNull(optNodes);
- assertTrue(optNodes.equals(Optional.absent()));
+ assertEquals(Optional.absent(), optNodes);
}
@Test
assertNotNull(optOvsdbBri);
assertTrue(optOvsdbBri.equals(Optional.absent()));
- suppress(MemberMatcher.method(BridgeOperationalState.class, "getBridgeNode", InstanceIdentifier.class));
Node node = mock(Node.class);
Optional<Node> optNode = Optional.of(node);
- when(briOperationState.getBridgeNode(any(InstanceIdentifier.class))).thenReturn(optNode);
+ doReturn(optNode).when(briOperationState).getBridgeNode(any(InstanceIdentifier.class));
OvsdbBridgeAugmentation ovsdbBriAug = mock(OvsdbBridgeAugmentation.class);
- when(node.augmentation(OvsdbBridgeAugmentation.class)).thenReturn(ovsdbBriAug);
+ doReturn(ovsdbBriAug).when(node).augmentation(OvsdbBridgeAugmentation.class);
Optional<OvsdbBridgeAugmentation> ovsdbBriAugOptional = briOperationState.getOvsdbBridgeAugmentation(iid);
assertNotNull(ovsdbBriAugOptional);
assertTrue(ovsdbBriAugOptional.get() instanceof OvsdbBridgeAugmentation);
List<TerminationPoint> termPntList = new ArrayList<>();
termPntList.add(termPnt);
- suppress(MemberMatcher.method(BridgeOperationalState.class, "getBridgeNode", InstanceIdentifier.class));
Node node = mock(Node.class);
Optional<Node> optNode = Optional.of(node);
- when(briOperationState.getBridgeNode(any(InstanceIdentifier.class))).thenReturn(optNode);
+ doReturn(optNode).when(briOperationState).getBridgeNode(any(InstanceIdentifier.class));
when(node.getTerminationPoint()).thenReturn(termPntList);
TerminationPointKey termPntKey = mock(TerminationPointKey.class);
when(termPnt.key()).thenReturn(termPntKey);
- final InstanceIdentifier<?> iid2 = PowerMockito.mock(InstanceIdentifier.class);
- //PowerMockito.suppress(MemberMatcher.method(InstanceIdentifier.class, "firstKeyOf", Class.class, Class.class));
- //PowerMockito.when(iid2.firstKeyOf(TerminationPoint.class, TerminationPointKey.class)).thenReturn(termPntKey);
- Optional<TerminationPoint> optTermPnt = briOperationState.getBridgeTerminationPoint(iid2);
- assertNotNull(optTermPnt);
- //assertTrue(optTermPnt.get() instanceof TerminationPoint);
+ Optional<TerminationPoint> optTermPnt = briOperationState.getBridgeTerminationPoint(
+ iidNode.child(TerminationPoint.class, termPntKey));
+ assertTrue(optTermPnt.isPresent());
}
@Test
verify(briOperationState, times(1)).getBridgeNode(any(InstanceIdentifier.class));
assertTrue(optOvsdbTermPoint.equals(Optional.absent()));
- PowerMockito.suppress(MemberMatcher.method(BridgeOperationalState.class, "getBridgeTerminationPoint",
- InstanceIdentifier.class));
TerminationPoint termPoint = mock(TerminationPoint.class);
Optional<TerminationPoint> termPntOptional = Optional.of(termPoint);
- when(briOperationState.getBridgeTerminationPoint(any(InstanceIdentifier.class))).thenReturn(termPntOptional);
+ doReturn(termPntOptional).when(briOperationState).getBridgeTerminationPoint(any(InstanceIdentifier.class));
OvsdbTerminationPointAugmentation ovsdbTermPntAug = mock(OvsdbTerminationPointAugmentation.class);
- when(termPoint.augmentation(OvsdbTerminationPointAugmentation.class)).thenReturn(ovsdbTermPntAug);
+ doReturn(ovsdbTermPntAug).when(termPoint).augmentation(OvsdbTerminationPointAugmentation.class);
Optional<OvsdbTerminationPointAugmentation> ovsdbTermPointOpt = briOperationState
.getOvsdbTerminationPointAugmentation(iid);
assertNotNull(ovsdbTermPointOpt);
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
-import static org.powermock.api.support.membermodification.MemberMatcher.field;
import java.util.HashMap;
import java.util.HashSet;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.powermock.core.classloader.annotations.PrepareForTest;
-import org.powermock.modules.junit4.PowerMockRunner;
import org.powermock.reflect.Whitebox;
-@RunWith(PowerMockRunner.class)
-@PrepareForTest()
+@RunWith(MockitoJUnitRunner.class)
public class DataChangesManagedByOvsdbNodeEventTest {
@Mock private InstanceIdentifier<?> iid;
@Before
public void setUp() throws Exception {
dataChangesManagedByOvsdbNodeEvent = mock(DataChangesManagedByOvsdbNodeEvent.class, Mockito.CALLS_REAL_METHODS);
- field(DataChangesManagedByOvsdbNodeEvent.class, "event").set(dataChangesManagedByOvsdbNodeEvent, event);
+ Whitebox.getField(DataChangesManagedByOvsdbNodeEvent.class, "event").set(dataChangesManagedByOvsdbNodeEvent,
+ event);
}
@Test
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
import org.opendaylight.ovsdb.southbound.InstanceIdentifierCodec;
-import org.powermock.core.classloader.annotations.PrepareForTest;
-import org.powermock.modules.junit4.PowerMockRunner;
-@PrepareForTest({})
-@RunWith(PowerMockRunner.class)
+@RunWith(MockitoJUnitRunner.class)
public class TransactCommandAggregatorTest {
private final List<TransactCommand> commands = new ArrayList<>();
*/
package org.opendaylight.ovsdb.southbound.reconciliation.configuration;
-import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import com.google.common.base.Optional;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
import org.mockito.stubbing.Answer;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
-import org.powermock.api.mockito.PowerMockito;
-import org.powermock.core.classloader.annotations.PrepareForTest;
-import org.powermock.modules.junit4.PowerMockRunner;
-@PrepareForTest({BridgeConfigReconciliationTask.class,
- OvsdbConnectionInstance.class, InstanceIdentifier.class, Optional.class})
-@RunWith(PowerMockRunner.class)
+@RunWith(MockitoJUnitRunner.class)
public class BridgeConfigReconciliationTaskTest {
private static final String BR01 = "br01";
private static final String BR02 = "br02";
@Test
public void testReconcileConfiguration() throws Exception {
- BridgeConfigReconciliationTask underTest = PowerMockito.spy(configurationReconciliationTask);
- PowerMockito.doNothing().when(underTest, "reconcileBridgeConfigurations", any(Map.class));
- assertEquals(true, underTest.reconcileConfiguration(ovsdbConnectionManager));
+ BridgeConfigReconciliationTask underTest = spy(configurationReconciliationTask);
+ doNothing().when(underTest).reconcileBridgeConfigurations(any(Map.class));
+ assertTrue(underTest.reconcileConfiguration(ovsdbConnectionManager));
Map<InstanceIdentifier<?>, DataObject> changes = new HashMap<>();
for (Node bridgeNode : topology.getNode()) {
changes.putAll(createExpectedConfigurationChanges(bridgeNode));
}
- PowerMockito.verifyPrivate(underTest).invoke("reconcileBridgeConfigurations", changes);
+ verify(underTest).reconcileBridgeConfigurations(changes);
}
private Node createBridgeNode(final String bridgeName) {
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.schema.DatabaseSchema;
import org.opendaylight.ovsdb.southbound.OvsdbConnectionInstance;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfo;
-import org.powermock.modules.junit4.PowerMockRunner;
-@RunWith(PowerMockRunner.class)
+@RunWith(MockitoJUnitRunner.class)
public class AbstractTransactionCommandTest {
private AbstractTransactionCommandChild abstractTransactionCommand1;
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.Mockito.doNothing;
+import static org.mockito.Mockito.doReturn;
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 java.util.HashMap;
-import java.util.HashSet;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
-import org.mockito.stubbing.Answer;
+import org.mockito.runners.MockitoJUnitRunner;
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.southbound.InstanceIdentifierCodec;
import org.opendaylight.ovsdb.southbound.OvsdbConnectionInstance;
import org.opendaylight.ovsdb.southbound.SouthboundConstants;
-import org.opendaylight.ovsdb.southbound.SouthboundMapper;
import org.opendaylight.ovsdb.southbound.SouthboundUtil;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.DatapathTypeBase;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.DatapathTypeNetdev;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.DatapathTypeSystem;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeBase;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.InterfaceTypeInternal;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentationBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ConnectionInfo;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.DatapathTypeEntry;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.DatapathTypeEntryBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.InterfaceTypeEntry;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.InterfaceTypeEntryBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchExternalIds;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchExternalIdsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchOtherConfigs;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchOtherConfigsBuilder;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.api.support.membermodification.MemberMatcher;
import org.powermock.api.support.membermodification.MemberModifier;
-import org.powermock.core.classloader.annotations.PrepareForTest;
-import org.powermock.modules.junit4.PowerMockRunner;
import org.powermock.reflect.Whitebox;
-@PrepareForTest({ TyperUtils.class, OpenVSwitchUpdateCommand.class, SouthboundUtil.class, SouthboundMapper.class,
- InstanceIdentifier.class })
-@RunWith(PowerMockRunner.class)
+@RunWith(MockitoJUnitRunner.class)
public class OpenVSwitchUpdateCommandTest {
@Mock private OpenVSwitchUpdateCommand openVSwitchUpdateCommand;
@Ignore("Broken mock-based test")
public void testExecute() throws Exception {
PowerMockito.mockStatic(TyperUtils.class);
- Map<UUID, OpenVSwitch> updatedOpenVSwitchRows = new HashMap<>();
UUID uuid = mock(UUID.class);
OpenVSwitch ovs = mock(OpenVSwitch.class);
- updatedOpenVSwitchRows.put(uuid, ovs);
when(TyperUtils.extractRowsUpdated(eq(OpenVSwitch.class), any(TableUpdates.class), any(DatabaseSchema.class)))
- .thenReturn(updatedOpenVSwitchRows);
- Map<UUID, OpenVSwitch> deletedOpenVSwitchRows = new HashMap<>();
+ .thenReturn(ImmutableMap.of(uuid, ovs));
OpenVSwitch ovs1 = mock(OpenVSwitch.class);
-
- deletedOpenVSwitchRows.put(uuid, ovs1);
when(TyperUtils.extractRowsOld(eq(OpenVSwitch.class), any(TableUpdates.class), any(DatabaseSchema.class)))
- .thenReturn(deletedOpenVSwitchRows);
+ .thenReturn(ImmutableMap.of(uuid, ovs1));
//mock getUpdates() and getDbSchema()
when(openVSwitchUpdateCommand.getUpdates()).thenReturn(updates);
//Test getInstanceIdentifier(): case 1:
// ovs.getExternalIdsColumn().getData().containsKey(SouthboundConstants.IID_EXTERNAL_ID_KEY)) == true
Column<GenericTableSchema, Map<String, String>> column = mock(Column.class);
- Map<String, String> map = new HashMap<>();
- map.put(SouthboundConstants.IID_EXTERNAL_ID_KEY, "iidString");
when(ovs.getExternalIdsColumn()).thenReturn(column);
- when(column.getData()).thenReturn(map);
+ when(column.getData()).thenReturn(ImmutableMap.of(SouthboundConstants.IID_EXTERNAL_ID_KEY, "iidString"));
PowerMockito.mockStatic(SouthboundUtil.class);
MemberModifier.suppress(MemberMatcher.method(OpenVSwitchUpdateCommand.class, "getOvsdbConnectionInstance"));
InstanceIdentifier<Node> iid = mock(InstanceIdentifier.class);
@Test
@SuppressWarnings("unchecked")
public void testSetOtherConfig() throws Exception {
- OpenVSwitch oldEntry = mock(OpenVSwitch.class);
OpenVSwitch openVSwitch = mock(OpenVSwitch.class);
Column<GenericTableSchema, Map<String, String>> column = mock(Column.class);
when(openVSwitch.getOtherConfigColumn()).thenReturn(column);
- Map<String, String> map = new HashMap<>();
- when(column.getData()).thenReturn(map);
+ when(column.getData()).thenReturn(ImmutableMap.of("foo", "bar"));
+
+ OpenVSwitch oldEntry = mock(OpenVSwitch.class);
when(oldEntry.getOtherConfigColumn()).thenReturn(column);
- MemberModifier.suppress(MemberMatcher.method(OpenVSwitchUpdateCommand.class, "removeOldConfigs",
- ReadWriteTransaction.class, Map.class, OpenVSwitch.class));
- MemberModifier.suppress(MemberMatcher.method(OpenVSwitchUpdateCommand.class, "setNewOtherConfigs",
- OvsdbNodeAugmentationBuilder.class, Map.class));
+ doNothing().when(openVSwitchUpdateCommand).removeOldConfigs(any(ReadWriteTransaction.class), any(Map.class),
+ any(OpenVSwitch.class));
+ doNothing().when(openVSwitchUpdateCommand).setNewOtherConfigs(any(OvsdbNodeAugmentationBuilder.class),
+ any(Map.class));
ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
OvsdbNodeAugmentationBuilder ovsdbNodeBuilder = mock(OvsdbNodeAugmentationBuilder.class);
transaction, ovsdbNodeBuilder, oldEntry, openVSwitch);
verify(openVSwitch, times(2)).getOtherConfigColumn();
verify(oldEntry, times(2)).getOtherConfigColumn();
- PowerMockito.verifyPrivate(openVSwitchUpdateCommand).invoke("removeOldConfigs",
- any(ReadWriteTransaction.class),
- any(Map.class), any(OpenVSwitch.class));
+ verify(openVSwitchUpdateCommand).removeOldConfigs(any(ReadWriteTransaction.class), any(Map.class),
+ any(OpenVSwitch.class));
}
@Test
public void testRemoveOldConfigs() throws Exception {
ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
- Map<String, String> oldOtherConfigs = new HashMap<>();
- oldOtherConfigs.put("OpenvswitchOtherConfigsKey", "OpenvswitchOtherConfigsValue");
doNothing().when(transaction).delete(any(LogicalDatastoreType.class), any(KeyedInstanceIdentifier.class));
//suppress getNodeId()
- MemberModifier.suppress(
- MemberMatcher.method(OpenVSwitchUpdateCommand.class, "getNodeId", OpenVSwitch.class));
- PowerMockito.whenNew(NodeKey.class).withAnyArguments().thenReturn(mock(NodeKey.class));
+ doReturn(null).when(openVSwitchUpdateCommand).getNodeId(any());
OpenVSwitch ovs = mock(OpenVSwitch.class);
Whitebox.invokeMethod(openVSwitchUpdateCommand, "removeOldConfigs",
- transaction, oldOtherConfigs, ovs);
+ transaction, ImmutableMap.of("OpenvswitchOtherConfigsKey", "OpenvswitchOtherConfigsValue"), ovs);
verify(transaction).delete(any(LogicalDatastoreType.class), any(KeyedInstanceIdentifier.class));
}
@Test
- @SuppressWarnings("unchecked")
public void testSetNewOtherConfigs() throws Exception {
- Map<String, String> otherConfigs = new HashMap<>();
- otherConfigs.put("otherConfigKey", "otherConfigValue");
-
- OpenvswitchOtherConfigsBuilder openvswitchOtherConfigsBuilder = mock(OpenvswitchOtherConfigsBuilder.class);
- PowerMockito.whenNew(OpenvswitchOtherConfigsBuilder.class).withNoArguments()
- .thenReturn(openvswitchOtherConfigsBuilder);
- when(openvswitchOtherConfigsBuilder.setOtherConfigKey(anyString())).thenReturn(openvswitchOtherConfigsBuilder);
- when(openvswitchOtherConfigsBuilder.setOtherConfigValue(anyString()))
- .thenReturn(openvswitchOtherConfigsBuilder);
- when(openvswitchOtherConfigsBuilder.build()).thenReturn(mock(OpenvswitchOtherConfigs.class));
- OvsdbNodeAugmentationBuilder ovsdbNodeBuilder = mock(OvsdbNodeAugmentationBuilder.class);
- when(ovsdbNodeBuilder.setOpenvswitchOtherConfigs(any(List.class))).thenReturn(ovsdbNodeBuilder);
-
- Whitebox.invokeMethod(openVSwitchUpdateCommand, "setNewOtherConfigs", ovsdbNodeBuilder, otherConfigs);
- verify(openvswitchOtherConfigsBuilder).setOtherConfigKey(anyString());
- verify(openvswitchOtherConfigsBuilder).setOtherConfigValue(anyString());
- verify(ovsdbNodeBuilder).setOpenvswitchOtherConfigs(any(List.class));
+ OvsdbNodeAugmentationBuilder ovsdbNodeBuilder = new OvsdbNodeAugmentationBuilder();
+ Whitebox.invokeMethod(openVSwitchUpdateCommand, "setNewOtherConfigs", ovsdbNodeBuilder,
+ ImmutableMap.of("otherConfigKey", "otherConfigValue"));
+
+ final List<OpenvswitchOtherConfigs> otherConfigsList = ovsdbNodeBuilder.getOpenvswitchOtherConfigs();
+ assertEquals(1, otherConfigsList.size());
+ final OpenvswitchOtherConfigs otherConfig = otherConfigsList.get(0);
+ assertEquals("otherConfigKey", otherConfig.getOtherConfigKey());
+ assertEquals("otherConfigValue", otherConfig.getOtherConfigValue());
}
@Test
Column<GenericTableSchema, Map<String, String>> column = mock(Column.class);
when(openVSwitch.getExternalIdsColumn()).thenReturn(column);
- Map<String, String> map = new HashMap<>();
- when(column.getData()).thenReturn(map);
+ when(column.getData()).thenReturn(ImmutableMap.of("foo", "bar"));
when(oldEntry.getExternalIdsColumn()).thenReturn(column);
- MemberModifier.suppress(MemberMatcher.method(OpenVSwitchUpdateCommand.class, "removeExternalIds",
- ReadWriteTransaction.class, Map.class, OpenVSwitch.class));
- MemberModifier.suppress(MemberMatcher.method(OpenVSwitchUpdateCommand.class, "setNewExternalIds",
- OvsdbNodeAugmentationBuilder.class, Map.class));
+ doNothing().when(openVSwitchUpdateCommand).removeExternalIds(any(ReadWriteTransaction.class), any(Map.class),
+ any(OpenVSwitch.class));
+ doNothing().when(openVSwitchUpdateCommand).setNewExternalIds(
+ any(OvsdbNodeAugmentationBuilder.class), any(Map.class));
ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
OvsdbNodeAugmentationBuilder ovsdbNodeBuilder = mock(OvsdbNodeAugmentationBuilder.class);
transaction, ovsdbNodeBuilder, oldEntry, openVSwitch);
verify(openVSwitch, times(2)).getExternalIdsColumn();
verify(oldEntry, times(2)).getExternalIdsColumn();
- PowerMockito.verifyPrivate(openVSwitchUpdateCommand).invoke("removeExternalIds",
- any(ReadWriteTransaction.class), any(Map.class),
+ verify(openVSwitchUpdateCommand).removeExternalIds(any(ReadWriteTransaction.class), any(Map.class),
any(OpenVSwitch.class));
}
@Test
public void testRemoveExternalIds() throws Exception {
ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
- Map<String, String> oldExternalIds = new HashMap<>();
- oldExternalIds.put("OpenvswitchExternalIdKey", "OpenvswitchExternalIdValue");
doNothing().when(transaction).delete(any(LogicalDatastoreType.class), any(KeyedInstanceIdentifier.class));
//suppress getNodeId()
- MemberModifier.suppress(
- MemberMatcher.method(OpenVSwitchUpdateCommand.class, "getNodeId", OpenVSwitch.class));
- PowerMockito.whenNew(NodeKey.class).withAnyArguments().thenReturn(mock(NodeKey.class));
OpenVSwitch ovs = mock(OpenVSwitch.class);
+ doReturn(mock(NodeId.class)).when(openVSwitchUpdateCommand).getNodeId(any());
Whitebox.invokeMethod(openVSwitchUpdateCommand, "removeExternalIds",
- transaction, oldExternalIds, ovs);
+ transaction, ImmutableMap.of("OpenvswitchExternalIdKey", "OpenvswitchExternalIdValue"), ovs);
verify(transaction).delete(any(LogicalDatastoreType.class), any(KeyedInstanceIdentifier.class));
}
- @SuppressWarnings("unchecked")
@Test
public void testSetNewExternalIds() throws Exception {
- Map<String, String> externalIds = new HashMap<>();
- externalIds.put("externalIdsKey", "externalIdsValue");
-
- OvsdbNodeAugmentationBuilder ovsdbNodeBuilder = mock(OvsdbNodeAugmentationBuilder.class);
- OpenvswitchExternalIdsBuilder ovsExternalIdsBuilder = mock(OpenvswitchExternalIdsBuilder.class);
- PowerMockito.whenNew(OpenvswitchExternalIdsBuilder.class).withNoArguments().thenReturn(ovsExternalIdsBuilder);
- when(ovsExternalIdsBuilder.setExternalIdKey(anyString())).thenReturn(ovsExternalIdsBuilder);
- when(ovsExternalIdsBuilder.setExternalIdValue(anyString())).thenReturn(ovsExternalIdsBuilder);
- when(ovsExternalIdsBuilder.build()).thenReturn(mock(OpenvswitchExternalIds.class));
- when(ovsdbNodeBuilder.setOpenvswitchExternalIds(any(List.class))).thenReturn(ovsdbNodeBuilder);
-
- Whitebox.invokeMethod(openVSwitchUpdateCommand, "setNewExternalIds", ovsdbNodeBuilder, externalIds);
- verify(ovsExternalIdsBuilder).setExternalIdKey(anyString());
- verify(ovsExternalIdsBuilder).setExternalIdValue(anyString());
- verify(ovsdbNodeBuilder).setOpenvswitchExternalIds(any(List.class));
+ OvsdbNodeAugmentationBuilder ovsdbNodeBuilder = new OvsdbNodeAugmentationBuilder();
+ Whitebox.invokeMethod(openVSwitchUpdateCommand, "setNewExternalIds", ovsdbNodeBuilder,
+ ImmutableMap.of("externalIdsKey", "externalIdsValue"));
+
+ final List<OpenvswitchExternalIds> externalIdsList = ovsdbNodeBuilder.getOpenvswitchExternalIds();
+ assertEquals(1, externalIdsList.size());
+ final OpenvswitchExternalIds externalId = externalIdsList.get(0);
+ assertEquals("externalIdsKey", externalId.getExternalIdKey());
+ assertEquals("externalIdsValue", externalId.getExternalIdValue());
}
@Test
Column<GenericTableSchema, Set<String>> column = mock(Column.class);
when(openVSwitch.getIfaceTypesColumn()).thenReturn(column);
- Set<String> set = new HashSet<>();
- set.add("dpdk");
- set.add("dpdkr");
- set.add("dpdkvhostuser");
- set.add("dpdkvhostuserclient");
- set.add("geneve");
- set.add("gre");
- set.add("internal");
- set.add("ipsec_gre");
- set.add("lisp");
- set.add("patch");
- set.add("stt");
- set.add("system");
- set.add("tap");
- set.add("vxlan");
- when(column.getData()).thenReturn(set);
- PowerMockito.mockStatic(SouthboundMapper.class);
- when(SouthboundMapper.createInterfaceType(anyString()))
- .thenAnswer((Answer<Class<? extends InterfaceTypeBase>>) invocation -> InterfaceTypeInternal.class);
-
- InterfaceTypeEntry ifEntry = mock(InterfaceTypeEntry.class);
- InterfaceTypeEntryBuilder interfaceTypeEntryBldr = mock(InterfaceTypeEntryBuilder.class);
- PowerMockito.whenNew(InterfaceTypeEntryBuilder.class).withNoArguments().thenReturn(interfaceTypeEntryBldr);
- when(interfaceTypeEntryBldr.setInterfaceType(InterfaceTypeInternal.class)).thenReturn(interfaceTypeEntryBldr);
- when(interfaceTypeEntryBldr.build()).thenReturn(ifEntry);
+ when(column.getData()).thenReturn(ImmutableSet.of(
+ "dpdk",
+ "dpdkr",
+ "dpdkvhostuser",
+ "dpdkvhostuserclient",
+ "geneve",
+ "gre",
+ "internal",
+ "ipsec_gre",
+ "lisp",
+ "patch",
+ "stt",
+ "system",
+ "tap",
+ "vxlan"));
+ OvsdbNodeAugmentationBuilder ovsdbNodeBuilder = new OvsdbNodeAugmentationBuilder();
- OvsdbNodeAugmentationBuilder ovsdbNodeBuilder = mock(OvsdbNodeAugmentationBuilder.class);
- when(ovsdbNodeBuilder.setInterfaceTypeEntry(any(List.class))).thenReturn(ovsdbNodeBuilder);
Whitebox.invokeMethod(openVSwitchUpdateCommand, "setInterfaceTypes", ovsdbNodeBuilder, openVSwitch);
verify(openVSwitch).getIfaceTypesColumn();
- verify(interfaceTypeEntryBldr,times(14)).setInterfaceType(InterfaceTypeInternal.class);
+
+ List<InterfaceTypeEntry> interfaceTypeEntries = ovsdbNodeBuilder.getInterfaceTypeEntry();
+ assertEquals(14, interfaceTypeEntries.size());
}
@Test
OpenVSwitch openVSwitch = mock(OpenVSwitch.class);
Column<GenericTableSchema, Set<String>> column = mock(Column.class);
when(openVSwitch.getDatapathTypesColumn()).thenReturn(column);
- Set<String> set = new HashSet<>();
- set.add("netdev");
- set.add("system");
- when(column.getData()).thenReturn(set);
- PowerMockito.mockStatic(SouthboundMapper.class);
- when(SouthboundMapper.createDatapathType(anyString()))
- .thenAnswer((Answer<Class<? extends DatapathTypeBase>>) invocation -> DatapathTypeSystem.class);
- DatapathTypeEntry dpEntry = mock(DatapathTypeEntry.class);
- DatapathTypeEntryBuilder datapathTypeEntryBuilder = mock(DatapathTypeEntryBuilder.class);
- PowerMockito.whenNew(DatapathTypeEntryBuilder.class).withNoArguments().thenReturn(datapathTypeEntryBuilder);
- when(datapathTypeEntryBuilder.setDatapathType(DatapathTypeSystem.class)).thenReturn(datapathTypeEntryBuilder);
- when(datapathTypeEntryBuilder.build()).thenReturn(dpEntry);
+ when(column.getData()).thenReturn(ImmutableSet.of("netdev", "system"));
- OvsdbNodeAugmentationBuilder ovsdbNodeBuilder = mock(OvsdbNodeAugmentationBuilder.class);
- when(ovsdbNodeBuilder.setDatapathTypeEntry(any(List.class))).thenReturn(ovsdbNodeBuilder);
+ OvsdbNodeAugmentationBuilder ovsdbNodeBuilder = new OvsdbNodeAugmentationBuilder();
Whitebox.invokeMethod(openVSwitchUpdateCommand, "setDataPathTypes", ovsdbNodeBuilder, openVSwitch);
+
verify(openVSwitch).getDatapathTypesColumn();
- verify(datapathTypeEntryBuilder,times(2)).setDatapathType(DatapathTypeSystem.class);
+ List<DatapathTypeEntry> entries = ovsdbNodeBuilder.getDatapathTypeEntry();
+ assertEquals(2, entries.size());
+ assertEquals(DatapathTypeNetdev.class, entries.get(0).getDatapathType());
+ assertEquals(DatapathTypeSystem.class, entries.get(1).getDatapathType());
}
@Test
OpenVSwitch openVSwitch = mock(OpenVSwitch.class);
Column<GenericTableSchema, Set<String>> column = mock(Column.class);
when(openVSwitch.getOvsVersionColumn()).thenReturn(column);
- Set<String> set = new HashSet<>();
- set.add("v2.3.0");
- when(column.getData()).thenReturn(set);
+ when(column.getData()).thenReturn(ImmutableSet.of("v2.3.0"));
OvsdbNodeAugmentationBuilder ovsdbNodeBuilder = mock(OvsdbNodeAugmentationBuilder.class);
when(ovsdbNodeBuilder.setOvsVersion(anyString())).thenReturn(ovsdbNodeBuilder);
OpenVSwitch openVSwitch = mock(OpenVSwitch.class);
Column<GenericTableSchema, Set<String>> column = mock(Column.class);
when(openVSwitch.getDbVersionColumn()).thenReturn(column);
- Set<String> set = new HashSet<>();
- set.add("7.6.1");
- when(column.getData()).thenReturn(set);
+ when(column.getData()).thenReturn(ImmutableSet.of("7.6.1"));
OvsdbNodeAugmentationBuilder ovsdbNodeBuilder = mock(OvsdbNodeAugmentationBuilder.class);
when(ovsdbNodeBuilder.setOvsVersion(anyString())).thenReturn(ovsdbNodeBuilder);
import static org.junit.Assert.assertEquals;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.ManagerEntry;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.powermock.api.mockito.PowerMockito;
-import org.powermock.core.classloader.annotations.PrepareForTest;
-import org.powermock.modules.junit4.PowerMockRunner;
import org.powermock.reflect.Whitebox;
-@PrepareForTest({OvsdbNodeRemoveCommand.class})
-@RunWith(PowerMockRunner.class)
+@RunWith(MockitoJUnitRunner.class)
public class OvsdbNodeRemoveCommandTest {
private static final long ONE_CONNECTED_MANAGER = 1;
@Before
public void setUp() throws Exception {
- ovsdbNodeRemoveCommand = PowerMockito.mock(OvsdbNodeRemoveCommand.class, Mockito.CALLS_REAL_METHODS);
+ ovsdbNodeRemoveCommand = mock(OvsdbNodeRemoveCommand.class, Mockito.CALLS_REAL_METHODS);
}
@Test
OvsdbNodeAugmentation ovsdbNodeAugmentation = mock(OvsdbNodeAugmentation.class);
when(ovsdbNode.augmentation(OvsdbNodeAugmentation.class)).thenReturn(ovsdbNodeAugmentation);
- PowerMockito.doReturn(true).when(ovsdbNodeRemoveCommand, "checkIfOnlyConnectedManager",
- any(OvsdbNodeAugmentation.class));
+ doReturn(true).when(ovsdbNodeRemoveCommand).checkIfOnlyConnectedManager(any(OvsdbNodeAugmentation.class));
List<ManagedNodeEntry> listManagedNodeEntry = new ArrayList<>();
ManagedNodeEntry managedNode = mock(ManagedNodeEntry.class);
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
import org.opendaylight.ovsdb.lib.message.TableUpdates;
import org.opendaylight.ovsdb.lib.notation.Version;
import org.opendaylight.ovsdb.southbound.InstanceIdentifierCodec;
import org.opendaylight.ovsdb.southbound.OvsdbConnectionInstance;
import org.opendaylight.ovsdb.southbound.SouthboundConstants;
-import org.powermock.api.mockito.PowerMockito;
-import org.powermock.api.support.membermodification.MemberModifier;
-import org.powermock.core.classloader.annotations.PrepareForTest;
-import org.powermock.modules.junit4.PowerMockRunner;
import org.powermock.reflect.Whitebox;
-@PrepareForTest({})
-@RunWith(PowerMockRunner.class)
+@RunWith(MockitoJUnitRunner.class)
public class OvsdbOperationalCommandAggregatorTest {
private static final int NUMBER_OF_COMMANDS = 15;
- private List<TransactionCommand> commands = new ArrayList<>();
+ private final List<TransactionCommand> commands = new ArrayList<>();
private OvsdbOperationalCommandAggregator ovsdbOperationalCommandAggregator;
@Before
public void setUp() throws Exception {
- ovsdbOperationalCommandAggregator = PowerMockito.mock(OvsdbOperationalCommandAggregator.class,
+ ovsdbOperationalCommandAggregator = mock(OvsdbOperationalCommandAggregator.class,
Mockito.CALLS_REAL_METHODS);
//mock commands field
commands.add(mock(OvsdbControllerRemovedCommand.class));
commands.add(mock(OvsdbPortUpdateCommand.class));
commands.add(mock(OvsdbPortRemoveCommand.class));
- MemberModifier.field(OvsdbOperationalCommandAggregator.class, "commands").set(ovsdbOperationalCommandAggregator,
+ Whitebox.getField(OvsdbOperationalCommandAggregator.class, "commands").set(ovsdbOperationalCommandAggregator,
commands);
}
import static org.junit.Assert.assertTrue;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import static org.powermock.api.support.membermodification.MemberMatcher.field;
+import static org.powermock.reflect.Whitebox.getField;
import java.util.ArrayList;
import java.util.HashMap;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
import org.opendaylight.controller.md.sal.binding.api.BindingTransactionChain;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.AsyncTransaction;
import org.opendaylight.controller.md.sal.common.api.data.TransactionChain;
import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;
-import org.powermock.api.mockito.PowerMockito;
-import org.powermock.api.support.membermodification.MemberModifier;
-import org.powermock.core.classloader.annotations.PrepareForTest;
-import org.powermock.modules.junit4.PowerMockRunner;
import org.powermock.reflect.Whitebox;
-@RunWith(PowerMockRunner.class)
-@PrepareForTest({TransactionInvokerImpl.class})
+@RunWith(MockitoJUnitRunner.class)
public class TransactionInvokerImplTest {
private static final int QUEUE_SIZE = 10000;
@Mock private BindingTransactionChain chain;
@Mock private DataBroker db;
- private BlockingQueue<TransactionCommand> inputQueue = new LinkedBlockingQueue<>(QUEUE_SIZE);
- private BlockingQueue<ReadWriteTransaction> successfulTxQ
+ private final BlockingQueue<TransactionCommand> inputQueue = new LinkedBlockingQueue<>(QUEUE_SIZE);
+ private final BlockingQueue<ReadWriteTransaction> successfulTxQ
= new LinkedBlockingQueue<>(QUEUE_SIZE);
- private BlockingQueue<AsyncTransaction<?, ?>> failedTransactionQ
+ private
final BlockingQueue<AsyncTransaction<?, ?>> failedTransactionQ
= new LinkedBlockingQueue<>(QUEUE_SIZE);
@Mock private ExecutorService executor;
@Mock private AtomicBoolean runTask;
- private Map<ReadWriteTransaction,TransactionCommand> transactionToCommand
+ private final Map<ReadWriteTransaction,TransactionCommand> transactionToCommand
= new HashMap<>();
- private List<ReadWriteTransaction> pendingTransactions = new ArrayList<>();
+ private final List<ReadWriteTransaction> pendingTransactions = new ArrayList<>();
private TransactionInvokerImpl transactionInvokerImpl;
@Before
public void setUp() throws Exception {
- transactionInvokerImpl = PowerMockito.mock(TransactionInvokerImpl.class, Mockito.CALLS_REAL_METHODS);
- MemberModifier.field(TransactionInvokerImpl.class, "chain").set(transactionInvokerImpl, chain);
- MemberModifier.field(TransactionInvokerImpl.class, "db").set(transactionInvokerImpl, db);
+ transactionInvokerImpl = mock(TransactionInvokerImpl.class, Mockito.CALLS_REAL_METHODS);
+ getField(TransactionInvokerImpl.class, "chain").set(transactionInvokerImpl, chain);
+ getField(TransactionInvokerImpl.class, "db").set(transactionInvokerImpl, db);
}
@Test
public void testTransactionInvokerImpl() throws Exception {
- MemberModifier.field(TransactionInvokerImpl.class, "inputQueue").set(transactionInvokerImpl, inputQueue);
+ getField(TransactionInvokerImpl.class, "inputQueue").set(transactionInvokerImpl, inputQueue);
when(db.createTransactionChain(any(TransactionChainListener.class)))
.thenReturn(mock(BindingTransactionChain.class));
TransactionInvokerImpl transactionInvokerImpl1 = new TransactionInvokerImpl(db);
@Test
public void testInvoke() throws Exception {
- MemberModifier.field(TransactionInvokerImpl.class, "inputQueue").set(transactionInvokerImpl, inputQueue);
+ getField(TransactionInvokerImpl.class, "inputQueue").set(transactionInvokerImpl, inputQueue);
TransactionCommand command = mock(TransactionCommand.class);
transactionInvokerImpl.invoke(command);
BlockingQueue<TransactionCommand> testInputQueue = Whitebox.getInternalState(transactionInvokerImpl,
@Test
public void testOnTransactionChainFailed() throws Exception {
- field(TransactionInvokerImpl.class, "failedTransactionQueue").set(transactionInvokerImpl,
+ getField(TransactionInvokerImpl.class, "failedTransactionQueue").set(transactionInvokerImpl,
failedTransactionQ);
AsyncTransaction<?, ?> transaction = mock(AsyncTransaction.class);
Throwable cause = mock(Throwable.class);
public void testExtractResubmitCommands() throws Exception {
AsyncTransaction<?, ?> transaction = mock(ReadWriteTransaction.class);
failedTransactionQ.put(transaction);
- field(TransactionInvokerImpl.class, "failedTransactionQueue").set(transactionInvokerImpl,
+ getField(TransactionInvokerImpl.class, "failedTransactionQueue").set(transactionInvokerImpl,
failedTransactionQ);
AsyncTransaction tx1 = mock(ReadWriteTransaction.class);
pendingTransactions.add((ReadWriteTransaction) tx1);
pendingTransactions.add((ReadWriteTransaction) transaction);
pendingTransactions.add((ReadWriteTransaction) tx2);
- MemberModifier.field(TransactionInvokerImpl.class, "pendingTransactions").set(transactionInvokerImpl,
+ getField(TransactionInvokerImpl.class, "pendingTransactions").set(transactionInvokerImpl,
pendingTransactions);
List<ReadWriteTransaction> transactions = new ArrayList<>();
transactionToCommand.put((ReadWriteTransaction) tx1, txCommand);
transactionToCommand.put((ReadWriteTransaction) tx2, txCommand);
transactionToCommand.put((ReadWriteTransaction) transaction, txCommand);
- MemberModifier.field(TransactionInvokerImpl.class, "transactionToCommand").set(transactionInvokerImpl,
+ getField(TransactionInvokerImpl.class, "transactionToCommand").set(transactionInvokerImpl,
transactionToCommand);
- PowerMockito.suppress(MemberModifier.method(TransactionInvokerImpl.class, "resetTransactionQueue"));
+ doNothing().when(transactionInvokerImpl).resetTransactionQueue();
List<TransactionCommand> testCommands = new ArrayList<>();
testCommands.add(txCommand);
when(db.createTransactionChain(any(TransactionInvokerImpl.class))).thenReturn(chain);
failedTransactionQ.add(mock(AsyncTransaction.class));
- field(TransactionInvokerImpl.class, "pendingTransactions").set(transactionInvokerImpl, pendingTransactions);
- field(TransactionInvokerImpl.class, "transactionToCommand").set(transactionInvokerImpl, transactionToCommand);
- field(TransactionInvokerImpl.class, "failedTransactionQueue").set(transactionInvokerImpl, failedTransactionQ);
- field(TransactionInvokerImpl.class, "successfulTransactionQueue").set(transactionInvokerImpl, successfulTxQ);
+ getField(TransactionInvokerImpl.class, "pendingTransactions").set(transactionInvokerImpl, pendingTransactions);
+ getField(TransactionInvokerImpl.class, "transactionToCommand").set(transactionInvokerImpl,
+ transactionToCommand);
+ getField(TransactionInvokerImpl.class, "failedTransactionQueue").set(transactionInvokerImpl,
+ failedTransactionQ);
+ getField(TransactionInvokerImpl.class, "successfulTransactionQueue").set(transactionInvokerImpl, successfulTxQ);
Whitebox.invokeMethod(transactionInvokerImpl, "resetTransactionQueue");
assertNotNull(Whitebox.getInternalState(transactionInvokerImpl, "pendingTransactions"));
public void testRecordPendingTransaction() throws Exception {
TransactionCommand command = mock(TransactionCommand.class);
ReadWriteTransaction transaction = mock(ReadWriteTransaction.class);
- field(TransactionInvokerImpl.class, "pendingTransactions").set(transactionInvokerImpl, pendingTransactions);
- field(TransactionInvokerImpl.class, "transactionToCommand").set(transactionInvokerImpl, transactionToCommand);
+ getField(TransactionInvokerImpl.class, "pendingTransactions").set(transactionInvokerImpl, pendingTransactions);
+ getField(TransactionInvokerImpl.class, "transactionToCommand").set(transactionInvokerImpl,
+ transactionToCommand);
Whitebox.invokeMethod(transactionInvokerImpl, "recordPendingTransaction", command, transaction);
List<ReadWriteTransaction> testPendingTransactions = Whitebox.getInternalState(transactionInvokerImpl,
@Test
public void testExtractCommands() throws Exception {
List<TransactionCommand> commands = new ArrayList<>();
- PowerMockito.doReturn(commands).when(transactionInvokerImpl, "extractResubmitCommands");
+ doReturn(commands).when(transactionInvokerImpl).extractResubmitCommands();
List<TransactionCommand> resubmitCommands = new ArrayList<>();
resubmitCommands.add(mock(TransactionCommand.class));
- PowerMockito.doReturn(resubmitCommands).when(transactionInvokerImpl, "extractCommandsFromQueue");
+ doReturn(resubmitCommands).when(transactionInvokerImpl).extractCommandsFromQueue();
List<TransactionCommand> testCommands = new ArrayList<>();
testCommands.addAll(resubmitCommands);
public void testExtractCommandsFromQueue() throws Exception {
TransactionCommand command = mock(TransactionCommand.class);
inputQueue.add(command);
- MemberModifier.field(TransactionInvokerImpl.class, "inputQueue").set(transactionInvokerImpl, inputQueue);
+ getField(TransactionInvokerImpl.class, "inputQueue").set(transactionInvokerImpl, inputQueue);
List<TransactionCommand> testResult = new ArrayList<>();
testResult.add(command);
assertEquals(testResult, Whitebox.invokeMethod(transactionInvokerImpl, "extractCommandsFromQueue"));
successfulTxQ.add(transaction);
pendingTransactions.add(transaction);
transactionToCommand.put(transaction, mock(TransactionCommand.class));
- field(TransactionInvokerImpl.class, "successfulTransactionQueue").set(transactionInvokerImpl, successfulTxQ);
- field(TransactionInvokerImpl.class, "pendingTransactions").set(transactionInvokerImpl, pendingTransactions);
- field(TransactionInvokerImpl.class, "transactionToCommand").set(transactionInvokerImpl, transactionToCommand);
+ getField(TransactionInvokerImpl.class, "successfulTransactionQueue").set(transactionInvokerImpl, successfulTxQ);
+ getField(TransactionInvokerImpl.class, "pendingTransactions").set(transactionInvokerImpl, pendingTransactions);
+ getField(TransactionInvokerImpl.class, "transactionToCommand").set(transactionInvokerImpl,
+ transactionToCommand);
Whitebox.invokeMethod(transactionInvokerImpl, "forgetSuccessfulTransactions");
@Test
public void testClose() throws Exception {
- MemberModifier.field(TransactionInvokerImpl.class, "executor").set(transactionInvokerImpl, executor);
- MemberModifier.field(TransactionInvokerImpl.class, "runTask").set(transactionInvokerImpl, runTask);
+ getField(TransactionInvokerImpl.class, "executor").set(transactionInvokerImpl, executor);
+ getField(TransactionInvokerImpl.class, "runTask").set(transactionInvokerImpl, runTask);
doNothing().when(executor).shutdown();
transactionInvokerImpl.close();
verify(executor).shutdown();
Code Review / ovsdb.git / commitdiff