在 Python Django 中运行单元测试时如何禁用日志记录？

Question

我正在使用基于简单单元测试的测试运行器来测试我的 Django 应用程序。

我的应用程序本身配置为在 settings.py 中使用基本记录器，使用：

logging.basicConfig(level=logging.DEBUG)

在我的应用程序代码中使用：

logger = logging.getLogger(__name__)
logger.setLevel(getattr(settings, 'LOG_LEVEL', logging.DEBUG))

但是，在运行单元测试时，我想禁用日志记录，以便它不会扰乱我的测试结果输出。有没有一种简单的方法可以以全局方式关闭日志记录，以便应用程序特定的记录器在我运行测试时不会将内容写入控制台？

Answer 1

logging.disable(logging.CRITICAL)

将禁用严重程度低于或等于 CRITICAL 的所有日志记录调用。可以使用以下命令重新启用日志记录

logging.disable(logging.NOTSET)

Answer 2

由于您使用的是 Django，因此您可以将这些行添加到您的 settings.py 中：

import sys
import logging

if len(sys.argv) > 1 and sys.argv[1] == 'test':
    logging.disable(logging.CRITICAL)

这样您就不必在测试中的每个 setUp() 中添加该行。

您还可以通过这种方式根据您的测试需求进行一些方便的更改。

还有另一种“更好”或“更干净”的方法可以为您的测试添加细节，那就是创建您自己的测试运行程序。

只需创建一个如下所示的类：

import logging

from django.test.simple import DjangoTestSuiteRunner
from django.conf import settings

class MyOwnTestRunner(DjangoTestSuiteRunner):
    def run_tests(self, test_labels, extra_tests=None, **kwargs):

        # Don't show logging messages while testing
        logging.disable(logging.CRITICAL)

        return super(MyOwnTestRunner, self).run_tests(test_labels, extra_tests, **kwargs)

现在添加到您的 settings.py 文件中：

TEST_RUNNER = "PATH.TO.PYFILE.MyOwnTestRunner"
#(for example, 'utils.mytest_runner.MyOwnTestRunner')

这可以让您进行一项非常方便的修改，而其他方法则无法做到这一点，即让 Django 只测试您想要的应用程序。您可以通过更改 test_labels 并将此行添加到测试运行器来做到这一点：

if not test_labels:
    test_labels = ['my_app1', 'my_app2', ...]

Answer 3

有没有一种简单的方法可以以全局方式关闭日志记录，以便应用程序特定的记录器在我运行测试时不会将内容写入控制台？

其他答案通过全局设置日志记录基础设施以忽略任何内容来防止“将内容写入控制台”。这可行，但我发现这种方法太生硬了。我的方法是执行配置更改，该更改仅执行防止日志在控制台上泄露所需的操作。因此，我将 自定义日志记录过滤器 添加到我的 设置中.py：

from logging import Filter

class NotInTestingFilter(Filter):

    def filter(self, record):
        # Although I normally just put this class in the settings.py
        # file, I have my reasons to load settings here. In many
        # cases, you could skip the import and just read the setting
        # from the local symbol space.
        from django.conf import settings

        # TESTING_MODE is some settings variable that tells my code
        # whether the code is running in a testing environment or
        # not. Any test runner I use will load the Django code in a
        # way that makes it True.
        return not settings.TESTING_MODE

我配置 Django记录以使用过滤器：

LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'filters': {
        'testing': {
            '()': NotInTestingFilter
        }
    },
    'formatters': {
        'verbose': {
            'format': ('%(levelname)s %(asctime)s %(module)s '
                       '%(process)d %(thread)d %(message)s')
        },
    },
    'handlers': {
        'console': {
            'level': 'DEBUG',
            'class': 'logging.StreamHandler',
            'filters': ['testing'],
            'formatter': 'verbose'
        },
    },
    'loggers': {
        'foo': {
            'handlers': ['console'],
            'level': 'DEBUG',
            'propagate': True,
        },
    }
}

