Why Testing multiple exceptions in PyTest? - Purpose & Use Cases

The Big Idea

What if you could catch all your code's error problems with just one neat test?

The Scenario

Imagine you have a function that can fail in several ways, like dividing by zero or accessing a missing file. You try to test each error by running the function and watching closely for crashes.

The Problem

Manually checking each error means running the function many times, guessing which error might happen, and writing repeated code. It's slow, easy to miss errors, and hard to keep track of all possible failures.

The Solution

Testing multiple exceptions with pytest lets you write simple, clear tests that check many error cases at once. You can tell pytest to expect different errors in one place, so your tests stay neat and catch all problems reliably.

Before vs After

✗ Before

try:
    func()
except ZeroDivisionError:
    pass
try:
    func()
except FileNotFoundError:
    pass

✓ After

import pytest

@pytest.mark.parametrize('error', [ZeroDivisionError, FileNotFoundError])
def test_errors(error):
    with pytest.raises(error):
        func()

What It Enables

This approach makes testing many error cases fast, clear, and less error-prone, so you can trust your code works well in all bad situations.

Real Life Example

When building a calculator app, you want to test that dividing by zero or entering invalid input both raise the right errors without writing separate tests for each.

Key Takeaways

Manual error testing is slow and repetitive.

pytest lets you test many exceptions in one simple test.

This saves time and improves test coverage.

Practice

1. What does pytest.raises((ValueError, TypeError)) do in a test?

easy

A. It passes if either ValueError or TypeError is raised during the test.

B. It passes only if both ValueError and TypeError are raised together.

C. It fails if any exception is raised during the test.

D. It ignores exceptions and always passes the test.

Solution

1. Step 1: Understand pytest.raises with tuple

   Using a tuple inside pytest.raises means the test expects any one of those exceptions.

2. Step 2: Effect on test pass/fail

   If the code raises either ValueError or TypeError, the test passes. If no exception or a different exception is raised, it fails.

3. Final Answer:

   It passes if either ValueError or TypeError is raised during the test. -> Option A

4. Quick Check:

   pytest.raises with tuple = any exception in tuple passes [OK]

Hint: Tuple in pytest.raises means any listed exception passes [OK]

Common Mistakes:

• Thinking both exceptions must be raised simultaneously
• Assuming it passes without exceptions
• Confusing tuple with multiple separate pytest.raises calls

2. Which of the following is the correct syntax to test for multiple exceptions in pytest?

easy

A. with pytest.raises{ValueError, TypeError}:

B. with pytest.raises(ValueError, TypeError):

C. with pytest.raises([ValueError, TypeError]):

D. with pytest.raises((ValueError, TypeError)):

Solution

1. Step 1: Recall pytest.raises syntax

   pytest.raises expects a single exception or a tuple of exceptions inside parentheses.

2. Step 2: Identify correct tuple syntax

   Only with pytest.raises((ValueError, TypeError)): uses a tuple (parentheses with comma-separated exceptions) correctly.

3. Final Answer:

   with pytest.raises((ValueError, TypeError)): -> Option D

4. Quick Check:

   Tuple syntax with parentheses and comma = correct [OK]

Hint: Use parentheses and comma for multiple exceptions in pytest.raises [OK]

Common Mistakes:

• Using multiple arguments without tuple
• Using list brackets instead of tuple
• Using curly braces which are invalid syntax

3. What will be the result of this pytest test?

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

medium

A. Test fails due to syntax error.

B. Test passes because KeyError is raised.

C. Test passes because IndexError is raised.

D. Test fails because no exception is raised.

Solution

1. Step 1: Identify exception raised by d['b']

   Accessing a missing key in a dictionary raises KeyError.

2. Step 2: Check if KeyError is in the tuple

   KeyError is in (KeyError, IndexError), so pytest.raises expects it and test passes.

3. Final Answer:

   Test passes because KeyError is raised. -> Option B

4. Quick Check:

   Missing dict key = KeyError, in tuple = pass [OK]

Hint: Missing dict key raises KeyError, matches tuple exceptions [OK]

Common Mistakes:

• Thinking IndexError is raised instead
• Assuming no exception is raised
• Confusing KeyError with ValueError

4. What will be the result of this pytest test?

def test_divide():
    with pytest.raises((ZeroDivisionError, ValueError)):
        result = 10 / 0
        int('abc')

medium

A. The test will pass because ZeroDivisionError is raised first.

B. The test will fail because the second line after exception is unreachable.

C. The test will fail because only ZeroDivisionError is raised, not ValueError.

D. The test will fail due to syntax error in pytest.raises.

Solution

1. Step 1: Analyze exception flow in with block

   ZeroDivisionError occurs at 10 / 0, so the next line int('abc') is never executed.

2. Step 2: Understand pytest.raises behavior

   ZeroDivisionError is in the expected tuple, so test passes. ValueError is unreachable.

3. Step 3: Confirm test outcome

   Since a matching exception (ZeroDivisionError) is raised first, the test passes.

4. Final Answer:

   The test will pass because ZeroDivisionError is raised first. -> Option A

5. Quick Check:

   Exception stops code, later lines unreachable; matching exc = pass [OK]

Hint: Exception stops code; lines after are not run [OK]

Common Mistakes:

• Thinking both exceptions must be raised simultaneously
• Thinking test fails due to syntax
• Ignoring unreachable code after exception

5. You want to test a function that can raise either IndexError or KeyError depending on input. Which pytest test code correctly checks both exceptions in one test?

hard

A. def test_func():
with pytest.raises(IndexError, KeyError):
func_that_raises()

B. def test_func():
with pytest.raises([IndexError, KeyError]):
func_that_raises()

C. def test_func():
with pytest.raises((IndexError, KeyError)):
func_that_raises()

D. def test_func():
with pytest.raises({IndexError, KeyError}):
func_that_raises()

Solution

1. Step 1: Recall correct syntax for multiple exceptions

   pytest.raises expects a tuple of exceptions to check multiple exceptions in one block.

2. Step 2: Identify correct tuple usage

   def test_func(): with pytest.raises((IndexError, KeyError)): func_that_raises() uses a tuple (parentheses with comma-separated exceptions), which is correct syntax.

3. Step 3: Check other options

   Options A, B, and D use invalid syntax: multiple arguments without tuple, list, or set instead of tuple.

4. Final Answer:

   def test_func(): with pytest.raises((IndexError, KeyError)): func_that_raises() -> Option C

5. Quick Check:

   Tuple of exceptions in pytest.raises = correct [OK]

Hint: Use tuple (parentheses, commas) for multiple exceptions in pytest.raises [OK]

Common Mistakes:

• Passing exceptions as separate arguments
• Using list or set instead of tuple
• Forgetting parentheses around exceptions