Spring Retry组件的单元测试实践：避免常见陷阱与正确姿势

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.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.http.HttpEntity;
import org.springframework.retry.annotation.EnableRetry;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;

import static org.junit.Assert.assertEquals;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.*;

@RunWith(SpringRunner.class)
@ContextConfiguration(classes = DeltaHelperTest.TestConfig.class)
public class DeltaHelperTest {

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

    @Autowired
    private MyRestService mockRestService; // 模拟的MyRestService依赖

    @Autowired
    private MyStorageService mockMyStorageService; // 模拟的MyStorageService依赖

    @Before
    public void setUp() {
        // 设置重试次数，确保测试可控
        System.setProperty("delta.process.retries", "2");
        // 重置所有模拟对象的行为，避免测试间互相影响
        reset(mockRestService, mockMyStorageService);
    }

    @After
    public void validate() {
        // 验证Mockito使用是否正确，例如是否有未验证的交互
        validateMockitoUsage();
    }

    @Test
    public void retriesAfterOneFailAndThenPass() throws Exception {
        // 模拟MyRestService的行为：第一次调用抛出异常，第二次调用成功返回
        when(mockRestService.call(any(String.class), any(HttpEntity.class)))
                .thenThrow(new RuntimeException("Simulated network error")) // 第一次调用失败
                .thenReturn("success"); // 第二次调用成功

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

        // 验证mockRestService被调用了两次（一次初始调用 + 一次重试）
        verify(mockRestService, times(2)).call(any(String.class), any(HttpEntity.class));
        // 验证最终结果是第二次调用成功返回的值
        assertEquals("success", result);
        // 验证recover方法没有被调用，因为重试成功了
        verify(mockMyStorageService, never()).save(any(String.class));
    }

    @Test
    public void retriesFailAndRecover() throws Exception {
        // 模拟MyRestService的行为：每次调用都抛出异常，直到达到最大重试次数
        when(mockRestService.call(any(String.class), any(HttpEntity.class)))
                .thenThrow(new RuntimeException("Persistent network error"));

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

        // 验证mockRestService被调用了最大重试次数 + 1 次 (初始调用 + 2次重试 = 3次)
        verify(mockRestService, times(3)).call(any(String.class), any(HttpEntity.class));
        // 验证最终结果是recover方法返回的值
        assertEquals("recover", result);
        // 验证mockMyStorageService的save方法被调用，表明recover方法被触发
        verify(mockMyStorageService, times(1)).save(eq("anotherApi"));
    }

    @Configuration
    @EnableRetry // 启用Spring Retry功能
    @EnableAspectJAutoProxy(proxyTargetClass = true) // 启用AspectJ代理，确保@Retryable生效
    public static class TestConfig {

        @Bean
        public DeltaHelper deltaHelper() {
            // DeltaHelper是SUT，应该是一个真实实例。
            // 它的依赖项MyRestService和MyStorageService将由Spring自动注入下面定义的mock bean。
            return new DeltaHelper();
        }

        @Bean
        public MyRestService myRestService() {
            // 提供MyRestService的mock实例
            return mock(MyRestService.class);
        }

        @Bean
        public MyStorageService myStorageService() {
            // 提供MyStorageService的mock实例
            return mock(MyStorageService.class);
        }

        // MyRepo是MyStorageService的依赖。
        // 由于MyStorageService本身已被mock，我们无需为MyRepo提供mock，
        // 除非MyStorageService是一个真实实例，且其内部逻辑需要MyRepo的mock行为。
        // @Bean
        // public MyRepo myRepository() {
        //     return mock(MyRepo.class);
        // }
    }
}