JUnit测试中覆盖异常捕获块（Catch Block）的实用策略

public class MyService {
    private final SnsProducer snsProducer;

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

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

// SnsProducer 接口示例
public interface SnsProducer {
    void send(String message) throws JsonProcessingException;
}

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

@Test
void snsTest_incorrectAttempt1() {
    // 假设service是MyService的实例，这里尝试模拟service的doCreate方法
    // 当doCreate方法被调用时，直接抛出JsonProcessingException
    // 注意：doCreate方法签名中并未声明抛出JsonProcessingException
    when(service.doCreate(anyString())).thenThrow(new JsonProcessingException("Json Processing Error"){});

    // 期望doCreate方法会抛出SnSException
    assertThrows(SnSException.class, () -> service.doCreate(anyString()));
}

@Test
void snsTest_incorrectAttempt2() {
    // 假设service是MyService的实例，这里尝试模拟service的doCreate方法
    // 这种模拟方式本身是合法的，但它绕过了doCreate方法内部的try-catch逻辑
    when(service.doCreate(anyString())).thenThrow(new SnSException("Exception"));

    // 期望doCreate方法会抛出SnSException
    assertThrows(SnSException.class, () -> service.doCreate(anyString()));
}

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

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

// 假设这些是你的实际类和接口
// public interface SnsProducer { void send(String message) throws JsonProcessingException; }
// public class MyService { ... }
// public class SnSException extends RuntimeException { ... }

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

    @Mock // 模拟SnsProducer接口
    private SnsProducer snsProducer;

    @InjectMocks // 注入模拟的SnsProducer到MyService实例中
    private MyService myService;

    // 可以选择在每个测试前初始化，但@Mock和@InjectMocks通常会自动处理
    // @BeforeEach
    // void setUp() {
    //     // 如果不使用@ExtendWith(MockitoExtension.class)，则需要手动初始化
    //     // MockitoAnnotations.openMocks(this);
    //     // myService = new MyService(snsProducer); // 如果没有@InjectMocks
    // }

    @Test
    void doCreate_shouldThrowSnSException_whenJsonProcessingExceptionOccurs() throws JsonProcessingException {
        String testMessage = "{\"key\":\"value\"}";

        // 1. 模拟内部依赖 snsProducer 的行为
        // 当 snsProducer.send(testMessage) 被调用时，抛出 JsonProcessingException
        // 注意：这里使用的是 doThrow().when() 语法，因为它更适合模拟 void 方法抛出检查型异常
        doThrow(new JsonProcessingException("Simulated JSON processing error") {})
            .when(snsProducer).send(testMessage);

        // 2. 调用被测试的服务方法
        // 期望 myService.doCreate(testMessage) 会抛出 SnSException
        assertThrows(SnSException.class, () -> myService.doCreate(testMessage));

        // 3. 验证 snsProducer.send 方法确实被调用了一次
        verify(snsProducer, times(1)).send(testMessage);
    }

    @Test
    void doCreate_shouldCallSnsProducerSend_whenMessageIsValid() throws JsonProcessingException {
        String testMessage = "{\"key\":\"value\"}";

        // 1. 模拟 snsProducer 的正常行为（不抛出异常）
        doNothing().when(snsProducer).send(testMessage);

        // 2. 调用服务方法
        myService.doCreate(testMessage);

        // 3. 验证 snsProducer.send 方法确实被调用了一次
        verify(snsProducer, times(1)).send(testMessage);
    }
}