Asserting exceptions (pytest.raises) - Deep Dive

Overview - Asserting exceptions (pytest.raises)

What is it?

Asserting exceptions with pytest.raises means checking if a piece of code causes an error you expect. When testing software, sometimes you want to make sure that wrong inputs or actions cause the right kind of failure. Pytest provides a simple way to catch these errors and confirm they happen as planned. This helps keep your code safe and predictable.

Why it matters

Without checking for expected errors, bugs can hide silently or cause crashes in unexpected ways. If your tests don't confirm that errors happen when they should, your software might behave unpredictably or insecurely. Using pytest.raises ensures your program handles bad situations properly, making it more reliable and easier to fix when things go wrong.

Where it fits

Before learning this, you should know basic pytest test functions and how to write simple assertions. After mastering asserting exceptions, you can explore advanced pytest features like fixtures, parameterized tests, and mocking. This topic fits into the testing journey after you understand how to check normal outputs and before you handle complex test setups.

Mental Model

Core Idea

Asserting exceptions means deliberately causing and catching errors in tests to confirm your code fails correctly when it should.

Think of it like...

It's like testing a fire alarm by setting off smoke to see if it rings; you want to confirm the alarm works when danger happens.

┌─────────────────────────────┐
│   Test code runs block      │
│   that should raise error   │
├─────────────────────────────┤
│ If error occurs and matches │
│ expected type, test passes  │
│ Else, test fails            │
└─────────────────────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding exceptions in Python

Concept: Learn what exceptions are and how Python signals errors.

In Python, exceptions are special events that happen when something goes wrong, like dividing by zero or accessing a missing file. When an exception occurs, Python stops normal code and looks for a way to handle the error. If none is found, the program crashes with an error message.

Result

You understand that exceptions are signals of errors and that they stop normal code flow unless handled.

Knowing what exceptions are is essential because testing often involves checking how your code reacts to errors.

2

Foundation

Basic pytest test and assertion

Concept: Learn how to write a simple test function and check results with assert.

Pytest runs functions starting with 'test_' as tests. Inside, you use assert statements to check if values are what you expect. For example, assert 2 + 2 == 4 checks if the sum is correct. If the assert fails, pytest reports a test failure.

Result

You can write a test that passes or fails based on simple conditions.

Understanding basic asserts prepares you to check not only values but also errors in tests.

3

Intermediate

Using pytest.raises to catch exceptions

🤔Before reading on: do you think pytest.raises runs the code inside it immediately or later? Commit to your answer.

Concept: Learn how to use pytest.raises as a context manager to check for expected exceptions.

Pytest.raises is used with a 'with' statement. You write 'with pytest.raises(ExpectedError):' and then the code that should cause that error inside the block. If the error happens and matches ExpectedError, the test passes. If no error or a different error happens, the test fails.

Result

You can confirm that specific code raises the expected exception during tests.

Understanding that pytest.raises runs code inside its block and watches for errors helps you test error handling precisely.

4

Intermediate

Checking exception details with pytest.raises

🤔Before reading on: do you think pytest.raises can check the error message text? Commit to yes or no.

Concept: Learn how to access the caught exception to check its message or attributes.

Pytest.raises returns an object with the caught exception info. You can assign it to a variable like 'excinfo = pytest.raises(...)'. Then, check 'excinfo.value' for the exception instance. For example, assert 'message' in str(excinfo.value) checks the error message contains 'message'.

Result

You can verify not only the error type but also the error message or other details.

Knowing how to inspect the exception object lets you write more precise and meaningful tests.

5

Intermediate

Using pytest.raises as a function call wrapper

🤔Before reading on: can pytest.raises be used as a function call wrapper instead of a context manager? Commit to yes or no.

Concept: Learn the alternative syntax of pytest.raises to test exceptions from function calls.

Besides the 'with' block, pytest.raises can be called like a function: 'pytest.raises(ExpectedError, func, arg1, arg2)'. This runs func(arg1, arg2) and checks if it raises ExpectedError. This is useful for short calls or when you prefer not to use 'with'.

Result

You can choose the syntax style that fits your test code better.

