如何为单元测试流程中调用的静态方法返回不同的值？

在单元测试中，静态方法通常被视为难以模拟（mock）的对象，因为它们属于类本身而不是类的实例，这使得它们在测试中的行为难以控制和预测。然而，有多种方法可以为单元测试流程中调用的静态方法返回不同的值。

基础概念

静态方法：静态方法是属于类的方法，不需要创建类的实例即可调用。它们通常用于工具类或辅助函数。

单元测试：单元测试是对软件中的最小可测试单元进行检查和验证的过程。通常，这些单元是单个方法或函数。

类型与应用场景

Mock框架：使用专门的mock框架（如Mockito、PowerMockito、JMock等）来模拟静态方法。
依赖注入：通过依赖注入的方式，将静态方法的调用委托给一个接口，然后在测试中替换这个接口的实现。
反射：使用Java反射机制来修改静态方法的行为。

示例代码

假设我们有一个包含静态方法的类StringUtils：

public class StringUtils {
    public static boolean isBlank(String str) {
        return str == null || str.trim().isEmpty();
    }
}

我们希望在单元测试中为isBlank方法返回不同的值。

使用Mockito和PowerMockito

首先，添加必要的依赖：

<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-core</artifactId>
    <version>3.11.2</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.powermock</groupId>
    <artifactId>powermock-module-junit4</artifactId>
    <version>2.0.9</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.powermock</groupId>
    <artifactId>powermock-api-mockito2</artifactId>
    <version>2.0.9</version>
    <scope>test</scope>
</dependency>

然后，编写测试用例：

import org.junit.Test;
import org.junit.runner.RunWith;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;

@RunWith(PowerMockRunner.class)
@PrepareForTest(StringUtils.class)
public class StringUtilsTest {

    @Test
    public void testIsBlank_ReturnsTrue() {
        PowerMockito.mockStatic(StringUtils.class);
        PowerMockito.when(StringUtils.isBlank("")).thenReturn(true);

        boolean result = StringUtils.isBlank("");
        assert result == true;
    }

    @Test
    public void testIsBlank_ReturnsFalse() {
        PowerMockito.mockStatic(StringUtils.class);
        PowerMockito.when(StringUtils.isBlank("Hello")).thenReturn(false);

        boolean result = StringUtils.isBlank("Hello");
        assert result == false;
    }
}

使用依赖注入

定义一个接口来封装静态方法的调用：

public interface StringChecker {
    boolean isBlank(String str);
}

实现这个接口：

public class DefaultStringChecker implements StringChecker {
    @Override
    public boolean isBlank(String str) {
        return StringUtils.isBlank(str);
    }
}

在需要使用的地方注入这个接口：

public class SomeService {
    private final StringChecker stringChecker;

    public SomeService(StringChecker stringChecker) {
        this.stringChecker = stringChecker;
    }

    public boolean checkString(String str) {
        return stringChecker.isBlank(str);
    }
}

在测试中替换实现：

import org.junit.Test;
import static org.mockito.Mockito.*;

public class SomeServiceTest {

    @Test
    public void testCheckString_ReturnsTrue() {
        StringChecker mockChecker = mock(StringChecker.class);
        when(mockChecker.isBlank("")).thenReturn(true);

        SomeService service = new SomeService(mockChecker);
        boolean result = service.checkString("");
        assert result == true;
    }

    @Test
 public void testCheckString_ReturnsFalse() {
        StringChecker mockChecker = mock(StringChecker.class);
        when(mockChecker.isBlank("Hello")).thenReturn(false);

        SomeService service = new SomeService(mockChecker);
        boolean result = service.checkString("Hello");
        assert result == false;
    }
}