V6.0.0

Author: ddc

pythonLogs/core/factory.py

@@ -309,7 +309,7 @@ def create_logger(
                     showlocation=final_config.showlocation,
                     rotateatutc=final_config.rotateatutc,
                 ).init()
-            case _ as unreachable:
+            case _ as unreachable:  # pragma: no cover
                 assert_never(unreachable)
 
     @staticmethod

tests/core/test_log_utils_windows.py

@@ -170,7 +170,7 @@ def test_gzip_file_windows_retry_mechanism(self):
             file_handle.close()
 
             # Mock time.sleep to verify retry mechanism
-            with patch('pythonLogs.log_utils.time.sleep') as mock_sleep:
+            with patch('pythonLogs.core.log_utils.time.sleep') as mock_sleep:
                 # Mock open to raise PermissionError on first call, succeed on second
                 call_count = 0
                 original_open = open
@@ -186,8 +186,8 @@ def mock_open_side_effect(*args, real_open=original_open, **kwargs):
                         return real_open(*args, **kwargs)
 
                 # Always mock platform as win32 and open with retry behavior
-                with patch('pythonLogs.log_utils.sys.platform', 'win32'):
-                    with patch('pythonLogs.log_utils.open', side_effect=mock_open_side_effect):
+                with patch('pythonLogs.core.log_utils.sys.platform', 'win32'):
+                    with patch('pythonLogs.core.log_utils.open', side_effect=mock_open_side_effect):
                         result = log_utils.gzip_file_with_sufix(file_path, "retry_test")
 
                         # Verify retry was attempted (sleep was called)
@@ -505,9 +505,9 @@ def mock_open_side_effect(*args, **kwargs):
                     return original_open(*args, **kwargs)
 
             # Mock sys.platform to be Windows and time.sleep to verify retry
-            with unittest.mock.patch('pythonLogs.log_utils.sys.platform', 'win32'):
-                with unittest.mock.patch('pythonLogs.log_utils.time.sleep') as mock_sleep:
-                    with unittest.mock.patch('pythonLogs.log_utils.open', side_effect=mock_open_side_effect):
+            with unittest.mock.patch('pythonLogs.core.log_utils.sys.platform', 'win32'):
+                with unittest.mock.patch('pythonLogs.core.log_utils.time.sleep') as mock_sleep:
+                    with unittest.mock.patch('pythonLogs.core.log_utils.open', side_effect=mock_open_side_effect):
                         result = log_utils.gzip_file_with_sufix(file_path, "comprehensive_retry")
 
                         # Verify retries were attempted (sleep should be called twice)

tests/factory/test_factory.py

@@ -315,11 +315,10 @@ def test_factory_ensure_initialized_behavior(self):
         LoggerFactory._ensure_initialized()
         assert LoggerFactory._initialized is True
 
-    def test_factory_atexit_cleanup_error_handling(self):
-        """Test atexit cleanup error handling."""
-
-        # Mock the clear_registry method to raise an expected error type
-        with patch.object(LoggerFactory, 'clear_registry', side_effect=OSError("Test error")):
+    @pytest.mark.parametrize("error_type", [OSError, ValueError, RuntimeError])
+    def test_factory_atexit_cleanup_error_handling(self, error_type):
+        """Test atexit cleanup handles expected exceptions gracefully."""
+        with patch.object(LoggerFactory, 'clear_registry', side_effect=error_type("Test error")):
             # Should not raise an exception (silently ignored)
             LoggerFactory._atexit_cleanup()
 
@@ -449,3 +448,47 @@ def test_factory_large_scale_operations(self):
         for logger in created_loggers:
             logger.info("Scale test message")
             assert logger.name is not None
+
+    def test_factory_get_memory_limits(self):
+        """Test get_memory_limits returns current settings."""
+        # Set specific limits
+        LoggerFactory.set_memory_limits(max_loggers=75, ttl_seconds=2400)
+
+        # Get and verify limits
+        limits = LoggerFactory.get_memory_limits()
+        assert limits['max_loggers'] == 75
+        assert limits['ttl_seconds'] == 2400
+
+    @pytest.mark.skipif(
+        sys.platform == "win32",
+        reason="Windows file locking issues with TemporaryDirectory - see test_factory_windows.py",
+    )
+    def test_timed_rotating_log_context_manager(self):
+        """Test TimedRotatingLog context manager __enter__ and __exit__."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            with TimedRotatingLog(
+                name="context_timed_test",
+                directory=temp_dir,
+                when="midnight",
+                level="INFO",
+            ) as logger:
+                logger.info("Message inside context manager")
+                assert logger.name == "context_timed_test"
+            # Logger should be cleaned up after exiting context
+
+    def test_shutdown_logger_convenience_function(self):
+        """Test shutdown_logger convenience function."""
+        from pythonLogs.core.factory import shutdown_logger
+
+        # Create and register a logger
+        LoggerFactory.get_or_create_logger(LoggerType.BASIC, name="shutdown_conv_test")
+        assert "shutdown_conv_test" in get_registered_loggers()
+
+        # Shutdown via convenience function
+        result = shutdown_logger("shutdown_conv_test")
+        assert result is True
+        assert "shutdown_conv_test" not in get_registered_loggers()
+
+        # Try shutting down non-existent logger
+        result = shutdown_logger("non_existent_conv")
+        assert result is False