JUnit与Mockito：精准测试内部依赖抛出检查型异常的catch块

public class MyService {

    private SnsProducer snsProducer; // 假设这是一个被注入的依赖

    public MyService(SnsProducer snsProducer) {
        this.snsProducer = snsProducer;
    }

    public void doCreate(Message message) {
        try {
            snsProducer.send(message);
        } catch (JsonProcessingException jpe) {
            // 将JsonProcessingException包装成自定义的SnSException抛出
            throw new SnSException("Could not parse Message to publish to SNS", jpe);
        }
    }
}

// 假设SnSException是一个自定义的运行时异常
class SnSException extends RuntimeException {
    public SnSException(String message, Throwable cause) {
        super(message, cause);
    }
}

// 假设SnsProducer接口及其send方法
interface SnsProducer {
    void send(Message message) throws JsonProcessingException;
}

// 假设Message是一个简单的POJO
class Message {}

@Test
void snsTest_IncorrectAttempt1() {
    // 假设service和message已被正确初始化
    // MyService service = new MyService(mock(SnsProducer.class));
    // Message message = new Message();

    // 尝试让service.doCreate(message)直接抛出JsonProcessingException
    // 这里的service是真实的实例，不是mock对象
    // 如果service是mock对象，且doCreate方法没有声明抛出JsonProcessingException，
    // 则会编译错误或运行时异常
    // when(service.doCreate(message)).thenThrow(new JsonProcessingException("Json Processing Error"){}); // 编译错误或运行时异常
    // assertThrows(SnSException.class, () -> service.doCreate(message));
}

@Test
void snsTest_IncorrectAttempt2() {
    // 假设service和message已被正确初始化
    // MyService service = new MyService(mock(SnsProducer.class));
    // Message message = new Message();

    // 尝试让service.doCreate(message)直接抛出SnSException
    // when(service.doCreate(message)).thenThrow(new SnSException("Exception", new JsonProcessingException(""))); // 假设service是mock对象
    // assertThrows(SnSException.class, () -> service.doCreate(message));
}

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import com.fasterxml.jackson.core.JsonProcessingException;

import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.when;

public class MyServiceTest {

    @Mock
    private SnsProducer snsProducer; // 模拟SnsProducer依赖

    @InjectMocks
    private MyService myService; // 注入mock的snsProducer到myService中

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this); // 初始化mock对象
    }

    @Test
    void doCreate_shouldThrowSnSException_whenJsonProcessingExceptionOccurs() throws JsonProcessingException {
        Message testMessage = new Message(); // 创建一个测试消息对象

        // 核心：当snsProducer.send(any(Message.class))被调用时，抛出JsonProcessingException
        // 这里使用doThrow().when()，或者when().thenThrow()都可以，取决于个人偏好和方法签名
        // 因为send方法声明了throws JsonProcessingException，所以可以直接使用when().thenThrow()
        when(snsProducer.send(any(Message.class)))
            .thenThrow(new JsonProcessingException("模拟的JSON处理错误") {});

        // 验证当调用myService.doCreate(testMessage)时，是否抛出了SnSException
        assertThrows(SnSException.class, () -> myService.doCreate(testMessage));
    }
}