用Mockito模拟静态方法

我已经写了一家工厂来生产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(...);

    }

更多信息：

• 为什么Mockito不模拟静态方法？

避免无法避免的静态方法的典型策略是创建包装对象并改用包装对象。

包装对象成为真正的静态类的外观，您无需对其进行测试。

包装对象可能像

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批注，那么它会更加容易。只需使您的包装器bean @ApplicationScoped，将其作为协作者注入即可（您甚至不需要杂乱的构造函数进行测试），然后继续进行模拟。

我有一个类似的问题。直到我进行更改后@PrepareForTest(TheClassThatContainsStaticMethod.class)，接受的答案才对我不起作用： 根据PowerMock的嘲笑Static文档。

而且我不必使用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());
    }
}

如前所述，您不能使用嘲讽来模拟静态方法。

如果不能更改测试框架，则可以执行以下操作：

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

您可以进行一些重构：

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

要模拟静态方法，您应该使用Powermock来查看：https : //github.com/powermock/powermock/wiki/MockStatic。Mockito 不提供此功能。

您可以阅读有关Mockito的不错的文章：http: //refcardz.dzone.com/refcardz/mockito

Mockito无法捕获静态方法，但是自Mockito 2.14.0起，您可以通过创建静态方法的调用实例来模拟它。

示例（从他们的测试中提取）：

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代码。（来源）

免责声明：Mockito团队认为通向静态的道路铺平了道路。但是，Mockito的工作不是保护代码免受静态方法的侵害。如果您不喜欢团队进行静态模拟，请停止在组织中使用Powermockito。Mockito需要发展为一个工具包，并对如何编写Java测试抱有坚定的看法（例如，不要模拟静态！！！）。但是，Mockito不是教条。我们不想阻止不建议使用的情况，例如静态模拟。这不是我们的工作。

我还写了Mockito和AspectJ的组合：https : //github.com/iirekm/varia/tree/develop/ajmock

您的示例变为：

when(() -> DriverManager.getConnection(...)).thenReturn(...);

由于该方法是静态的，因此它已经拥有使用它所需的一切，因此它无法实现模拟的目的。模拟静态方法被认为是不好的做法。

如果尝试这样做，则意味着您要执行测试的方式存在问题。

当然，您可以使用PowerMockito或任何其他能够执行此操作的框架，但是请尝试重新考虑您的方法。

例如：尝试模拟/提供静态方法消耗的对象。

使用JMockit框架。它为我工作。您不必编写模拟DBConenction.getConnection（）方法的语句。只需下面的代码就足够了。

下面的@Mock是mockit.Mock包

Connection jdbcConnection = Mockito.mock(Connection.class);

MockUp<DBConnection> mockUp = new MockUp<DBConnection>() {

            DBConnection singleton = new DBConnection();

            @Mock
            public DBConnection getInstance() { 
                return singleton;
            }

            @Mock
            public Connection getConnection() {
                return jdbcConnection;
            }
         };