高效单元测试：使用Mocking框架处理服务依赖

interface MyService {
    int getItem();
}

@Service
class MyServiceImpl implements MyService {
    private final List<Loader> loaders;

    public MyServiceImpl(List<Loader> loaders) {
        this.loaders = loaders;
    }

    public int getItem() {
       Loader loader = getTheLoader(); // 假设这里有逻辑选择一个Loader
       return loader.getItem();
    }

    // 假设 getTheLoader() 是一个私有或受保护的方法，用于从 loaders 列表中选择一个 Loader
    private Loader getTheLoader() {
        // 示例：简单返回第一个Loader，实际可能更复杂
        return loaders.isEmpty() ? null : loaders.get(0);
    }
}

interface Loader {
    int getItem();
}

@TestInstance(TestInstance.Lifecycle.PER_CLASS)
public class MyServiceTests {

    private MyService myService;

    static class TestLoader implements Loader {
       @Override
       public int getItem() {
           // 实际的Loader逻辑或测试桩逻辑
           return 10;
       }
    }

    @BeforeAll
    void init() {
        myService = new MyServiceImpl(List.of(new TestLoader()));
    }
    // ... 测试方法
}

<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-core</artifactId>
    <version>5.10.0</version> <!-- 使用最新稳定版本 -->
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-junit-jupiter</artifactId>
    <version>5.10.0</version> <!-- 如果使用JUnit 5 -->
    <scope>test</scope>
</dependency>

import org.junit.jupiter.api.BeforeEach; // 注意这里改为BeforeEach
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.InjectMocks;
import org.mockito.junit.jupiter.MockitoExtension;

import java.util.List;

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

@ExtendWith(MockitoExtension.class) // 启用Mockito JUnit 5扩展
public class MyServiceTests {

    @Mock // 声明一个Loader接口的模拟对象
    private Loader mockLoader;

    @InjectMocks // 声明要测试的MyServiceImpl实例，Mockito会自动注入mockLoader
    private MyServiceImpl myService;

    // 如果不使用@InjectMocks，则需要手动在@BeforeEach中实例化
    // private MyService myService;
    // @BeforeEach
    // void setup() {
    //     myService = new MyServiceImpl(List.of(mockLoader));
    // }

    @Test
    void getItemShouldCallLoaderGetItem() {
        // 1. 设置模拟对象的行为 (Stubbing)
        // 当mockLoader的getItem()方法被调用时，返回50
        when(mockLoader.getItem()).thenReturn(50);

        // 2. 调用被测方法
        int result = myService.getItem();

        // 3. 验证结果和交互 (Verification)
        assertEquals(50, result, "MyService应该返回Loader的getItem结果");

        // 验证mockLoader的getItem()方法是否被调用了1次
        verify(mockLoader, times(1)).getItem();
        // 验证mockLoader上没有其他交互
        verifyNoMoreInteractions(mockLoader);
    }

    @Test
    void getItemShouldHandleMultipleLoaders() {
        // 假设MyServiceImpl的getTheLoader()方法总是取第一个loader
        // 这里我们创建一个包含一个mockLoader的列表
        // 注意：如果使用@InjectMocks，Mockito会尝试注入到构造函数中。
        // 对于List<Loader>这样的集合依赖，通常需要手动设置或更复杂的Mockito配置。
        // 最简单的方式是手动实例化MyServiceImpl并传入mockLoader列表。
        myService = new MyServiceImpl(List.of(mockLoader)); // 覆盖@InjectMocks的自动注入，以便传入列表

        when(mockLoader.getItem()).thenReturn(100);

        int result = myService.getItem();

        assertEquals(100, result);
        verify(mockLoader, times(1)).getItem();
    }
}