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)