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.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>

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.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();
}

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.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;

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.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

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 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();
}
}

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.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();

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.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();
}
}

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.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());

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.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();
}
}

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

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