Writing a unit test for Python logger formatted output
From the documentation (http://packages.python.org/testfixtures/logging.html):
To help with this, TestFixtures allows you to easily capture the output of calls to Python’s logging framework and make sure they were as expected. There are three different techniques, depending on the type of test you are writing.
- The context manager
- The decorator
- The manual usage
The examples are included in the documentation. The shortened version is below.
The context manager
>>> import logging
>>> from testfixtures import LogCapture
>>> with LogCapture() as l:
... logger = logging.getLogger()
... logger.info('a message')
... logger.error('an error')
And after that you can check the logs for equality:
>>> l.check(
... ('root', 'INFO', 'a message'),
... ('root', 'ERROR', 'another error'),
... )
Traceback (most recent call last):
...
AssertionError: Sequence not as expected:
same:
(('root', 'INFO', 'a message'),)
first:
(('root', 'ERROR', 'another error'),)
second:
(('root', 'ERROR', 'an error'),)
The decorator
Similar to the previous, but applied to specific function:
from testfixtures import log_capture
@log_capture()
def test_function(l):
logger = logging.getLogger()
logger.info('a message')
logger.error('an error')
l.check(
('root', 'INFO', 'a message'),
('root', 'ERROR', 'an error'),
)
Manual usage
>>> from testfixtures import LogCapture
>>> l = LogCapture()
After which you can also "check" the logs:
>>> l.check(('root', 'INFO', 'a message'))
<...>
EDIT: To access specific logs and analyze them in a custom way, you can just iterate through l.records
(where l
is just LogCapture
's instance) and access some properties of each of them (eg. msg
contains message sent to logger, levelname
contains codename of the level, and there are plenty other properties).
If you want to use only standard libraries, this solution could help. It is based on unittest
and mock
libraries.
For example if you have script.py
with following content.
logger = logging.getLogger(__name__)
def log_something():
logger.debug("something")
You could write a test for it that will look like this.
import unittest
import mock
from script import log_something
@mock.patch("script.logger")
def test_function(mock_log):
log_something()
assertTrue(
"something" in mock_log.debug.call_args_list[0][0][0]
)
This is using the call_args_list from the mock
library.
To explain [0][0][0]
at the end:
The
call_args_list
is a list ofcall
objects, which looks like this[call("something")]
. So the first[0]
is returning the firstcall
object.The second
[0]
returns the tuple of arguments for thecall
object. It will look like this("something",)
.Third
[0]
returns the first argument that was given tologger
in our case. So the final string will be only"something"
.