def test_aliases_change_builtin_severity_levels(logging, log):
"""
This test asserts a specific behavior of how adding log levels
behaves when using the python logging modules. If you add a level
using logging-levels for a log level that already exists, your new
level will override any existing level. This can be intended, but
it can have unintended consequences if you're not expecting it.
"""
assert not hasattr(logging, 'SUPPRESSED')
add_log_level(SUPPRESSED=logging.WARN, logging=logging)
assert logging.SUPPRESSED == logging.WARN
message = 'Testing suppressed logging {0}'.format(uuid4())
log.suppressed(message)
lvl, msg = log.last()
assert lvl == 'SUPPRESSED'
assert msg == message
message = 'Testing warning logging {0}'.format(uuid4())
# Python still tracks a shortcut for WARN here, but after adding
# SUPPRESSED at the same level above, python has updated it's mapping
# from NAME to LVL to be this latest level name. This severity alias
# will work, but the level name will be the new level.
log.warn(message)
lvl, msg = log.last()
assert lvl == 'SUPPRESSED'
assert msg == message
def test_add_levels(logging, log):
"""
Ensure that we can add a couple log levels and log with them
"""
assert not hasattr(logging, 'TEST')
assert not hasattr(logging, 'FOO')
add_log_level(TEST=5, FOO=1, logging=logging)
assert logging.TEST == 5
assert logging.FOO == 1
for i in range(10):
message = 'Testing TEST {0}'.format(uuid4())
log.test(message)
lvl, msg = log.last()
assert lvl == 'TEST'
assert msg == message
for i in range(10):
message = 'Testing FOO {0}'.format(uuid4())
log.foo(message)
lvl, msg = log.last()
assert lvl == 'FOO'
assert msg == message
def test_root_logger_methods(logging):
"""
Ensure new logging methods work on root logger
"""
assert not hasattr(logging, 'roof')
add_log_level(ROOF=1, logging=logging)
logging.roof('Test roof')
def test_log_level_must_be_int(logging, log):
"""
Ensure log levels are ints
"""
with pytest.raises(ValueError):
add_log_level(DANG='dang', logging=logging)
# Do it correctly this time
add_log_level(DANG=1, logging=logging)
assert logging.DANG == 1
def add_standards(logging):
"""
Add standard log levels to ``logging`` module
"""
add_log_level(
# Log debug details of constant changes
TRACE=5 ,
# Log debug with a little more chattyness
VERBOSE=7,
logging=logging
)
# Log a suppressed exception at warning level
add_log_level(
SUPPRESSED=logging.WARN,
exceptions=True,
logging=logging
)
def test_add_levels_with_exceptions(logging, log):
"""
Ensure that we can add a log level that
also logs exception.
"""
assert not hasattr(logging, 'WTF')
add_log_level(WTF=5000, logging=logging, exceptions=True)
assert logging.WTF == 5000
try:
raise Exception('What was that?')
except:
log.wtf('Something just happened')
lines = ''.join(log.readlines())
assert lines.startswith('WTF:')
assert 'Exception: What was that?' in lines
def test_log_level_works(logging, log):
"""
Ensure that log messages only appear in the logging
if the log level is within range.
"""
add_log_level(SPAM=1, NOISE=5, IMPORTANT=1000, logging=logging)
log.setLevel(logging.DEBUG)
# Debug message should appear
log.debug('debug')
assert log.last() == ['DEBUG', 'debug']
# Noise message should NOT appear
log.noise('noise')
assert not log.last()
# Spam message should NOT appear
log.spam('spam')
assert not log.last()
# Important message should appear
log.important('important')
assert log.last() == ['IMPORTANT', 'important']
log.setLevel(logging.NOISE)
# Noise message should now appear
log.noise('noise')
assert log.last() == ['NOISE', 'noise']
# Important message should still appear
log.important('important')
assert log.last() == ['IMPORTANT', 'important']
# Spam message should NOT appear
log.spam('spam')
assert not log.last()
def add_standards(logging):
"""
Add standard log levels to ``logging`` module
"""
add_log_level(
# From syslog: System is unusable.
# This level should not be used by applications.
EMERGENCY=100,
# From syslog: Should be corrected immediately.
# Loss of the primary ISP connection.
ALERT=70,
# From syslog: Events that are unusual, but not error conditions.
NOTICE=25,
# Log debug messages with a little more chattyness
VERBOSE=7,
# Log debug details of constant changes
TRACE=5,
logging=logging
)
# Log a suppressed exception at warning level
add_log_level(
# We want this to be nearly the same as WARN, but we don't
# want to blow away the WARN log level name. If we used a
# level below WARN these suppressed exceptions would not be
# logged when setting the log level to WARN. Since we're
# deliberately trying to expose exceptions and such at this
# level we're choosing something right above the WARN level
# so that we don't collide and so that it still gets logged.
SUPPRESSED=logging.WARN + 1,
exceptions=True,
logging=logging
)
def test_names_must_be_upper_case(logging):
"""
Ensure logging names must be uppercase
"""
with pytest.raises(KeyError):
# Lowercase not OK
add_log_level(foo=1, logging=logging)
# Upper case OK
add_log_level(FOO=1, logging=logging)
# Underscore OK
add_log_level(FOO_BAR=1, logging=logging)
def test_override_default_levels(logging, log):
"""
Ensure we can not overwrite existing log levels
"""
# Override default log levels?
assert logging.DEBUG == 10
with pytest.raises(KeyError):
add_log_level(DEBUG=5000, logging=logging)
# Override custom log levels?
add_log_level(MONKEY=1000, logging=logging)
assert logging.MONKEY == 1000
with pytest.raises(KeyError):
add_log_level(MONKEY=1000, logging=logging)
