Managing Django Request Logging During Tests

Based on the Django logging documentation, there are a few approaches you can take to handle verbose django.request logging during test runs without modifying your global logging settings.

Option 1: Use a Context Manager to Temporarily Silence Loggers

You can create a custom context manager that temporarily modifies the logging level for specific loggers during test execution:

PYTHONCopied
import logging
from contextlib import contextmanager

@contextmanager
def silence_logger(logger_name, level=logging.CRITICAL):
    """Temporarily increase the log level of a specific logger."""
    logger = logging.getLogger(logger_name)
    original_level = logger.level
    logger.setLevel(level)
    try:
        yield
    finally:
        logger.setLevel(original_level)

# Usage in tests
def test_expected_error():
    with silence_logger("django.request"):
        response = self.client.get("/some-url/")
    self.assertContains(response, "needle", status=HTTPStatus.BAD_REQUEST)

Option 2: Use Python's unittest.mock to Patch the Logger

You can temporarily patch the logger during specific test cases:

PYTHONCopied
from unittest.mock import patch

def test_expected_error():
    with patch("django.utils.log.request_logger.error") as mock_error:
        response = self.client.get("/some-url/")
        self.assertContains(response, "needle", status=HTTPStatus.BAD_REQUEST)

Option 3: Create a Custom Filter for Test Environments

You could implement a custom filter that conditionally allows log messages based on test context:

PYTHONCopied
class TestAwareFilter(logging.Filter):
    def filter(self, record):
        # Implement logic to determine if this is an expected error in a test
        # For example, check thread-local storage for a flag set by your tests
        from threading import local
        thread_local = local()
        return not getattr(thread_local, 'suppress_expected_errors', False)

# Then in your test:
from threading import local
thread_local = local()

def test_expected_error():
    thread_local.suppress_expected_errors = True
    try:
        response = self.client.get("/some-url/")
        self.assertContains(response, "needle", status=HTTPStatus.BAD_REQUEST)
    finally:
        thread_local.suppress_expected_errors = False

Option 4: Use Environment Variables for Test-Specific Logging

As shown in the Django documentation, you can use environment variables to control logging levels dynamically:

PYTHONCopied
# In your test setup
import os
os.environ["DJANGO_LOG_LEVEL"] = "ERROR"  # Only show errors and above

# Then in your settings.py
"level": os.getenv("DJANGO_LOG_LEVEL", "WARNING")

# Reset after tests if needed
def tearDown(self):
    os.environ.pop("DJANGO_LOG_LEVEL", None)

The most straightforward approach is likely Option 1, as it provides a clean way to temporarily silence specific loggers only during the execution of expected error tests, without affecting the rest of your test suite or application logging.