Java中测试私有方法内部创建的对象：使用可注入工厂模式

// 待测试的依赖对象
class ObjectNeeded2Mock {
    public String doSomething() {
        return "Real Value";
    }
    // 更多业务逻辑
}

// 私有方法内部创建依赖对象的类
class ParentClass {

    public ParentClass() {}

    public String method1(String argument) {
        // ... 其他逻辑
        Obj resultObj = privateMethod(argument); // 调用私有方法
        return "Processed: " + resultObj.getValue();
    }

    private Obj privateMethod(String argument) {
        // 问题所在：ObjectNeeded2Mock在这里被直接实例化
        ObjectNeeded2Mock obj = new ObjectNeeded2Mock();
        String processedValue = obj.doSomething() + " " + argument;
        return new Obj(processedValue);
    }
}

// 辅助类
class Obj {
    private String value;
    public Obj(String value) { this.value = value; }
    public String getValue() { return value; }
}

// 1. 定义一个工厂接口
interface ObjectNeeded2MockFactory {
    ObjectNeeded2Mock create();
}

// 2. 提供一个默认的工厂实现
class DefaultObjectNeeded2MockFactory implements ObjectNeeded2MockFactory {
    @Override
    public ObjectNeeded2Mock create() {
        return new ObjectNeeded2Mock(); // 实际创建对象
    }
}

// 3. 重构ParentClass，通过构造函数注入工厂
class ParentClass {
    private final ObjectNeeded2MockFactory factory;

    // 构造函数注入工厂
    public ParentClass(ObjectNeeded2MockFactory factory) {
        this.factory = factory;
    }

    public String method1(String argument) {
        // ... 其他逻辑
        Obj resultObj = privateMethod(argument);
        return "Processed: " + resultObj.getValue();
    }

    private Obj privateMethod(String argument) {
        // 现在通过工厂创建ObjectNeeded2Mock
        ObjectNeeded2Mock obj = factory.create();
        String processedValue = obj.doSomething() + " " + argument;
        return new Obj(processedValue);
    }
}

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
import static org.mockito.Mockito.*;
import static org.junit.jupiter.api.Assertions.*;

class ParentClassTest {

    private ObjectNeeded2MockFactory mockFactory;
    private ObjectNeeded2Mock mockObjectNeeded2Mock;
    private ParentClass parentClass;

    @BeforeEach
    void setUp() {
        // 1. Mock工厂接口
        mockFactory = mock(ObjectNeeded2MockFactory.class);
        // 2. Mock ObjectNeeded2Mock实例
        mockObjectNeeded2Mock = mock(ObjectNeeded2Mock.class);

        // 3. 配置mockFactory，使其在调用create()时返回mockObjectNeeded2Mock
        when(mockFactory.create()).thenReturn(mockObjectNeeded2Mock);

        // 4. 使用mockFactory实例化ParentClass
        parentClass = new ParentClass(mockFactory);
    }

    @Test
    void testMethod1_withMockedDependency() {
        // Arrange
        String testArgument = "testArgument";
        String mockedResultFromObj = "Mocked Result";

        // 配置mockObjectNeeded2Mock的行为
        when(mockObjectNeeded2Mock.doSomething()).thenReturn(mockedResultFromObj);

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

        // Assert
        // 验证工厂的create方法是否被调用
        verify(mockFactory, times(1)).create();
        // 验证mockObjectNeeded2Mock的doSomething方法是否被调用
        verify(mockObjectNeeded2Mock, times(1)).doSomething();

        // 验证最终结果是否符合预期
        String expectedResult = "Processed: " + mockedResultFromObj + " " + testArgument;
        assertEquals(expectedResult, actualResult);
    }
}