最终结果：当我测试时，没有任何内容发送到控制台，但其他一切都保持不变。

为什么要这样做？

我设计的代码包含仅在特定情况下触发的日志记录指令，并且在出现问题时应该输出诊断所需的准确数据。因此，我测试他们做了他们应该做的事情，因此完全禁用日志记录对我来说是不可行的。我不想在软件投入生产后发现我认为会记录的内容没有被记录。

此外，一些测试运行器（例如Nose）会在测试期间捕获日志，并将日志的相关部分与测试失败一起输出。它对于找出测试失败的原因很有用。如果日志记录完全关闭，则无法捕获任何内容。

Answer 4

我喜欢 Hassek 的自定义测试运行器想法。需要注意的是，DjangoTestSuiteRunner 不再是 Django 1.6+ 中的默认测试运行器，它已被 DiscoverRunner 取代。对于默认行为，测试运行程序应该更像：

import logging

from django.test.runner import DiscoverRunner

class NoLoggingTestRunner(DiscoverRunner):
    def run_tests(self, test_labels, extra_tests=None, **kwargs):

        # disable logging below CRITICAL while testing
        logging.disable(logging.CRITICAL)

        return super(NoLoggingTestRunner, self).run_tests(test_labels, extra_tests, **kwargs)

Answer 5

我发现，对于 unittest 或类似框架中的测试，安全禁用单元测试中不需要的日志记录的最有效方法是在 setUp/<特定测试用例的 code>tearDown 方法。这可以让我们专门针对应禁用日志的位置。您还可以在您正在测试的类的记录器上明确执行此操作。

import unittest
import logging

class TestMyUnitTest(unittest.TestCase):
    def setUp(self):
        logging.disable(logging.CRITICAL)

    def tearDown(self):
        logging.disable(logging.NOTSET)

Answer 6

我正在使用一个简单的方法装饰器来仅在特定的测试方法中禁用日志记录。

def disable_logging(f):

    def wrapper(*args):
        logging.disable(logging.CRITICAL)
        result = f(*args)
        logging.disable(logging.NOTSET)

        return result

    return wrapper

然后我按照以下示例使用它：

class ScenarioTestCase(TestCase):

    @disable_logging
    test_scenario(self):
        pass

Answer 7

有一些漂亮且干净的方法可以使用 unittest.mock.patch 方法暂停测试中的日志记录。

foo.py：

import logging


logger = logging.getLogger(__name__)

def bar():
    logger.error('There is some error output here!')
    return True

测试.py：

from unittest import mock, TestCase
from foo import bar


class FooBarTestCase(TestCase):
    @mock.patch('foo.logger', mock.Mock())
    def test_bar(self):
        self.assertTrue(bar())

并且 python3 -m unittest 测试将不会产生任何日志输出。

Answer 8

有时您需要日志，有时则不需要。我的 settings.py 中有此代码，

import sys

if '--no-logs' in sys.argv:
    print('> Disabling logging levels of CRITICAL and below.')
    sys.argv.remove('--no-logs')
    logging.disable(logging.CRITICAL)

因此，如果您使用 --no-logs 选项运行测试，您将仅获得关键 日志：

$ python ./manage.py tests --no-logs
> Disabling logging levels of CRITICAL and below.

如果您想加快持续集成流程的测试速度，这将非常有帮助。

Answer 9

如果我希望暂时抑制特定的记录器，我已经编写了一个我发现有用的小上下文管理器：

from contextlib import contextmanager
import logging

@contextmanager
def disable_logger(name):
    """Temporarily disable a specific logger."""
    logger = logging.getLogger(name)
    old_value = logger.disabled
    logger.disabled = True
    try:
        yield
    finally:
        logger.disabled = old_value

然后您可以像这样使用它：

class MyTestCase(TestCase):
    def test_something(self):
        with disable_logger('<logger name>'):
            # code that causes the logger to fire

这具有重新启用记录器（或设置回其状态）的优点之前的状态）一旦 with 完成。

