Java单元测试：私有方法内对象创建的Mock挑战与可注入工厂模式解决方案

class ParentClass {

    public String method1(String argument) {
        // ... 其他逻辑 ...
        Obj obj1 = privateMethod(argument); // 调用私有方法
        return obj1.process(); // 假设Obj有一个process方法
    }

    private Obj privateMethod(String argument) {
        // 直接在这里创建了具体对象
        ObjectNeeded2Mock obj = new ObjectNeeded2Mock(argument);
        // ... 使用obj进行一些操作 ...
        return obj;
    }
}

class ObjectNeeded2Mock {
    private String data;
    public ObjectNeeded2Mock(String data) {
        this.data = data;
    }
    public String process() {
        return "Processed: " + data;
    }
}

// ObjectNeeded2MockFactory.java
interface ObjectNeeded2MockFactory {
    ObjectNeeded2Mock create(String argument);
}

// DefaultObjectNeeded2MockFactory.java
class DefaultObjectNeeded2MockFactory implements ObjectNeeded2MockFactory {
    @Override
    public ObjectNeeded2Mock create(String argument) {
        return new ObjectNeeded2Mock(argument); // 实际的实例化
    }
}

// ParentClass.java
class ParentClass {
    private final ObjectNeeded2MockFactory factory; // 注入工厂

    // 通过构造函数注入工厂，推荐方式
    public ParentClass(ObjectNeeded2MockFactory factory) {
        this.factory = factory;
    }

    public String method1(String argument) {
        // ... 其他逻辑 ...
        Obj obj1 = privateMethod(argument);
        return obj1.process();
    }

    private Obj privateMethod(String argument) {
        // 现在通过工厂创建对象
        ObjectNeeded2Mock obj = factory.create(argument);
        // ... 使用obj进行一些操作 ...
        return obj;
    }
}

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

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

class ParentClassTest {

    @Mock
    private ObjectNeeded2MockFactory mockFactory; // Mock工厂

    @Mock
    private ObjectNeeded2Mock mockObjectNeeded2Mock; // Mock工厂将返回的对象

    private ParentClass parentClass;

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this); // 初始化所有@Mock注解的字段
        parentClass = new ParentClass(mockFactory); // 将Mock工厂注入到被测试类中
    }

    @Test
    void method1_shouldUseMockedObject_whenCalled() {
        String testArgument = "testData";
        String expectedProcessedResult = "Mocked Processed: " + testArgument;

        // 1. 配置mockFactory的行为：当调用create方法时，返回mockObjectNeeded2Mock
        when(mockFactory.create(testArgument)).thenReturn(mockObjectNeeded2Mock);

        // 2. 配置mockObjectNeeded2Mock的行为：当调用process方法时，返回预期的结果
        when(mockObjectNeeded2Mock.process()).thenReturn(expectedProcessedResult);

        // 调用被测试的公共方法
        String actualResult = parentClass.method1(testArgument);

        // 验证结果
        assertEquals(expectedProcessedResult, actualResult);

        // 验证工厂的create方法是否被调用，且参数正确
        verify(mockFactory).create(testArgument);
        // 验证mockObjectNeeded2Mock的process方法是否被调用
        verify(mockObjectNeeded2Mock).process();
    }
}