blocks|key|973681|text|logging.disable(logging.CRITICAL)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|973682|将禁用所有级别低于或等于CRITICAL的日志记录调用。可以使用以下命令重新启用日志记录|unstyled|offset|length|style|CODE|973683|logging.disable(logging.NOTSET)|973684|entityMap^0|0|C|8|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|P|8|@$G|Q|H|R|I|J]]|9|@]|A|$]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$B|C]]|$1|M|3|-4|5|F|7|T|8|@]|9|@]|A|$]]]|N|$]]

<pre><code>logging.disable(logging.CRITICAL)
</code></pre>

will disable all logging calls with levels less severe than or equal to <code>CRITICAL</code>. Logging can be re-enabled with

<pre><code>logging.disable(logging.NOTSET)
</code></pre>

blocks|key|758197|text|由于您使用的是Django，因此可以将以下代码行添加到settings.py：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|758198|import+sys
import+logging

if+len(sys.argv)+>+1+and+sys.argv[1]+==+'test':
++++logging.disable(logging.CRITICAL)|code-block|syntax|javascript|758199|这样，您就不必在测试的每个setUp()中都添加这一行。|offset|length|style|CODE|758200|您还可以通过这种方式为您的测试需求做一些方便的更改。|758201|还有另一种“更好”或“更干净”的方法来给你的测试添加细节，那就是制作你自己的测试跑步器。|758202|只需像这样创建一个类：|758203|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)|758204|现在添加到您的settings.py文件中：|758205|TEST_RUNNER+=+"PATH.TO.PYFILE.MyOwnTestRunner"
#(for+example,+'utils.mytest_runner.MyOwnTestRunner')|758206|这让您可以做一个非常方便的修改，这是另一种方法没有的，那就是让Django只测试您想要的应用程序。您可以通过更改test_labels，将以下代码行添加到测试运行器来完成此操作：|758207|if+not+test_labels:
++++test_labels+=+['my_app1',+'my_app2',+...]|758208|entityMap^0|0|0|D|7|0|0|0|0|0|0|0|1K|B|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|16|8|@$I|17|J|18|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|19|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1A|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1B|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|1C|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|1D|8|@]|9|@]|A|$]]|$1|W|3|X|5|D|7|1E|8|@]|9|@]|A|$E|F]]|$1|Y|3|Z|5|6|7|1F|8|@$I|1G|J|1H|K|L]]|9|@]|A|$]]|$1|10|3|11|5|D|7|1I|8|@]|9|@]|A|$E|F]]|$1|12|3|-4|5|6|7|1J|8|@]|9|@]|A|$]]]|13|$]]

Since you are in Django, you could add these lines to your settings.py:

<pre><code>import sys
import logging

if len(sys.argv) &gt; 1 and sys.argv[1] == 'test':
 logging.disable(logging.CRITICAL)
</code></pre>

That way you don't have to add that line in every <code>setUp()</code> on your tests.

You could also do a couple of handy changes for your test needs this way.

There is another "nicer" or "cleaner" way to add specifics to your tests and that is making your own test runner.

Just create a class like this:

<pre><code>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)
</code></pre>

And now add to your settings.py file:

<pre><code>TEST_RUNNER = "PATH.TO.PYFILE.MyOwnTestRunner"
#(for example, 'utils.mytest_runner.MyOwnTestRunner')
</code></pre>

This lets you do one really handy modification that the other approach doesn't, which is to make Django just tests the applications that you want. You can do that by changing the <code>test_labels</code> adding this line to the test runner:

<pre><code>if not test_labels:
 test_labels = ['my_app1', 'my_app2', ...]
</code></pre>

blocks|key|758259|text|我喜欢Hassek的自定义测试运行器的想法。应该注意的是，DjangoTestSuiteRunner不再是Django+1.6%2B中的默认测试运行器，它已经被DiscoverRunner所取代。对于默认行为，测试运行器应该更像这样：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|758260|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)|code-block|syntax|javascript|758261|entityMap^0|T|L|26|E|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

I like Hassek's custom test runner idea. It should be noted that <code>DjangoTestSuiteRunner</code> is no longer the default test runner in Django 1.6+, it has been replaced by the <code>DiscoverRunner</code>. For default behaviour, the test runner should be more like:

<pre><code>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)
</code></pre>

blocks|key|973896|text|在我的例子中，我有一个专门为测试目的创建的设置文件settings/test.py，如下所示：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|973897|from+.base+import+*

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

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

LOGGING+=+{}|code-block|syntax|javascript|973898|我在/etc/environment中设置了一个环境变量DJANGO_SETTINGS_MODULE=settings.test。|973899|entityMap^0|P|G|0|0|2|G|S|10|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|X|8|@]|D|@]|E|$]]]|N|$]]

