fixed app_logger.py test cases and pylint issue.

Author: VishalS-Microsoft

src/tests/backend/common/database/database_factory_test.py

@@ -71,7 +71,7 @@ async def test_get_database():
 async def test_main_function():
     """Test the main function in database factory."""
     with patch("common.database.database_factory.DatabaseFactory.get_database", new_callable=AsyncMock, return_value=AsyncMock()) as mock_get_database, patch("builtins.print") as mock_print:
-      
+
         from common.database.database_factory import main
         await main()
 

src/tests/backend/common/logger/app_logger_test.py

@@ -1,9 +1,10 @@
 import json
 import logging
-import pytest
-from unittest.mock import patch, MagicMock
+from unittest.mock import MagicMock, patch
+
+from common.logger.app_logger import AppLogger, LogLevel  # Adjust the import based on your actual path
 
-from src.backend.common.logger.app_logger import AppLogger, LogLevel
+import pytest
 
 
 @pytest.fixture
@@ -12,11 +13,16 @@ def logger_name():
 
 
 @pytest.fixture
-def app_logger(logger_name):
-    return AppLogger(logger_name)
+def logger_instance(logger_name):
+    """Fixture to return AppLogger with mocked handler"""
+    with patch("common.logger.app_logger.logging.getLogger") as mock_get_logger:
+        mock_logger = MagicMock()
+        mock_get_logger.return_value = mock_logger
+        yield AppLogger(logger_name)
 
 
-def test_log_level_constants():
+def test_log_levels():
+    """Ensure log levels are set correctly"""
     assert LogLevel.NONE == logging.NOTSET
     assert LogLevel.DEBUG == logging.DEBUG
     assert LogLevel.INFO == logging.INFO
@@ -25,90 +31,64 @@ def test_log_level_constants():
     assert LogLevel.CRITICAL == logging.CRITICAL
 
 
-@patch("src.backend.common.logger.app_logger.logging.getLogger")
-def test_app_logger_init(mock_get_logger, logger_name):
-    mock_logger = MagicMock()
-    mock_get_logger.return_value = mock_logger
-
-    logger = AppLogger(logger_name)
-
-    assert logger.logger == mock_logger
-    mock_logger.setLevel.assert_called_once_with(logging.DEBUG)
-    
-    # New Correct Check: Check that addHandler was called with StreamHandler
-    assert mock_logger.addHandler.called
-    handler_arg = mock_logger.addHandler.call_args[0][0]
-    assert isinstance(handler_arg, logging.StreamHandler)
-
-
-
-def test_format_message_without_kwargs(app_logger):
-    message = "test message"
-    formatted = app_logger._format_message(message)
-    expected = json.dumps({"message": message})
-    assert formatted == expected
+def test_format_message_basic(logger_instance):
+    result = logger_instance._format_message("Test message")
+    parsed = json.loads(result)
+    assert parsed["message"] == "Test message"
+    assert "context" not in parsed
 
 
-def test_format_message_with_kwargs(app_logger):
-    message = "test message"
-    context = {"user": "john", "action": "login"}
-    formatted = app_logger._format_message(message, **context)
-    expected = json.dumps({"message": message, "context": context})
-    assert formatted == expected
+def test_format_message_with_context(logger_instance):
+    result = logger_instance._format_message("Contextual message", key1="value1", key2="value2")
+    parsed = json.loads(result)
+    assert parsed["message"] == "Contextual message"
+    assert parsed["context"] == {"key1": "value1", "key2": "value2"}
 
 
-@patch.object(logging.Logger, "debug")
-def test_debug(mock_debug, app_logger):
-    app_logger.debug("Debug Message", user="test")
-    assert mock_debug.called
-    args, kwargs = mock_debug.call_args
-    log_entry = json.loads(args[0])
-    assert log_entry["message"] == "Debug Message"
-    assert "context" in log_entry
-    assert log_entry["context"]["user"] == "test"
+def test_debug_log(logger_instance):
+    with patch.object(logger_instance.logger, "debug") as mock_debug:
+        logger_instance.debug("Debug log", user="tester")
+        mock_debug.assert_called_once()
+        log_json = json.loads(mock_debug.call_args[0][0])
+        assert log_json["message"] == "Debug log"
+        assert log_json["context"]["user"] == "tester"
 
 
-@patch.object(logging.Logger, "info")
-def test_info(mock_info, app_logger):
-    app_logger.info("Info Message", user="test")
-    assert mock_info.called
-    args, kwargs = mock_info.call_args
-    log_entry = json.loads(args[0])
-    assert log_entry["message"] == "Info Message"
+def test_info_log(logger_instance):
+    with patch.object(logger_instance.logger, "info") as mock_info:
+        logger_instance.info("Info log", module="log_module")
+        mock_info.assert_called_once()
+        log_json = json.loads(mock_info.call_args[0][0])
+        assert log_json["message"] == "Info log"
+        assert log_json["context"]["module"] == "log_module"
 
 
-@patch.object(logging.Logger, "warning")
-def test_warning(mock_warning, app_logger):
-    app_logger.warning("Warning Message", user="test")
-    assert mock_warning.called
-    args, kwargs = mock_warning.call_args
-    log_entry = json.loads(args[0])
-    assert log_entry["message"] == "Warning Message"
+def test_warning_log(logger_instance):
+    with patch.object(logger_instance.logger, "warning") as mock_warning:
+        logger_instance.warning("Warning log")
+        mock_warning.assert_called_once()
 
 
-@patch.object(logging.Logger, "error")
-def test_error(mock_error, app_logger):
-    app_logger.error("Error Message", user="test")
-    assert mock_error.called
-    args, kwargs = mock_error.call_args
-    log_entry = json.loads(args[0])
-    assert log_entry["message"] == "Error Message"
+def test_error_log(logger_instance):
+    with patch.object(logger_instance.logger, "error") as mock_error:
+        logger_instance.error("Error log", error_code=500)
+        mock_error.assert_called_once()
+        log_json = json.loads(mock_error.call_args[0][0])
+        assert log_json["message"] == "Error log"
+        assert log_json["context"]["error_code"] == 500
 
 
-@patch.object(logging.Logger, "critical")
-def test_critical(mock_critical, app_logger):
-    app_logger.critical("Critical Message", user="test")
-    assert mock_critical.called
-    args, kwargs = mock_critical.call_args
-    log_entry = json.loads(args[0])
-    assert log_entry["message"] == "Critical Message"
+def test_critical_log(logger_instance):
+    with patch.object(logger_instance.logger, "critical") as mock_critical:
+        logger_instance.critical("Critical log")
+        mock_critical.assert_called_once()
 
 
-@patch("src.backend.common.logger.app_logger.logging.getLogger")
-def test_set_min_log_level(mock_get_logger):
-    mock_logger = MagicMock()
-    mock_get_logger.return_value = mock_logger
+def test_set_min_log_level():
+    with patch("common.logger.app_logger.logging.getLogger") as mock_get_logger:
+        mock_logger = MagicMock()
+        mock_get_logger.return_value = mock_logger
 
-    AppLogger.set_min_log_level(LogLevel.ERROR)
+        AppLogger.set_min_log_level(LogLevel.ERROR)
 
-    mock_logger.setLevel.assert_called_with(LogLevel.ERROR)
+        mock_logger.setLevel.assert_called_once_with(LogLevel.ERROR)