Java单元测试：如何Mock私有方法中创建的对象？引入工厂模式的解决方案

// 假设这是需要测试的原始类
class ParentClass {

    public ParentClass() {}

    public String method1(String argument) {
        // ... method1 的一些业务逻辑 ...
        Obj obj1 = privateMethod(argument); // 内部调用私有方法
        // ... 使用 obj1 进行更多操作 ...
        return "Result from method1 based on " + obj1.getData();
    }

    private Obj privateMethod(String argument) {
        // 这里直接创建了 ObjectNeeded2Mock 的实例
        ObjectNeeded2Mock obj = new ObjectNeeded2Mock(argument); 
        String data = obj.performComplexOperation(); // 假设这是一个复杂或外部依赖的操作
        // ... 使用 data ...
        return new Obj(data); // 返回一个 Obj 实例
    }
}

// 辅助类定义
class Obj {
    private String data;
    public Obj(String data) { this.data = data; }
    public String getData() { return data; }
}

class ObjectNeeded2Mock {
    private String initData;
    public ObjectNeeded2Mock(String data) { this.initData = data; }
    public String performComplexOperation() {
        // 模拟一个复杂的、耗时的或有外部依赖的操作
        System.out.println("Performing complex operation with: " + initData);
        return "Processed:" + initData;
    }
}

interface ObjectNeeded2MockFactory {
    ObjectNeeded2Mock createObjectNeeded2Mock(String argument);
}

class DefaultObjectNeeded2MockFactory implements ObjectNeeded2MockFactory {
    @Override
    public ObjectNeeded2Mock createObjectNeeded2Mock(String argument) {
        return new ObjectNeeded2Mock(argument);
    }
}

class ParentClass {
    private final ObjectNeeded2MockFactory objectNeeded2MockFactory;

    // 推荐使用构造函数注入
    public ParentClass(ObjectNeeded2MockFactory objectNeeded2MockFactory) {
        this.objectNeeded2MockFactory = objectNeeded2MockFactory;
    }

    // 提供一个默认构造函数，用于非测试环境或简化初始化
    public ParentClass() {
        this(new DefaultObjectNeeded2MockFactory());
    }

    public String method1(String argument) {
        // ... method1 的一些业务逻辑 ...
        Obj obj1 = privateMethod(argument);
        // ... 使用 obj1 进行更多操作 ...
        return "Result from method1 based on " + obj1.getData();
    }

    private Obj privateMethod(String argument) {
        // 现在通过工厂来创建 ObjectNeeded2Mock 实例
        ObjectNeeded2Mock obj = objectNeeded2MockFactory.createObjectNeeded2Mock(argument);
        String data = obj.performComplexOperation();
        return new Obj(data);
    }
}

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.Mockito.*;

class ParentClassTest {

    @Mock
    private ObjectNeeded2MockFactory mockFactory; // Mock 工厂接口

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

    @InjectMocks
    private ParentClass parentClass; // 将 Mock 注入到 ParentClass 实例中

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this); // 初始化所有 @Mock 和 @InjectMocks 注解

        // 配置 mockFactory：当调用 createObjectNeeded2Mock 时，返回 mockObjectNeeded2Mock
        when(mockFactory.createObjectNeeded2Mock(anyString())).thenReturn(mockObjectNeeded2Mock);
    }

    @Test
    void testMethod1_withMockedPrivateDependency() {
        // Arrange
        String testArgument = "testData";
        String expectedProcessedData = "MockedProcessed:testData";

        // 配置 mockObjectNeeded2Mock 的行为：当调用 performComplexOperation 时，返回预期的模拟数据
        when(mockObjectNeeded2Mock.performComplexOperation()).thenReturn(expectedProcessedData);

        // Act
        String result = parentClass.method1(testArgument);

        // Assert
        // 验证工厂是否被调用以创建对象
        verify(mockFactory, times(1)).createObjectNeeded2Mock(testArgument);
        // 验证被 Mock 的对象的 performComplexOperation 方法是否被调用
        verify(mockObjectNeeded2Mock, times(1)).performComplexOperation();
        // 验证 method1 的最终结果是否符合预期
        assertEquals("Result from method1 based on " + expectedProcessedData, result);
    }
}