In my case I have a settings file <code>settings/test.py</code> created specifically for testing purposes, here's what it looks like:

<pre><code>from .base import *

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

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

LOGGING = {}
</code></pre>

I put an environment variable <code>DJANGO_SETTINGS_MODULE=settings.test</code> to <code>/etc/environment</code>.

blocks|key|973938|text|有时你想要日志，有时你不想。我的settings.py中有以下代码|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|973939|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)|code-block|syntax|javascript|973940|因此，如果您使用--no-logs选项运行测试，您将只获得critical日志：|973941|$+python+./manage.py+tests+--no-logs
>+Disabling+logging+levels+of+CRITICAL+and+below.|973942|如果你想加速你的持续集成流程的测试，这是非常有帮助的。|973943|entityMap^0|G|B|0|0|8|9|T|8|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|12|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|13|8|@]|D|@]|E|$]]]|R|$]]

Sometimes you want the logs and sometimes not. I have this code in my <code>settings.py</code>

<pre><code>import sys

if '--no-logs' in sys.argv:
 print('&gt; Disabling logging levels of CRITICAL and below.')
 sys.argv.remove('--no-logs')
 logging.disable(logging.CRITICAL)
</code></pre>

So if you run your test with the <code>--no-logs</code> options you'll get only the <code>critical</code> logs:

<pre><code>$ python ./manage.py tests --no-logs
&gt; Disabling logging levels of CRITICAL and below.
</code></pre>

It's very helpful if you want speedup the tests on your continuous integration flow.

blocks|key|758363|text|我发现，对于unittest或类似框架中的测试，在单元测试中安全地禁用不需要的日志记录的最有效方法是在特定测试用例的setUp/tearDown方法中启用/禁用。这可以让一个目标明确到应该禁用日志的地方。您也可以在要测试的类的记录器上显式地执行此操作。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|758364|import+unittest
import+logging

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

++++def+tearDown(self):
++++++++logging.disable(logging.NOTSET)|code-block|syntax|javascript|758365|entityMap^0|6|8|1M|5|1S|8|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|U|8|@]|D|@]|E|$]]]|L|$]]

I've found that for tests within <code>unittest</code> or similar a framework, the most effective way to safely disable unwanted logging in unit tests is to enable/disable in the <code>setUp</code>/<code>tearDown</code> methods of a particular test case. This lets one target specifically where logs should be disabled. You could also do this explicitly on the logger of the class you're testing.

<pre><code>import unittest
import logging

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

 def tearDown(self):
 logging.disable(logging.NOTSET)
</code></pre>

blocks|key|758389|text|如果你不想在unittest的setUp()和tearDown()中重复地打开/关闭它(看不到原因)，你可以在每个类中只做一次：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|758390|++++import+unittest
++++import+logging

++++class+TestMyUnitTest(unittest.TestCase):
++++++++@classmethod
++++++++def+setUpClass(cls):
++++++++++++logging.disable(logging.CRITICAL)
++++++++@classmethod
++++++++def+tearDownClass(cls):
++++++++++++logging.disable(logging.NOTSET)|code-block|syntax|javascript|758391|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If you don't want it repeatedly turn it on/off in setUp() and tearDown() for unittest (don't see the reason for that), you could just do it once per class:

<pre class="lang-py prettyprint-override"><code> import unittest
 import logging

 class TestMyUnitTest(unittest.TestCase):
 @classmethod
 def setUpClass(cls):
 logging.disable(logging.CRITICAL)
 @classmethod
 def tearDownClass(cls):
 logging.disable(logging.NOTSET)
</code></pre>

blocks|key|758438|text|如果你有不同的初始化程序模块用于测试，开发和生产，那么你可以在初始化程序中禁用或重定向任何东西。我有local.py、test.py和production.py，它们都继承自common.y。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|758439|common.py执行所有的主要配置，包括以下代码片段：|758440|LOGGING+=+{
'version':+1,
'disable_existing_loggers':+False,
'formatters':+{
++++'django.server':+{
++++++++'()':+'django.utils.log.ServerFormatter',
++++++++'format':+'[%25(server_time)s]+%25(message)s',
++++},
++++'verbose':+{
++++++++'format':+'%25(levelname)s+%25(asctime)s+%25(module)s+%25(process)d+%25(thread)d+%25(message)s'
++++},
++++'simple':+{
++++++++'format':+'%25(levelname)s+%25(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,
++++},
}|code-block|syntax|javascript|758441|然后在test.py中，我有这样的代码：|758442|console_logger+=+Common.LOGGING.get('handlers').get('console')
console_logger['class']+=+'logging.FileHandler
console_logger['filename']+=+'./unitest.log|758443|这将控制台处理程序替换为FileHandler，这意味着仍然可以进行日志记录，但我不必接触生产代码库。|758444|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

If you have different initaliser modules for test, dev and production then you can disable anything or redirect it in the initialser. I have local.py, test.py and production.py that all inherit from common.y

common.py does all the main config including this snippet :

<pre><code>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,
 },
}
</code></pre>

