crawlo 1.2.3__py3-none-any.whl → 1.2.4__py3-none-any.whl

tests/test_env_config.py

@@ -1,122 +1,122 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-环境变量配置工具测试
-"""
-import os
-import sys
-import unittest
-from unittest.mock import patch
-
-# 添加项目根目录到Python路径
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
-
-from crawlo.utils.env_config import EnvConfigManager, get_env_var, get_redis_config, get_runtime_config
-
-
-class TestEnvConfigManager(unittest.TestCase):
-    """环境变量配置管理器测试"""
-
-    def test_get_env_var_str(self):
-        """测试字符串环境变量获取"""
-        with patch.dict(os.environ, {'TEST_VAR': 'test_value'}):
-            result = EnvConfigManager.get_env_var('TEST_VAR', 'default', str)
-            self.assertEqual(result, 'test_value')
-        
-        # 测试默认值
-        result = EnvConfigManager.get_env_var('NON_EXISTENT_VAR', 'default', str)
-        self.assertEqual(result, 'default')
-
-    def test_get_env_var_int(self):
-        """测试整数环境变量获取"""
-        with patch.dict(os.environ, {'TEST_INT': '42'}):
-            result = EnvConfigManager.get_env_var('TEST_INT', 0, int)
-            self.assertEqual(result, 42)
-        
-        # 测试默认值
-        result = EnvConfigManager.get_env_var('NON_EXISTENT_VAR', 10, int)
-        self.assertEqual(result, 10)
-        
-        # 测试无效值
-        with patch.dict(os.environ, {'INVALID_INT': 'not_a_number'}):
-            result = EnvConfigManager.get_env_var('INVALID_INT', 5, int)
-            self.assertEqual(result, 5)
-
-    def test_get_env_var_float(self):
-        """测试浮点数环境变量获取"""
-        with patch.dict(os.environ, {'TEST_FLOAT': '3.14'}):
-            result = EnvConfigManager.get_env_var('TEST_FLOAT', 0.0, float)
-            self.assertEqual(result, 3.14)
-        
-        # 测试默认值
-        result = EnvConfigManager.get_env_var('NON_EXISTENT_VAR', 2.5, float)
-        self.assertEqual(result, 2.5)
-
-    def test_get_env_var_bool(self):
-        """测试布尔环境变量获取"""
-        # 测试 True 值
-        for true_val in ['1', 'true', 'True', 'TRUE', 'yes', 'on']:
-            with patch.dict(os.environ, {'TEST_BOOL': true_val}):
-                result = EnvConfigManager.get_env_var('TEST_BOOL', False, bool)
-                self.assertTrue(result)
-        
-        # 测试 False 值
-        for false_val in ['0', 'false', 'False', 'FALSE', 'no', 'off', '']:
-            with patch.dict(os.environ, {'TEST_BOOL': false_val}):
-                result = EnvConfigManager.get_env_var('TEST_BOOL', True, bool)
-                self.assertFalse(result)
-        
-        # 测试默认值
-        result = EnvConfigManager.get_env_var('NON_EXISTENT_VAR', True, bool)
-        self.assertTrue(result)
-
-    def test_get_redis_config(self):
-        """测试 Redis 配置获取"""
-        with patch.dict(os.environ, {
-            'REDIS_HOST': 'localhost',
-            'REDIS_PORT': '6380',
-            'REDIS_PASSWORD': 'secret',
-            'REDIS_DB': '1'
-        }):
-            config = get_redis_config()
-            self.assertEqual(config['REDIS_HOST'], 'localhost')
-            self.assertEqual(config['REDIS_PORT'], 6380)
-            self.assertEqual(config['REDIS_PASSWORD'], 'secret')
-            self.assertEqual(config['REDIS_DB'], 1)
-        
-        # 测试默认值
-        with patch.dict(os.environ, {}):
-            config = get_redis_config()
-            self.assertEqual(config['REDIS_HOST'], '127.0.0.1')
-            self.assertEqual(config['REDIS_PORT'], 6379)
-            self.assertEqual(config['REDIS_PASSWORD'], '')
-            self.assertEqual(config['REDIS_DB'], 0)
-
-    def test_get_runtime_config(self):
-        """测试运行时配置获取"""
-        with patch.dict(os.environ, {
-            'CRAWLO_MODE': 'distributed',
-            'PROJECT_NAME': 'test_project',
-            'CONCURRENCY': '20'
-        }):
-            config = get_runtime_config()
-            self.assertEqual(config['CRAWLO_MODE'], 'distributed')
-            self.assertEqual(config['PROJECT_NAME'], 'test_project')
-            self.assertEqual(config['CONCURRENCY'], 20)
-        
-        # 测试默认值
-        with patch.dict(os.environ, {}):
-            config = get_runtime_config()
-            self.assertEqual(config['CRAWLO_MODE'], 'standalone')
-            self.assertEqual(config['PROJECT_NAME'], 'crawlo')
-            self.assertEqual(config['CONCURRENCY'], 8)
-
-    def test_convenience_functions(self):
-        """测试便捷函数"""
-        with patch.dict(os.environ, {'TEST_CONVENIENCE': 'convenience_value'}):
-            result = get_env_var('TEST_CONVENIENCE', 'default')
-            self.assertEqual(result, 'convenience_value')
-
-
-if __name__ == '__main__':
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+环境变量配置工具测试
+"""
+import os
+import sys
+import unittest
+from unittest.mock import patch
+
+# 添加项目根目录到Python路径
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+
+from crawlo.utils.env_config import EnvConfigManager, get_env_var, get_redis_config, get_runtime_config
+
+
+class TestEnvConfigManager(unittest.TestCase):
+    """环境变量配置管理器测试"""
+
+    def test_get_env_var_str(self):
+        """测试字符串环境变量获取"""
+        with patch.dict(os.environ, {'TEST_VAR': 'test_value'}):
+            result = EnvConfigManager.get_env_var('TEST_VAR', 'default', str)
+            self.assertEqual(result, 'test_value')
+        
+        # 测试默认值
+        result = EnvConfigManager.get_env_var('NON_EXISTENT_VAR', 'default', str)
+        self.assertEqual(result, 'default')
+
+    def test_get_env_var_int(self):
+        """测试整数环境变量获取"""
+        with patch.dict(os.environ, {'TEST_INT': '42'}):
+            result = EnvConfigManager.get_env_var('TEST_INT', 0, int)
+            self.assertEqual(result, 42)
+        
+        # 测试默认值
+        result = EnvConfigManager.get_env_var('NON_EXISTENT_VAR', 10, int)
+        self.assertEqual(result, 10)
+        
+        # 测试无效值
+        with patch.dict(os.environ, {'INVALID_INT': 'not_a_number'}):
+            result = EnvConfigManager.get_env_var('INVALID_INT', 5, int)
+            self.assertEqual(result, 5)
+
+    def test_get_env_var_float(self):
+        """测试浮点数环境变量获取"""
+        with patch.dict(os.environ, {'TEST_FLOAT': '3.14'}):
+            result = EnvConfigManager.get_env_var('TEST_FLOAT', 0.0, float)
+            self.assertEqual(result, 3.14)
+        
+        # 测试默认值
+        result = EnvConfigManager.get_env_var('NON_EXISTENT_VAR', 2.5, float)
+        self.assertEqual(result, 2.5)
+
+    def test_get_env_var_bool(self):
+        """测试布尔环境变量获取"""
+        # 测试 True 值
+        for true_val in ['1', 'true', 'True', 'TRUE', 'yes', 'on']:
+            with patch.dict(os.environ, {'TEST_BOOL': true_val}):
+                result = EnvConfigManager.get_env_var('TEST_BOOL', False, bool)
+                self.assertTrue(result)
+        
+        # 测试 False 值
+        for false_val in ['0', 'false', 'False', 'FALSE', 'no', 'off', '']:
+            with patch.dict(os.environ, {'TEST_BOOL': false_val}):
+                result = EnvConfigManager.get_env_var('TEST_BOOL', True, bool)
+                self.assertFalse(result)
+        
+        # 测试默认值
+        result = EnvConfigManager.get_env_var('NON_EXISTENT_VAR', True, bool)
+        self.assertTrue(result)
+
+    def test_get_redis_config(self):
+        """测试 Redis 配置获取"""
+        with patch.dict(os.environ, {
+            'REDIS_HOST': 'localhost',
+            'REDIS_PORT': '6380',
+            'REDIS_PASSWORD': 'secret',
+            'REDIS_DB': '1'
+        }):
+            config = get_redis_config()
+            self.assertEqual(config['REDIS_HOST'], 'localhost')
+            self.assertEqual(config['REDIS_PORT'], 6380)
+            self.assertEqual(config['REDIS_PASSWORD'], 'secret')
+            self.assertEqual(config['REDIS_DB'], 1)
+        
+        # 测试默认值
+        with patch.dict(os.environ, {}):
+            config = get_redis_config()
+            self.assertEqual(config['REDIS_HOST'], '127.0.0.1')
+            self.assertEqual(config['REDIS_PORT'], 6379)
+            self.assertEqual(config['REDIS_PASSWORD'], '')
+            self.assertEqual(config['REDIS_DB'], 0)
+
+    def test_get_runtime_config(self):
+        """测试运行时配置获取"""
+        with patch.dict(os.environ, {
+            'CRAWLO_MODE': 'distributed',
+            'PROJECT_NAME': 'test_project',
+            'CONCURRENCY': '20'
+        }):
+            config = get_runtime_config()
+            self.assertEqual(config['CRAWLO_MODE'], 'distributed')
+            self.assertEqual(config['PROJECT_NAME'], 'test_project')
+            self.assertEqual(config['CONCURRENCY'], 20)
+        
+        # 测试默认值
+        with patch.dict(os.environ, {}):
+            config = get_runtime_config()
+            self.assertEqual(config['CRAWLO_MODE'], 'standalone')
+            self.assertEqual(config['PROJECT_NAME'], 'crawlo')
+            self.assertEqual(config['CONCURRENCY'], 8)
+
+    def test_convenience_functions(self):
+        """测试便捷函数"""
+        with patch.dict(os.environ, {'TEST_CONVENIENCE': 'convenience_value'}):
+            result = get_env_var('TEST_CONVENIENCE', 'default')
+            self.assertEqual(result, 'convenience_value')
+
+
+if __name__ == '__main__':
     unittest.main()

