This is an automated email from the ASF dual-hosted git repository.
dahn pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/cloudstack.git
The following commit(s) were added to refs/heads/main by this push:
new 5fda9c36873 Upgrade mockito (#7577)
5fda9c36873 is described below
commit 5fda9c36873e8221dc5c48d0e1ae5ad4cde3ddd1
Author: Vishesh <[email protected]>
AuthorDate: Mon Jun 12 16:04:23 2023 +0530
Upgrade mockito (#7577)
---
pom.xml | 3 +-
.../test/java/com/cloud/utils/FileUtilTest.java | 25 ++---
.../test/java/com/cloud/utils/TestProfiler.java | 9 +-
.../com/cloud/utils/UriUtilsParametrizedTest.java | 21 ++---
.../java/com/cloud/utils/net/NetUtilsTest.java | 29 +++---
.../java/com/cloud/utils/ssh/SshHelperTest.java | 26 ++----
.../cloud/utils/validation/ChecksumUtilTest.java | 20 ++--
.../utils/jsinterpreter/JsInterpreterTest.java | 12 +--
.../ReflectionToStringBuilderUtilsTest.java | 103 +++++++++++----------
.../org.mockito.plugins.MockMaker | 1 +
10 files changed, 115 insertions(+), 134 deletions(-)
diff --git a/pom.xml b/pom.xml
index 10dce9226fc..2497dee7e0a 100644
--- a/pom.xml
+++ b/pom.xml
@@ -113,7 +113,7 @@
<cs.junit.dataprovider.version>1.13.1</cs.junit.dataprovider.version>
<cs.junit.jupiter.version>5.9.1</cs.junit.jupiter.version>
<cs.guava-testlib.version>18.0</cs.guava-testlib.version>
- <cs.mockito.version>3.2.4</cs.mockito.version>
+ <cs.mockito.version>3.12.4</cs.mockito.version>
<cs.powermock.version>2.0.5</cs.powermock.version>
<cs.selenium.server.version>1.0-20081010.060147</cs.selenium.server.version>
<cs.selenium-java-client-driver.version>1.0.1</cs.selenium-java-client-driver.version>
@@ -1062,6 +1062,7 @@
<exclude>ui/public/**</exclude>
<exclude>ui/legacy/**</exclude>
<exclude>utils/testsmallfileinactive</exclude>
+
<exclude>utils/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker</exclude>
</excludes>
</configuration>
</plugin>
diff --git a/utils/src/test/java/com/cloud/utils/FileUtilTest.java
b/utils/src/test/java/com/cloud/utils/FileUtilTest.java
index 70ad39cd585..87e1a18e85a 100644
--- a/utils/src/test/java/com/cloud/utils/FileUtilTest.java
+++ b/utils/src/test/java/com/cloud/utils/FileUtilTest.java
@@ -20,49 +20,52 @@ import com.cloud.utils.ssh.SshHelper;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
+import org.mockito.MockedStatic;
import org.mockito.Mockito;
-import org.powermock.api.mockito.PowerMockito;
-import org.powermock.core.classloader.annotations.PowerMockIgnore;
-import org.powermock.core.classloader.annotations.PrepareForTest;
-import org.powermock.modules.junit4.PowerMockRunner;
+import org.mockito.junit.MockitoJUnitRunner;
import java.io.File;
import static org.mockito.ArgumentMatchers.nullable;
-@PrepareForTest(value = {SshHelper.class})
-@RunWith(PowerMockRunner.class)
-@PowerMockIgnore({"com.sun.org.apache.xerces.*", "javax.xml.parsers.*",
"javax.xml.*", "org.w3c.dom.*", "org.xml.*"})
+@RunWith(MockitoJUnitRunner.class)
public class FileUtilTest {
@Test
public void successfulScpTest() throws Exception {
- PowerMockito.mockStatic(SshHelper.class);
+ MockedStatic<SshHelper> sshHelperMocked =
Mockito.mockStatic(SshHelper.class);
String basePath = "/tmp";
String[] files = new String[] { "file1.txt" };
int sshPort = 3922;
String controlIp = "10.0.0.10";
String destPath = "/home/cloud/";
File pemFile = new File("/root/.ssh/id_rsa");
- PowerMockito.doNothing().when(SshHelper.class, "scpTo",
Mockito.anyString(), Mockito.anyInt(), Mockito.anyString(),
Mockito.any(File.class), nullable(String.class), Mockito.anyString(),
Mockito.any(String[].class), Mockito.anyString());
+ sshHelperMocked.when(() ->
+ SshHelper.scpTo(
+ Mockito.anyString(), Mockito.anyInt(),
Mockito.anyString(), Mockito.any(File.class), nullable(String.class),
Mockito.anyString(), Mockito.any(String[].class), Mockito.anyString()
+ )).then(invocation -> null);
FileUtil.scpPatchFiles(controlIp, destPath, sshPort, pemFile, files,
basePath);
+ sshHelperMocked.close();
}
@Test
public void FailingScpFilesTest() throws Exception {
- PowerMockito.mockStatic(SshHelper.class);
String basePath = "/tmp";
String[] files = new String[] { "file1.txt" };
int sshPort = 3922;
String controlIp = "10.0.0.10";
String destPath = "/home/cloud/";
File pemFile = new File("/root/.ssh/id_rsa");
- PowerMockito.doThrow(new Exception()).when(SshHelper.class, "scpTo",
Mockito.anyString(), Mockito.anyInt(), Mockito.anyString(),
Mockito.any(File.class), Mockito.anyString(), Mockito.anyString(),
Mockito.any(String[].class), Mockito.anyString());
+ MockedStatic<SshHelper> sshHelperMocked =
Mockito.mockStatic(SshHelper.class);
+ sshHelperMocked.when(() ->
+ SshHelper.scpTo(Mockito.anyString(), Mockito.anyInt(),
Mockito.anyString(), Mockito.any(File.class), Mockito.anyString(),
Mockito.anyString(), Mockito.any(String[].class), Mockito.anyString()
+ )).thenThrow(new Exception());
try {
FileUtil.scpPatchFiles(controlIp, destPath, sshPort, pemFile,
files, basePath);
} catch (Exception e) {
Assert.assertEquals("Failed to scp files to system VM",
e.getMessage());
}
+ sshHelperMocked.close();
}
diff --git a/utils/src/test/java/com/cloud/utils/TestProfiler.java
b/utils/src/test/java/com/cloud/utils/TestProfiler.java
index 1520963c6e3..1d2d5f7aecd 100644
--- a/utils/src/test/java/com/cloud/utils/TestProfiler.java
+++ b/utils/src/test/java/com/cloud/utils/TestProfiler.java
@@ -23,16 +23,11 @@ import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
-import org.powermock.core.classloader.annotations.PowerMockIgnore;
-import org.powermock.core.classloader.annotations.PrepareForTest;
-import org.powermock.modules.junit4.PowerMockRunner;
import com.cloud.utils.testcase.Log4jEnabledTestCase;
+import org.mockito.junit.MockitoJUnitRunner;
-@RunWith(PowerMockRunner.class)
-@PowerMockIgnore({ "javax.management.*", "com.sun.org.apache.xerces.*",
"javax.xml.*",
- "org.xml.*", "org.w3c.dom.*", "com.sun.org.apache.xalan.*",
"javax.activation.*" })
-@PrepareForTest(Profiler.class)
+@RunWith(MockitoJUnitRunner.class)
public class TestProfiler extends Log4jEnabledTestCase {
private static final long SLEEP_TIME_NANO = 1000000000L;
diff --git a/utils/src/test/java/com/cloud/utils/UriUtilsParametrizedTest.java
b/utils/src/test/java/com/cloud/utils/UriUtilsParametrizedTest.java
index 68479f51d9f..3f1e707c607 100644
--- a/utils/src/test/java/com/cloud/utils/UriUtilsParametrizedTest.java
+++ b/utils/src/test/java/com/cloud/utils/UriUtilsParametrizedTest.java
@@ -31,18 +31,12 @@ import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
+import org.mockito.MockedStatic;
import org.mockito.Mockito;
-import org.powermock.api.mockito.PowerMockito;
-import org.powermock.core.classloader.annotations.PowerMockIgnore;
-import org.powermock.core.classloader.annotations.PrepareForTest;
-import org.powermock.modules.junit4.PowerMockRunner;
-import org.powermock.modules.junit4.PowerMockRunnerDelegate;
import com.google.common.collect.ImmutableSet;
-@RunWith(PowerMockRunner.class)
-@PowerMockRunnerDelegate(Parameterized.class)
-@PowerMockIgnore({"javax.xml.*", "org.apache.xerces.*", "org.xml.*",
"org.w3c.*"})
+@RunWith(Parameterized.class)
public class UriUtilsParametrizedTest {
@FunctionalInterface
public interface ThrowingBlock<E extends Exception> {
@@ -149,14 +143,11 @@ public class UriUtilsParametrizedTest {
}
@Test
- @PrepareForTest({UriUtils.class})
-
public void validateUrl() throws Exception {
+ MockedStatic<InetAddress> inetAddressMocked =
Mockito.mockStatic(InetAddress.class);
InetAddress inetAddressMock = Mockito.mock(InetAddress.class);
-
- PowerMockito.mockStatic(InetAddress.class);
-
PowerMockito.when(InetAddress.getByName(Mockito.anyString())).thenReturn(inetAddressMock);
+ inetAddressMocked.when(() ->
InetAddress.getByName(Mockito.anyString())).thenReturn(inetAddressMock);
if (expectSuccess) {
UriUtils.validateUrl(format, url);
@@ -164,14 +155,14 @@ public class UriUtilsParametrizedTest {
assertThrows(() -> UriUtils.validateUrl(format, url),
IllegalArgumentException.class);
}
- PowerMockito.verifyStatic(InetAddress.class);
- InetAddress.getByName(Mockito.anyString());
+ inetAddressMocked.verify(() ->
InetAddress.getByName(Mockito.anyString()));
Mockito.verify(inetAddressMock).isAnyLocalAddress();
Mockito.verify(inetAddressMock).isLinkLocalAddress();
Mockito.verify(inetAddressMock).isLoopbackAddress();
Mockito.verify(inetAddressMock).isMulticastAddress();
+ inetAddressMocked.close();
}
@Test
diff --git a/utils/src/test/java/com/cloud/utils/net/NetUtilsTest.java
b/utils/src/test/java/com/cloud/utils/net/NetUtilsTest.java
index 53e2e3ae376..4a6c5df4fd0 100644
--- a/utils/src/test/java/com/cloud/utils/net/NetUtilsTest.java
+++ b/utils/src/test/java/com/cloud/utils/net/NetUtilsTest.java
@@ -52,15 +52,12 @@ import com.googlecode.ipv6.IPv6Address;
import com.googlecode.ipv6.IPv6Network;
import org.junit.runner.RunWith;
+import org.mockito.MockedStatic;
import org.mockito.Mockito;
-import org.powermock.api.mockito.PowerMockito;
-import org.powermock.core.classloader.annotations.PowerMockIgnore;
-import org.powermock.core.classloader.annotations.PrepareForTest;
-import org.powermock.modules.junit4.PowerMockRunner;
+import org.mockito.runners.MockitoJUnitRunner;
-@RunWith(PowerMockRunner.class)
-@PowerMockIgnore({"jdk.xml.internal.*", "javax.xml.parsers.*",
"org.xml.sax.*", "org.w3c.dom.*"})
+@RunWith(MockitoJUnitRunner.class)
public class NetUtilsTest {
private static final String WIDE_SHARED_NET_CIDR_IP = "10.20.0.0";
private static final List<String> WIDE_SHARED_NET_USED_IPS =
List.of("10.20.0.22", "10.20.1.22", "10.20.2.22");
@@ -815,34 +812,34 @@ public class NetUtilsTest {
}
@Test
- @PrepareForTest(NetUtils.class)
public void getNetworkInterfaceTestReturnNullWhenGetByNameReturnsNull()
throws SocketException {
- PowerMockito.mockStatic(NetworkInterface.class);
-
PowerMockito.when(NetworkInterface.getByName(Mockito.anyString())).thenReturn(null);
+ MockedStatic<NetworkInterface> networkInterfaceMocked =
Mockito.mockStatic(NetworkInterface.class);
+
Mockito.when(NetworkInterface.getByName(Mockito.anyString())).thenReturn(null);
NetworkInterface result = NetUtils.getNetworkInterface(" test ");
Assert.assertNull(result);
+ networkInterfaceMocked.close();
}
@Test
- @PrepareForTest(NetUtils.class)
public void
getNetworkInterfaceTestReturnNullWhenGetByNameThrowsException() throws
SocketException {
- PowerMockito.mockStatic(NetworkInterface.class);
-
PowerMockito.when(NetworkInterface.getByName(Mockito.anyString())).thenThrow(SocketException.class);
+ MockedStatic<NetworkInterface> networkInterfaceMocked =
Mockito.mockStatic(NetworkInterface.class);
+
Mockito.when(NetworkInterface.getByName(Mockito.anyString())).thenThrow(SocketException.class);
NetworkInterface result = NetUtils.getNetworkInterface(" test ");
Assert.assertNull(result);
+ networkInterfaceMocked.close();
}
@Test
- @PrepareForTest(NetUtils.class)
public void getNetworkInterfaceTestReturnInterfaceReturnedByGetByName()
throws SocketException {
- NetworkInterface expected = PowerMockito.mock(NetworkInterface.class);
- PowerMockito.mockStatic(NetworkInterface.class);
-
PowerMockito.when(NetworkInterface.getByName(Mockito.anyString())).thenReturn(expected);
+ MockedStatic<NetworkInterface> networkInterfaceMocked =
Mockito.mockStatic(NetworkInterface.class);
+ NetworkInterface expected = Mockito.mock(NetworkInterface.class);
+
Mockito.when(NetworkInterface.getByName(Mockito.anyString())).thenReturn(expected);
NetworkInterface result = NetUtils.getNetworkInterface(" test ");
Assert.assertEquals(expected, result);
+ networkInterfaceMocked.close();
}
}
diff --git a/utils/src/test/java/com/cloud/utils/ssh/SshHelperTest.java
b/utils/src/test/java/com/cloud/utils/ssh/SshHelperTest.java
index 37bd089dfc5..04d84435abe 100644
--- a/utils/src/test/java/com/cloud/utils/ssh/SshHelperTest.java
+++ b/utils/src/test/java/com/cloud/utils/ssh/SshHelperTest.java
@@ -25,38 +25,31 @@ import java.io.InputStream;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
+import org.mockito.MockedStatic;
import org.mockito.Mockito;
-import org.powermock.api.mockito.PowerMockito;
-import org.powermock.core.classloader.annotations.PowerMockIgnore;
-import org.powermock.core.classloader.annotations.PrepareForTest;
-import org.powermock.modules.junit4.PowerMockRunner;
+import org.mockito.runners.MockitoJUnitRunner;
import com.trilead.ssh2.ChannelCondition;
import com.trilead.ssh2.Connection;
import com.trilead.ssh2.Session;
-@PrepareForTest({ Thread.class, SshHelper.class })
-@PowerMockIgnore({ "javax.management.*", "com.sun.org.apache.xerces.*",
"javax.xml.*",
- "org.xml.*", "org.w3c.dom.*", "com.sun.org.apache.xalan.*",
"javax.activation.*" })
-@RunWith(PowerMockRunner.class)
+@RunWith(MockitoJUnitRunner.class)
public class SshHelperTest {
@Test
public void canEndTheSshConnectionTest() throws Exception {
- PowerMockito.spy(SshHelper.class);
+ MockedStatic<SshHelper> sshHelperMocked =
Mockito.mockStatic(SshHelper.class, Mockito.CALLS_REAL_METHODS);
Session mockedSession = Mockito.mock(Session.class);
- PowerMockito.doReturn(true).when(SshHelper.class,
"isChannelConditionEof", Mockito.anyInt());
-
Mockito.when(mockedSession.waitForCondition(ChannelCondition.EXIT_STATUS,
1l)).thenReturn(0);
- PowerMockito.doNothing().when(SshHelper.class,
"throwSshExceptionIfConditionsTimeout", Mockito.anyInt());
+
Mockito.when(SshHelper.isChannelConditionEof(Mockito.anyInt())).thenReturn(true);
+
Mockito.when(mockedSession.waitForCondition(ChannelCondition.EXIT_STATUS,
1L)).thenReturn(0);
SshHelper.canEndTheSshConnection(1, mockedSession, 0);
-
- PowerMockito.verifyStatic(SshHelper.class);
- SshHelper.isChannelConditionEof(Mockito.anyInt());
- SshHelper.throwSshExceptionIfConditionsTimeout(Mockito.anyInt());
+ sshHelperMocked.verify(() ->
SshHelper.isChannelConditionEof(Mockito.anyInt()), Mockito.times(1));
+ sshHelperMocked.verify(() ->
SshHelper.throwSshExceptionIfConditionsTimeout(Mockito.anyInt()));
Mockito.verify(mockedSession).waitForCondition(ChannelCondition.EXIT_STATUS,
1l);
+ sshHelperMocked.close();
}
@Test(expected = SshException.class)
@@ -143,7 +136,6 @@ public class SshHelperTest {
@Test
public void openConnectionSessionTest() throws IOException,
InterruptedException {
Connection conn = Mockito.mock(Connection.class);
- PowerMockito.mockStatic(Thread.class);
SshHelper.openConnectionSession(conn);
Mockito.verify(conn).openSession();
diff --git
a/utils/src/test/java/com/cloud/utils/validation/ChecksumUtilTest.java
b/utils/src/test/java/com/cloud/utils/validation/ChecksumUtilTest.java
index 08cc389621e..2b99275b978 100644
--- a/utils/src/test/java/com/cloud/utils/validation/ChecksumUtilTest.java
+++ b/utils/src/test/java/com/cloud/utils/validation/ChecksumUtilTest.java
@@ -20,37 +20,35 @@ import com.cloud.utils.script.Script;
import org.apache.cloudstack.utils.security.DigestHelper;
import org.junit.Test;
import org.junit.runner.RunWith;
+import org.mockito.MockedStatic;
import org.mockito.Mockito;
-import org.powermock.api.mockito.PowerMockito;
-import org.powermock.core.classloader.annotations.PowerMockIgnore;
-import org.powermock.core.classloader.annotations.PrepareForTest;
-import org.powermock.modules.junit4.PowerMockRunner;
+import org.mockito.junit.MockitoJUnitRunner;
+
import java.io.File;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-@PrepareForTest(value = {Script.class, DigestHelper.class})
-@RunWith(PowerMockRunner.class)
-@PowerMockIgnore({"com.sun.org.apache.xerces.*", "javax.xml.parsers.*",
"javax.xml.*", "org.w3c.dom.*", "org.xml.*"})
+@RunWith(MockitoJUnitRunner.class)
public class ChecksumUtilTest {
@Test
public void invalidFileForCheckSumValidationTest() {
- PowerMockito.mockStatic(Script.class);
+ MockedStatic<Script> scriptMocked = Mockito.mockStatic(Script.class);
Mockito.when(Script.findScript(Mockito.anyString(),
Mockito.anyString())).thenReturn(null);
try {
ChecksumUtil.calculateCurrentChecksum(Mockito.anyString(),
Mockito.anyString());
} catch (Exception e) {
assertTrue(e.getMessage().contains("Unable to find cloudScripts
path, cannot update SystemVM"));
}
+ scriptMocked.close();
}
@Test
public void generateChecksumTest() {
- PowerMockito.mockStatic(Script.class);
- PowerMockito.mockStatic(DigestHelper.class);
+ MockedStatic<Script> scriptMocked = Mockito.mockStatic(Script.class);
+ MockedStatic<DigestHelper> digestHelperMocked =
Mockito.mockStatic(DigestHelper.class);
Mockito.when(Script.findScript(Mockito.anyString(),
Mockito.anyString())).thenReturn("/dummyPath");
Mockito.when(DigestHelper.calculateChecksum(Mockito.any(File.class))).thenReturn("dummy-checksum");
try {
@@ -58,5 +56,7 @@ public class ChecksumUtilTest {
} catch (Exception e) {
fail("Failed to generate checksum");
}
+ scriptMocked.close();
+ digestHelperMocked.close();
}
}
diff --git
a/utils/src/test/java/org/apache/cloudstack/utils/jsinterpreter/JsInterpreterTest.java
b/utils/src/test/java/org/apache/cloudstack/utils/jsinterpreter/JsInterpreterTest.java
index 1567d897fe6..d1814625929 100644
---
a/utils/src/test/java/org/apache/cloudstack/utils/jsinterpreter/JsInterpreterTest.java
+++
b/utils/src/test/java/org/apache/cloudstack/utils/jsinterpreter/JsInterpreterTest.java
@@ -35,16 +35,12 @@ import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.Spy;
+import org.mockito.junit.MockitoJUnitRunner;
import org.openjdk.nashorn.api.scripting.NashornScriptEngineFactory;
-import org.powermock.core.classloader.annotations.PowerMockIgnore;
-import org.powermock.core.classloader.annotations.PrepareForTest;
-import org.powermock.modules.junit4.PowerMockRunner;
import javax.script.ScriptEngine;
-@RunWith(PowerMockRunner.class)
-@PowerMockIgnore({"javax.xml.*", "org.apache.xerces.*", "org.xml.*",
"org.w3c.*"})
-@PrepareForTest(JsInterpreter.class)
+@RunWith(MockitoJUnitRunner.class)
public class JsInterpreterTest {
private long timeout = 2000;
@@ -95,7 +91,6 @@ public class JsInterpreterTest {
public void executeScriptTestReturnResultOfScriptExecution() {
String script = "5";
Object expected = new Object();
-
Mockito.doReturn(script).when(jsInterpreterSpy).addVariablesToScript(Mockito.anyString());
Mockito.doReturn(expected).when(jsInterpreterSpy).executeScript(Mockito.anyString());
Object result = jsInterpreterSpy.executeScript(script);
@@ -173,9 +168,8 @@ public class JsInterpreterTest {
}
@Test
- @PrepareForTest(NashornScriptEngineFactory.class)
public void setScriptEngineDisablingJavaLanguageTest() {
- NashornScriptEngineFactory nashornScriptEngineFactoryMock =
Mockito.mock(NashornScriptEngineFactory.class);
+ NashornScriptEngineFactory nashornScriptEngineFactoryMock =
Mockito.spy(NashornScriptEngineFactory.class);
ScriptEngine scriptEngineMock = Mockito.mock(ScriptEngine.class);
Mockito.doReturn(scriptEngineMock).when(nashornScriptEngineFactoryMock).getScriptEngine(Mockito.anyString());
diff --git
a/utils/src/test/java/org/apache/cloudstack/utils/reflectiontostringbuilderutils/ReflectionToStringBuilderUtilsTest.java
b/utils/src/test/java/org/apache/cloudstack/utils/reflectiontostringbuilderutils/ReflectionToStringBuilderUtilsTest.java
index 4a2a2a6989b..75befde3efd 100644
---
a/utils/src/test/java/org/apache/cloudstack/utils/reflectiontostringbuilderutils/ReflectionToStringBuilderUtilsTest.java
+++
b/utils/src/test/java/org/apache/cloudstack/utils/reflectiontostringbuilderutils/ReflectionToStringBuilderUtilsTest.java
@@ -33,16 +33,12 @@ import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
+import org.mockito.MockedStatic;
import org.mockito.Mockito;
-import org.powermock.api.mockito.PowerMockito;
-import org.powermock.core.classloader.annotations.PowerMockIgnore;
-import org.powermock.core.classloader.annotations.PrepareForTest;
-import org.powermock.modules.junit4.PowerMockRunner;
+import org.mockito.junit.MockitoJUnitRunner;
import org.reflections.ReflectionUtils;
-@RunWith(PowerMockRunner.class)
-@PowerMockIgnore({"org.w3c.*", "javax.xml.*", "org.xml.*"})
-@PrepareForTest(ReflectionToStringBuilderUtils.class)
+@RunWith(MockitoJUnitRunner.class)
public class ReflectionToStringBuilderUtilsTest extends TestCase {
private static final Set<ToStringStyle> TO_STRING_STYLES = new
HashSet<>(Arrays.asList(ToStringStyle.DEFAULT_STYLE, ToStringStyle.JSON_STYLE,
ToStringStyle.MULTI_LINE_STYLE,
@@ -95,60 +91,63 @@ public class ReflectionToStringBuilderUtilsTest extends
TestCase {
@Test
public void validateGetObjectClassInvalidObjectMustReturnNull(){
- PowerMockito.spy(ReflectionToStringBuilderUtils.class);
-
PowerMockito.when(ReflectionToStringBuilderUtils.isValidObject(Mockito.any())).thenReturn(false);
-
+ MockedStatic<ReflectionToStringBuilderUtils>
reflectionToStringBuilderUtilsMocked =
Mockito.mockStatic(ReflectionToStringBuilderUtils.class,
Mockito.CALLS_REAL_METHODS);
+ reflectionToStringBuilderUtilsMocked.when(() ->
ReflectionToStringBuilderUtils.isValidObject(Mockito.any())).thenReturn(false);
Class<?> result =
ReflectionToStringBuilderUtils.getObjectClass("test");
Assert.assertNull(result);
+ reflectionToStringBuilderUtilsMocked.close();
}
@Test
public void
validateGetObjectClassObjectIsNotACollectionMustReturnObjectClass(){
Class<?> expectedResult = classToReflect;
- PowerMockito.spy(ReflectionToStringBuilderUtils.class);
-
PowerMockito.when(ReflectionToStringBuilderUtils.isValidObject(Mockito.any())).thenReturn(true);
-
PowerMockito.when(ReflectionToStringBuilderUtils.isCollection(Mockito.any())).thenReturn(false);
+ MockedStatic<ReflectionToStringBuilderUtils>
reflectionToStringBuilderUtilsMocked =
Mockito.mockStatic(ReflectionToStringBuilderUtils.class,
Mockito.CALLS_REAL_METHODS);
+ reflectionToStringBuilderUtilsMocked.when(() ->
ReflectionToStringBuilderUtils.isValidObject(Mockito.any())).thenReturn(true);
+ reflectionToStringBuilderUtilsMocked.when(() ->
ReflectionToStringBuilderUtils.isCollection(Mockito.any())).thenReturn(false);
Class<?> result =
ReflectionToStringBuilderUtils.getObjectClass("test");
Assert.assertEquals(expectedResult, result);
+ reflectionToStringBuilderUtilsMocked.close();
}
@Test
public void
validateGetObjectClassObjectIsAnEmptyCollectionMustReturnNull(){
- PowerMockito.spy(ReflectionToStringBuilderUtils.class);
-
PowerMockito.when(ReflectionToStringBuilderUtils.isValidObject(Mockito.any())).thenReturn(true);
-
PowerMockito.when(ReflectionToStringBuilderUtils.isCollection(Mockito.any())).thenReturn(true);
+ MockedStatic<ReflectionToStringBuilderUtils>
reflectionToStringBuilderUtilsMocked =
Mockito.mockStatic(ReflectionToStringBuilderUtils.class,
Mockito.CALLS_REAL_METHODS);
+ reflectionToStringBuilderUtilsMocked.when(() ->
ReflectionToStringBuilderUtils.isValidObject(Mockito.any())).thenReturn(true);
+ reflectionToStringBuilderUtilsMocked.when(() ->
ReflectionToStringBuilderUtils.isCollection(Mockito.any())).thenReturn(true);
Class<?> result = ReflectionToStringBuilderUtils.getObjectClass(new
ArrayList<String>());
Assert.assertNull(result);
+ reflectionToStringBuilderUtilsMocked.close();
}
@Test
public void
validateGetObjectClassObjectIsACollectionWithOnlyNullValuesMustReturnNull(){
- PowerMockito.spy(ReflectionToStringBuilderUtils.class);
-
PowerMockito.when(ReflectionToStringBuilderUtils.isValidObject(Mockito.any())).thenReturn(true);
-
PowerMockito.when(ReflectionToStringBuilderUtils.isCollection(Mockito.any())).thenReturn(true);
+ MockedStatic<ReflectionToStringBuilderUtils>
reflectionToStringBuilderUtilsMocked =
Mockito.mockStatic(ReflectionToStringBuilderUtils.class,
Mockito.CALLS_REAL_METHODS);
+ reflectionToStringBuilderUtilsMocked.when(() ->
ReflectionToStringBuilderUtils.isValidObject(Mockito.any())).thenReturn(true);
+ reflectionToStringBuilderUtilsMocked.when(() ->
ReflectionToStringBuilderUtils.isCollection(Mockito.any())).thenReturn(true);
Class<?> result = ReflectionToStringBuilderUtils.getObjectClass(new
ArrayList<String>(Arrays.asList(null, null)));
Assert.assertNull(result);
+ reflectionToStringBuilderUtilsMocked.close();
}
@Test
public void
validateGetObjectClassObjectIsACollectionWithAtLeastOneObjectsMustReturnObjectClass(){
Class<?> expectedResult = classToReflect;
-
- PowerMockito.spy(ReflectionToStringBuilderUtils.class);
-
PowerMockito.when(ReflectionToStringBuilderUtils.isValidObject(Mockito.any())).thenReturn(true);
-
PowerMockito.when(ReflectionToStringBuilderUtils.isCollection(Mockito.any())).thenReturn(true);
+ MockedStatic<ReflectionToStringBuilderUtils>
reflectionToStringBuilderUtilsMocked =
Mockito.mockStatic(ReflectionToStringBuilderUtils.class,
Mockito.CALLS_REAL_METHODS);
+ reflectionToStringBuilderUtilsMocked.when(() ->
ReflectionToStringBuilderUtils.isValidObject(Mockito.any())).thenReturn(true);
+ reflectionToStringBuilderUtilsMocked.when(() ->
ReflectionToStringBuilderUtils.isCollection(Mockito.any())).thenReturn(true);
Class<?> result = ReflectionToStringBuilderUtils.getObjectClass(new
ArrayList<>(Arrays.asList(null, "test1")));
Assert.assertEquals(expectedResult, result);
+ reflectionToStringBuilderUtilsMocked.close();
}
@Test
@@ -163,12 +162,13 @@ public class ReflectionToStringBuilderUtilsTest extends
TestCase {
@Test
public void validateGetNonSelectedFieldsNullObjectClassMustReturnNull(){
- PowerMockito.spy(ReflectionToStringBuilderUtils.class);
-
PowerMockito.when(ReflectionToStringBuilderUtils.getObjectClass(Mockito.any())).thenReturn(null);
+ MockedStatic<ReflectionToStringBuilderUtils>
reflectionToStringBuilderUtilsMocked =
Mockito.mockStatic(ReflectionToStringBuilderUtils.class,
Mockito.CALLS_REAL_METHODS);
+ reflectionToStringBuilderUtilsMocked.when(() ->
ReflectionToStringBuilderUtils.getObjectClass(Mockito.any())).thenReturn(null);
String[] result =
ReflectionToStringBuilderUtils.getNonSelectedFields(null, "test1", "test2");
Assert.assertNull(result);
+ reflectionToStringBuilderUtilsMocked.close();
}
@Test
@@ -250,26 +250,28 @@ public class ReflectionToStringBuilderUtilsTest extends
TestCase {
@Test
public void
validateReflectOnlySelectedFieldsNullNonSelectedFieldsMustReturnNull() throws
Exception{
- PowerMockito.spy(ReflectionToStringBuilderUtils.class);
-
PowerMockito.when(ReflectionToStringBuilderUtils.getNonSelectedFields(Mockito.any(),
Mockito.any())).thenReturn(null);
+ MockedStatic<ReflectionToStringBuilderUtils>
reflectionToStringBuilderUtilsMocked =
Mockito.mockStatic(ReflectionToStringBuilderUtils.class,
Mockito.CALLS_REAL_METHODS);
+ reflectionToStringBuilderUtilsMocked.when(() ->
ReflectionToStringBuilderUtils.getNonSelectedFields(Mockito.any(),
Mockito.any())).thenReturn(null);
TO_STRING_STYLES.forEach(style -> {
String result =
ReflectionToStringBuilderUtils.reflectOnlySelectedFields(null, style, "-");
Assert.assertNull(result);
});
+ reflectionToStringBuilderUtilsMocked.close();
}
@Test
public void
validateReflectOnlySelectedFieldsEmptyNonSelectedFieldsMustReturnEmptyString()
throws Exception{
String expectedResult = "";
- PowerMockito.spy(ReflectionToStringBuilderUtils.class);
-
PowerMockito.when(ReflectionToStringBuilderUtils.getNonSelectedFields(Mockito.any(),
Mockito.any())).thenReturn(new String[0]);
+ MockedStatic<ReflectionToStringBuilderUtils>
reflectionToStringBuilderUtilsMocked =
Mockito.mockStatic(ReflectionToStringBuilderUtils.class,
Mockito.CALLS_REAL_METHODS);
+ reflectionToStringBuilderUtilsMocked.when(() ->
ReflectionToStringBuilderUtils.getNonSelectedFields(Mockito.any(),
Mockito.any())).thenReturn(new String[0]);
TO_STRING_STYLES.forEach(style -> {
String result =
ReflectionToStringBuilderUtils.reflectOnlySelectedFields(null, style, "-");
Assert.assertEquals(expectedResult, result);
});
+ reflectionToStringBuilderUtilsMocked.close();
}
@Test
@@ -277,80 +279,85 @@ public class ReflectionToStringBuilderUtilsTest extends
TestCase {
String fieldToRemove = classToReflectRemovedField;
String expectedResult = "test";
- PowerMockito.spy(ReflectionToStringBuilderUtils.class);
-
PowerMockito.when(ReflectionToStringBuilderUtils.getNonSelectedFields(Mockito.any(),
Mockito.any())).thenReturn(classToReflectFieldsNamesArray);
-
PowerMockito.when(ReflectionToStringBuilderUtils.reflectCollection(Mockito.any(),
Mockito.any(), Mockito.anyString(), Mockito.any())).thenReturn(expectedResult);
+ MockedStatic<ReflectionToStringBuilderUtils>
reflectionToStringBuilderUtilsMocked =
Mockito.mockStatic(ReflectionToStringBuilderUtils.class,
Mockito.CALLS_REAL_METHODS);
+ reflectionToStringBuilderUtilsMocked.when(() ->
ReflectionToStringBuilderUtils.getNonSelectedFields(Mockito.any(),
Mockito.any())).thenReturn(classToReflectFieldsNamesArray);
+ reflectionToStringBuilderUtilsMocked.when(() ->
ReflectionToStringBuilderUtils.reflectCollection(Mockito.any(), Mockito.any(),
Mockito.anyString(), Mockito.any())).thenReturn(expectedResult);
TO_STRING_STYLES.forEach(style -> {
String result =
ReflectionToStringBuilderUtils.reflectOnlySelectedFields(new Object(), style,
"-", fieldToRemove);
Assert.assertEquals(expectedResult, result);
});
+ reflectionToStringBuilderUtilsMocked.close();
}
@Test
public void
validateReflectOnlySelectedFieldsObjectIsNotACollectionMustReflectObject()
throws Exception{
String expectedResult = "test";
- PowerMockito.spy(ReflectionToStringBuilderUtils.class);
-
PowerMockito.when(ReflectionToStringBuilderUtils.getNonSelectedFields(Mockito.any(),
Mockito.any())).thenReturn(classToReflectFieldsNamesArray);
-
PowerMockito.when(ReflectionToStringBuilderUtils.reflectCollection(Mockito.any(),
Mockito.any(), Mockito.anyString(), Mockito.any())).thenReturn(null);
+ MockedStatic<ReflectionToStringBuilderUtils>
reflectionToStringBuilderUtilsMocked =
Mockito.mockStatic(ReflectionToStringBuilderUtils.class,
Mockito.CALLS_REAL_METHODS);
+ reflectionToStringBuilderUtilsMocked.when(() ->
ReflectionToStringBuilderUtils.getNonSelectedFields(Mockito.any(),
Mockito.any())).thenReturn(classToReflectFieldsNamesArray);
+ reflectionToStringBuilderUtilsMocked.when(() ->
ReflectionToStringBuilderUtils.reflectCollection(Mockito.any(), Mockito.any(),
Mockito.anyString(), Mockito.any())).thenReturn(null);
for (ToStringStyle style : TO_STRING_STYLES){
-
PowerMockito.doReturn(expectedResult).when(ReflectionToStringBuilderUtils.class,
"getReflectedObject", Mockito.any(), Mockito.any(), Mockito.any());
+ reflectionToStringBuilderUtilsMocked.when(() ->
ReflectionToStringBuilderUtils.getReflectedObject(Mockito.any(), Mockito.any(),
Mockito.any())).thenReturn(expectedResult);
String result =
ReflectionToStringBuilderUtils.reflectOnlySelectedFields(expectedResult, style,
"-", classToReflectFieldsNamesArray);
Assert.assertEquals(expectedResult, result);
}
+ reflectionToStringBuilderUtilsMocked.close();
}
@Test
public void
validateReflectOnlySelectedFieldsDefaultStyleReflectionNullMustReturnNull(){
String expectedResult = null;
- PowerMockito.spy(ReflectionToStringBuilderUtils.class);
-
PowerMockito.when(ReflectionToStringBuilderUtils.reflectOnlySelectedFields(Mockito.any(),
Mockito.any(), Mockito.anyString(), Mockito.any())).thenReturn(null);
+ MockedStatic<ReflectionToStringBuilderUtils>
reflectionToStringBuilderUtilsMocked =
Mockito.mockStatic(ReflectionToStringBuilderUtils.class,
Mockito.CALLS_REAL_METHODS);
+ reflectionToStringBuilderUtilsMocked.when(() ->
ReflectionToStringBuilderUtils.reflectOnlySelectedFields(Mockito.any(),
Mockito.any(), Mockito.anyString(), Mockito.any())).thenReturn(null);
String result =
ReflectionToStringBuilderUtils.reflectOnlySelectedFields(new Object(),
(String[]) null);
Assert.assertEquals(expectedResult, result);
+ reflectionToStringBuilderUtilsMocked.close();
}
@Test
public void
validateReflectOnlySelectedFieldsDefaultStyleReflectCollectionMustReturnValue(){
String expectedResult = "[test]";
- PowerMockito.spy(ReflectionToStringBuilderUtils.class);
-
PowerMockito.when(ReflectionToStringBuilderUtils.reflectOnlySelectedFields(Mockito.any(),
Mockito.any(), Mockito.anyString(), Mockito.any())).thenReturn("test");
-
PowerMockito.when(ReflectionToStringBuilderUtils.isCollection(Mockito.any())).thenReturn(true);
+ MockedStatic<ReflectionToStringBuilderUtils>
reflectionToStringBuilderUtilsMocked =
Mockito.mockStatic(ReflectionToStringBuilderUtils.class,
Mockito.CALLS_REAL_METHODS);
+ reflectionToStringBuilderUtilsMocked.when(() ->
ReflectionToStringBuilderUtils.reflectOnlySelectedFields(Mockito.any(),
Mockito.any(), Mockito.anyString(), Mockito.any())).thenReturn("test");
+ reflectionToStringBuilderUtilsMocked.when(() ->
ReflectionToStringBuilderUtils.isCollection(Mockito.any())).thenReturn(true);
String result =
ReflectionToStringBuilderUtils.reflectOnlySelectedFields(new Object());
Assert.assertEquals(expectedResult, result);
+ reflectionToStringBuilderUtilsMocked.close();
}
@Test
public void
validateReflectOnlySelectedFieldsDefaultStyleReflectMustReturnValue(){
String expectedResult = "test";
- PowerMockito.spy(ReflectionToStringBuilderUtils.class);
-
PowerMockito.when(ReflectionToStringBuilderUtils.reflectOnlySelectedFields(Mockito.any(),
Mockito.any(), Mockito.anyString(), Mockito.any())).thenReturn(expectedResult);
-
PowerMockito.when(ReflectionToStringBuilderUtils.isCollection(Mockito.any())).thenReturn(false);
+ MockedStatic<ReflectionToStringBuilderUtils>
reflectionToStringBuilderUtilsMocked =
Mockito.mockStatic(ReflectionToStringBuilderUtils.class,
Mockito.CALLS_REAL_METHODS);
+ reflectionToStringBuilderUtilsMocked.when(() ->
ReflectionToStringBuilderUtils.reflectOnlySelectedFields(Mockito.any(),
Mockito.any(), Mockito.anyString(), Mockito.any())).thenReturn(expectedResult);
+ reflectionToStringBuilderUtilsMocked.when(() ->
ReflectionToStringBuilderUtils.isCollection(Mockito.any())).thenReturn(false);
String result =
ReflectionToStringBuilderUtils.reflectOnlySelectedFields(new Object());
Assert.assertEquals(expectedResult, result);
+ reflectionToStringBuilderUtilsMocked.close();
}
@Test
public void
reflectCollectionTestCallBaseReflectCollectionMethodWithDefaultParameters() {
String expected = "test";
- PowerMockito.spy(ReflectionToStringBuilderUtils.class);
-
PowerMockito.when(ReflectionToStringBuilderUtils.reflectCollection(Mockito.any(),
Mockito.any(), Mockito.anyString(), Mockito.any())).thenReturn(expected);
+ MockedStatic<ReflectionToStringBuilderUtils>
reflectionToStringBuilderUtilsMocked =
Mockito.mockStatic(ReflectionToStringBuilderUtils.class,
Mockito.CALLS_REAL_METHODS);
+ reflectionToStringBuilderUtilsMocked.when(() ->
ReflectionToStringBuilderUtils.reflectCollection(Mockito.any(), Mockito.any(),
Mockito.anyString(), Mockito.any())).thenReturn(expected);
Object object = Mockito.mock(Object.class);
String result =
ReflectionToStringBuilderUtils.reflectCollection(object);
Assert.assertEquals(expected, result);
- PowerMockito.verifyStatic(ReflectionToStringBuilderUtils.class);
String[] excludeFields = null;
- ReflectionToStringBuilderUtils.reflectCollection(object,
DEFAULT_STYLE, DEFAULT_MULTIPLE_VALUES_SEPARATOR, excludeFields);
+ reflectionToStringBuilderUtilsMocked.verify(() ->
ReflectionToStringBuilderUtils.reflectCollection(object, DEFAULT_STYLE,
DEFAULT_MULTIPLE_VALUES_SEPARATOR, excludeFields));
+ reflectionToStringBuilderUtilsMocked.close();
}
}
diff --git
a/utils/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker
b/utils/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker
new file mode 100644
index 00000000000..ca6ee9cea8e
--- /dev/null
+++ b/utils/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker
@@ -0,0 +1 @@
+mock-maker-inline
\ No newline at end of file
