正确地单元测试Spring Retry组件：避免常见陷阱与最佳实践

public static <T> T any() {
    reportMatcher(Any.ANY);
    return null; // 注意这里：它返回null
}

// 错误示例 (在调用SUT时使用any())
deltaHelper.process(any(), any()); // 实际调用的是 deltaHelper.process(null, null);

// 正确示例 (在设置mock行为时使用any())
when(mockRestService.call(any(), any())).thenThrow(new RuntimeException());

// 正确示例 (在验证mock调用时使用any())
verify(mockRestService, times(2)).call(any(), any());

// 正确示例 (在调用SUT时使用真实参数)
String apiArg = "testApi";
HttpEntity<?> entityArg = new HttpEntity<>("testBody");
deltaHelper.process(apiArg, entityArg);

// DeltaHelper.java (SUT)
@Component
public class DeltaHelper {

    @Autowired
    MyRestService restService;

    @Autowired
    MyStorageService myStorageService;

    @NotNull
    @Retryable(
            value = Exception.class,
            maxAttemptsExpression = "${delta.process.retries}" // 从属性文件读取重试次数
    )
    public String process(String api, HttpEntity<?> entity) {
        System.out.println("Attempting to call restService for API: " + api);
        return restService.call(api, entity);
    }

    @Recover
    public String recover(Exception e, String api, HttpEntity<?> entity) {
        System.out.println("Recovering from exception: " + e.getMessage() + " for API: " + api);
        myStorageService.save(api);
        return "recover_success";
    }
}

// MyRestService.java (Dependency)
public class MyRestService extends org.springframework.web.client.RestTemplate {
    public String call(String api, HttpEntity<?> entity) {
        // 模拟实际的REST调用
        System.out.println("MyRestService.call invoked for API: " + api);
        // 实际应用中会进行网络请求
        return "real_response_from_" + api;
    }
}

// MyStorageService.java (Another Dependency)
@Service
public class MyStorageService {
    @Autowired
    MyRepo myRepo;

    @Async
    public MyEntity save(String api) {
        System.out.println("MyStorageService.save invoked for API: " + api);
        return myRepo.save(new MyEntity(api, System.currentTimeMillis()));
    }
}

// MyRepo.java (Simple interface/class for demonstration)
public interface MyRepo {
    MyEntity save(MyEntity entity);
}

public class MyEntity {
    private String api;
    private Long timestamp;
    public MyEntity(String api, Long timestamp) {
        this.api = api;
        this.timestamp = timestamp;
    }
    // Getters and Setters
}

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.http.HttpEntity;
import org.springframework.retry.annotation.EnableRetry;
import org.springframework.test.context.junit4.SpringRunner;

import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.*;
import static org.mockito.Mockito.validateMockitoUsage;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = DeltaHelperTest.TestConfig.class) // 使用 @SpringBootTest 加载测试配置
public class DeltaHelperTest {

    @Autowired
    private DeltaHelper deltaHelper; // SUT: 真实实例

    @MockBean
    private MyRestService mockRestService; // 依赖: 模拟实例

    @MockBean
    private MyStorageService mockMyStorageService; // 依赖: 模拟实例，用于验证recover方法

    @MockBean
    private MyRepo mockMyRepo; // 依赖: 模拟实例，如果MyStorageService的save方法需要mock MyRepo

    @Before
    public void setUp() {
        // 设置重试次数的系统属性，确保@Retryable的maxAttemptsExpression能正确解析
        System.setProperty("delta.process.retries", "2");
        // 清除mock的调用历史，防止测试之间互相影响
        reset(mockRestService, mockMyStorageService, mockMyRepo);
    }

    @After
    public void validate() {
        // 验证所有mock对象是否有未验证的交互
        validateMockitoUsage();
    }

    @Test
    public void retriesAfterOneFailAndThenPass() throws Exception {
        // 1. 设置mockRestService的行为：
        // 第一次调用抛出异常 (触发重试)
        // 第二次调用返回成功 (重试成功)
        when(mockRestService.call(any(String.class), any(HttpEntity.class)))
                .thenThrow(new RuntimeException("Simulated network error"))
                .thenReturn("successful_response");

        // 2. 调用SUT的实际方法，并传入真实的参数
        String apiArg = "testApi";
        HttpEntity<?> entityArg = new HttpEntity<>("testBody");
        String result = deltaHelper.process(apiArg, entityArg);

        // 3. 验证结果和交互
        // 验证mockRestService的call方法被调用了2次
        verify(mockRestService, times(2)).call(apiArg, entityArg);
        // 验证最终结果
        assertThat(result).isEqualTo("successful_response");
        // 验证recover方法没有被调用，因为重试成功了
        verify(mockMyStorageService, never()).save(any(String.class));
    }

    @Test
    public void retriesFailAndThenRecover() throws Exception {
        // 1. 设置mockRestService的行为：
        // 第一次和第二次调用都抛出异常 (达到最大重试次数，触发recover)
        when(mockRestService.call(any(String.class), any(HttpEntity.class)))
                .thenThrow(new RuntimeException("Simulated network error again"));

        // 2. 调用SUT的实际方法，并传入真实的参数
        String apiArg = "anotherApi";
        HttpEntity<?> entityArg = new HttpEntity<>("anotherBody");
        String result = deltaHelper.process(apiArg, entityArg);

        // 3. 验证结果和交互
        // 验证mockRestService的call方法被调用了2次 (maxAttemptsExpression = "2")
        verify(mockRestService, times(2)).call(apiArg, entityArg);
        // 验证最终结果是recover方法的返回值
        assertThat(result).isEqualTo("recover_success");
        // 验证mockMyStorageService的save方法被调用了1次 (在recover方法中)
        verify(mockMyStorageService, times(1)).save(apiArg);
    }

    @Configuration
    @EnableRetry // 启用Spring Retry功能
    // @EnableAspectJAutoProxy(proxyTargetClass=true) // 如果需要AspectJ代理，但对于Spring Retry通常是CGLIB代理
    @Import({DeltaHelper.