Java单元测试：利用工厂模式解决私有方法内部对象Mock难题

// 假设 ObjectNeeded2Mock 是一个需要被Mock的复杂依赖
public class ObjectNeeded2Mock {
    private String config;

    public ObjectNeeded2Mock(String config) {
        this.config = config;
    }

    public String doSomething() {
        return "Result from " + config;
    }
}

public class ParentClass {

    public ParentClass() {
        // 构造器可能还有其他初始化
    }

    public String publicMethod(String... arguments) {
        // ... publicMethod 的一些逻辑 ...
        ObjectNeeded2Mock obj1 = privateMethod(arguments[0]); // 调用私有方法
        return "Processed: " + obj1.doSomething();
    }

    private ObjectNeeded2Mock privateMethod(String argument) {
        // 问题所在：直接在这里创建对象，难以在外部控制
        ObjectNeeded2Mock obj = new ObjectNeeded2Mock("internal_config_" + argument);
        // ... privateMethod 的进一步初始化或操作 ...
        return obj;
    }
}

public interface ObjectFactory {
    ObjectNeeded2Mock createObject(String config);
}

public class DefaultObjectFactory implements ObjectFactory {
    @Override
    public ObjectNeeded2Mock createObject(String config) {
        return new ObjectNeeded2Mock(config);
    }
}

public class ParentClass {
    private final ObjectFactory objectFactory; // 注入工厂接口

    // 通过构造器注入工厂依赖
    public ParentClass(ObjectFactory objectFactory) {
        this.objectFactory = objectFactory;
    }

    public String publicMethod(String... arguments) {
        // ... publicMethod 的一些逻辑 ...
        ObjectNeeded2Mock obj1 = privateMethod(arguments[0]);
        return "Processed: " + obj1.doSomething();
    }

    private ObjectNeeded2Mock privateMethod(String argument) {
        // 通过工厂创建对象，而不是直接 new
        return objectFactory.createObject("internal_config_" + argument);
    }
}

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.when;
import static org.mockito.Mockito.verify; // 用于验证方法调用

public class ParentClassTest {

    @Mock
    private ObjectFactory mockObjectFactory; // Mock 工厂接口

    @Mock
    private ObjectNeeded2Mock mockObjectNeeded2Mock; // Mock 需要被工厂创建的对象

    @InjectMocks
    private ParentClass parentClass; // 注入被测试类，Mockito 会尝试将 mockObjectFactory 注入到 parentClass 的构造器中

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this); // 初始化 Mock 对象
    }

    @Test
    void testPublicMethodWhenPrivateMethodCreatesObject() {
        // 1. 定义当 mockObjectFactory 的 createObject 方法被调用时，返回我们 Mock 的 ObjectNeeded2Mock
        // 这里的 anyString() 表示无论传入什么字符串参数，都返回 mockObjectNeeded2Mock
        when(mockObjectFactory.createObject(anyString())).thenReturn(mockObjectNeeded2Mock);

        // 2. 定义我们 Mock 的 ObjectNeeded2Mock 的行为
        when(mockObjectNeeded2Mock.doSomething()).thenReturn("Mocked Result from ObjectNeeded2Mock");

        // 3. 调用被测试的公共方法
        String result = parentClass.publicMethod("testArgument");

        // 4. 验证结果是否符合预期
        assertEquals("Processed: Mocked Result from ObjectNeeded2Mock", result);

        // 5. （可选）验证工厂的 createObject 方法是否被调用，以及传入的参数是否正确
        // 这里假设 privateMethod 会传入 "internal_config_testArgument"
        verify(mockObjectFactory).createObject("internal_config_testArgument");
        verify(mockObjectNeeded2Mock).doSomething(); // 验证 mockObjectNeeded2Mock 的 doSomething 方法是否被调用
    }
}