如何在Mockito中模拟方法返回的对象：重构与依赖注入实践

class SomeClass {
    public void doSomeThing() {
        B b = new B(); // B的实例在内部创建
        A a = b.foo();
        a.foo();
    }
}

// 假设 A 和 B 是其他类
class A {
    public void foo() { /* 实际逻辑 */ }
}

class B {
    public A foo() { return new A(); /* 实际逻辑 */ }
}

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;

class SomeClassTest {

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

    @InjectMocks
    SomeClass someClass;

    @Test
    void testInitialAttempt() {
        // 尝试模拟 aMock 的行为
        Mockito.when(aMock.foo()).thenReturn( /* some value or do nothing */ ); 

        // 执行被测方法
        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 实例创建方式。在生产代码中，
  // 推荐始终使用带参数的构造函数。
  public SomeClass() {
    this(B::new);
  }

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

import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
import java.util.function.Supplier;

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

class SomeClassRefactoredTest {

    @Test
    void testWithRefactoredClass() {
        // 1. 模拟 A 对象
        final A aMock = mock(A.class);
        // 配置 aMock 的行为，例如当 aMock.foo() 被调用时
        // 这里只是示例，实际可能需要thenReturn()一个值或doNothing()
        when(aMock.foo()).thenAnswer(invocation -> {
            System.out.println("aMock.foo() was called!");
            return null; // 或者返回一个具体值
        });

        // 2. 模拟 B 对象
        final B bMock = mock(B.class);
        // 配置 bMock 的行为：当 bMock.foo() 被调用时，返回 aMock
        when(bMock.foo()).thenReturn(aMock);

        // 3. 创建一个 Supplier，使其在被调用时返回 bMock
        final Supplier<B> bSupplierMock = () -> bMock;

        // 4. 使用这个 Supplier 实例化 SomeClass
        final SomeClass someClass = new SomeClass(bSupplierMock);

        // 5. 执行被测方法并验证
        assertDoesNotThrow(() -> someClass.doSomeThing());

        // 可选：验证 mock 对象的交互
        Mockito.verify(bMock).foo(); // 验证 bMock 的 foo() 方法被调用
        Mockito.verify(aMock).foo(); // 验证 aMock 的 foo() 方法被调用
    }
}