V5.0.1

Author: ddc

.github/workflows/workflow.yml

@@ -13,7 +13,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: ["ubuntu-latest", "windows-latest", "macos-latest"]
+        os: ["ubuntu-latest", "macos-latest", "windows-latest"]
         python-version: ["3.12", "3.13"]
     steps:
       - uses: actions/checkout@v4
@@ -57,7 +57,7 @@ jobs:
     if: startsWith(github.ref, 'refs/tags/v')
     strategy:
       matrix:
-        os: ["ubuntu-latest", "windows-latest", "macos-latest"]
+        os: ["ubuntu-latest", "macos-latest", "windows-latest"]
         python-version: ["3.12", "3.13"]
     steps:
       - uses: actions/checkout@v4

tests/core/test_log_utils.py

@@ -140,7 +140,7 @@ def safe_close_and_delete_file(file_handler, filepath, max_attempts=3, delay=0.1
         try:
             file_handler.close()
         except (OSError, AttributeError):
-            # Handler might already be closed or not have a close method
+            # The Handler might already be closed or not have a close method
             pass
 
     # Small delay to ensure file handle is fully released
@@ -171,7 +171,7 @@ def cleanup_logger_handlers(logger):
             # Close the handler first
             handler.close()
         except (OSError, AttributeError):
-            # Handler might already be closed or not have a close method
+            # The Handler might already be closed or not have a close method
             pass
         finally:
             # Remove the handler from the logger
@@ -420,7 +420,7 @@ def test_is_older_than_x_days(self):
         try:
             assert os.path.isfile(file_path) == True
 
-            # When days=1, it compares against current time, so file should be "older" 
+            # When days=1, it compares against current time, so the file should be "older" 
             # due to the small time difference since creation
             result = log_utils.is_older_than_x_days(file_path, 1)
             assert result == True
@@ -566,7 +566,8 @@ def test_get_timezone_function(self):
 
         timezone = "America/Los_Angeles"
         result = log_utils.get_timezone_function(timezone)
-        assert result.__name__ == "<lambda>"
+        # On systems without timezone data (common on Windows), this falls back to localtime
+        assert result.__name__ in ["<lambda>", "localtime"]
 
     def test_write_stderr(self):
         """Test write_stderr function output"""
@@ -657,7 +658,9 @@ def test_stderr_timezone_caching(self):
                 log_utils.write_stderr("Test UTC message")
 
             output = stderr_capture.getvalue()
-            assert "+0000" in output or "Z" in output  # UTC timezone indicator
+            # On systems with UTC timezone data, should have +0000 or Z
+            # On Windows without timezone data, falls back to local time (no timezone indicator)
+            assert "+0000" in output or "Z" in output or ("]:[ERROR]:" in output and "Test UTC message" in output)
         finally:
             if original_tz is not None:
                 os.environ["LOG_TIMEZONE"] = original_tz
@@ -804,6 +807,7 @@ def close(self):
         assert new_logger is logger
         assert len(new_logger.handlers) == 0
 
+    @pytest.mark.skipif(sys.platform == "win32", reason="Unix/Linux/macOS-specific chmod test")
     def test_remove_old_logs_file_error(self):
         """Test remove_old_logs error handling when file deletion fails"""
         with tempfile.TemporaryDirectory() as temp_dir:
@@ -922,6 +926,7 @@ def test_gzip_file_io_error(self):
             finally:
                 os.chmod(temp_dir, 0o755)  # Restore for cleanup
 
+    @pytest.mark.skipif(sys.platform == "win32", reason="Unix/Linux/macOS-specific chmod test")
     def test_gzip_file_deletion_error(self):
         """Test gzip_file_with_sufix error when source file deletion fails"""
         with tempfile.TemporaryDirectory() as temp_dir:
@@ -1096,7 +1101,8 @@ def test_get_timezone_function_edge_cases(self):
         """Test get_timezone_function with various timezone inputs."""
         # Test standard timezones
         utc_func = log_utils.get_timezone_function("UTC")
-        assert utc_func.__name__ == "gmtime"
+        # On systems without UTC timezone data (common on Windows), this falls back to localtime
+        assert utc_func.__name__ in ["gmtime", "localtime"]
 
         local_func = log_utils.get_timezone_function("localtime")
         assert local_func.__name__ == "localtime"
@@ -1110,7 +1116,8 @@ def test_get_timezone_function_edge_cases(self):
 
         # Test custom timezone
         custom_func = log_utils.get_timezone_function("America/New_York")
-        assert custom_func.__name__ == "<lambda>"
+        # On systems without timezone data (common on Windows), this falls back to localtime
+        assert custom_func.__name__ in ["<lambda>", "localtime"]
 
         # Test function returns proper time tuple
         time_tuple = custom_func()
@@ -1289,10 +1296,11 @@ def worker():
             for t in threads:
                 t.join()
 
-            # Both should have seen the directory in cache
+            # Both should have seen the directory in the cache
             assert all(results)
             assert temp_dir in log_utils._checked_directories
 
+    @pytest.mark.skipif(sys.platform == "win32", reason="Unix/Linux/macOS-specific FIFO test")
     def test_delete_file_special_file_coverage(self):
         """Test delete_file with special file that exists but is neither file nor dir."""
         # This tests the elif path_obj.exists() branch (line 125)
@@ -1362,7 +1370,7 @@ def test_write_stderr_local_timezone_path(self):
     def test_get_log_path_write_permission_error(self):
         """Test get_log_path when directory exists but write check fails (Unix/Linux/macOS)."""
         with tempfile.TemporaryDirectory() as temp_dir:
-            # Create directory and make it non-writable
+            # Create a directory and make it non-writable
             test_dir = os.path.join(temp_dir, "non_writable")
             os.makedirs(test_dir)
 

tests/core/test_log_utils_windows.py

@@ -37,24 +37,18 @@ class TestLogUtilsWindows:
     @pytest.mark.skipif(sys.platform != "win32", reason="Windows-specific tests")
     def test_check_directory_permissions_windows(self):
         """Test Windows-specific directory permission behavior."""
-        import tempfile
-        
-        # On Windows, create a test in a deeply nested path that doesn't exist
-        # Use a path that's more likely to cause permission issues
         with tempfile.TemporaryDirectory() as temp_dir:
             # Create a deeply nested path that should trigger directory creation
             nested_path = os.path.join(temp_dir, "level1", "level2", "level3", "level4")
 
-            # This should succeed and create the directories
-            result = log_utils.check_directory_permissions(nested_path)
-            assert result == True
+            # This should succeed and create the directories (function returns None)
+            log_utils.check_directory_permissions(nested_path)
             assert os.path.exists(nested_path)
 
             # Test with a path that contains invalid characters (Windows-specific)
             try:
                 invalid_chars_path = os.path.join(temp_dir, "invalid<>:|*?\"path")
                 # This might raise different exceptions on different Windows versions
-                # So we'll catch the general case
                 with pytest.raises((PermissionError, OSError, ValueError)) as exec_info:
                     log_utils.check_directory_permissions(invalid_chars_path)
                 # The specific error message may vary
@@ -160,13 +154,12 @@ def test_gzip_file_with_sufix_windows_safe(self):
             if os.path.exists(file_path):
                 safe_close_and_delete_file(None, file_path)
 
+
     @pytest.mark.skipif(sys.platform != "win32", reason="Windows-specific tests")
-    def test_gzip_file_cross_platform_retry_mechanism(self):
-        """Test that gzip_file_with_sufix handles Windows file locking with retry (cross-platform)"""
+    def test_gzip_file_windows_retry_mechanism(self):
+        """Test that gzip_file_with_sufix handles Windows file locking with retry."""
         from unittest.mock import patch
 
-        # Import test utilities from the same directory
-        
         # Create a Windows-safe temporary file
         file_handle, file_path = create_windows_safe_temp_file(suffix=".log", text=True)
 
@@ -175,8 +168,8 @@ def test_gzip_file_cross_platform_retry_mechanism(self):
             file_handle.write("test content for retry test")
             file_handle.close()
 
-            # Mock sys.platform to simulate Windows
-            with patch('pythonLogs.log_utils.sys.platform', 'win32'):
+            # Test both with and without platform mocking to ensure retry works
+            for mock_platform in [False, True]:
                 # Mock time.sleep to verify retry mechanism
                 with patch('pythonLogs.log_utils.time.sleep') as mock_sleep:
                     # Mock open to raise PermissionError on first call, succeed on second
@@ -193,71 +186,31 @@ def mock_open_side_effect(*args, **kwargs):
                             # Subsequent calls - use real open
                             return original_open(*args, **kwargs)
 
-                    with patch('pythonLogs.log_utils.open', side_effect=mock_open_side_effect):
-                        # This should succeed after retry
-                        result = log_utils.gzip_file_with_sufix(file_path, "retry_test")
+                    context_manager = (
+                        patch('pythonLogs.log_utils.sys.platform', 'win32') if mock_platform 
+                        else patch('pythonLogs.log_utils.open', side_effect=mock_open_side_effect)
+                    )
+                    
+                    with context_manager:
+                        if mock_platform:
+                            with patch('pythonLogs.log_utils.open', side_effect=mock_open_side_effect):
+                                result = log_utils.gzip_file_with_sufix(file_path, f"retry_test_{mock_platform}")
+                        else:
+                            result = log_utils.gzip_file_with_sufix(file_path, f"retry_test_{mock_platform}")
 
                         # Verify retry was attempted (sleep was called)
                         mock_sleep.assert_called_once_with(0.1)
 
                         # Verify the operation eventually succeeded
                         assert result is not None
-                        assert result.endswith("_retry_test.log.gz")
+                        assert f"retry_test_{mock_platform}" in result
 
                         # Clean up the gzipped file
                         if result and os.path.exists(result):
                             safe_close_and_delete_file(None, result)
-            
-        finally:
-            # Clean up the original file
-            if os.path.exists(file_path):
-                safe_close_and_delete_file(None, file_path)
-
-    @pytest.mark.skipif(sys.platform != "win32", reason="Windows-specific tests")
-    def test_gzip_file_windows_retry_mechanism(self):
-        """Test that gzip_file_with_sufix handles Windows file locking with retry."""
-        from unittest.mock import patch
-        
-        # Import test utilities from the same directory
-        
-        # Create a Windows-safe temporary file
-        file_handle, file_path = create_windows_safe_temp_file(suffix=".log", text=True)
-        
-        try:
-            # Write content and close properly
-            file_handle.write("test content for retry test")
-            file_handle.close()
-            
-            # Mock time.sleep to verify retry mechanism
-            with patch('pythonLogs.log_utils.time.sleep') as mock_sleep:
-                # Mock open to raise PermissionError on first call, succeed on second
-                call_count = 0
-                original_open = open
-                
-                def mock_open_side_effect(*args, **kwargs):
-                    nonlocal call_count
-                    call_count += 1
-                    if call_count == 1:
-                        # First call - simulate Windows file locking
-                        raise PermissionError("Permission denied")
-                    else:
-                        # Subsequent calls - use real open
-                        return original_open(*args, **kwargs)
-                
-                with patch('pythonLogs.log_utils.open', side_effect=mock_open_side_effect):
-                    # This should succeed after retry
-                    result = log_utils.gzip_file_with_sufix(file_path, "retry_test")
-                    
-                    # Verify retry was attempted (sleep was called)
-                    mock_sleep.assert_called_once_with(0.1)
-                    
-                    # Verify the operation eventually succeeded
-                    assert result is not None
-                    assert result.endswith("_retry_test.log.gz")
-                    
-                    # Clean up the gzipped file
-                    if result and os.path.exists(result):
-                        safe_close_and_delete_file(None, result)
+                        
+                        # Reset for next iteration
+                        call_count = 0
 
         finally:
             # Clean up the original file
@@ -459,44 +412,7 @@ def windows_file_worker(worker_id):
             assert result['gzip_result'] is not None
             assert f"worker_{result['worker_id']}" in result['gzip_result']
 
-    @pytest.mark.skipif(sys.platform != "win32", reason="Windows-specific tests")
-    def test_get_log_path_unix_chmod_behavior(self):
-        """Test get_log_path behavior with Unix-style chmod (Windows alternative test)."""
-        with tempfile.TemporaryDirectory() as temp_dir:
-            test_file = "test.log"
-            # Test 1: Valid directory should return the correct path
-            result = log_utils.get_log_path(temp_dir, test_file)
-            assert result == os.path.join(temp_dir, test_file)
-
-            # Test 2: Directory that gets created should work fine
-            new_dir = os.path.join(temp_dir, "newdir")
-            result = log_utils.get_log_path(new_dir, test_file)
-            assert result == os.path.join(new_dir, test_file)
-            assert os.path.exists(new_dir)  # Should have been created
-
-            # Test 3: On Windows, we don't test chmod-based permission errors
-            # since Windows permission model is different from Unix
-            # This test would be: readonly directory + PermissionError expectation
-            # But Windows handles this differently, so we skip it
-            pytest.skip("Unix-style chmod permission test not applicable on Windows")
 
-    @pytest.mark.skipif(sys.platform != "win32", reason="Windows-specific tests")
-    def test_get_log_path_permission_error_windows(self):
-        """Test get_log_path permission handling specific to Windows."""
-        with tempfile.TemporaryDirectory() as temp_dir:
-            # On Windows, we test different permission scenarios
-            # Windows doesn't use Unix-style chmod, so we test other error conditions
-            
-            # Test with invalid path characters (Windows-specific)
-            try:
-                invalid_path = os.path.join(temp_dir, "invalid<>path")
-                # This might succeed on some Windows systems, so we don't assert failure
-                result = log_utils.get_log_path(invalid_path, "test.log")
-                # If it succeeds, just verify the path is returned
-                assert "test.log" in result
-            except (PermissionError, OSError, ValueError):
-                # Expected on Windows with invalid characters
-                pass
 
     @pytest.mark.skipif(sys.platform != "win32", reason="Windows-specific tests")
     def test_gzip_file_windows_permission_error(self):
@@ -532,25 +448,40 @@ def test_gzip_file_windows_permission_error(self):
                 safe_close_and_delete_file(None, file_path)
 
     @pytest.mark.skipif(sys.platform != "win32", reason="Windows-specific tests")
-    def test_get_log_path_write_permission_windows(self):
-        """Test get_log_path write permission check specific to Windows."""
+    def test_get_log_path_windows_comprehensive(self):
+        """Comprehensive test for get_log_path Windows-specific behaviors."""
         with tempfile.TemporaryDirectory() as temp_dir:
-            # Create directory 
-            test_dir = os.path.join(temp_dir, "test_write_perm")
-            os.makedirs(test_dir)
+            test_file = "test.log"
+            
+            # Test 1: Valid directory should return the correct path
+            result = log_utils.get_log_path(temp_dir, test_file)
+            assert result == os.path.join(temp_dir, test_file)
+
+            # Test 2: Directory that gets created should work fine
+            new_dir = os.path.join(temp_dir, "newdir")
+            result = log_utils.get_log_path(new_dir, test_file)
+            assert result == os.path.join(new_dir, test_file)
+            assert os.path.exists(new_dir)  # Should have been created
 
-            # On Windows, we test different permission scenarios
-            # Windows permission model is different from Unix chmod
+            # Test 3: Test with invalid path characters (Windows-specific)
+            try:
+                invalid_path = os.path.join(temp_dir, "invalid<>path")
+                result = log_utils.get_log_path(invalid_path, "test.log")
+                assert "test.log" in result
+            except (PermissionError, OSError, ValueError):
+                # Expected on Windows with invalid characters
+                pass
 
-            # Test normal operation (should succeed)
+            # Test 4: Test normal operation in created directory
+            test_dir = os.path.join(temp_dir, "test_write_perm")
+            os.makedirs(test_dir)
             result = log_utils.get_log_path(test_dir, "test.log")
             assert result == os.path.join(test_dir, "test.log")
 
-            # Windows-specific: Test with long path names (Windows limitation)
+            # Test 5: Windows-specific long path names (Windows limitation)
             long_filename = "a" * 200 + ".log"  # Very long filename
             try:
                 result = log_utils.get_log_path(test_dir, long_filename)
-                # May succeed or fail depending on Windows version and filesystem
                 assert long_filename in result
             except (OSError, PermissionError):
                 # Expected on some Windows systems with path length limitations