Understanding both syntax forms increases your flexibility in writing clear tests.

6

Advanced

Common pitfalls with pytest.raises usage

🤔Before reading on: do you think code outside the pytest.raises block can cause the test to pass even if the error is not raised? Commit to yes or no.

Concept: Learn mistakes that cause false positives or negatives when asserting exceptions.

A common mistake is putting only part of the code inside pytest.raises, so the error happens outside the block and is not caught. Another is catching too broad exceptions, hiding real bugs. Also, forgetting to check exception messages can miss subtle errors.

Result

You avoid false test passes or misses by correctly scoping code and checking error details.

Knowing these pitfalls helps you write reliable tests that truly verify error handling.

7

Expert

pytest.raises internals and advanced usage

🤔Before reading on: do you think pytest.raises uses Python's try-except internally or a different mechanism? Commit to your answer.

Concept: Explore how pytest.raises works inside and how to customize it for complex tests.

Pytest.raises uses Python's try-except to catch exceptions during the block execution. It records the exception info and provides it to the test. Advanced users can use it with custom matchers to check error messages with regex or subclass exceptions. It integrates with pytest's reporting to show clear failure messages.

Result

You understand the mechanism behind pytest.raises and how to extend it for precise testing.

Understanding the internals lets you debug tricky test failures and write custom exception checks.

Under the Hood

Pytest.raises works by running the code inside a try-except block that catches exceptions of the expected type. If the exception occurs, it stores the exception object and allows the test to inspect it. If no exception or a different one occurs, pytest.raises raises a test failure. This mechanism leverages Python's built-in exception handling but wraps it to integrate with pytest's test runner and reporting.

Why designed this way?

This design uses Python's native exception handling for simplicity and reliability. Wrapping it in a context manager makes tests readable and clear. Alternatives like manual try-except blocks are more verbose and error-prone. Pytest.raises also provides rich failure messages and integrates with pytest's reporting, improving developer experience.

┌─────────────────────────────┐
│ pytest.raises context starts│
├─────────────────────────────┤
│ try:                       │
│   run test code block       │
│ except ExpectedError as e:  │
│   store exception info      │
│ else:                      │
│   raise test failure       │
└─────────────────────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does pytest.raises catch exceptions raised outside its block? Commit to yes or no.

Common Belief: Pytest.raises will catch any exception raised anywhere in the test function.

Reality: Pytest.raises only catches exceptions raised inside its 'with' block or function call; exceptions outside are not caught.

Why it matters: If you put code that raises exceptions outside the block, the test will fail unexpectedly or pass incorrectly, hiding real bugs.

Quick: Can pytest.raises check the content of an exception message by default? Commit to yes or no.

Common Belief: Pytest.raises automatically verifies the exception message matches the expected error type.

Reality: Pytest.raises only checks the exception type by default; checking the message requires extra code using the returned exception info.

Why it matters: Without checking messages, tests may pass even if the error reason is wrong, missing subtle bugs.

Quick: Is it safe to catch very broad exceptions like Exception with pytest.raises? Commit to yes or no.

Common Belief: Catching broad exceptions with pytest.raises is fine and catches all errors you want to test.

Reality: Catching broad exceptions can hide unexpected bugs and make tests less precise; it's better to catch specific exception types.

Why it matters: Broad catches can mask real problems, making debugging harder and reducing test quality.

Quick: Does pytest.raises run the code inside its block immediately or delay execution? Commit to your answer.

Common Belief: Pytest.raises delays running the code until after the test finishes.

Reality: Pytest.raises runs the code inside its block immediately during the test execution to catch exceptions as they happen.

Why it matters: Misunderstanding this can lead to wrong test structure and missed exceptions.

Expert Zone

1

Pytest.raises can be combined with regex matching on exception messages for very precise error validation.

2

Using pytest.raises as a function call wrapper is less common but useful for concise tests without 'with' blocks.

3

Pytest.raises integrates with pytest's rich failure reporting, showing exactly where and why the expected exception was not raised.

When NOT to use

