Testing multiple exceptions in PyTest - Build an Automation Script

Verify function raises correct exceptions for invalid inputs

Preconditions (2)

Step 1: Call 'process_input' with input that should raise ValueError

Step 2: Verify that ValueError is raised

Step 3: Call 'process_input' with input that should raise TypeError

Step 4: Verify that TypeError is raised

Step 5: Call 'process_input' with input that should raise KeyError

Step 6: Verify that KeyError is raised

✅ Expected Result: The function raises the expected exceptions for each invalid input

Automation Requirements - pytest

Assertions Needed:

Assert that ValueError is raised for invalid value input

Assert that TypeError is raised for invalid type input

Assert that KeyError is raised for missing key input

Best Practices:

Use pytest.raises context manager for exception testing

Write separate test functions or parameterize tests for clarity

Keep test code simple and readable

Automated Solution

PyTest

import pytest

# Example function to test

def process_input(data):
    if not isinstance(data, dict):
        raise TypeError("Input must be a dictionary")
    if 'key' not in data:
        raise KeyError("Missing 'key' in input")
    value = data['key']
    if value < 0:
        raise ValueError("Value must be non-negative")
    return value * 2


def test_process_input_raises_value_error():
    with pytest.raises(ValueError) as exc_info:
        process_input({'key': -1})
    assert str(exc_info.value) == "Value must be non-negative"


def test_process_input_raises_type_error():
    with pytest.raises(TypeError) as exc_info:
        process_input(['not', 'a', 'dict'])
    assert str(exc_info.value) == "Input must be a dictionary"


def test_process_input_raises_key_error():
    with pytest.raises(KeyError) as exc_info:
        process_input({'wrong_key': 10})
    assert str(exc_info.value) == "'Missing \'key\' in input'" or str(exc_info.value) == "'key'"

The code defines a sample function process_input that raises different exceptions based on input.

Each test function uses pytest.raises as a context manager to check for the expected exception.

Assertions check the exception message to ensure the correct error was raised.

This approach keeps tests clear and focused on one exception each, following best practices.

Common Mistakes - 3 Pitfalls

Not using pytest.raises and instead using try-except blocks manually

Catching too broad exceptions or multiple exceptions in one test without clarity

Not asserting the exception message

Bonus Challenge

Now add data-driven testing with 3 different invalid inputs to check all exceptions in one parameterized test

Show Hint

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