如何在单元测试中有效模拟方法返回的对象：解耦与依赖注入实践

class A {
    public void foo() {
        System.out.println("A's foo called");
    }
}

class B {
    public A foo() {
        System.out.println("B's foo called");
        return new A(); // B's foo returns a new A
    }
}

class SomeClass {
    public void doSomeThing() {
        B b = new B(); // SomeClass internally creates B
        A a = b.foo();
        a.foo();
    }
}

import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;

public class SomeClassTest {

    @Mock
    A aMock; // 尝试模拟 A

    @InjectMocks
    SomeClass someClass;

    @Test
    void testDoSomeThingFails() {
        // 尝试配置 aMock 的行为，但这个 aMock 实例并不会被 SomeClass 使用
        Mockito.when(aMock.foo()).thenReturn(/* 某些值或行为 */ null); 

        // 这里的测试会失败，因为 SomeClass 内部创建了 B 和 A 的实例
        // 它并不知道我们创建的 aMock
        assertDoesNotThrow(() -> someClass.doSomeThing());
    }
}

import java.util.function.Supplier;

class SomeClass {
  private final Supplier<? extends B> bFactory;

  // 构造函数：允许外部注入如何创建 B 的逻辑
  public SomeClass(final Supplier<? extends B> bFactory) {
    this.bFactory = bFactory;
  }

  // 无参构造函数：为了向后兼容性或生产环境的便利
  // 在生产代码中，它会使用默认的 B::new 来创建 B 的实例
  public SomeClass() {
    this(B::new); 
  }

  public void doSomeThing() {
    // 通过注入的 Supplier 获取 B 的实例
    B b = this.bFactory.get(); 
    A a = b.foo();
    a.foo();
  }
}

import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

public class SomeClassRefactoredTest {

    @Test
    void testDoSomeThingWithMocks() {
        // 1. 创建 A 的模拟对象
        final A aMock = mock(A.class);
        // 2. 配置 A 模拟对象的行为 (如果需要)
        // 例如：当 aMock.foo() 被调用时，不抛出异常
        when(aMock.foo()).thenAnswer(invocation -> {
            System.out.println("Mocked A's foo called");
            return null; // 或者返回其他期望值
        });

        // 3. 创建 B 的模拟对象
        final B bMock = mock(B.class);
        // 4. 配置 B 模拟对象的 foo() 方法，使其返回 aMock
        when(bMock.foo()).thenReturn(aMock);

        // 5. 实例化 SomeClass，注入一个返回 bMock 的 Supplier
        final SomeClass someClass = new SomeClass(() -> bMock);

        // 6. 执行测试并断言
        assertDoesNotThrow(() -> someClass.doSomeThing());

        // 验证 mock 对象是否被正确调用 (可选)
        Mockito.verify(bMock).foo();
        Mockito.verify(aMock).foo();
    }
}