In real-world Python programs, you may want to track when exceptions occur within a specific part of your code. Context managers make this process simple and consistent. By creating a custom context manager that logs exceptions, you can ensure that important errors are always noticed, even if you want the exception to continue propagating after being logged. This challenge will give you hands-on practice with the context management protocol and exception handling.


import unittest
import user_code
import ast
import re   
import unittest
import importlib
import io
from contextlib import redirect_stdout

class TestTask(unittest.TestCase):
    def test_no_exception_prints_nothing(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            with user_code.ExceptionLogger():
                x = 1 + 1
        output = normalize_text(f.getvalue())
        _dynamic_test(
            self,
            output.strip() == '',
            "No output when no exception occurs.",
            f"Expected no output, got: '{output}'",
        )

    def test_exception_prints_correct_message(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        try:
            with redirect_stdout(f):
                with user_code.ExceptionLogger():
                    raise ValueError("Test error")
        except ValueError:
            pass
        output = normalize_text(f.getvalue())
        expected = normalize_text("Exception caught: ValueError: Test error")
        _dynamic_test(
            self,
            expected in output,
            f"Prints correct exception message: {expected}",
            f"Expected output: '{expected}' not found in: '{output}'",
        )

    def test_exception_is_not_suppressed(self):
        import user_code
        importlib.reload(user_code)
        try:
            with user_code.ExceptionLogger():
                raise KeyError("Missing key!")
        except KeyError as e:
            _dynamic_test(
                self,
                str(e) == "'Missing key!'",
                "Exception is not suppressed and propagates.",
                f"Expected exception to propagate with message 'Missing key!', got: '{e}'",
            )
        else:
            _dynamic_test(
                self,
                False,
                "",
                "Exception was suppressed, but should have propagated.",
            )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\s{2,}", " ", text)
    text = re.sub(r"\s*([,:?])\s*", r"\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    for i, node in enumerate(tree.body):
        if isinstance(node, ast.Assign):
            for target in node.targets:
                if isinstance(target, ast.Name) and target.id == var_name:
                    start_line = node.lineno - 1
                    line = lines[start_line]
                    indent = ' ' * (len(line) - len(line.lstrip()))
                    lines[start_line] = f"{indent}{var_name} = {value}"
                    next_line = len(lines)
                    for next_node in tree.body[i+1:]:
                        if hasattr(next_node, 'lineno'):
                            next_line = next_node.lineno - 1
                            break
                    if next_line > start_line + 1:
                        lines[start_line+1:next_line] = []
                    
                    return '\\n'.join(lines)
    return code

if __name__ == "__main__":
    unittest.main()


test_main.py

Master the art of resource management in Python by learning how to use and create context managers. This course covers the underlying protocol, practical applications, and advanced techniques for robust and efficient code.

Explore the fundamentals of context managers, their protocol, and how they simplify resource management in Python.

Delve into creating your own context managers using both classes and generator functions.

Solidify your understanding by tackling practical tasks that require context managers in various scenarios.

Challenge: Exception Logging Context Manager

Oplossing

Awesome!

Challenge: Exception Logging Context Manager

Oplossing