Then in test.py I have this:

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

This replaces the console handler with a FileHandler and means still get logging but I do not have to touch the production code base.

blocks|key|974096|text|我使用一个简单的方法修饰器来禁用特定测试方法中的日志记录。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|974097|def+disable_logging(f):

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

++++++++return+result

++++return+wrapper|code-block|syntax|javascript|974098|然后我像下面的例子一样使用它：|974099|class+ScenarioTestCase(TestCase):

++++@disable_logging
++++test_scenario(self):
++++++++pass|974100|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I am using a simple method decorator to disable logging only in a particular test method.

<pre><code>def disable_logging(f):

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

 return result

 return wrapper
</code></pre>

And then I use it as in the following example:

<pre><code>class ScenarioTestCase(TestCase):

 @disable_logging
 test_scenario(self):
 pass
</code></pre>

blocks|key|758558|text|如果您使用的是pytest|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|758559|由于pytest捕获日志消息并仅显示失败测试的日志消息，因此您通常不希望禁用任何日志记录。相反，对测试使用单独的settings.py文件(例如，test_settings.py)，并添加到其中：|758560|LOGGING_CONFIG+=+None|code-block|syntax|javascript|758561|这告诉Django完全跳过配置日志。LOGGING设置将被忽略，并且可以从设置中删除。|758562|使用这种方法，您不会获得通过测试的任何日志记录，而会获得失败测试的所有可用日志记录。|758563|测试将使用pytest设置的日志记录运行。您可以在pytest设置(例如tox.ini)中根据您的喜好对其进行配置。要包括调试级日志消息，请使用log_level+=+DEBUG+(或相应的命令行参数)。|758564|entityMap^0|7|6|0|1K|B|21|G|0|0|I|7|0|0|5|6|P|6|10|7|20|H|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|X|8|@$9|Y|A|Z|B|C]|$9|10|A|11|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|12|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|13|8|@$9|14|A|15|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|16|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|17|8|@$9|18|A|19|B|C]|$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]|$9|1E|A|1F|B|C]]|D|@]|E|$]]|$1|S|3|-4|5|6|7|1G|8|@]|D|@]|E|$]]]|T|$]]

If you're using <code>pytest</code>:

Since pytest captures log messages and only displays them for failed tests, you typically don't want to disable any logging. Instead, use a separate <code>settings.py</code> file for tests (e.g., <code>test_settings.py</code>), and add to it:

<pre><code>LOGGING_CONFIG = None
</code></pre>

This tells Django to skip configuring the logging altogether. The <code>LOGGING</code> setting will be ignored and can be removed from the settings.

With this approach, you don't get any logging for passed tests, and you get all available logging for failed tests. 

The tests will run using the logging that was set up by <code>pytest</code>. It can be configured to your liking in the <code>pytest</code> settings (e.g., <code>tox.ini</code>). To include debug level log messages, use <code>log_level = DEBUG</code> (or the corresponding command line argument).

blocks|key|974259|text|在我希望暂时禁止特定记录器的情况下，我编写了一个小的上下文管理器，我发现它很有用：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|974260|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|code-block|syntax|javascript|974261|然后您可以像这样使用它：|974262|class+MyTestCase(TestCase):
++++def+test_something(self):
++++++++with+disable_logger('<logger+name>'):
++++++++++++#+code+that+causes+the+logger+to+fire|974263|这样做的好处是，一旦with完成，记录器就会重新启用(或设置回以前的状态)。|offset|length|style|CODE|974264|entityMap^0|0|0|0|0|A|4|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@$M|X|N|Y|O|P]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

In cases where I wish to temporarily suppress a specific logger, I've written a little context manager that I've found useful:

<pre><code>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
</code></pre>

You then use it like:

<pre><code>class MyTestCase(TestCase):
 def test_something(self):
 with disable_logger('&lt;logger name&gt;'):
 # code that causes the logger to fire
</code></pre>

This has the advantage that the logger is re-enabled (or set back to its prior state) once the <code>with</code> completes.

blocks|key|758737|text|您可以将其放在单元测试__init__.py文件的顶层目录中。这将在单元测试套件中全局禁用日志记录。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|758738|#+tests/unit/__init__.py
import+logging

logging.disable(logging.CRITICAL)|code-block|syntax|javascript|758739|entityMap^0|B|B|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

You can put this in the top level directory for unit tests <code>__init__.py</code> file. This will disable logging globally in the unit test suite.

<pre class="lang-py prettyprint-override"><code># tests/unit/__init__.py
import logging

