Testing custom exceptions in PyTest - Framework Patterns

Framework Mode - Testing custom exceptions

Folder Structure

tests/
├── test_custom_exceptions.py
├── conftest.py
utils/
├── exceptions.py
├── helpers.py
pytest.ini

Test Framework Layers

• Custom Exceptions Layer: utils/exceptions.py contains user-defined exception classes.
• Helper Utilities Layer: utils/helpers.py has functions that may raise custom exceptions.
• Test Layer: tests/test_custom_exceptions.py contains pytest test functions that verify the custom exceptions are raised correctly.
• Configuration Layer: pytest.ini for pytest settings and conftest.py for fixtures or shared test setup.

Configuration Patterns

• pytest.ini: Configure test markers, addopts for verbosity, and test paths.
• conftest.py: Define fixtures for reusable test data or setup, e.g., objects that trigger exceptions.
• Environment Handling: Use environment variables or pytest command line options to toggle test modes if needed.
• Exception Testing: Use pytest.raises() context manager to assert exceptions are raised as expected.

Test Reporting and CI/CD Integration

• Use pytest's built-in reporting with clear pass/fail output for exception tests.
• Integrate with CI/CD pipelines (GitHub Actions, Jenkins, GitLab CI) to run tests on each commit or pull request.
• Generate HTML or XML reports using pytest plugins like pytest-html or pytest-junitxml for detailed test results.
• Fail fast on exception test failures to catch issues early.

Best Practices

1. Isolate Exception Tests: Write focused tests that only check if the correct custom exception is raised.
2. Use pytest.raises: Always use pytest.raises() context manager for clear and readable exception assertions.
3. Meaningful Exception Messages: Ensure custom exceptions have clear messages to help debugging.
4. Keep Exceptions Simple: Custom exceptions should inherit from Exception or a relevant base and not contain complex logic.
5. Reuse Fixtures: Use fixtures in conftest.py to provide test data or objects that trigger exceptions, avoiding duplication.

Self Check

Where would you add a new custom exception class for handling invalid user input in this framework structure?

Key Result

Organize custom exceptions in a utils folder, test them with pytest.raises in tests, and configure pytest for clear reporting.

Practice

1. What is the main purpose of using pytest.raises() in testing custom exceptions?

easy

A. To check if a specific exception is raised during a function call

B. To skip a test when an exception occurs

C. To automatically fix exceptions in the code

D. To print the exception message to the console

Solution

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

   This function is used to verify that a specific exception is raised when running a block of code.

2. Step 2: Identify the purpose in testing

   It helps confirm that error handling works as expected by catching the intended exception type.

3. Final Answer:

   To check if a specific exception is raised during a function call -> Option A

4. Quick Check:

   pytest.raises() checks exceptions [OK]

Hint: Remember: pytest.raises() tests if code throws an error [OK]

Common Mistakes:

• Thinking pytest.raises() fixes errors
• Using pytest.raises() to skip tests
• Expecting pytest.raises() to print messages

2. Which of the following is the correct syntax to test if a function foo() raises a custom exception MyError using pytest?

easy

A. assert pytest.raises(MyError, foo)

B. pytest.raises(MyError, foo())

C. with pytest.raises(MyError): foo()

D. pytest.check_exception(MyError, foo())

Solution

1. Step 1: Recall pytest.raises() usage

   The correct way is to use it as a context manager with with and call the function inside the block.

2. Step 2: Analyze each option

   with pytest.raises(MyError): foo() uses the context manager correctly. Options B and C misuse the function call or assert. pytest.check_exception(MyError, foo()) uses a non-existent function.

3. Final Answer:

   with pytest.raises(MyError): foo() -> Option C

4. Quick Check:

   Use context manager with pytest.raises() [OK]

Hint: Use 'with pytest.raises(Exception):' before calling function [OK]

Common Mistakes:

• Calling function inside pytest.raises() without 'with'
• Using assert with pytest.raises() incorrectly
• Using non-existent pytest functions

3. Given the code below, what will be the test result?

class MyError(Exception):
    pass

def func():
    raise MyError("Error happened")

def test_func():
    with pytest.raises(MyError) as exc_info:
        func()
    assert str(exc_info.value) == "Error happened"

medium

A. Test raises a syntax error

B. Test fails because the exception type is wrong

C. Test fails because the exception message is incorrect

D. Test passes because the exception and message match

Solution

1. Step 1: Check exception type raised by func()

   func() raises MyError with message "Error happened".

2. Step 2: Verify test assertions

   The test uses pytest.raises(MyError) to catch the exception and asserts the message matches exactly.

3. Final Answer:

   Test passes because the exception and message match -> Option D

4. Quick Check:

   Exception type and message match = pass [OK]

Hint: Match both exception type and message for success [OK]

Common Mistakes:

• Ignoring exception message in assertion
• Catching wrong exception type
• Forgetting to call the function inside the context

4. Identify the error in the following pytest test for a custom exception:

def test_error():
    with pytest.raises(ValueError):
        raise TypeError("Wrong type")

medium

A. The test will pass because any exception is accepted

B. The test will fail because the raised exception type does not match the expected

C. The test has a syntax error due to missing colon

D. The test will raise an error because ValueError is not imported

Solution

1. Step 1: Compare expected and raised exceptions

   The test expects a ValueError but raises a TypeError instead.

2. Step 2: Understand pytest.raises() behavior

   pytest.raises() fails the test if the raised exception type does not match the expected one.

3. Final Answer:

   The test will fail because the raised exception type does not match the expected -> Option B

4. Quick Check:

   Exception type mismatch causes test failure [OK]

Hint: Expected and raised exception types must match exactly [OK]

Common Mistakes:

• Assuming any exception passes the test
• Ignoring exception type differences
• Confusing syntax errors with logic errors

5. You have a custom exception MyError that can be raised with different messages. How can you write a pytest test that checks the exception is raised and the message contains the word "timeout" regardless of other text?

hard

A. Use with pytest.raises(MyError, match="timeout"): to match substring

B. Use with pytest.raises(MyError) as e: then assert str(e.value) == "timeout"

C. Use assertRaises(MyError, "timeout") to check message

D. Use pytest.raises(MyError, message_contains="timeout")

Solution

1. Step 1: Recall pytest.raises() match parameter

   pytest.raises() accepts a match argument to check if the exception message matches a regex or substring.

2. Step 2: Compare options for message checking

   with pytest.raises(MyError, match="timeout"): correctly uses the match parameter to verify the message contains "timeout". with pytest.raises(MyError) as e: followed by assert str(e.value) == "timeout" only checks for exact match, failing if there is extra text. Options C and D use invalid syntax.

3. Final Answer:

   Use with pytest.raises(MyError, match="timeout"): -> Option A

4. Quick Check:

   Use match parameter to check message substring [OK]

Hint: Use pytest.raises(..., match="text") to check message content [OK]

Common Mistakes:

• Using exact match instead of substring check for the message
• Using non-existent pytest.raises() parameters
• Not checking message content at all