Answer 10

禁用整个模块的日志记录：

import logging


def setUpModule():
    """Disable logging while doing these tests."""
    logging.disable()


def tearDownModule():
    """Re-enable logging after doing these tests."""
    logging.disable(logging.NOTSET)


class TestFoo(unittest.TestCase):

    def test_foo(self):
        pass

Answer 11

如果您使用的是 pytest：

由于 pytest 捕获日志消息并且仅在失败的测试中显示它们，因此您通常不想禁用任何日志记录。相反，使用单独的 settings.py 文件进行测试（例如，test_settings.py），并向其中添加：

LOGGING_CONFIG = None

这告诉 Django 完全跳过配置日志记录。 LOGGING 设置将被忽略，并且可以从设置中删除。

使用这种方法，您不会获得通过的测试的任何日志记录，并且会获得失败的测试的所有可用日志记录。

测试将使用 pytest 设置的日志记录运行。可以根据您的喜好在 pytest 设置中对其进行配置（例如，tox.ini）。要包含调试级别日志消息，请使用 log_level = DEBUG （或相应的命令行参数）。

Answer 12

您可以将其放在单元测试 __init__.py 文件的顶级目录中。这将在单元测试套件中全局禁用日志记录。

# tests/unit/__init__.py
import logging

logging.disable(logging.CRITICAL)

Answer 13

我的一些测试包含有关日志输出的断言，因此更改日志级别会破坏它们。相反，我更改了 Django LOGGING 设置以使用

if 'test' in sys.argv:
    _LOG_HANDLERS = ['null']
else:
    _LOG_HANDLERS = ['console']
    
LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'simple': {
            'format': '%(levelname)s %(message)s'
        },
    },
    'handlers': {
        'null': {
            'level': 'DEBUG',
            'class': 'logging.NullHandler',
        },
        'console': {
            'level': 'DEBUG',
            'class': 'logging.StreamHandler',
            'formatter': 'simple',
        },
    },
    'loggers': {
        'django': {
            'handlers': _LOG_HANDLERS,
            'propagate': True,
            'level': 'INFO',
        },
    }
}

Answer 14

如果您不希望在单元测试的 setUp() 和 TeaDown() 中重复打开/关闭它（看不到原因），您可以每个类执行一次：

    import unittest
    import logging

    class TestMyUnitTest(unittest.TestCase):
        @classmethod
        def setUpClass(cls):
            logging.disable(logging.CRITICAL)
        @classmethod
        def tearDownClass(cls):
            logging.disable(logging.NOTSET)

Answer 15

bh

对我来说效果很好 - 在 conftest.py 中：

 import confing
 # disable logging for tests
 [logging.disable(level) for level in [logging.DEBUG,
                                       logging.INFO,
                                       logging.ERROR,
                                       logging.CRITICAL]]

Answer 16

就我而言，我有一个专门为测试目的创建的设置文件 settings/test.py ，如下所示：

from .base import *

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': 'test_db'
    }
}

PASSWORD_HASHERS = (
    'django.contrib.auth.hashers.MD5PasswordHasher',
)

LOGGING = {}

我将一个环境变量 DJANGO_SETTINGS_MODULE=settings.test 添加到/etc/environment。

Answer 17

如果您有不同的初始化程序模块用于测试、开发和生产，那么您可以禁用任何内容或在初始化程序中重定向它。我有 local.py、test.py 和 production.py，它们都继承自 common.y

common.py 执行所有主要配置，包括此代码片段：