logging.disable(logging.CRITICAL)
</code></pre>

blocks|key|758793|text|我的一些测试包含关于日志输出的断言，因此更改日志级别会破坏它们。相反，我更改了我的Django+LOGGING设置，以便在运行测试时使用NullHandler：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|758794|if+'test'+in+sys.argv:
++++_LOG_HANDLERS+=+['null']
else:
++++_LOG_HANDLERS+=+['console']
++++
LOGGING+=+{
++++'version':+1,
++++'disable_existing_loggers':+False,
++++'formatters':+{
++++++++'simple':+{
++++++++++++'format':+'%25(levelname)s+%25(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',
++++++++},
++++}
}|code-block|syntax|javascript|758795|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/3/library/logging.handlers.html#nullhandler^0|1C|7|1W|B|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@$9|V|A|W|1|X]]|E|$]]|$1|F|3|G|5|H|7|Y|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]]]

Some of my tests contain assertions about log output, so changing the log level breaks them. Instead, I changed my Django <code>LOGGING</code> settings to use a <a href="https://docs.python.org/3/library/logging.handlers.html#nullhandler" rel="nofollow noreferrer">NullHandler</a> when running tests:
<pre><code>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',
 },
 }
}
</code></pre>

blocks|key|758868|text|如果你正在使用pytest，你可以安装一个非常有用的pytest-mock插件，并定义一个自动使用的，会话范围的fixture，它可以由一个env变量触发：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|758869|#+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")|code-block|syntax|javascript|758870|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/pytest-dev/pytest-mock^0|Q|B|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

In case you're using pytest, you can install the super useful <a href="https://github.com/pytest-dev/pytest-mock" rel="nofollow noreferrer">pytest-mock</a> plugin and define an auto-used, session-scoped fixture that can be triggered by an env var:
<pre class="lang-py prettyprint-override"><code># conftest.py

import os
import pytest


@pytest.fixture(autouse=True, scope=&quot;session&quot;)
def _shut_logger(session_mocker):
 if os.getenv(&quot;SHUT_LOGGER&quot;, None):
 return session_mocker.patch(&quot;foo.logger&quot;)
</code></pre>

blocks|key|974476|text|禁用整个模块的日志记录：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|974477|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|code-block|syntax|javascript|974478|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Disable logging for the entire module:
<pre><code>import logging


def setUpModule():
 &quot;&quot;&quot;Disable logging while doing these tests.&quot;&quot;&quot;
 logging.disable()


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


class TestFoo(unittest.TestCase):

 def test_foo(self):
 pass
</code></pre>

blocks|key|758955|text|b.h.|type|unstyled|depth|inlineStyleRanges|entityRanges|data|758956|for+me+works+whell+-+in+conftest.py：|758957|+import+confing
+#+disable+logging+for+tests
+[logging.disable(level)+for+level+in+[logging.DEBUG,
+++++++++++++++++++++++++++++++++++++++logging.INFO,
+++++++++++++++++++++++++++++++++++++++logging.ERROR,
+++++++++++++++++++++++++++++++++++++++logging.CRITICAL]]|code-block|syntax|javascript|758958|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

b.h.
for me works whell - in conftest.py:
<pre><code> import confing
 # disable logging for tests
 [logging.disable(level) for level in [logging.DEBUG,
 logging.INFO,
 logging.ERROR,
 logging.CRITICAL]]
</code></pre>

blocks|key|759006|text|我们使用structlog，它的禁用有点复杂：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|759007|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,
++++]
++++...

)|code-block|syntax|javascript|759008|entityMap|0|LINK|mutability|MUTABLE|url|https://structlog.org/^0|4|9|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

We use <a href="https://structlog.org" rel="nofollow noreferrer">structlog</a>, which is a bit more complicated to disable:
<pre><code>from structlog import DropEvent

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


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

)
</code></pre>

I am using a simple unit test based test runner to test my Django application.

My application itself is configured to use a basic logger in settings.py using:

<pre><code>logging.basicConfig(level=logging.DEBUG)
</code></pre>

And in my application code using:

<pre><code>logger = logging.getLogger(__name__)
logger.setLevel(getattr(settings, 'LOG_LEVEL', logging.DEBUG))
</code></pre>

However, when running unittests, I'd like to disable logging so that it doesn't clutter my test result output. Is there a simple way to turn off logging in a global way, so that the application specific loggers aren't writing stuff out to the console when I run tests?

How can I disable logging while running unit tests in Python Django?

我使用一个简单的基于单元测试的测试运行器来测试我的Django应用程序。我的应用程序本身被配置为在settings.py中使用一个基本的记录器，使用：logging.basicConfig(level=logging.DEBUG)在我的应用程序代码中使用：logger = logging.getLogger(__nam...

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

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

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

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

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