Java 单元测试：assertThrows 验证异常方法

1. 常见误区：使用 assertThat().isInstanceOf() 验证异常

在编写单元测试时，我们经常需要验证某个方法在特定条件下是否会抛出预期的异常。一个常见的错误尝试是使用 AssertJ 的 assertThat() 结合 isInstanceOf() 方法来检查异常类型。让我们通过一个具体的例子来分析这个问题。

假设我们有一个 Application 类，其中包含一个 enterTheAmount 方法，该方法接收用户输入的金额，并要求金额必须是 LOTTO_PRICE (例如 1000) 的倍数。如果金额不符合要求，它将抛出 IllegalArgumentException。

// Application.java
import java.io.Console; // 假设这里有一个Console工具类，或者使用Scanner

public class Application {
    public static int enterTheAmount() {
        final int LOTTO_PRICE = 1000;
        // 模拟从控制台读取输入，实际测试中会通过System.setIn重定向
        // int amount = Integer.parseInt(Console.readLine()); // 原始代码，这里简化为直接读取

        // 为了方便测试，我们修改为从参数获取，或者在测试中模拟Console.readLine()
        // 这里为了演示，我们假设Console.readLine()返回一个字符串，并转换为int
        // 实际测试时，需要通过System.setIn()来模拟输入流
        String input = readSimulatedInput(); // 假设这是一个模拟读取输入的方法
        int amount = Integer.parseInt(input);

        if (amount % LOTTO_PRICE != 0) {
            throw new IllegalArgumentException("输入的金额必须是 " + LOTTO_PRICE + " 的倍数。");
        }
        return amount / LOTTO_PRICE;
    }

    // 模拟读取输入，在实际测试中会用ByteArrayInputStream替换
    private static String readSimulatedInput() {
        // 这是一个占位符，在实际测试中会被System.setIn(new ByteArrayInputStream(...))替换
        return "1234"; // 默认返回一个无效值
    }
}

现在，为了测试当输入无效金额时是否抛出 IllegalArgumentException，一些开发者可能会尝试编写如下的测试代码：

import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows; // 提前引入正确的断言

import java.io.ByteArrayInputStream;
import java.io.InputStream;

public class ApplicationTest {

    // 模拟System.in的辅助方法
    private void setSimulatedInput(String input) {
        InputStream in = new ByteArrayInputStream(input.getBytes());
        System.setIn(in);
    }

    @Test
    void validateTheEnteredAmount_IncorrectApproach() {
        setSimulatedInput("1234"); // 设置一个无效输入

        // 这种断言方式是错误的，它会尝试执行enterTheAmount()方法，
        // 如果该方法抛出异常，测试会在assertThat()被调用之前就失败，
        // 而不是捕获异常并检查其类型。
        // try {
        //     assertThat(Application.enterTheAmount()).isInstanceOf(IllegalArgumentException.class);
        //     // 如果代码执行到这里，说明没有抛出异常，测试应该失败
        //     fail("Expected IllegalArgumentException was not thrown.");
        // } catch (IllegalArgumentException e) {
        //     // 捕获到异常，说明抛出了，测试通过
        //     // 但这种方式冗长且不符合断言库的初衷
        //     assertThat(e).isInstanceOf(IllegalArgumentException.class); // 这里的isInstanceOf是多余的，因为已经捕获到了
        // }

        // 上述注释代码是手动捕获异常的演示，但不是AssertJ或JUnit推荐的测试异常方式。
        // 直接使用assertThat(Application.enterTheAmount()).isInstanceOf(...)
        // 会导致测试失败，因为当enterTheAmount()抛出异常时，
        // 异常会在assertThat()方法被调用之前就传播出来，导致测试中断。
        // 因此，这种方式无法达到验证异常的目的。
    }
}

上述 validateTheEnteredAmount_IncorrectApproach 方法中的 assertThat(Application.enterTheAmount()).isInstanceOf(IllegalArgumentException.class); 尝试验证 enterTheAmount() 方法的返回值是否为 IllegalArgumentException 的实例。然而，当 enterTheAmount() 抛出 IllegalArgumentException 时，这个异常会立即中断当前方法的执行，导致 assertThat() 根本无法被调用，测试会直接失败，而不是通过 AssertJ 来验证异常类型。

2. 正确实践：使用 assertThrows 验证异常

为了正确地验证方法是否抛出特定异常，JUnit 5 提供了 assertThrows() 方法。这个方法专门用于捕获并断言代码块中抛出的异常。