tests/test_error_handler_compatibility.py

@@ -1,113 +1,113 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-错误处理模块兼容性测试
-验证简化版 ErrorHandler 与增强版 EnhancedErrorHandler 的兼容性
-"""
-import sys
-import os
-import unittest
-from unittest.mock import patch, MagicMock
-
-# 添加项目根目录到Python路径
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
-
-from crawlo.utils.error_handler import ErrorHandler, default_error_handler, handle_exception
-from crawlo.utils.enhanced_error_handler import EnhancedErrorHandler
-
-
-class TestErrorHandlerCompatibility(unittest.TestCase):
-    """错误处理模块兼容性测试"""
-
-    def setUp(self):
-        """测试前准备"""
-        self.error_handler = ErrorHandler("test_logger")
-        # 禁用实际日志输出
-        self.error_handler.logger.error = MagicMock()
-        self.error_handler.logger.debug = MagicMock()
-        self.error_handler._enhanced_handler.logger.error = MagicMock()
-        self.error_handler._enhanced_handler.logger.debug = MagicMock()
-
-    def test_init(self):
-        """测试初始化"""
-        self.assertIsInstance(self.error_handler._enhanced_handler, EnhancedErrorHandler)
-        self.assertEqual(self.error_handler._enhanced_handler.logger.name, "test_logger")
-
-    def test_handle_error(self):
-        """测试错误处理"""
-        test_exception = ValueError("Test error")
-        
-        # 测试不抛出异常的情况
-        try:
-            self.error_handler.handle_error(test_exception, "Test context", raise_error=False)
-        except Exception:
-            self.fail("handle_error should not raise exception when raise_error=False")
-        
-        # 验证增强版处理器被调用（通过检查日志是否被调用）
-        self.assertTrue(self.error_handler._enhanced_handler.logger.error.called)
-
-    def test_safe_call(self):
-        """测试安全调用"""
-        def failing_function():
-            raise RuntimeError("Function failed")
-        
-        # 测试函数失败时返回默认值
-        result = self.error_handler.safe_call(failing_function, default_return="default")
-        self.assertEqual(result, "default")
-        
-        # 测试正常函数
-        def normal_function(x, y):
-            return x + y
-        
-        result = self.error_handler.safe_call(normal_function, 1, 2, default_return=0)
-        self.assertEqual(result, 3)
-
-    def test_retry_on_failure(self):
-        """测试失败重试装饰器"""
-        call_count = 0
-        
-        @self.error_handler.retry_on_failure(max_retries=2, delay=0.01)
-        def failing_function():
-            nonlocal call_count
-            call_count += 1
-            if call_count < 3:
-                raise ValueError("Temporary failure")
-            return "success"
-        
-        # 第三次调用应该成功
-        result = failing_function()
-        self.assertEqual(result, "success")
-        self.assertEqual(call_count, 3)
-
-    def test_handle_exception_decorator(self):
-        """测试异常处理装饰器"""
-        @handle_exception(context="Test function", raise_error=False)
-        def decorated_function():
-            raise ValueError("Decorated function error")
-        
-        # 调用装饰后的函数不应该抛出异常
-        try:
-            decorated_function()
-        except Exception:
-            self.fail("Decorated function should not raise exception when raise_error=False")
-
-    def test_async_handle_exception_decorator(self):
-        """测试异步异常处理装饰器"""
-        import asyncio
-        
-        @handle_exception(context="Async test function", raise_error=False)
-        async def async_decorated_function():
-            raise ValueError("Async decorated function error")
-        
-        # 调用装饰后的异步函数不应该抛出异常
-        async def test_async():
-            try:
-                await async_decorated_function()
-            except Exception:
-                self.fail("Async decorated function should not raise exception when raise_error=False")
-        
-        asyncio.run(test_async())
-
-
-if __name__ == '__main__':
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+错误处理模块兼容性测试
+验证简化版 ErrorHandler 与增强版 EnhancedErrorHandler 的兼容性
+"""
+import sys
+import os
+import unittest
+from unittest.mock import patch, MagicMock
+
+# 添加项目根目录到Python路径
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+
+from crawlo.utils.error_handler import ErrorHandler, default_error_handler, handle_exception
+from crawlo.utils.enhanced_error_handler import EnhancedErrorHandler
+
+
+class TestErrorHandlerCompatibility(unittest.TestCase):
+    """错误处理模块兼容性测试"""
+
+    def setUp(self):
+        """测试前准备"""
+        self.error_handler = ErrorHandler("test_logger")
+        # 禁用实际日志输出
+        self.error_handler.logger.error = MagicMock()
+        self.error_handler.logger.debug = MagicMock()
+        self.error_handler._enhanced_handler.logger.error = MagicMock()
+        self.error_handler._enhanced_handler.logger.debug = MagicMock()
+
+    def test_init(self):
+        """测试初始化"""
+        self.assertIsInstance(self.error_handler._enhanced_handler, EnhancedErrorHandler)
+        self.assertEqual(self.error_handler._enhanced_handler.logger.name, "test_logger")
+
+    def test_handle_error(self):
+        """测试错误处理"""
+        test_exception = ValueError("Test error")
+        
+        # 测试不抛出异常的情况
+        try:
+            self.error_handler.handle_error(test_exception, "Test context", raise_error=False)
+        except Exception:
+            self.fail("handle_error should not raise exception when raise_error=False")
+        
+        # 验证增强版处理器被调用（通过检查日志是否被调用）
+        self.assertTrue(self.error_handler._enhanced_handler.logger.error.called)
+
+    def test_safe_call(self):
+        """测试安全调用"""
+        def failing_function():
+            raise RuntimeError("Function failed")
+        
+        # 测试函数失败时返回默认值
+        result = self.error_handler.safe_call(failing_function, default_return="default")
+        self.assertEqual(result, "default")
+        
+        # 测试正常函数
+        def normal_function(x, y):
+            return x + y
+        
+        result = self.error_handler.safe_call(normal_function, 1, 2, default_return=0)
+        self.assertEqual(result, 3)
+
+    def test_retry_on_failure(self):
+        """测试失败重试装饰器"""
+        call_count = 0
+        
+        @self.error_handler.retry_on_failure(max_retries=2, delay=0.01)
+        def failing_function():
+            nonlocal call_count
+            call_count += 1
+            if call_count < 3:
+                raise ValueError("Temporary failure")
+            return "success"
+        
+        # 第三次调用应该成功
+        result = failing_function()
+        self.assertEqual(result, "success")
+        self.assertEqual(call_count, 3)
+
+    def test_handle_exception_decorator(self):
+        """测试异常处理装饰器"""
+        @handle_exception(context="Test function", raise_error=False)
+        def decorated_function():
+            raise ValueError("Decorated function error")
+        
+        # 调用装饰后的函数不应该抛出异常
+        try:
+            decorated_function()
+        except Exception:
+            self.fail("Decorated function should not raise exception when raise_error=False")
+
+    def test_async_handle_exception_decorator(self):
+        """测试异步异常处理装饰器"""
+        import asyncio
+        
+        @handle_exception(context="Async test function", raise_error=False)
+        async def async_decorated_function():
+            raise ValueError("Async decorated function error")
+        
+        # 调用装饰后的异步函数不应该抛出异常
+        async def test_async():
+            try:
+                await async_decorated_function()
+            except Exception:
+                self.fail("Async decorated function should not raise exception when raise_error=False")
+        
+        asyncio.run(test_async())
+
+
+if __name__ == '__main__':
     unittest.main()