def test_func_changes_logging_level(self):
self.addCleanup(pkg_logging.finish_logging)
self.remove_these.append(self.config_default_log)
self.remove_these.append(self.module_default_log)
pkg_logging.setup_logging()
expected_level = pkg_logging.get_default_logging_level()
pkg_logger = pkg_logging.getLogger()
initial_level = pkg_logger.level
self.assertEqual(expected_level, initial_level)
new_level = "CRITICAL"
pkg_logging.setLevel(new_level)
intermediate_level = pkg_logger.level
self.assertNotEqual(initial_level, intermediate_level)
self.assertEqual(new_level,
pkg_logging.get_current_logging_level_by_name())
pkg_logging.setLevel(initial_level)
penultimate_level = pkg_logger.level
self.assertEqual(initial_level, penultimate_level)
new_level = "ERROR"
pkg_logging.setLevel("ERROR")
final_level = pkg_logger.level
self.assertNotEqual(penultimate_level, final_level)
self.assertEqual(new_level,
pkg_logging.get_current_logging_level_by_name())
reset_level = pkg_logging.reset_logging_level()
self.assertNotEqual(final_level, reset_level)
self.assertEqual(initial_level, reset_level)
def test_wrapped_logger_logs_after_setup_to_destinations(self):
self.assertFalse(os.path.exists(self.default_log_filename),
msg="Precondition.")
levels = "DEBUG INFO WARNING ERROR CRITICAL".split()
with testfixtures.OutputCapture(separate=True) as streams:
pkg_logging.setup_logging()
self.addCleanup(pkg_logging.finish_logging)
wrapped_logger = pkg_logging.getLogger()
# Preconditon: agnostic of logger setting, essentially tests the
# handlers.
pkg_logging.setLevel("DEBUG")
for level in levels:
wrapped_logger.log(self.coded_levels[level], self.message)
with self.subTest(criteria="logs all levels to file"):
self.wrapped_logger_has_logged_to_file(levels)
with self.subTest(criteria="logs to stderr not stdout"):
stdout = streams.stdout.getvalue().strip()
stderr = streams.stderr.getvalue().strip()
self.assertEqual(len(stdout), 0)
self.assertGreaterEqual(len(stderr), 1)
self.assertIn(self.message, stderr)
with self.subTest(criteria="logs specific levels to stderr"):
expected_levels = "ERROR CRITICAL".split()
unexpected_levels = "DEBUG INFO WARNING ".split()
self.assertSubstringsInString(expected_levels, stderr)
self.assertSubstringsNotInString(unexpected_levels, stderr)
def test_getLogger_returns_wrapped_logger(self):
import logging
pkg_logging.setup_logging()
self.addCleanup(pkg_logging.finish_logging)
logger = pkg_logging.getLogger()
self.assertIsInstance(logger, logging.LoggerAdapter)
self.assertIsInstance(logger, pkg_logging.LoggerWrapper)
def test_setup_function_overloads_config_logfilename_DEFAULT(self):
self.precondition()
expected = self.module_default_log
self.remove_these.append(expected)
with testfixtures.OutputCapture() as _:
pkg_logging.setup_logging()
pkg_logging.finish_logging()
self.assertFalse(os.path.exists(self.config_default_log))
self.assertTrue(os.path.exists(expected))
def test_setup_function_overloads_config_logfilename_USERCHOICE(self):
with tempfile.TemporaryDirectory() as dirname:
user_defined_logfilename = os.path.join(dirname, "foobar.log")
self.precondition(other_file=user_defined_logfilename)
with testfixtures.OutputCapture() as _:
pkg_logging.setup_logging(user_defined_logfilename)
pkg_logging.finish_logging()
self.assertFalse(os.path.exists(self.config_default_log))
self.assertFalse(os.path.exists(self.module_default_log))
self.assertTrue(os.path.exists(user_defined_logfilename))
def test_setup_function_has_kwarg_to_suppress_logging_True(self):
self.addCleanup(pkg_logging.finish_logging)
self.remove_these.append(self.config_default_log)
self.remove_these.append(self.module_default_log)
should_suppress = True
message = f"FOOBAR - suppress kwarg is {should_suppress}"
with testfixtures.OutputCapture() as output:
pkg_logging.setup_logging(suppress=should_suppress)
logger = pkg_logging.getLogger()
logger.critical(message)
self.assertEqual("", output.captured)
self.assertNotIn(message, output.captured)
def test_setup_function_raises_package_error_with_bad_config(self):
self.precondition()
expected_exception = exceptions.LoggingSetupError
expected_substrings = ["Could", "not", "setup", "logging"]
dirname = tempfile.TemporaryDirectory()
dirname.cleanup() # Explictly closed to provide a non-existant dir
bad_logfilename = os.path.join(dirname.name, "foo.log")
self.assertFalse(os.path.exists(os.path.dirname(bad_logfilename)))
with self.assertRaises(expected_exception) as fail:
pkg_logging.setup_logging(bad_logfilename)
pkg_logging.finish_logging()
self.assertSubstringsInString(expected_substrings, str(fail.exception))
def test_wrapped_logger_autologs_after_setup_exceptions_specially(self):
pkg_logging.setup_logging()
self.addCleanup(pkg_logging.finish_logging)
msg = self.message
errors = {
"ERROR": exceptions.RecomposeError(msg),
"WARNING": exceptions.RecomposeWarning(msg),
"CRITICAL": Exception(msg)
}
wrapped_logger = pkg_logging.getLogger()
for level, error in errors.items():
with self.subTest():
with self.assertLogs(wrapped_logger.logger):
wrapped_logger.autolog(error)
def test_wrapped_logger_logs_after_setup_by_level(self):
self.assertFalse(os.path.exists(self.default_log_filename),
msg="Precondition.")
pkg_logging.setup_logging()
self.addCleanup(pkg_logging.finish_logging)
levels = "DEBUG INFO WARNING ERROR CRITICAL".split()
wrapped_logger = pkg_logging.getLogger()
# Preconditon: agnostic of logger setting, essentially tests the
# handlers.
pkg_logging.setLevel("DEBUG")
for level in levels:
with self.subTest(level=level):
self.wrapped_logger_logs(wrapped_logger, level)
def main_wrapper(log_filename=None, log_level=None, **kwargs):
"""Entry point with logging tidyed as necessary."""
if log_filename:
suppress = False
else:
suppress = True
try:
pkg_logging.setup_logging(log_filename, suppress)
if log_level is not None:
pkg_logging.setLevel(log_level)
logger = pkg_logging.getLogger()
log_level_actual = pkg_logging.get_current_logging_level_by_name()
logger.info(f"Logging level set at {log_level_actual}.")
main(**kwargs)
finally:
pkg_logging.finish_logging()
def test_setup_function_sets_root_logger_to_INFO_level(self):
import logging
self.addCleanup(pkg_logging.finish_logging)
self.remove_these.append(self.config_default_log)
self.remove_these.append(self.module_default_log)
expected_level = logging.INFO
pkg_logging.setup_logging()
# Test reporting function
default_level = pkg_logging.get_default_logging_level()
self.assertEqual(default_level, expected_level)
# Test package
pkg_logger = pkg_logging.getLogger()
self.assertEqual(pkg_logger.name, "recomposeLogger")
self.assertGreaterEqual(pkg_logger.level, expected_level)
# Test builtin/root
builtin_logger = logging.getLogger()
self.assertEqual(builtin_logger.name, "root")
self.assertGreaterEqual(pkg_logger.level, expected_level)