Avoid pytest.raises when you want to test code that should not raise exceptions or when you want to catch exceptions for recovery inside the code. Instead, use normal try-except blocks or pytest's 'recwarn' to check warnings. For asynchronous code, use pytest-asyncio or other async-aware tools.

Production Patterns

In real projects, pytest.raises is used to test input validation, API error handling, and boundary conditions. It is often combined with parameterized tests to check many error cases efficiently. Teams use it to ensure their code fails safely and predictably, preventing crashes or security issues.

Connections

Exception handling in programming

builds-on

Understanding how exceptions work in Python is essential to using pytest.raises effectively, as it relies on catching these errors.

Test-driven development (TDD)

builds-on

Asserting exceptions is a key part of TDD, where you write tests for expected failures before implementing code.

Safety checks in engineering

analogy

Just like safety engineers test emergency brakes to ensure they work under failure, asserting exceptions tests software's ability to handle errors safely.

Common Pitfalls

#1 Placing code that raises exceptions outside the pytest.raises block.

Wrong approach:

def test_error():
faulty_function() # raises error here
with pytest.raises(ValueError):
pass

Correct approach:

def test_error():
with pytest.raises(ValueError):
faulty_function()

Root cause:

Misunderstanding that pytest.raises only catches exceptions inside its block.

#2 Not checking exception message when multiple errors share the same type.

Wrong approach:

with pytest.raises(ValueError):
function_that_raises('wrong input')

Correct approach:

with pytest.raises(ValueError) as excinfo:
function_that_raises('wrong input')
assert 'wrong input' in str(excinfo.value)

Root cause:

Assuming exception type alone is enough to verify correct error cause.

#3 Catching too broad exceptions hiding real bugs.

Wrong approach:

with pytest.raises(Exception):
function_that_might_raise()

Correct approach:

with pytest.raises(SpecificError):
function_that_might_raise()

Root cause:

Not specifying precise exception types reduces test accuracy.

Key Takeaways

Asserting exceptions with pytest.raises lets you confirm your code fails correctly when it should, improving reliability.

Pytest.raises works by running code inside a block and catching expected exceptions immediately during test execution.

You must put the code that raises the error inside the pytest.raises block to catch it properly.

Checking exception messages or attributes makes your tests more precise and meaningful.

Avoid catching broad exceptions to prevent hiding real bugs and maintain test quality.

Practice

1. What is the main purpose of using pytest.raises in a test?

easy

A. To ignore exceptions and continue the test

B. To skip a test when an exception occurs

C. To print the exception message during test execution

D. To check if a specific exception is raised by the code inside the with block

Solution

1. Step 1: Understand the role of pytest.raises

   pytest.raises is used to verify that a certain exception is raised by the code inside its with block.

2. Step 2: Compare options with the purpose

   Only To check if a specific exception is raised by the code inside the with block correctly states that it checks for a specific exception. Other options describe unrelated behaviors.

3. Final Answer:

   To check if a specific exception is raised by the code inside the with block -> Option D

4. Quick Check:

   pytest.raises checks exceptions = A [OK]

Hint: Remember: pytest.raises confirms expected errors happen [OK]

Common Mistakes:

• Thinking pytest.raises skips tests
• Assuming it prints exceptions automatically
• Believing it ignores exceptions

2. Which of the following is the correct syntax to assert that a ValueError is raised when calling func() using pytest.raises?

easy

A. pytest.raises(ValueError, func())

B. with pytest.raises(ValueError): func()

C. with pytest.raises('ValueError'): func()

D. pytest.raises(ValueError): func()

Solution

1. Step 1: Recall correct pytest.raises syntax

   The correct way is to use a with statement with pytest.raises(ExceptionType): followed by the code that should raise the exception.

2. Step 2: Evaluate each option

   with pytest.raises(ValueError): func() uses the correct with block and exception type. pytest.raises(ValueError, func()) calls the function inside the argument, which runs before checking. with pytest.raises('ValueError'): func() uses a string instead of the exception class. pytest.raises(ValueError): func() misses the with keyword.

3. Final Answer:

   with pytest.raises(ValueError): func() -> Option B

4. Quick Check:

   Use with + pytest.raises(Exception): code [OK]

