apache/cloudstack
1
0
Fork 0
mirror of https://github.com/apache/cloudstack.git synced 2025-10-26 08:42:29 +01:00
Code Issues Packages Projects Releases Wiki Activity

Upgrade mockito (#7577)

Browse Source
This commit is contained in:
Vishesh 2023-06-12 16:04:23 +05:30 committed by GitHub
parent ae10263b3b
commit 5fda9c3687
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
10 changed files with 115 additions and 134 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
pom.xml
View File

@ -113,7 +113,7 @@
<cs.junit.dataprovider.version>1.13.1</cs.junit.dataprovider.version> <cs.junit.dataprovider.version>1.13.1</cs.junit.dataprovider.version>
<cs.junit.jupiter.version>5.9.1</cs.junit.jupiter.version> <cs.junit.jupiter.version>5.9.1</cs.junit.jupiter.version>
<cs.guava-testlib.version>18.0</cs.guava-testlib.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.powermock.version>2.0.5</cs.powermock.version>
<cs.selenium.server.version>1.0-20081010.060147</cs.selenium.server.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> <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/public/**</exclude>
<exclude>ui/legacy/**</exclude> <exclude>ui/legacy/**</exclude>
<exclude>utils/testsmallfileinactive</exclude> <exclude>utils/testsmallfileinactive</exclude>
<exclude>utils/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker</exclude>
</excludes> </excludes>
</configuration> </configuration>
</plugin> </plugin>

25
utils/src/test/java/com/cloud/utils/FileUtilTest.java
View File

@ -20,49 +20,52 @@ import com.cloud.utils.ssh.SshHelper;
import org.junit.Assert; import org.junit.Assert;
import org.junit.Test; import org.junit.Test;
import org.junit.runner.RunWith; import org.junit.runner.RunWith;
import org.mockito.MockedStatic;
import org.mockito.Mockito; import org.mockito.Mockito;
import org.powermock.api.mockito.PowerMockito; import org.mockito.junit.MockitoJUnitRunner;
import org.powermock.core.classloader.annotations.PowerMockIgnore;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import java.io.File; import java.io.File;
import static org.mockito.ArgumentMatchers.nullable; import static org.mockito.ArgumentMatchers.nullable;
@PrepareForTest(value = {SshHelper.class}) @RunWith(MockitoJUnitRunner.class)
@RunWith(PowerMockRunner.class)
@PowerMockIgnore({"com.sun.org.apache.xerces.*", "javax.xml.parsers.*", "javax.xml.*", "org.w3c.dom.*", "org.xml.*"})
public class FileUtilTest { public class FileUtilTest {
@Test @Test
public void successfulScpTest() throws Exception { public void successfulScpTest() throws Exception {
PowerMockito.mockStatic(SshHelper.class); MockedStatic<SshHelper> sshHelperMocked = Mockito.mockStatic(SshHelper.class);
String basePath = "/tmp"; String basePath = "/tmp";
String[] files = new String[] { "file1.txt" }; String[] files = new String[] { "file1.txt" };
int sshPort = 3922; int sshPort = 3922;
String controlIp = "10.0.0.10"; String controlIp = "10.0.0.10";
String destPath = "/home/cloud/"; String destPath = "/home/cloud/";
File pemFile = new File("/root/.ssh/id_rsa"); 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); FileUtil.scpPatchFiles(controlIp, destPath, sshPort, pemFile, files, basePath);
sshHelperMocked.close();
} }
@Test @Test
public void FailingScpFilesTest() throws Exception { public void FailingScpFilesTest() throws Exception {
PowerMockito.mockStatic(SshHelper.class);
String basePath = "/tmp"; String basePath = "/tmp";
String[] files = new String[] { "file1.txt" }; String[] files = new String[] { "file1.txt" };
int sshPort = 3922; int sshPort = 3922;
String controlIp = "10.0.0.10"; String controlIp = "10.0.0.10";
String destPath = "/home/cloud/"; String destPath = "/home/cloud/";
File pemFile = new File("/root/.ssh/id_rsa"); 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 { try {
FileUtil.scpPatchFiles(controlIp, destPath, sshPort, pemFile, files, basePath); FileUtil.scpPatchFiles(controlIp, destPath, sshPort, pemFile, files, basePath);
} catch (Exception e) { } catch (Exception e) {
Assert.assertEquals("Failed to scp files to system VM", e.getMessage()); Assert.assertEquals("Failed to scp files to system VM", e.getMessage());
} }
sshHelperMocked.close();
} }

9
utils/src/test/java/com/cloud/utils/TestProfiler.java
View File

@ -23,16 +23,11 @@ import org.junit.Assert;
import org.junit.Before; import org.junit.Before;
import org.junit.Test; import org.junit.Test;
import org.junit.runner.RunWith; 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 com.cloud.utils.testcase.Log4jEnabledTestCase;
import org.mockito.junit.MockitoJUnitRunner;
@RunWith(PowerMockRunner.class) @RunWith(MockitoJUnitRunner.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)
public class TestProfiler extends Log4jEnabledTestCase { public class TestProfiler extends Log4jEnabledTestCase {
private static final long SLEEP_TIME_NANO = 1000000000L; private static final long SLEEP_TIME_NANO = 1000000000L;

21
utils/src/test/java/com/cloud/utils/UriUtilsParametrizedTest.java
View File

@ -31,18 +31,12 @@ import org.junit.Assert;
import org.junit.Test; import org.junit.Test;
import org.junit.runner.RunWith; import org.junit.runner.RunWith;
import org.junit.runners.Parameterized; import org.junit.runners.Parameterized;
import org.mockito.MockedStatic;
import org.mockito.Mockito; 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; import com.google.common.collect.ImmutableSet;
@RunWith(PowerMockRunner.class) @RunWith(Parameterized.class)
@PowerMockRunnerDelegate(Parameterized.class)
@PowerMockIgnore({"javax.xml.*", "org.apache.xerces.*", "org.xml.*", "org.w3c.*"})
public class UriUtilsParametrizedTest { public class UriUtilsParametrizedTest {
@FunctionalInterface @FunctionalInterface
public interface ThrowingBlock<E extends Exception> { public interface ThrowingBlock<E extends Exception> {
@ -149,14 +143,11 @@ public class UriUtilsParametrizedTest {
} }
@Test @Test
@PrepareForTest({UriUtils.class})
public void validateUrl() throws Exception { public void validateUrl() throws Exception {
MockedStatic<InetAddress> inetAddressMocked = Mockito.mockStatic(InetAddress.class);
InetAddress inetAddressMock = Mockito.mock(InetAddress.class); InetAddress inetAddressMock = Mockito.mock(InetAddress.class);
inetAddressMocked.when(() -> InetAddress.getByName(Mockito.anyString())).thenReturn(inetAddressMock);
PowerMockito.mockStatic(InetAddress.class);
PowerMockito.when(InetAddress.getByName(Mockito.anyString())).thenReturn(inetAddressMock);
if (expectSuccess) { if (expectSuccess) {
UriUtils.validateUrl(format, url); UriUtils.validateUrl(format, url);
@ -164,14 +155,14 @@ public class UriUtilsParametrizedTest {
assertThrows(() -> UriUtils.validateUrl(format, url), IllegalArgumentException.class); assertThrows(() -> UriUtils.validateUrl(format, url), IllegalArgumentException.class);
} }
PowerMockito.verifyStatic(InetAddress.class); inetAddressMocked.verify(() -> InetAddress.getByName(Mockito.anyString()));
InetAddress.getByName(Mockito.anyString());
Mockito.verify(inetAddressMock).isAnyLocalAddress(); Mockito.verify(inetAddressMock).isAnyLocalAddress();
Mockito.verify(inetAddressMock).isLinkLocalAddress(); Mockito.verify(inetAddressMock).isLinkLocalAddress();
Mockito.verify(inetAddressMock).isLoopbackAddress(); Mockito.verify(inetAddressMock).isLoopbackAddress();
Mockito.verify(inetAddressMock).isMulticastAddress(); Mockito.verify(inetAddressMock).isMulticastAddress();
inetAddressMocked.close();
} }
@Test @Test

29
utils/src/test/java/com/cloud/utils/net/NetUtilsTest.java
View File

@ -52,15 +52,12 @@ import com.googlecode.ipv6.IPv6Address;
import com.googlecode.ipv6.IPv6Network; import com.googlecode.ipv6.IPv6Network;
import org.junit.runner.RunWith; import org.junit.runner.RunWith;
import org.mockito.MockedStatic;
import org.mockito.Mockito; import org.mockito.Mockito;
import org.powermock.api.mockito.PowerMockito; import org.mockito.runners.MockitoJUnitRunner;
import org.powermock.core.classloader.annotations.PowerMockIgnore;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
@RunWith(PowerMockRunner.class) @RunWith(MockitoJUnitRunner.class)
@PowerMockIgnore({"jdk.xml.internal.*", "javax.xml.parsers.*", "org.xml.sax.*", "org.w3c.dom.*"})
public class NetUtilsTest { public class NetUtilsTest {
private static final String WIDE_SHARED_NET_CIDR_IP = "10.20.0.0"; 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"); 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 @Test
@PrepareForTest(NetUtils.class)
public void getNetworkInterfaceTestReturnNullWhenGetByNameReturnsNull() throws SocketException { public void getNetworkInterfaceTestReturnNullWhenGetByNameReturnsNull() throws SocketException {
PowerMockito.mockStatic(NetworkInterface.class); MockedStatic<NetworkInterface> networkInterfaceMocked = Mockito.mockStatic(NetworkInterface.class);
PowerMockito.when(NetworkInterface.getByName(Mockito.anyString())).thenReturn(null); Mockito.when(NetworkInterface.getByName(Mockito.anyString())).thenReturn(null);
NetworkInterface result = NetUtils.getNetworkInterface(" test "); NetworkInterface result = NetUtils.getNetworkInterface(" test ");
Assert.assertNull(result); Assert.assertNull(result);
networkInterfaceMocked.close();
} }
@Test @Test
@PrepareForTest(NetUtils.class)
public void getNetworkInterfaceTestReturnNullWhenGetByNameThrowsException() throws SocketException { public void getNetworkInterfaceTestReturnNullWhenGetByNameThrowsException() throws SocketException {
PowerMockito.mockStatic(NetworkInterface.class); MockedStatic<NetworkInterface> networkInterfaceMocked = Mockito.mockStatic(NetworkInterface.class);
PowerMockito.when(NetworkInterface.getByName(Mockito.anyString())).thenThrow(SocketException.class); Mockito.when(NetworkInterface.getByName(Mockito.anyString())).thenThrow(SocketException.class);
NetworkInterface result = NetUtils.getNetworkInterface(" test "); NetworkInterface result = NetUtils.getNetworkInterface(" test ");
Assert.assertNull(result); Assert.assertNull(result);
networkInterfaceMocked.close();
} }
@Test @Test
@PrepareForTest(NetUtils.class)
public void getNetworkInterfaceTestReturnInterfaceReturnedByGetByName() throws SocketException { public void getNetworkInterfaceTestReturnInterfaceReturnedByGetByName() throws SocketException {
NetworkInterface expected = PowerMockito.mock(NetworkInterface.class); MockedStatic<NetworkInterface> networkInterfaceMocked = Mockito.mockStatic(NetworkInterface.class);
PowerMockito.mockStatic(NetworkInterface.class); NetworkInterface expected = Mockito.mock(NetworkInterface.class);
PowerMockito.when(NetworkInterface.getByName(Mockito.anyString())).thenReturn(expected); Mockito.when(NetworkInterface.getByName(Mockito.anyString())).thenReturn(expected);
NetworkInterface result = NetUtils.getNetworkInterface(" test "); NetworkInterface result = NetUtils.getNetworkInterface(" test ");
Assert.assertEquals(expected, result); Assert.assertEquals(expected, result);
networkInterfaceMocked.close();
} }
} }

26
utils/src/test/java/com/cloud/utils/ssh/SshHelperTest.java
View File

@ -25,38 +25,31 @@ import java.io.InputStream;
import org.junit.Assert; import org.junit.Assert;
import org.junit.Test; import org.junit.Test;
import org.junit.runner.RunWith; import org.junit.runner.RunWith;
import org.mockito.MockedStatic;
import org.mockito.Mockito; import org.mockito.Mockito;
import org.powermock.api.mockito.PowerMockito; import org.mockito.runners.MockitoJUnitRunner;
import org.powermock.core.classloader.annotations.PowerMockIgnore;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import com.trilead.ssh2.ChannelCondition; import com.trilead.ssh2.ChannelCondition;
import com.trilead.ssh2.Connection; import com.trilead.ssh2.Connection;
import com.trilead.ssh2.Session; import com.trilead.ssh2.Session;
@PrepareForTest({ Thread.class, SshHelper.class }) @RunWith(MockitoJUnitRunner.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)
public class SshHelperTest { public class SshHelperTest {
@Test @Test
public void canEndTheSshConnectionTest() throws Exception { 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); Session mockedSession = Mockito.mock(Session.class);
PowerMockito.doReturn(true).when(SshHelper.class, "isChannelConditionEof", Mockito.anyInt()); Mockito.when(SshHelper.isChannelConditionEof(Mockito.anyInt())).thenReturn(true);
Mockito.when(mockedSession.waitForCondition(ChannelCondition.EXIT_STATUS, 1l)).thenReturn(0); Mockito.when(mockedSession.waitForCondition(ChannelCondition.EXIT_STATUS, 1L)).thenReturn(0);
PowerMockito.doNothing().when(SshHelper.class, "throwSshExceptionIfConditionsTimeout", Mockito.anyInt());
SshHelper.canEndTheSshConnection(1, mockedSession, 0); SshHelper.canEndTheSshConnection(1, mockedSession, 0);
sshHelperMocked.verify(() -> SshHelper.isChannelConditionEof(Mockito.anyInt()), Mockito.times(1));
PowerMockito.verifyStatic(SshHelper.class); sshHelperMocked.verify(() -> SshHelper.throwSshExceptionIfConditionsTimeout(Mockito.anyInt()));
SshHelper.isChannelConditionEof(Mockito.anyInt());
SshHelper.throwSshExceptionIfConditionsTimeout(Mockito.anyInt());
Mockito.verify(mockedSession).waitForCondition(ChannelCondition.EXIT_STATUS, 1l); Mockito.verify(mockedSession).waitForCondition(ChannelCondition.EXIT_STATUS, 1l);
sshHelperMocked.close();
} }
@Test(expected = SshException.class) @Test(expected = SshException.class)
@ -143,7 +136,6 @@ public class SshHelperTest {
@Test @Test
public void openConnectionSessionTest() throws IOException, InterruptedException { public void openConnectionSessionTest() throws IOException, InterruptedException {
Connection conn = Mockito.mock(Connection.class); Connection conn = Mockito.mock(Connection.class);
PowerMockito.mockStatic(Thread.class);
SshHelper.openConnectionSession(conn); SshHelper.openConnectionSession(conn);
Mockito.verify(conn).openSession(); Mockito.verify(conn).openSession();

20
utils/src/test/java/com/cloud/utils/validation/ChecksumUtilTest.java
View File

@ -20,37 +20,35 @@ import com.cloud.utils.script.Script;
import org.apache.cloudstack.utils.security.DigestHelper; import org.apache.cloudstack.utils.security.DigestHelper;
import org.junit.Test; import org.junit.Test;
import org.junit.runner.RunWith; import org.junit.runner.RunWith;
import org.mockito.MockedStatic;
import org.mockito.Mockito; import org.mockito.Mockito;
import org.powermock.api.mockito.PowerMockito; import org.mockito.junit.MockitoJUnitRunner;
import org.powermock.core.classloader.annotations.PowerMockIgnore;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import java.io.File; import java.io.File;
import static org.junit.Assert.assertTrue; import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail; import static org.junit.Assert.fail;
@PrepareForTest(value = {Script.class, DigestHelper.class}) @RunWith(MockitoJUnitRunner.class)
@RunWith(PowerMockRunner.class)
@PowerMockIgnore({"com.sun.org.apache.xerces.*", "javax.xml.parsers.*", "javax.xml.*", "org.w3c.dom.*", "org.xml.*"})
public class ChecksumUtilTest { public class ChecksumUtilTest {
@Test @Test
public void invalidFileForCheckSumValidationTest() { public void invalidFileForCheckSumValidationTest() {
PowerMockito.mockStatic(Script.class); MockedStatic<Script> scriptMocked = Mockito.mockStatic(Script.class);
Mockito.when(Script.findScript(Mockito.anyString(), Mockito.anyString())).thenReturn(null); Mockito.when(Script.findScript(Mockito.anyString(), Mockito.anyString())).thenReturn(null);
try { try {
ChecksumUtil.calculateCurrentChecksum(Mockito.anyString(), Mockito.anyString()); ChecksumUtil.calculateCurrentChecksum(Mockito.anyString(), Mockito.anyString());
} catch (Exception e) { } catch (Exception e) {
assertTrue(e.getMessage().contains("Unable to find cloudScripts path, cannot update SystemVM")); assertTrue(e.getMessage().contains("Unable to find cloudScripts path, cannot update SystemVM"));
} }
scriptMocked.close();
} }
@Test @Test
public void generateChecksumTest() { public void generateChecksumTest() {
PowerMockito.mockStatic(Script.class); MockedStatic<Script> scriptMocked = Mockito.mockStatic(Script.class);
PowerMockito.mockStatic(DigestHelper.class); MockedStatic<DigestHelper> digestHelperMocked = Mockito.mockStatic(DigestHelper.class);
Mockito.when(Script.findScript(Mockito.anyString(), Mockito.anyString())).thenReturn("/dummyPath"); Mockito.when(Script.findScript(Mockito.anyString(), Mockito.anyString())).thenReturn("/dummyPath");
Mockito.when(DigestHelper.calculateChecksum(Mockito.any(File.class))).thenReturn("dummy-checksum"); Mockito.when(DigestHelper.calculateChecksum(Mockito.any(File.class))).thenReturn("dummy-checksum");
try { try {
@ -58,5 +56,7 @@ public class ChecksumUtilTest {
} catch (Exception e) { } catch (Exception e) {
fail("Failed to generate checksum"); fail("Failed to generate checksum");
} }
scriptMocked.close();
digestHelperMocked.close();
} }
} }

12
utils/src/test/java/org/apache/cloudstack/utils/jsinterpreter/JsInterpreterTest.java
View File

@ -35,16 +35,12 @@ import org.mockito.InjectMocks;
import org.mockito.Mock; import org.mockito.Mock;
import org.mockito.Mockito; import org.mockito.Mockito;
import org.mockito.Spy; import org.mockito.Spy;
import org.mockito.junit.MockitoJUnitRunner;
import org.openjdk.nashorn.api.scripting.NashornScriptEngineFactory; 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; import javax.script.ScriptEngine;
@RunWith(PowerMockRunner.class) @RunWith(MockitoJUnitRunner.class)
@PowerMockIgnore({"javax.xml.*", "org.apache.xerces.*", "org.xml.*", "org.w3c.*"})
@PrepareForTest(JsInterpreter.class)
public class JsInterpreterTest { public class JsInterpreterTest {
private long timeout = 2000; private long timeout = 2000;
@ -95,7 +91,6 @@ public class JsInterpreterTest {
public void executeScriptTestReturnResultOfScriptExecution() { public void executeScriptTestReturnResultOfScriptExecution() {
String script = "5"; String script = "5";
Object expected = new Object(); Object expected = new Object();
Mockito.doReturn(script).when(jsInterpreterSpy).addVariablesToScript(Mockito.anyString());
Mockito.doReturn(expected).when(jsInterpreterSpy).executeScript(Mockito.anyString()); Mockito.doReturn(expected).when(jsInterpreterSpy).executeScript(Mockito.anyString());
Object result = jsInterpreterSpy.executeScript(script); Object result = jsInterpreterSpy.executeScript(script);
@ -173,9 +168,8 @@ public class JsInterpreterTest {
} }
@Test @Test
@PrepareForTest(NashornScriptEngineFactory.class)
public void setScriptEngineDisablingJavaLanguageTest() { public void setScriptEngineDisablingJavaLanguageTest() {
NashornScriptEngineFactory nashornScriptEngineFactoryMock = Mockito.mock(NashornScriptEngineFactory.class); NashornScriptEngineFactory nashornScriptEngineFactoryMock = Mockito.spy(NashornScriptEngineFactory.class);
ScriptEngine scriptEngineMock = Mockito.mock(ScriptEngine.class); ScriptEngine scriptEngineMock = Mockito.mock(ScriptEngine.class);
Mockito.doReturn(scriptEngineMock).when(nashornScriptEngineFactoryMock).getScriptEngine(Mockito.anyString()); Mockito.doReturn(scriptEngineMock).when(nashornScriptEngineFactoryMock).getScriptEngine(Mockito.anyString());

103
utils/src/test/java/org/apache/cloudstack/utils/reflectiontostringbuilderutils/ReflectionToStringBuilderUtilsTest.java
View File

@ -33,16 +33,12 @@ import org.junit.Assert;
import org.junit.Before; import org.junit.Before;
import org.junit.Test; import org.junit.Test;
import org.junit.runner.RunWith; import org.junit.runner.RunWith;
import org.mockito.MockedStatic;
import org.mockito.Mockito; import org.mockito.Mockito;
import org.powermock.api.mockito.PowerMockito; import org.mockito.junit.MockitoJUnitRunner;
import org.powermock.core.classloader.annotations.PowerMockIgnore;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import org.reflections.ReflectionUtils; import org.reflections.ReflectionUtils;
@RunWith(PowerMockRunner.class) @RunWith(MockitoJUnitRunner.class)
@PowerMockIgnore({"org.w3c.*", "javax.xml.*", "org.xml.*"})
@PrepareForTest(ReflectionToStringBuilderUtils.class)
public class ReflectionToStringBuilderUtilsTest extends TestCase { 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, 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 @Test
public void validateGetObjectClassInvalidObjectMustReturnNull(){ public void validateGetObjectClassInvalidObjectMustReturnNull(){
PowerMockito.spy(ReflectionToStringBuilderUtils.class); MockedStatic<ReflectionToStringBuilderUtils> reflectionToStringBuilderUtilsMocked = Mockito.mockStatic(ReflectionToStringBuilderUtils.class, Mockito.CALLS_REAL_METHODS);
PowerMockito.when(ReflectionToStringBuilderUtils.isValidObject(Mockito.any())).thenReturn(false); reflectionToStringBuilderUtilsMocked.when(() -> ReflectionToStringBuilderUtils.isValidObject(Mockito.any())).thenReturn(false);
Class<?> result = ReflectionToStringBuilderUtils.getObjectClass("test"); Class<?> result = ReflectionToStringBuilderUtils.getObjectClass("test");
Assert.assertNull(result); Assert.assertNull(result);
reflectionToStringBuilderUtilsMocked.close();
} }
@Test @Test
public void validateGetObjectClassObjectIsNotACollectionMustReturnObjectClass(){ public void validateGetObjectClassObjectIsNotACollectionMustReturnObjectClass(){
Class<?> expectedResult = classToReflect; Class<?> expectedResult = classToReflect;
PowerMockito.spy(ReflectionToStringBuilderUtils.class); MockedStatic<ReflectionToStringBuilderUtils> reflectionToStringBuilderUtilsMocked = Mockito.mockStatic(ReflectionToStringBuilderUtils.class, Mockito.CALLS_REAL_METHODS);
PowerMockito.when(ReflectionToStringBuilderUtils.isValidObject(Mockito.any())).thenReturn(true); reflectionToStringBuilderUtilsMocked.when(() -> ReflectionToStringBuilderUtils.isValidObject(Mockito.any())).thenReturn(true);
PowerMockito.when(ReflectionToStringBuilderUtils.isCollection(Mockito.any())).thenReturn(false); reflectionToStringBuilderUtilsMocked.when(() -> ReflectionToStringBuilderUtils.isCollection(Mockito.any())).thenReturn(false);
Class<?> result = ReflectionToStringBuilderUtils.getObjectClass("test"); Class<?> result = ReflectionToStringBuilderUtils.getObjectClass("test");
Assert.assertEquals(expectedResult, result); Assert.assertEquals(expectedResult, result);
reflectionToStringBuilderUtilsMocked.close();
} }
@Test @Test
public void validateGetObjectClassObjectIsAnEmptyCollectionMustReturnNull(){ public void validateGetObjectClassObjectIsAnEmptyCollectionMustReturnNull(){
PowerMockito.spy(ReflectionToStringBuilderUtils.class); MockedStatic<ReflectionToStringBuilderUtils> reflectionToStringBuilderUtilsMocked = Mockito.mockStatic(ReflectionToStringBuilderUtils.class, Mockito.CALLS_REAL_METHODS);
PowerMockito.when(ReflectionToStringBuilderUtils.isValidObject(Mockito.any())).thenReturn(true); reflectionToStringBuilderUtilsMocked.when(() -> ReflectionToStringBuilderUtils.isValidObject(Mockito.any())).thenReturn(true);
PowerMockito.when(ReflectionToStringBuilderUtils.isCollection(Mockito.any())).thenReturn(true); reflectionToStringBuilderUtilsMocked.when(() -> ReflectionToStringBuilderUtils.isCollection(Mockito.any())).thenReturn(true);
Class<?> result = ReflectionToStringBuilderUtils.getObjectClass(new ArrayList<String>()); Class<?> result = ReflectionToStringBuilderUtils.getObjectClass(new ArrayList<String>());
Assert.assertNull(result); Assert.assertNull(result);
reflectionToStringBuilderUtilsMocked.close();
} }
@Test @Test
public void validateGetObjectClassObjectIsACollectionWithOnlyNullValuesMustReturnNull(){ public void validateGetObjectClassObjectIsACollectionWithOnlyNullValuesMustReturnNull(){
PowerMockito.spy(ReflectionToStringBuilderUtils.class); MockedStatic<ReflectionToStringBuilderUtils> reflectionToStringBuilderUtilsMocked = Mockito.mockStatic(ReflectionToStringBuilderUtils.class, Mockito.CALLS_REAL_METHODS);
PowerMockito.when(ReflectionToStringBuilderUtils.isValidObject(Mockito.any())).thenReturn(true); reflectionToStringBuilderUtilsMocked.when(() -> ReflectionToStringBuilderUtils.isValidObject(Mockito.any())).thenReturn(true);
PowerMockito.when(ReflectionToStringBuilderUtils.isCollection(Mockito.any())).thenReturn(true); reflectionToStringBuilderUtilsMocked.when(() -> ReflectionToStringBuilderUtils.isCollection(Mockito.any())).thenReturn(true);
Class<?> result = ReflectionToStringBuilderUtils.getObjectClass(new ArrayList<String>(Arrays.asList(null, null))); Class<?> result = ReflectionToStringBuilderUtils.getObjectClass(new ArrayList<String>(Arrays.asList(null, null)));
Assert.assertNull(result); Assert.assertNull(result);
reflectionToStringBuilderUtilsMocked.close();
} }
@Test @Test
public void validateGetObjectClassObjectIsACollectionWithAtLeastOneObjectsMustReturnObjectClass(){ public void validateGetObjectClassObjectIsACollectionWithAtLeastOneObjectsMustReturnObjectClass(){
Class<?> expectedResult = classToReflect; Class<?> expectedResult = classToReflect;
MockedStatic<ReflectionToStringBuilderUtils> reflectionToStringBuilderUtilsMocked = Mockito.mockStatic(ReflectionToStringBuilderUtils.class, Mockito.CALLS_REAL_METHODS);
PowerMockito.spy(ReflectionToStringBuilderUtils.class); reflectionToStringBuilderUtilsMocked.when(() -> ReflectionToStringBuilderUtils.isValidObject(Mockito.any())).thenReturn(true);
PowerMockito.when(ReflectionToStringBuilderUtils.isValidObject(Mockito.any())).thenReturn(true); reflectionToStringBuilderUtilsMocked.when(() -> ReflectionToStringBuilderUtils.isCollection(Mockito.any())).thenReturn(true);
PowerMockito.when(ReflectionToStringBuilderUtils.isCollection(Mockito.any())).thenReturn(true);
Class<?> result = ReflectionToStringBuilderUtils.getObjectClass(new ArrayList<>(Arrays.asList(null, "test1"))); Class<?> result = ReflectionToStringBuilderUtils.getObjectClass(new ArrayList<>(Arrays.asList(null, "test1")));
Assert.assertEquals(expectedResult, result); Assert.assertEquals(expectedResult, result);
reflectionToStringBuilderUtilsMocked.close();
} }
@Test @Test
@ -163,12 +162,13 @@ public class ReflectionToStringBuilderUtilsTest extends TestCase {
@Test @Test
public void validateGetNonSelectedFieldsNullObjectClassMustReturnNull(){ public void validateGetNonSelectedFieldsNullObjectClassMustReturnNull(){
PowerMockito.spy(ReflectionToStringBuilderUtils.class); MockedStatic<ReflectionToStringBuilderUtils> reflectionToStringBuilderUtilsMocked = Mockito.mockStatic(ReflectionToStringBuilderUtils.class, Mockito.CALLS_REAL_METHODS);
PowerMockito.when(ReflectionToStringBuilderUtils.getObjectClass(Mockito.any())).thenReturn(null); reflectionToStringBuilderUtilsMocked.when(() -> ReflectionToStringBuilderUtils.getObjectClass(Mockito.any())).thenReturn(null);
String[] result = ReflectionToStringBuilderUtils.getNonSelectedFields(null, "test1", "test2"); String[] result = ReflectionToStringBuilderUtils.getNonSelectedFields(null, "test1", "test2");
Assert.assertNull(result); Assert.assertNull(result);
reflectionToStringBuilderUtilsMocked.close();
} }
@Test @Test
@ -250,26 +250,28 @@ public class ReflectionToStringBuilderUtilsTest extends TestCase {
@Test @Test
public void validateReflectOnlySelectedFieldsNullNonSelectedFieldsMustReturnNull() throws Exception{ public void validateReflectOnlySelectedFieldsNullNonSelectedFieldsMustReturnNull() throws Exception{
PowerMockito.spy(ReflectionToStringBuilderUtils.class); MockedStatic<ReflectionToStringBuilderUtils> reflectionToStringBuilderUtilsMocked = Mockito.mockStatic(ReflectionToStringBuilderUtils.class, Mockito.CALLS_REAL_METHODS);
PowerMockito.when(ReflectionToStringBuilderUtils.getNonSelectedFields(Mockito.any(), Mockito.any())).thenReturn(null); reflectionToStringBuilderUtilsMocked.when(() -> ReflectionToStringBuilderUtils.getNonSelectedFields(Mockito.any(), Mockito.any())).thenReturn(null);
TO_STRING_STYLES.forEach(style -> { TO_STRING_STYLES.forEach(style -> {
String result = ReflectionToStringBuilderUtils.reflectOnlySelectedFields(null, style, "-"); String result = ReflectionToStringBuilderUtils.reflectOnlySelectedFields(null, style, "-");
Assert.assertNull(result); Assert.assertNull(result);
}); });
reflectionToStringBuilderUtilsMocked.close();
} }
@Test @Test
public void validateReflectOnlySelectedFieldsEmptyNonSelectedFieldsMustReturnEmptyString() throws Exception{ public void validateReflectOnlySelectedFieldsEmptyNonSelectedFieldsMustReturnEmptyString() throws Exception{
String expectedResult = ""; String expectedResult = "";
PowerMockito.spy(ReflectionToStringBuilderUtils.class); MockedStatic<ReflectionToStringBuilderUtils> reflectionToStringBuilderUtilsMocked = Mockito.mockStatic(ReflectionToStringBuilderUtils.class, Mockito.CALLS_REAL_METHODS);
PowerMockito.when(ReflectionToStringBuilderUtils.getNonSelectedFields(Mockito.any(), Mockito.any())).thenReturn(new String[0]); reflectionToStringBuilderUtilsMocked.when(() -> ReflectionToStringBuilderUtils.getNonSelectedFields(Mockito.any(), Mockito.any())).thenReturn(new String[0]);
TO_STRING_STYLES.forEach(style -> { TO_STRING_STYLES.forEach(style -> {
String result = ReflectionToStringBuilderUtils.reflectOnlySelectedFields(null, style, "-"); String result = ReflectionToStringBuilderUtils.reflectOnlySelectedFields(null, style, "-");
Assert.assertEquals(expectedResult, result); Assert.assertEquals(expectedResult, result);
}); });
reflectionToStringBuilderUtilsMocked.close();
} }
@Test @Test
@ -277,80 +279,85 @@ public class ReflectionToStringBuilderUtilsTest extends TestCase {
String fieldToRemove = classToReflectRemovedField; String fieldToRemove = classToReflectRemovedField;
String expectedResult = "test"; String expectedResult = "test";
PowerMockito.spy(ReflectionToStringBuilderUtils.class); MockedStatic<ReflectionToStringBuilderUtils> reflectionToStringBuilderUtilsMocked = Mockito.mockStatic(ReflectionToStringBuilderUtils.class, Mockito.CALLS_REAL_METHODS);
PowerMockito.when(ReflectionToStringBuilderUtils.getNonSelectedFields(Mockito.any(), Mockito.any())).thenReturn(classToReflectFieldsNamesArray); reflectionToStringBuilderUtilsMocked.when(() -> ReflectionToStringBuilderUtils.getNonSelectedFields(Mockito.any(), Mockito.any())).thenReturn(classToReflectFieldsNamesArray);
PowerMockito.when(ReflectionToStringBuilderUtils.reflectCollection(Mockito.any(), Mockito.any(), Mockito.anyString(), Mockito.any())).thenReturn(expectedResult); reflectionToStringBuilderUtilsMocked.when(() -> ReflectionToStringBuilderUtils.reflectCollection(Mockito.any(), Mockito.any(), Mockito.anyString(), Mockito.any())).thenReturn(expectedResult);
TO_STRING_STYLES.forEach(style -> { TO_STRING_STYLES.forEach(style -> {
String result = ReflectionToStringBuilderUtils.reflectOnlySelectedFields(new Object(), style, "-", fieldToRemove); String result = ReflectionToStringBuilderUtils.reflectOnlySelectedFields(new Object(), style, "-", fieldToRemove);
Assert.assertEquals(expectedResult, result); Assert.assertEquals(expectedResult, result);
}); });
reflectionToStringBuilderUtilsMocked.close();
} }
@Test @Test
public void validateReflectOnlySelectedFieldsObjectIsNotACollectionMustReflectObject() throws Exception{ public void validateReflectOnlySelectedFieldsObjectIsNotACollectionMustReflectObject() throws Exception{
String expectedResult = "test"; String expectedResult = "test";
PowerMockito.spy(ReflectionToStringBuilderUtils.class); MockedStatic<ReflectionToStringBuilderUtils> reflectionToStringBuilderUtilsMocked = Mockito.mockStatic(ReflectionToStringBuilderUtils.class, Mockito.CALLS_REAL_METHODS);
PowerMockito.when(ReflectionToStringBuilderUtils.getNonSelectedFields(Mockito.any(), Mockito.any())).thenReturn(classToReflectFieldsNamesArray); reflectionToStringBuilderUtilsMocked.when(() -> ReflectionToStringBuilderUtils.getNonSelectedFields(Mockito.any(), Mockito.any())).thenReturn(classToReflectFieldsNamesArray);
PowerMockito.when(ReflectionToStringBuilderUtils.reflectCollection(Mockito.any(), Mockito.any(), Mockito.anyString(), Mockito.any())).thenReturn(null); reflectionToStringBuilderUtilsMocked.when(() -> ReflectionToStringBuilderUtils.reflectCollection(Mockito.any(), Mockito.any(), Mockito.anyString(), Mockito.any())).thenReturn(null);
for (ToStringStyle style : TO_STRING_STYLES){ 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); String result = ReflectionToStringBuilderUtils.reflectOnlySelectedFields(expectedResult, style, "-", classToReflectFieldsNamesArray);
Assert.assertEquals(expectedResult, result); Assert.assertEquals(expectedResult, result);
} }
reflectionToStringBuilderUtilsMocked.close();
} }
@Test @Test
public void validateReflectOnlySelectedFieldsDefaultStyleReflectionNullMustReturnNull(){ public void validateReflectOnlySelectedFieldsDefaultStyleReflectionNullMustReturnNull(){
String expectedResult = null; String expectedResult = null;
PowerMockito.spy(ReflectionToStringBuilderUtils.class); MockedStatic<ReflectionToStringBuilderUtils> reflectionToStringBuilderUtilsMocked = Mockito.mockStatic(ReflectionToStringBuilderUtils.class, Mockito.CALLS_REAL_METHODS);
PowerMockito.when(ReflectionToStringBuilderUtils.reflectOnlySelectedFields(Mockito.any(), Mockito.any(), Mockito.anyString(), Mockito.any())).thenReturn(null); reflectionToStringBuilderUtilsMocked.when(() -> ReflectionToStringBuilderUtils.reflectOnlySelectedFields(Mockito.any(), Mockito.any(), Mockito.anyString(), Mockito.any())).thenReturn(null);
String result = ReflectionToStringBuilderUtils.reflectOnlySelectedFields(new Object(), (String[]) null); String result = ReflectionToStringBuilderUtils.reflectOnlySelectedFields(new Object(), (String[]) null);
Assert.assertEquals(expectedResult, result); Assert.assertEquals(expectedResult, result);
reflectionToStringBuilderUtilsMocked.close();
} }
@Test @Test
public void validateReflectOnlySelectedFieldsDefaultStyleReflectCollectionMustReturnValue(){ public void validateReflectOnlySelectedFieldsDefaultStyleReflectCollectionMustReturnValue(){
String expectedResult = "[test]"; String expectedResult = "[test]";
PowerMockito.spy(ReflectionToStringBuilderUtils.class); MockedStatic<ReflectionToStringBuilderUtils> reflectionToStringBuilderUtilsMocked = Mockito.mockStatic(ReflectionToStringBuilderUtils.class, Mockito.CALLS_REAL_METHODS);
PowerMockito.when(ReflectionToStringBuilderUtils.reflectOnlySelectedFields(Mockito.any(), Mockito.any(), Mockito.anyString(), Mockito.any())).thenReturn("test"); reflectionToStringBuilderUtilsMocked.when(() -> ReflectionToStringBuilderUtils.reflectOnlySelectedFields(Mockito.any(), Mockito.any(), Mockito.anyString(), Mockito.any())).thenReturn("test");
PowerMockito.when(ReflectionToStringBuilderUtils.isCollection(Mockito.any())).thenReturn(true); reflectionToStringBuilderUtilsMocked.when(() -> ReflectionToStringBuilderUtils.isCollection(Mockito.any())).thenReturn(true);
String result = ReflectionToStringBuilderUtils.reflectOnlySelectedFields(new Object()); String result = ReflectionToStringBuilderUtils.reflectOnlySelectedFields(new Object());
Assert.assertEquals(expectedResult, result); Assert.assertEquals(expectedResult, result);
reflectionToStringBuilderUtilsMocked.close();
} }
@Test @Test
public void validateReflectOnlySelectedFieldsDefaultStyleReflectMustReturnValue(){ public void validateReflectOnlySelectedFieldsDefaultStyleReflectMustReturnValue(){
String expectedResult = "test"; String expectedResult = "test";
PowerMockito.spy(ReflectionToStringBuilderUtils.class); MockedStatic<ReflectionToStringBuilderUtils> reflectionToStringBuilderUtilsMocked = Mockito.mockStatic(ReflectionToStringBuilderUtils.class, Mockito.CALLS_REAL_METHODS);
PowerMockito.when(ReflectionToStringBuilderUtils.reflectOnlySelectedFields(Mockito.any(), Mockito.any(), Mockito.anyString(), Mockito.any())).thenReturn(expectedResult); reflectionToStringBuilderUtilsMocked.when(() -> ReflectionToStringBuilderUtils.reflectOnlySelectedFields(Mockito.any(), Mockito.any(), Mockito.anyString(), Mockito.any())).thenReturn(expectedResult);
PowerMockito.when(ReflectionToStringBuilderUtils.isCollection(Mockito.any())).thenReturn(false); reflectionToStringBuilderUtilsMocked.when(() -> ReflectionToStringBuilderUtils.isCollection(Mockito.any())).thenReturn(false);
String result = ReflectionToStringBuilderUtils.reflectOnlySelectedFields(new Object()); String result = ReflectionToStringBuilderUtils.reflectOnlySelectedFields(new Object());
Assert.assertEquals(expectedResult, result); Assert.assertEquals(expectedResult, result);
reflectionToStringBuilderUtilsMocked.close();
} }
@Test @Test
public void reflectCollectionTestCallBaseReflectCollectionMethodWithDefaultParameters() { public void reflectCollectionTestCallBaseReflectCollectionMethodWithDefaultParameters() {
String expected = "test"; String expected = "test";
PowerMockito.spy(ReflectionToStringBuilderUtils.class); MockedStatic<ReflectionToStringBuilderUtils> reflectionToStringBuilderUtilsMocked = Mockito.mockStatic(ReflectionToStringBuilderUtils.class, Mockito.CALLS_REAL_METHODS);
PowerMockito.when(ReflectionToStringBuilderUtils.reflectCollection(Mockito.any(), Mockito.any(), Mockito.anyString(), Mockito.any())).thenReturn(expected); reflectionToStringBuilderUtilsMocked.when(() -> ReflectionToStringBuilderUtils.reflectCollection(Mockito.any(), Mockito.any(), Mockito.anyString(), Mockito.any())).thenReturn(expected);
Object object = Mockito.mock(Object.class); Object object = Mockito.mock(Object.class);
String result = ReflectionToStringBuilderUtils.reflectCollection(object); String result = ReflectionToStringBuilderUtils.reflectCollection(object);
Assert.assertEquals(expected, result); Assert.assertEquals(expected, result);
PowerMockito.verifyStatic(ReflectionToStringBuilderUtils.class);
String[] excludeFields = null; 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();
} }
} }

1
utils/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker Normal file
View File

@ -0,0 +1 @@
mock-maker-inline