如果你正在使用pytest，你可以安装超级有用的pytest-mock插件，并定义一个自动使用的会话范围的fixture，可以由env var触发:

# 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")

有没有一种简单的方法以全局方式关闭日志记录，这样当我运行测试时，特定于应用程序的日志记录器就不会把东西写到控制台了?

其他答案通过全局设置日志基础设施以忽略任何内容来防止“将内容写入控制台”。这是可行的，但我觉得这种方法太生硬了。我的方法是执行配置更改，只做防止日志泄漏到控制台上所需的事情。所以我在settings.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)将在测试期间捕获日志，并将日志的相关部分与测试失败一起输出。它有助于找出测试失败的原因。如果日志记录完全关闭，那么就无法捕获任何东西。

如果你有不同的初始化器模块用于测试，开发和生产，那么你可以禁用任何东西或重定向初始化器。我有local。py, test。py和production。py，它们都继承自common。y

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，这意味着仍然可以获得日志记录，但我不必触及生产代码库。

我喜欢Hassek的自定义测试运行器的想法。值得注意的是，Django testsuiterunner不再是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)

在我希望暂时抑制特定记录器的情况下，我写了一个我发现有用的小上下文管理器:

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操作完成，记录器将被重新启用(或设置回其先前的状态)。

使用unittest.mock.patch方法有一些漂亮而干净的方法来暂停测试中的登录。

foo.py:

import logging


logger = logging.getLogger(__name__)

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

tests.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测试将不会产生日志输出。