如何使用Java JUnit和Mockito（Spring Boot）验证传递给静态函数的参数

Question

我是所有提到的技术的新手，所以这可能是一个愚蠢的问题。

我们有一个spring boot应用程序，我们需要通过JDBC写入PostgreSQL数据库。 因此，我们需要静态DriverManager.getConnection()方法来打开连接。

现在在我的单元测试中，我不想直接调用这个类。 相反，我想检查一下，使用正确的String调用DriverManager.getConnection() ，因为这是我预期的可观察外部行为。

我使用newConnection(ConnectionType.POSTGRESQL)方法将此行为封装到ConnectionFactory ，因为我们在此Application中使用了多个数据库。

现在我找不到通过Mockito验证这个外部依赖项是否使用正确的String调用的方法，就像你可以使用一个实例一样：

DriverManager dm = mock(DriverManager);

connectionFactory.newConnection(ConnectionType.POSTGRESQL);

verify(dm).getConnection("theConnectionStringToBeExpected");

那么如何使用静态依赖呢？

我试过了Captor -way，但这似乎只适用于直接使用

mockStatic(DriverManager.class);

final ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);

// What I have to do to verify
DriverManager.getConnection("theActualConnectionString");

// What I would like to do to verify
// connectionFactory.newConnection(ConnectionType.POSTGRESQL);

verifyStatic();
StaticService.getConnection(captor.capture());

assertEquals("theExpectedConnectionString", captor.getValue());

编辑：

这是我目前用于另一台服务器的讨厌的小解决方法......

public void driverManagerIsCorrectlyCalledForAds() throws Exception {
    mockStatic(DriverManager.class);

    doNothing().when(databaseDriverLoader).load();

    final Connection expectedConnection = mock(Connection.class);
    when(DriverManager.getConnection("jdbc:extendedsystems:advantage://server:1337/database_name;user=user;password=password;chartype=ansi"))
            .thenReturn(expectedConnection);

    Connection actualConnection = connectionFactory.newConnection(ConnectionType.ADS);

    assertEquals(expectedConnection, actualConnection);
}

编辑2：

识别TestClass：

import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import org.powermock.modules.junit4.PowerMockRunnerDelegate;
import org.springframework.test.context.junit4.SpringRunner;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

import static org.junit.Assert.assertEquals;
import static org.mockito.Matchers.anyString;
import static org.powermock.api.mockito.PowerMockito.*;

@RunWith(PowerMockRunner.class)
@PowerMockRunnerDelegate(SpringRunner.class)
@PrepareForTest({ConnectionFactory.class, DriverManager.class, DatabaseDriverInformation.class})
public class ConnectionFactoryTest {

    @InjectMocks
    ConnectionFactory connectionFactory;

    @Mock
    DatabaseDriverInformation databaseDriverInformation;

    @Mock
    DatabaseProperties databaseProperties;

    @Mock
    DatabaseProperties.Pg pg;

    @Mock
    DatabaseDriverLoader databaseDriverLoader;

    @Before
    public void setUp() {    
        doReturn(pg).when(databaseProperties).getPg();
        doReturn("server").when(ads).getServer();
        doReturn(1338).when(ads).getPort();
        doReturn("database_name").when(ads).getDatabasename();
        doReturn("user").when(ads).getUser();
        doReturn("password").when(ads).getPassword();
    }

    @Test
    public void driverManagerIsCorrectlyCalledForPg() throws Exception {
        mockStatic(DriverManager.class);
        doNothing().when(databaseDriverLoader).load();

        Connection expectedConnection = mock(Connection.class);
        when(DriverManager.getConnection("jdbc:postgresql://server:1338/database_name;user=user;password=password"))
                .thenReturn(expectedConnection);

        Connection actualConnection = connectionFactory.newConnection(ConnectionType.POSTGRESQL);

        assertEquals(expectedConnection, actualConnection);
    }
}

被测班：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.sql.*;

@Service()
public class ConnectionFactory {

    @Autowired
    private DatabaseDriverLoader databaseDriverLoader;

    @Autowired
    DatabaseProperties databaseProperties;


    public Connection newConnection(ConnectionType connectionType) {
        databaseDriverLoader.load();
        final String connectionString = connectionStringFor(connectionType);
        try {
            return DriverManager.getConnection(connectionString);
        } catch (SQLException sqlException) {
            throw new RuntimeException("Couldn't connect to Server");
        }

    }

    private String connectionStringFor(ConnectionType connectionType) {
        switch (connectionType) {
            case ADS:
                return this.adsConnectionString();
            case POSTGRESQL:
                return this.pgConnectionString();

            default:
                throw new RuntimeException("Invalid connection Type requested!");
        }
    }


    private String adsConnectionString() {
        return new StringBuilder()
                .append("jdbc:extendedsystems:advantage://")
                .append(databaseProperties.getAds().getServer())
                .append(":")
                .append(databaseProperties.getAds().getPort())
                .append("/")
                .append(databaseProperties.getAds().getDatabasename())
                .append(";user=")
                .append(databaseProperties.getAds().getUser())
                .append(";password=")
                .append(databaseProperties.getAds().getPassword())
                .append(";chartype=ansi")
                .toString();
    }

    private String pgConnectionString() {
        return new StringBuilder()
                .append("jdbc:postgresql://")
                .append(databaseProperties.getPg().getServer())
                .append(":")
                .append(databaseProperties.getPg().getPort())
                .append("/")
                .append(databaseProperties.getPg().getDatabasename())
                .append("?user=")
                .append(databaseProperties.getPg().getUser())
                .append("&password=")
                .append(databaseProperties.getPg().getPassword())
                .toString();
    }
}

我删除了包名，一些特定的导入和一些不必要的测试。

Answer 1

经过一番搜索，我发现了这个： 如何验证静态void方法已经被power mock调用

在本质上：

第一 ：

mockStatic(ClassWithStaticFunctionToVerify.class)

第二个 ：

Execute the Code that will call the function you want to verify later

第三名 ：

verifyStatic();
ClassWithStaticFunctionToVerify.functionYouWantToVerify("ParameterValueYouExpect");

有了它的帮助，我得到了以下解决方案，工作正常：

@Test
public void driverManagerIsCorrectlyCalledForPg() throws Exception {
    // Arrange
    mockStatic(DatabaseProperties.Pg.class);
    doReturn(pg).when(databaseProperties).getPg();
    doReturn("server").when(pg).getServer();
    doReturn(1338).when(pg).getPort();
    doReturn("database_name").when(pg).getDatabasename();
    doReturn("user").when(pg).getUser();
    doReturn("password").when(pg).getPassword();

    mockStatic(DriverManager.class);
    doNothing().when(databaseDriverLoader).loadAdsDriverClass();
    doNothing().when(databaseDriverLoader).loadPgDriverClass();

    when(DriverManager.getConnection(anyString())).thenReturn(expectedConnection);

    // Act
    connectionFactory.newConnection(ConnectionType.POSTGRESQL);

    // Assert
    verifyStatic();
    DriverManager.getConnection("jdbc:postgresql://server:1338/database_name?user=user&password=password");
}