LOGGING = {
'version': 1,
'disable_existing_loggers': False,
'formatters': {
    'django.server': {
        '()': 'django.utils.log.ServerFormatter',
        'format': '[%(server_time)s] %(message)s',
    },
    'verbose': {
        'format': '%(levelname)s %(asctime)s %(module)s %(process)d %(thread)d %(message)s'
    },
    'simple': {
        'format': '%(levelname)s %(message)s'
    },
},
'filters': {
    'require_debug_true': {
        '()': 'django.utils.log.RequireDebugTrue',
    },
},
'handlers': {
    'django.server': {
        'level': 'INFO',
        'class': 'logging.StreamHandler',
        'formatter': 'django.server',
    },
    'console': {
        'level': 'DEBUG',
        'class': 'logging.StreamHandler',
        'formatter': 'simple'
    },
    'mail_admins': {
        'level': 'ERROR',
        'class': 'django.utils.log.AdminEmailHandler'
    }
},
'loggers': {
    'django': {
        'handlers': ['console'],
        'level': 'INFO',
        'propagate': True,
    },
    'celery.tasks': {
        'handlers': ['console'],
        'level': 'DEBUG',
        'propagate': True,
    },
    'django.server': {
        'handlers': ['django.server'],
        'level': 'INFO',
        'propagate': False,
    },
}

然后在 test.py 中我有这个：

console_logger = Common.LOGGING.get('handlers').get('console')
console_logger['class'] = 'logging.FileHandler
console_logger['filename'] = './unitest.log

这用 FileHandler 替换了控制台处理程序，并且意味着仍然可以进行日志记录，但我不必接触生产代码库。

Answer 18

如果您使用 pytest，您可以安装超级有用的 pytest-mock 插件并定义一个自动使用的、会话范围内的固定装置，可以由环境变量触发：

# conftest.py

import os
import pytest


@pytest.fixture(autouse=True, scope="session")
def _shut_logger(session_mocker):
    if os.getenv("SHUT_LOGGER", None):
        return session_mocker.patch("foo.logger")

Answer 19

我们使用structlog，禁用它有点复杂：

from structlog import DropEvent

def disable_logging_in_tests(_, __, event_dict):
    if len(sys.argv) > 1 and sys.argv[1] == 'test':
        raise DropEvent
    return event_dict


structlog.configure(
    processors=[
        ...
        disable_logging_in_tests,
    ]
    ...

)

Answer 20

"""Module for custom test runner."""

import logging

from django.conf import settings
from django.test.runner import DiscoverRunner


class FastTestRunner(DiscoverRunner):
    """Custom Django test runner to speed up the test suite."""

    def setup_test_environment(self):
        """Override the setup_test_environment method to customize the test environment.

        This method is called before the test suite runs and is used to set up any necessary configurations.

        In this custom runner, we disable file writes during tests by changing the default storage backend
        to use Django's InMemoryStorage, which does not write files to the filesystem. Additionally, we
        use a faster password hasher (MD5) to speed up test cases involving user authentication.
        """
        super().setup_test_environment()

        # Disable file writes during tests by using Django's FileSystemStorage
        settings.STORAGES = {"default": {"BACKEND": "django.core.files.storage.InMemoryStorage"}}

        # Use a faster password hasher (MD5) to speed up test cases involving user authentication
        settings.PASSWORD_HASHERS = ("django.contrib.auth.hashers.MD5PasswordHasher",)

        # disable logging below CRITICAL while testing
        logging.disable(logging.CRITICAL)

Answer 21

如果您在 2021 年或以后想知道这个问题，您可能会问错问题

在现代版本的 Django* 上，使用开箱即用的配置，测试不应在屏幕上生成任何日志记录。因此，如果您问这个问题，真正的答案可能是“某些内容配置错误”。这是因为（默认情况下）：

• 打印日志消息控制台要求 debug 为 True
• 测试使用 DEBUG=False 运行

因此，如果您使用的记录器与您在 LOGGING['loggers'] 中定义的记录器匹配并由 处理>“console” 处理程序，测试不应在屏幕上生成任何日志记录。

如果您在测试中看到某些内容，则

• 说明您的记录器名称与您在 settings.LOGGING 中定义的内容不匹配，
• 正在使用 DEBUG=True 运行测试（需要覆盖）
• 已从控制台处理程序的过滤器中删除了“require_debug_true”。

*现代版本含义：2.1 及更高版本，即不是古代的。