如何正确单元测试异常捕获块中的适配器模式

public Method execute(@NonNull final String test) throws ServiceException {
    Object object;
    try {
        object = javaClient.fetchInfo(test);
    } catch (ClientException | InternalServerError e) {
        // 异常适配器将捕获到的异常转换为ServiceException并抛出
        throw serviceExceptionAdapter.apply(e);
    }
    return object;
}

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

class ProxyTest {

    private ExceptionAdapter serviceExceptionAdapter;
    private JavaClient mockJavaClient;
    private Proxy proxy;

    @BeforeEach
    void setup() {
        this.serviceExceptionAdapter = mock(ExceptionAdapter.class);
        this.mockJavaClient = mock(JavaClient.class);
        proxy = new Proxy(mockJavaClient, serviceExceptionAdapter);
    }

    @Test
    void test_InternalServerError_IncorrectMocking() {
        String testParam = "someTestValue";
        // 模拟javaClient抛出InternalServerError
        when(mockJavaClient.fetchInfo(any())).thenThrow(InternalServerError.class);

        // 错误：模拟serviceExceptionAdapter.apply(any())抛出ServiceException
        // 而不是返回ServiceException实例
        when(serviceExceptionAdapter.apply(any())).thenThrow(ServiceException.class);

        // 验证execute方法是否抛出ServiceException
        assertThrows(ServiceException.class, () -> proxy.execute(testParam));

        // 验证serviceExceptionAdapter.apply方法是否被调用一次
        verify(serviceExceptionAdapter, times(1)).apply(any());
    }
}

throw serviceExceptionAdapter.apply(e);

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

// 假设 ServiceException 是一个自定义异常
class ServiceException extends RuntimeException {
    public ServiceException(String message) {
        super(message);
    }
    public ServiceException(Throwable cause) {
        super(cause);
    }
}

// 假设 ExceptionAdapter 接口定义
interface ExceptionAdapter {
    ServiceException apply(Throwable e);
}

// 假设 JavaClient 接口定义
interface JavaClient {
    Object fetchInfo(String test) throws ClientException, InternalServerError;
}

// 假设 ClientException 和 InternalServerError 是自定义异常
class ClientException extends RuntimeException {}
class InternalServerError extends RuntimeException {}

// 被测试的 Proxy 类
class Proxy {
    private final JavaClient javaClient;
    private final ExceptionAdapter serviceExceptionAdapter;

    public Proxy(JavaClient javaClient, ExceptionAdapter serviceExceptionAdapter) {
        this.javaClient = javaClient;
        this.serviceExceptionAdapter = serviceExceptionAdapter;
    }

    public Object execute(final String test) throws ServiceException {
        Object object;
        try {
            object = javaClient.fetchInfo(test);
        } catch (ClientException | InternalServerError e) {
            throw serviceExceptionAdapter.apply(e);
        }
        return object;
    }
}


class ProxyTest {

    private ExceptionAdapter serviceExceptionAdapter;
    private JavaClient mockJavaClient;
    private Proxy proxy;

    @BeforeEach
    void setup() {
        this.serviceExceptionAdapter = mock(ExceptionAdapter.class);
        this.mockJavaClient = mock(JavaClient.class);
        proxy = new Proxy(mockJavaClient, serviceExceptionAdapter);
    }

    @Test
    void test_InternalServerError_CorrectMocking() {
        String testParam = "someTestValue";
        InternalServerError caughtException = new InternalServerError();
        ServiceException expectedServiceException = new ServiceException("Adapted from InternalServerError", caughtException);

        // 1. 模拟javaClient.fetchInfo()抛出InternalServerError
        when(mockJavaClient.fetchInfo(any())).thenThrow(caughtException);

        // 2. 模拟serviceExceptionAdapter.apply()返回一个ServiceException实例
        // 注意：这里使用thenReturn()而不是thenThrow()
        when(serviceExceptionAdapter.apply(caughtException)).thenReturn(expectedServiceException);

        // 3. 验证proxy.execute()是否抛出正确的ServiceException
        ServiceException actualException = assertThrows(ServiceException.class, () -> proxy.execute(testParam));
        assertEquals(expectedServiceException, actualException); // 验证抛出的异常是预期的实例

        // 4. 验证serviceExceptionAdapter.apply()方法是否被调用一次，并传入了正确的异常
        verify(serviceExceptionAdapter, times(1)).apply(caughtException);

        // 5. 验证javaClient.fetchInfo()方法是否被调用一次
        verify(mockJavaClient, times(1)).fetchInfo(testParam);
    }

    @Test
    void test_ClientException_CorrectMocking() {
        String testParam = "anotherTestValue";
        ClientException caughtException = new ClientException();
        ServiceException expectedServiceException = new ServiceException("Adapted from ClientException", caughtException);

        when(mockJavaClient.fetchInfo(any())).thenThrow(caughtException);
        when(serviceExceptionAdapter.apply(caughtException)).thenReturn(expectedServiceException);

        ServiceException actualException = assertThrows(ServiceException.class, () -> proxy.execute(testParam));
        assertEquals(expectedServiceException, actualException);

        verify(serviceExceptionAdapter, times(1)).apply(caughtException);
        verify(mockJavaClient, times(1)).fetchInfo(testParam);
    }
}