assertThrows() 方法的基本用法如下：

assertThrows(ExpectedExceptionType.class, () -> {
    // 可能会抛出ExpectedExceptionType异常的代码块
});

• ExpectedExceptionType.class: 期望捕获的异常类型。
• () -> { ... }: 一个 Executable 类型的 Lambda 表达式，其中包含可能抛出异常的代码。assertThrows() 会执行这个 Lambda 表达式，并捕获其中抛出的异常。

如果 Lambda 表达式中抛出了指定类型的异常，assertThrows() 会成功捕获并返回该异常实例，测试通过。如果抛出了其他类型的异常，或者根本没有抛出异常，测试将失败。

现在，让我们使用 assertThrows() 来修正之前的测试：

import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat; // 仍然可以使用AssertJ进行更详细的异常内容断言
import static org.junit.jupiter.api.Assertions.assertThrows;

import java.io.ByteArrayInputStream;
import java.io.InputStream;

public class ApplicationTest {

    // 模拟System.in的辅助方法
    private void setSimulatedInput(String input) {
        InputStream in = new ByteArrayInputStream(input.getBytes());
        System.setIn(in);
    }

    @Test
    void validateTheEnteredAmount_CorrectApproach() {
        setSimulatedInput("1234"); // 设置一个无效输入

        // 使用 assertThrows 验证是否抛出 IllegalArgumentException
        IllegalArgumentException thrown = assertThrows(
            IllegalArgumentException.class,
            () -> Application.enterTheAmount(), // 传递一个Lambda表达式，包含可能抛出异常的代码
            "Expected enterTheAmount() to throw IllegalArgumentException, but it didn't" // 失败时的消息
        );

        // 可以在此基础上进一步断言异常的详细信息，例如异常消息
        assertThat(thrown.getMessage()).contains("输入的金额必须是 1000 的倍数");
    }

    @Test
    void validateTheEnteredAmount_ValidInput() {
        setSimulatedInput("2000"); // 设置一个有效输入
        int result = Application.enterTheAmount();
        assertThat(result).isEqualTo(2); // 验证返回结果
    }
}

在 validateTheEnteredAmount_CorrectApproach 测试方法中：

1. setSimulatedInput("1234") 模拟了用户输入一个无效金额。
2. assertThrows(IllegalArgumentException.class, () -> Application.enterTheAmount()) 确保 Application.enterTheAmount() 方法在执行时会抛出 IllegalArgumentException。如果抛出的是其他异常或者没有抛出异常，测试都将失败。
3. assertThrows 方法会返回捕获到的异常实例，这使得我们可以进一步使用 AssertJ 或 JUnit 的其他断言来验证异常的详细信息，例如异常消息 (thrown.getMessage())。

3. 注意事项与最佳实践

• 选择正确的工具： 对于异常测试，assertThrows (JUnit 5)、expectedException (JUnit 4)、assertThatExceptionOfType (AssertJ) 等是专门设计来解决此类问题的工具。避免使用 try-catch 块来手动捕获异常并断言，因为它会使测试代码变得冗长且不易维护。
• 断言异常类型和消息： 仅仅验证异常是否被抛出通常是不够的。在许多情况下，您还需要验证抛出的异常类型是否正确，以及异常消息是否包含预期的信息，这有助于确保异常是在正确的上下文和原因下抛出的。
• 模拟输入流： 当被测试的方法依赖于 System.in 或其他外部输入时，在单元测试中，您需要使用 System.setIn(new ByteArrayInputStream(...)) 来模拟输入流，以确保测试的独立性和可重复性。记得在测试结束后恢复 System.in (例如使用 @AfterEach 或 try-finally 块)，以避免影响其他测试。
• 测试边界条件： 除了无效输入，还应该考虑其他边界条件，例如空输入、负数、最大/最小值等，以确保方法的健壮性。

4. 总结

正确地测试方法抛出异常是单元测试中不可或缺的一部分，它确保了代码在面对异常情况时能够按照预期行为。通过本文的讲解，我们理解了使用 assertThat().isInstanceOf() 直接验证异常的局限性，并掌握了使用 JUnit 5 的 assertThrows() 方法作为验证异常抛出的标准和推荐实践。采用正确的测试工具和方法，不仅能提高测试的效率和可读性，还能更准确地捕捉代码中的潜在问题，从而提升软件质量。