Exception Testing and Verification

Assert that specific code paths throw expected custom exceptions.

Mastering Exception Testing and Verification

In this lesson, you will learn how to verify that your application correctly handles failure states by asserting that specific code paths throw expected custom exceptions.

When building robust systems, validating that your code succeeds under ideal conditions is only half the battle. Equally important is ensuring that when things go wrong—such as a domain-specific business rule violation—your code "fails loudly" and predictably. In advanced architectures, we don't just want the system to crash; we want it to throw a precise CustomException so that upstream handlers can respond appropriately.

Validating Expected Failures

Using the AAA (Arrange, Act, Assert) pattern, exception testing focuses on the Act phase. You want to wrap the execution of a method in a delegate and verify that the framework catches the expected exception type.

If you are using xUnit, you leverage Assert.Throws<TException> to perform this validation. This method doesn't just check the type; it returns the exception instance, allowing you to inspect properties like Message or custom error codes.

Consider a scenario where a TransferFunds method must throw an InsufficientFundsException when a balance is too low:

[Fact]
public void TransferFunds_WhenBalanceIsLow_ThrowsInsufficientFundsException()
{
    // Arrange
    var account = new Account(balance: 10);
    var service = new BankService();

    // Act & Assert
    var exception = Assert.Throws<InsufficientFundsException>(() => 
        service.TransferFunds(account, 100));

    // Verify state within the exception
    Assert.Equal(10, exception.AvailableBalance);
}

Why This Matters

By asserting the exception type, you ensure that your code isn't just failing due to an unexpected null reference or an unrelated issue, but rather that your domain logic is correctly enforcing invariants. This prevents "silent failures" where a service might return a default value instead of signaling an invalid operation. If the code path executes successfully without throwing, or throws the wrong exception type, the test will correctly fail, alerting you to a regression in your defensive logic.

Key Takeaway: Exception testing ensures your domain logic enforces constraints by verifying that the system predictably throws the exact expected exception type when business rules are violated.