Hint: Always use 'with pytest.raises(Exception):' before the code [OK]

Common Mistakes:

• Calling the function inside pytest.raises() arguments
• Using exception name as string instead of class
• Omitting the 'with' keyword

3. What will be the output of the following test code?

import pytest

def test_zero_division():
    with pytest.raises(ZeroDivisionError) as exc_info:
        1 / 0
    assert 'division by zero' in str(exc_info.value)

medium

A. Test passes because ZeroDivisionError is raised and message matches

B. Test fails because exception message is not checked correctly

C. Test fails because ZeroDivisionError is not raised

D. SyntaxError due to incorrect use of pytest.raises

Solution

1. Step 1: Analyze the code behavior

   The code inside the with pytest.raises(ZeroDivisionError) as exc_info: block raises a ZeroDivisionError by dividing 1 by 0.

2. Step 2: Check the assertion

   The assertion verifies that the exception message contains 'division by zero', which is true for this error.

3. Final Answer:

   Test passes because ZeroDivisionError is raised and message matches -> Option A

4. Quick Check:

   Exception raised and message checked = D [OK]

Hint: Use exc_info.value to check exception message text [OK]

Common Mistakes:

• Not using 'as exc_info' to capture exception details
• Checking wrong exception message text
• Expecting no exception raised

4. Identify the error in this test code snippet:

def test_key_error():
    with pytest.raises(KeyError):
        d = {'a': 1}
        value = d['b']
    assert value == 1

medium

A. The variable 'value' is used outside the with block where it may not be assigned

B. The exception type should be ValueError, not KeyError

C. The dictionary key 'b' exists, so no exception is raised

D. pytest.raises cannot be used with dictionary lookups

Solution

1. Step 1: Understand variable scope and exception flow

   The line value = d['b'] raises a KeyError, so value is never assigned inside the with block.

2. Step 2: Identify the error in assertion

   After the with block, the code tries to assert value == 1, but value is undefined because the assignment never happened due to the exception.

3. Final Answer:

   The variable 'value' is used outside the with block where it may not be assigned -> Option A

4. Quick Check:

   Exception stops assignment, so variable undefined after [OK]

Hint: Don't use variables assigned inside exception blocks outside [OK]

Common Mistakes:

• Assuming variable is assigned despite exception
• Confusing exception types
• Thinking pytest.raises can't handle dict key errors

5. You want to test a function parse_int(s) that should raise ValueError with message containing 'invalid literal' when given a non-integer string. Which pytest code correctly asserts this behavior and checks the error message?

hard

A. with pytest.raises(ValueError):
parse_int('abc')
assert 'invalid literal' in e.value

B. pytest.raises(ValueError, parse_int('abc'))
assert 'invalid literal' in e.value

C. with pytest.raises(ValueError) as e:
parse_int('abc')
assert 'invalid literal' in str(e.value)

D. with pytest.raises('ValueError') as e:
parse_int('abc')
assert 'invalid literal' in str(e.value)

Solution

1. Step 1: Use correct syntax to capture exception info

   Use with pytest.raises(ValueError) as e: to catch the exception and store info in e.

2. Step 2: Check error message properly

   After the block, check if the string 'invalid literal' is in str(e.value). This converts the exception to string for message checking.

3. Step 3: Eliminate incorrect options

   with pytest.raises(ValueError): parse_int('abc') assert 'invalid literal' in e.value tries to use e outside the block without capturing it. pytest.raises(ValueError, parse_int('abc')) assert 'invalid literal' in e.value calls the function inside pytest.raises incorrectly and uses e undefined. with pytest.raises('ValueError') as e: parse_int('abc') assert 'invalid literal' in str(e.value) uses exception name as string instead of class.

4. Final Answer:

   with pytest.raises(ValueError) as e: parse_int('abc') assert 'invalid literal' in str(e.value) -> Option C

5. Quick Check:

   Capture exception with 'as' and check message string [OK]

Hint: Use 'as' to capture exception and check message with str(e.value) [OK]

Common Mistakes:

• Using exception name as string instead of class
• Calling function inside pytest.raises arguments
• Accessing exception info outside 'with' without 'as'