我已经编写了一个工厂来创建 java.sql.Connection 对象：
public class MySQLDatabaseConnectionFactory implements DatabaseConnectionFactory {
@Override public Connection getConnection() {
try {
return DriverManager.getConnection(...);
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
}
我想验证传递给DriverManager.getConnection的参数，但我不知道如何模拟静态方法。我正在使用JUnit 4和Mockito进行测试。有没有一种很好的方法来模拟/验证这个特定的用例？
在Mockito的基础上使用PowerMockito。
示例代码：
@RunWith(PowerMockRunner.class)
@PrepareForTest(DriverManager.class)
public class Mocker {
@Test
public void shouldVerifyParameters() throws Exception {
//given
PowerMockito.mockStatic(DriverManager.class);
BDDMockito.given(DriverManager.getConnection(...)).willReturn(...);
//when
sut.execute(); // System Under Test (sut)
//then
PowerMockito.verifyStatic();
DriverManager.getConnection(...);
}
更多信息：
@RunWith(PowerMockRunner.class)并在其下方添加@PowerMockRunnerDelegate(JUnit4.class)。 - EM-Creationshttps://github.com/mockito/mockito/releases/tag/v3.4.0
https://github.com/mockito/mockito/issues/1013
https://javadoc.io/doc/org.mockito/mockito-core/latest/org/mockito/Mockito.html#static_mocks
assertEquals("foo", Foo.method());
try (MockedStatic mocked = mockStatic(Foo.class)) {
mocked.when(Foo::method).thenReturn("bar");
assertEquals("bar", Foo.method());
mocked.verify(Foo::method);
}
assertEquals("foo", Foo.method());
@Test
public void testStaticMockWithVerification() throws SQLException {
try (MockedStatic<DriverManager> dummy = Mockito.mockStatic(DriverManager.class)) {
DatabaseConnectionFactory factory = new MySQLDatabaseConnectionFactory();
dummy.when(() -> DriverManager.getConnection("arg1", "arg2", "arg3"))
.thenReturn(new Connection() {/*...*/});
factory.getConnection();
dummy.verify(() -> DriverManager.getConnection(eq("arg1"), eq("arg2"), eq("arg3")));
}
}
mockito-inline）<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-junit-jupiter</artifactId>
<version>${mockito.version}</version>
<scope>test</scope>
</dependency>
规避无法避免使用的静态方法的典型策略是创建包装对象并使用包装对象而非实际静态类。
包装对象成为实际静态类的门面，您不会对其进行测试。
包装对象可能是这样的东西
public class Slf4jMdcWrapper {
public static final Slf4jMdcWrapper SINGLETON = new Slf4jMdcWrapper();
public String myApisToTheSaticMethodsInSlf4jMdcStaticUtilityClass() {
return MDC.getWhateverIWant();
}
}
最后，您要测试的类可以通过例如具有默认构造函数的方式来使用此单例对象：
public class SomeClassUnderTest {
final Slf4jMdcWrapper myMockableObject;
/** constructor used by CDI or whatever real life use case */
public myClassUnderTestContructor() {
this.myMockableObject = Slf4jMdcWrapper.SINGLETON;
}
/** constructor used in tests*/
myClassUnderTestContructor(Slf4jMdcWrapper myMock) {
this.myMockableObject = myMock;
}
}
这里有一个类可以轻松测试，因为您没有直接使用具有静态方法的类。
如果您正在使用CDI并且可以利用@Inject注释，则会更加容易。只需将您的Wrapper bean设置为@ApplicationScoped，将其注入为协作者（甚至不需要混乱的构造函数进行测试），然后进行模拟测试。
我遇到过类似的问题。接受的答案对我没有用，直到我做出了更改：@PrepareForTest(TheClassThatContainsStaticMethod.class)，根据PowerMock的mockStatic文档。
而且我不必使用BDDMockito。
我的类：
public class SmokeRouteBuilder {
public static String smokeMessageId() {
try {
return InetAddress.getLocalHost().getHostAddress();
} catch (UnknownHostException e) {
log.error("Exception occurred while fetching localhost address", e);
return UUID.randomUUID().toString();
}
}
}
我的测试类：
@RunWith(PowerMockRunner.class)
@PrepareForTest(SmokeRouteBuilder.class)
public class SmokeRouteBuilderTest {
@Test
public void testSmokeMessageId_exception() throws UnknownHostException {
UUID id = UUID.randomUUID();
mockStatic(InetAddress.class);
mockStatic(UUID.class);
when(InetAddress.getLocalHost()).thenThrow(UnknownHostException.class);
when(UUID.randomUUID()).thenReturn(id);
assertEquals(id.toString(), SmokeRouteBuilder.smokeMessageId());
}
}
对于使用JUnit 5的用户来说，Powermock不是一个选项。如果您只想使用Mockito成功地模拟静态方法，则需要以下依赖项。
testCompile group: 'org.mockito', name: 'mockito-core', version: '3.6.0'
testCompile group: 'org.mockito', name: 'mockito-junit-jupiter', version: '3.6.0'
testCompile group: 'org.mockito', name: 'mockito-inline', version: '3.6.0'
mockito-junit-jupiter 支持 JUnit 5。
而对于模拟静态方法的支持由 mockito-inline 依赖提供。
示例：
@Test
void returnUtilTest() {
assertEquals("foo", UtilClass.staticMethod("foo"));
try (MockedStatic<UtilClass> classMock = mockStatic(UtilClass.class)) {
classMock.when(() -> UtilClass.staticMethod("foo")).thenReturn("bar");
assertEquals("bar", UtilClass.staticMethod("foo"));
}
assertEquals("foo", UtilClass.staticMethod("foo"));
}
try-with-resource 块用于使静态模拟仅在该范围内保持临时。
如果不使用 try 块，请确保在断言完成后关闭模拟。
MockedStatic<UtilClass> classMock = mockStatic(UtilClass.class)
classMock.when(() -> UtilClass.staticMethod("foo")).thenReturn("bar");
assertEquals("bar", UtilClass.staticMethod("foo"));
classMock.close();
模拟void方法：
当在类上调用mockStatic时，该类中所有的静态void方法都会自动模拟为doNothing()。
如前所述，Mockito 无法模拟静态方法。
如果更改测试框架不是一个选项，则可以执行以下操作：
为 DriverManager 创建一个接口，对该接口进行模拟，通过某种依赖注入将其注入，并在该模拟上进行验证。
观察：当您在静态实体内调用静态方法时，需要在@PrepareForTest中更改类名。
例如：
securityAlgo = MessageDigest.getInstance(SECURITY_ALGORITHM);
如果您需要模拟MessageDigest类，请使用上述代码
@PrepareForTest(MessageDigest.class)
public class CustomObjectRule {
object = DatatypeConverter.printHexBinary(MessageDigest.getInstance(SECURITY_ALGORITHM)
.digest(message.getBytes(ENCODING)));
}
@PrepareForTest(CustomObjectRule.class)
PowerMockito.mockStatic(MessageDigest.class);
PowerMockito.when(MessageDigest.getInstance(Mockito.anyString()))
.thenThrow(new RuntimeException());
when(() -> DriverManager.getConnection(...)).thenReturn(...);
通过一些重构，您可以实现这个目标：
public class MySQLDatabaseConnectionFactory implements DatabaseConnectionFactory {
@Override public Connection getConnection() {
try {
return _getConnection(...some params...);
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
//method to forward parameters, enabling mocking, extension, etc
Connection _getConnection(...some params...) throws SQLException {
return DriverManager.getConnection(...some params...);
}
}
接下来，您可以扩展您的类MySQLDatabaseConnectionFactory以返回模拟连接，对参数进行断言等操作。
如果扩展的类位于同一包中（我鼓励您这样做），则可以将其放置在测试用例中。
public class MockedConnectionFactory extends MySQLDatabaseConnectionFactory {
Connection _getConnection(...some params...) throws SQLException {
if (some param != something) throw new InvalidParameterException();
//consider mocking some methods with when(yourMock.something()).thenReturn(value)
return Mockito.mock(Connection.class);
}
}
public class StaticMockingExperimentTest extends TestBase {
Foo mock = Mockito.mock(Foo.class);
MockHandler handler = Mockito.mockingDetails(mock).getMockHandler();
Method staticMethod;
InvocationFactory.RealMethodBehavior realMethod = new InvocationFactory.RealMethodBehavior() {
@Override
public Object call() throws Throwable {
return null;
}
};
@Before
public void before() throws Throwable {
staticMethod = Foo.class.getDeclaredMethod("staticMethod", String.class);
}
@Test
public void verify_static_method() throws Throwable {
//register staticMethod call on mock
Invocation invocation = Mockito.framework().getInvocationFactory().createInvocation(mock, withSettings().build(Foo.class), staticMethod, realMethod,
"some arg");
handler.handle(invocation);
//verify staticMethod on mock
//Mockito cannot capture static methods so we will simulate this scenario in 3 steps:
//1. Call standard 'verify' method. Internally, it will add verificationMode to the thread local state.
// Effectively, we indicate to Mockito that right now we are about to verify a method call on this mock.
verify(mock);
//2. Create the invocation instance using the new public API
// Mockito cannot capture static methods but we can create an invocation instance of that static invocation
Invocation verification = Mockito.framework().getInvocationFactory().createInvocation(mock, withSettings().build(Foo.class), staticMethod, realMethod,
"some arg");
//3. Make Mockito handle the static method invocation
// Mockito will find verification mode in thread local state and will try verify the invocation
handler.handle(verification);
//verify zero times, method with different argument
verify(mock, times(0));
Invocation differentArg = Mockito.framework().getInvocationFactory().createInvocation(mock, withSettings().build(Foo.class), staticMethod, realMethod,
"different arg");
handler.handle(differentArg);
}
@Test
public void stubbing_static_method() throws Throwable {
//register staticMethod call on mock
Invocation invocation = Mockito.framework().getInvocationFactory().createInvocation(mock, withSettings().build(Foo.class), staticMethod, realMethod,
"foo");
handler.handle(invocation);
//register stubbing
when(null).thenReturn("hey");
//validate stubbed return value
assertEquals("hey", handler.handle(invocation));
assertEquals("hey", handler.handle(invocation));
//default null value is returned if invoked with different argument
Invocation differentArg = Mockito.framework().getInvocationFactory().createInvocation(mock, withSettings().build(Foo.class), staticMethod, realMethod,
"different arg");
assertEquals(null, handler.handle(differentArg));
}
static class Foo {
private final String arg;
public Foo(String arg) {
this.arg = arg;
}
public static String staticMethod(String arg) {
return "";
}
@Override
public String toString() {
return "foo:" + arg;
}
}
}
他们的目标不是直接支持静态模拟，而是改进其公共API，以便其他库（如Powermockito）不必依赖内部API或直接复制一些Mockito代码。(来源：source)
免责声明：Mockito团队认为通向地狱的道路铺满了静态方法。然而，Mockito的工作并不是保护您的代码免受静态方法的影响。如果您不喜欢团队进行静态模拟，请停止在您的组织中使用Powermockito。Mockito需要作为一个具有偏见的工具包发展，对Java测试的编写方式有自己的看法（例如，不要模拟静态方法！）。然而，Mockito并不教条主义。我们不想阻止像静态模拟这样的不推荐使用情况。这只是不属于我们的工作范畴。
final类/方法或新创建对象的支持）是实现模拟所采用的方法自然而然产生的（但并非预期的）结果；该方法会动态创建新类以实现/扩展要进行模拟的类型。其他模拟库使用避免这些限制的其他方法。.NET世界中也发生了类似情况。 - Rogério