正确测试Spring Retry组件：避免空指针与Mockito误用

// DeltaHelper.java
@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 process for API: " + api); // 方便观察重试
        return restService.call(api, entity);
    }

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

// MyRestService.java
@Service
public class MyRestService extends org.springframework.web.client.RestTemplate {
    // 假设call方法存在并被DeltaHelper调用
    public String call(String api, HttpEntity<?> entity) {
        // 实际的REST调用逻辑
        throw new UnsupportedOperationException("Not implemented for real usage in test");
    }
}

// MyStorageService.java
@Service
public class MyStorageService {

    @Autowired
    MyRepo myRepo;

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

// MyRepo.java (接口或抽象类)
public interface MyRepo {
    MyEntity save(MyEntity entity);
}

// MyEntity.java
public class MyEntity {
    private String api;
    private long timestamp;

    public MyEntity(String api, long timestamp) {
        this.api = api;
        this.timestamp = timestamp;
    }
    // getters, setters
}

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
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.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.*;

@RunWith(SpringRunner.class)
@ContextConfiguration
public class DeltaHelperTest {

    @Autowired
    private DeltaHelper deltaHelper; // SUT，由Spring管理并注入Mock依赖

    @Autowired
    private MyRestService mockRestService; // 注入Mock对象，用于设置行为和验证

    @Autowired
    private MyStorageService mockMyStorageService; // 注入Mock对象

    @Autowired
    private MyRepo mockMyRepo; // 注入Mock对象

    @Before
    public void setUp() {
        // 设置重试次数，确保@Retryable的maxAttemptsExpression能正确解析
        System.setProperty("delta.process.retries", "2");
        // 重置所有Mock，确保每个测试方法都是干净的环境
        Mockito.reset(mockRestService, mockMyStorageService, mockMyRepo);
    }

    @After
    public void validate() {
        // 验证Mock的使用，确保没有未验证的交互
        validateMockitoUsage();
    }

    @Test
    public void retriesAfterOneFailAndThenPass() throws Exception {
        String testApi = "test-api-path";
        HttpEntity<?> testEntity = new HttpEntity<>("test-body");

        // 模拟restService的第一次调用抛出异常，第二次成功
        when(mockRestService.call(eq(testApi), eq(testEntity)))
                .thenThrow(new RuntimeException("Simulated first call failure")) // 第一次失败
                .thenReturn("success-response"); // 第二次成功

        // 调用SUT的方法，传入真实的参数
        String result = deltaHelper.process(testApi, testEntity);

        // 验证restService的call方法被调用了两次（一次失败，一次成功）
        verify(mockRestService, times(2)).call(eq(testApi), eq(testEntity));
        // 验证重试成功后返回的是第二次调用的结果
        assert "success-response".equals(result);
        // 验证recover方法没有被调用，因为重试成功了
        verify(mockMyStorageService, never()).save(anyString());
    }

    @Test
    public void retriesFailAndThenRecover() throws Exception {
        String testApi = "fail-api-path";
        HttpEntity<?> testEntity = new HttpEntity<>("fail-body");

        // 模拟restService的两次调用都抛出异常，触发recover
        when(mockRestService.call(eq(testApi), eq(testEntity)))
                .thenThrow(new RuntimeException("Simulated first call failure"))
                .thenThrow(new RuntimeException("Simulated second call failure")); // 第二次也失败

        // 调用SUT的方法，传入真实的参数
        String result = deltaHelper.process(testApi, testEntity);

        // 验证restService的call方法被调用了两次（达到maxAttemptsExpression设定的次数）
        verify(mockRestService, times(2)).call(eq(testApi), eq(testEntity));
        // 验证recover方法被调用了，因为重试失败
        verify(mockMyStorageService, times(1)).save(eq(testApi));
        // 验证返回的是recover方法的结果
        assert "recover".equals(result);
    }

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

        // DeltaHelper作为SUT，让Spring正常创建和注入
        @Bean
        public DeltaHelper deltaHelper() {
            return new DeltaHelper();
        }

        // 提供MyRestService的Mock Bean
        @Bean
        public MyRestService restService() {
            return mock(MyRestService.class);
        }

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

        // 提供MyRepo的Mock Bean
        @Bean
        public MyRepo myRepository() {
            return mock(MyRepo.class);
        }
    }
}