From e919604b763fd57aae6d0cce0f2842ad598229a0 Mon Sep 17 00:00:00 2001 From: Patrick Vu Date: Mon, 5 Jan 2026 15:55:23 +0700 Subject: [PATCH 1/3] enable keri logs --- src/keria/__init__.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/keria/__init__.py b/src/keria/__init__.py index 183f150d..ebbb4063 100644 --- a/src/keria/__init__.py +++ b/src/keria/__init__.py @@ -13,6 +13,7 @@ log_format_str = f"%(asctime)s [{log_name}] %(levelname)-8s %(module)s.%(funcName)s-%(lineno)s %(message)s" ogler = ogling.initOgler(prefix=log_name, syslogged=False) +keriLogger = ogler.getLogger() ogler.level = logging.INFO formatter = TruncatedFormatter(log_format_str) @@ -28,4 +29,5 @@ def set_log_level(loglevel, logger): """Set the log level for the logger.""" ogler.level = logging.getLevelName(loglevel.upper()) + keriLogger.setLevel(ogler.level) logger.setLevel(ogler.level) From 0136a19d5ee046def563023f915a4206ba4a304a Mon Sep 17 00:00:00 2001 From: Patrick Vu Date: Wed, 7 Jan 2026 14:16:05 +0700 Subject: [PATCH 2/3] cover new test for __init__.py code --- tests/test_init.py | 148 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 148 insertions(+) create mode 100644 tests/test_init.py diff --git a/tests/test_init.py b/tests/test_init.py new file mode 100644 index 00000000..1c8e27c1 --- /dev/null +++ b/tests/test_init.py @@ -0,0 +1,148 @@ +# -*- encoding: utf-8 -*- +""" +Tests for keria.__init__ module +""" + +import logging +import unittest +from unittest.mock import Mock +import keria + + +class TestKeriaInit(unittest.TestCase): + """Test cases for keria.__init__ module""" + + def test_module_attributes_exist(self): + """Test that required module attributes are defined""" + self.assertTrue(hasattr(keria, "__version__")) + self.assertTrue(hasattr(keria, "log_name")) + self.assertTrue(hasattr(keria, "log_format_str")) + self.assertTrue(hasattr(keria, "ogler")) + self.assertTrue(hasattr(keria, "keriLogger")) + self.assertTrue(hasattr(keria, "set_log_level")) + + def test_version_format(self): + """Test that version follows semantic versioning pattern""" + version = keria.__version__ + self.assertIsInstance(version, str) + # Basic check for version format (x.y.z) + parts = version.split(".") + self.assertEqual(len(parts), 3) + for part in parts: + self.assertTrue(part.isdigit()) + + def test_log_name_is_keria(self): + """Test that log_name is set to 'keria'""" + self.assertEqual(keria.log_name, "keria") + + def test_log_format_string_contains_expected_fields(self): + """Test that log format string contains expected logging fields""" + format_str = keria.log_format_str + expected_fields = [ + "%(asctime)s", + "%(levelname)-8s", + "%(module)s", + "%(funcName)s", + "%(lineno)s", + "%(message)s", + ] + for field in expected_fields: + self.assertIn(field, format_str) + # Check that it contains the keria prefix + self.assertIn("[keria]", format_str) + + def test_ogler_initialization(self): + """Test that ogler is properly initialized""" + self.assertIsNotNone(keria.ogler) + self.assertEqual(keria.ogler.level, logging.INFO) + + def test_logger_initialization(self): + """Test that keriLogger is properly initialized""" + self.assertIsNotNone(keria.keriLogger) + self.assertIsInstance(keria.keriLogger, logging.Logger) + + def test_set_log_level_function_exists(self): + """Test that set_log_level function is callable""" + self.assertTrue(callable(keria.set_log_level)) + + def test_set_log_level_with_debug(self): + """Test set_log_level function with DEBUG level""" + mock_logger = Mock() + + # Call the function + keria.set_log_level("DEBUG", mock_logger) + + # Check that ogler level was set + self.assertEqual(keria.ogler.level, logging.DEBUG) + + # Check that mock logger had setLevel called + mock_logger.setLevel.assert_called_with(logging.DEBUG) + + def test_set_log_level_with_info(self): + """Test set_log_level function with INFO level""" + mock_logger = Mock() + + # Call the function + keria.set_log_level("INFO", mock_logger) + + # Check that ogler level was set + self.assertEqual(keria.ogler.level, logging.INFO) + + # Check that mock logger had setLevel called + mock_logger.setLevel.assert_called_with(logging.INFO) + + def test_set_log_level_with_warning(self): + """Test set_log_level function with WARNING level""" + mock_logger = Mock() + + # Call the function + keria.set_log_level("WARNING", mock_logger) + + # Check that ogler level was set + self.assertEqual(keria.ogler.level, logging.WARNING) + + # Check that mock logger had setLevel called + mock_logger.setLevel.assert_called_with(logging.WARNING) + + def test_set_log_level_with_error(self): + """Test set_log_level function with ERROR level""" + mock_logger = Mock() + + # Call the function + keria.set_log_level("ERROR", mock_logger) + + # Check that ogler level was set + self.assertEqual(keria.ogler.level, logging.ERROR) + + # Check that mock logger had setLevel called + mock_logger.setLevel.assert_called_with(logging.ERROR) + + def test_set_log_level_with_lowercase(self): + """Test set_log_level function handles lowercase input""" + mock_logger = Mock() + + # Call the function with lowercase + keria.set_log_level("debug", mock_logger) + + # Check that it still works (function should uppercase it) + self.assertEqual(keria.ogler.level, logging.DEBUG) + mock_logger.setLevel.assert_called_with(logging.DEBUG) + + def test_truncated_formatter_imported(self): + """Test that TruncatedFormatter is properly imported and used""" + # Check that the handler has the correct formatter + self.assertIsNotNone(keria.logHandler) + self.assertIsNotNone(keria.formatter) + from keria.monitoring.logs import TruncatedFormatter + + self.assertIsInstance(keria.formatter, TruncatedFormatter) + + def test_log_handler_configuration(self): + """Test that log handler is properly configured""" + self.assertIsNotNone(keria.logHandler) + self.assertIsInstance(keria.logHandler, logging.StreamHandler) + self.assertEqual(keria.logHandler.formatter, keria.formatter) + + +if __name__ == "__main__": + unittest.main() From adb3b73d2624e3ebc6a5e86566badc27e6b0aa98 Mon Sep 17 00:00:00 2001 From: Patrick Vu Date: Wed, 7 Jan 2026 17:44:58 +0700 Subject: [PATCH 3/3] remove unnecessary tests --- tests/test_init.py | 129 +-------------------------------------------- 1 file changed, 1 insertion(+), 128 deletions(-) diff --git a/tests/test_init.py b/tests/test_init.py index 1c8e27c1..3178d39f 100644 --- a/tests/test_init.py +++ b/tests/test_init.py @@ -1,6 +1,6 @@ # -*- encoding: utf-8 -*- """ -Tests for keria.__init__ module +Test for keria.__init__ """ import logging @@ -10,139 +10,12 @@ class TestKeriaInit(unittest.TestCase): - """Test cases for keria.__init__ module""" - - def test_module_attributes_exist(self): - """Test that required module attributes are defined""" - self.assertTrue(hasattr(keria, "__version__")) - self.assertTrue(hasattr(keria, "log_name")) - self.assertTrue(hasattr(keria, "log_format_str")) - self.assertTrue(hasattr(keria, "ogler")) - self.assertTrue(hasattr(keria, "keriLogger")) - self.assertTrue(hasattr(keria, "set_log_level")) - - def test_version_format(self): - """Test that version follows semantic versioning pattern""" - version = keria.__version__ - self.assertIsInstance(version, str) - # Basic check for version format (x.y.z) - parts = version.split(".") - self.assertEqual(len(parts), 3) - for part in parts: - self.assertTrue(part.isdigit()) - - def test_log_name_is_keria(self): - """Test that log_name is set to 'keria'""" - self.assertEqual(keria.log_name, "keria") - - def test_log_format_string_contains_expected_fields(self): - """Test that log format string contains expected logging fields""" - format_str = keria.log_format_str - expected_fields = [ - "%(asctime)s", - "%(levelname)-8s", - "%(module)s", - "%(funcName)s", - "%(lineno)s", - "%(message)s", - ] - for field in expected_fields: - self.assertIn(field, format_str) - # Check that it contains the keria prefix - self.assertIn("[keria]", format_str) - - def test_ogler_initialization(self): - """Test that ogler is properly initialized""" - self.assertIsNotNone(keria.ogler) - self.assertEqual(keria.ogler.level, logging.INFO) - - def test_logger_initialization(self): - """Test that keriLogger is properly initialized""" - self.assertIsNotNone(keria.keriLogger) - self.assertIsInstance(keria.keriLogger, logging.Logger) - - def test_set_log_level_function_exists(self): - """Test that set_log_level function is callable""" - self.assertTrue(callable(keria.set_log_level)) - def test_set_log_level_with_debug(self): - """Test set_log_level function with DEBUG level""" mock_logger = Mock() - - # Call the function keria.set_log_level("DEBUG", mock_logger) - - # Check that ogler level was set self.assertEqual(keria.ogler.level, logging.DEBUG) - - # Check that mock logger had setLevel called mock_logger.setLevel.assert_called_with(logging.DEBUG) - def test_set_log_level_with_info(self): - """Test set_log_level function with INFO level""" - mock_logger = Mock() - - # Call the function - keria.set_log_level("INFO", mock_logger) - - # Check that ogler level was set - self.assertEqual(keria.ogler.level, logging.INFO) - - # Check that mock logger had setLevel called - mock_logger.setLevel.assert_called_with(logging.INFO) - - def test_set_log_level_with_warning(self): - """Test set_log_level function with WARNING level""" - mock_logger = Mock() - - # Call the function - keria.set_log_level("WARNING", mock_logger) - - # Check that ogler level was set - self.assertEqual(keria.ogler.level, logging.WARNING) - - # Check that mock logger had setLevel called - mock_logger.setLevel.assert_called_with(logging.WARNING) - - def test_set_log_level_with_error(self): - """Test set_log_level function with ERROR level""" - mock_logger = Mock() - - # Call the function - keria.set_log_level("ERROR", mock_logger) - - # Check that ogler level was set - self.assertEqual(keria.ogler.level, logging.ERROR) - - # Check that mock logger had setLevel called - mock_logger.setLevel.assert_called_with(logging.ERROR) - - def test_set_log_level_with_lowercase(self): - """Test set_log_level function handles lowercase input""" - mock_logger = Mock() - - # Call the function with lowercase - keria.set_log_level("debug", mock_logger) - - # Check that it still works (function should uppercase it) - self.assertEqual(keria.ogler.level, logging.DEBUG) - mock_logger.setLevel.assert_called_with(logging.DEBUG) - - def test_truncated_formatter_imported(self): - """Test that TruncatedFormatter is properly imported and used""" - # Check that the handler has the correct formatter - self.assertIsNotNone(keria.logHandler) - self.assertIsNotNone(keria.formatter) - from keria.monitoring.logs import TruncatedFormatter - - self.assertIsInstance(keria.formatter, TruncatedFormatter) - - def test_log_handler_configuration(self): - """Test that log handler is properly configured""" - self.assertIsNotNone(keria.logHandler) - self.assertIsInstance(keria.logHandler, logging.StreamHandler) - self.assertEqual(keria.logHandler.formatter, keria.formatter) - if __name__ == "__main__": unittest.main()