crawlo 1.4.1__py3-none-any.whl → 1.4.3__py3-none-any.whl

tests/test_authenticated_proxy.py

@@ -1,142 +1,142 @@
-#!/usr/bin/python
-# -*- coding: UTF-8 -*-
-"""
-测试带认证代理的功能
-"""
-
-import asyncio
-import aiohttp
-import httpx
-from crawlo.network.request import Request
-from crawlo.tools import AuthenticatedProxy
-
-
-async def test_proxy_with_aiohttp():
-    """测试AioHttp与认证代理"""
-    print("=== 测试AioHttp与认证代理 ===")
-    
-    # 代理配置
-    proxy_config = {
-        "http": "http://dwe20241014:Dwe0101014@182.201.243.186:58111",
-        "https": "http://dwe20241014:Dwe0101014@182.201.243.186:58111"
-    }
-    
-    # 创建代理对象
-    proxy_url = proxy_config["http"]
-    proxy = AuthenticatedProxy(proxy_url)
-    
-    print(f"原始代理URL: {proxy_url}")
-    print(f"清洁URL: {proxy.clean_url}")
-    print(f"认证信息: {proxy.get_auth_credentials()}")
-    
-    # 使用aiohttp直接测试
-    try:
-        auth = proxy.get_auth_credentials()
-        if auth:
-            basic_auth = aiohttp.BasicAuth(auth['username'], auth['password'])
-        else:
-            basic_auth = None
-            
-        async with aiohttp.ClientSession() as session:
-            async with session.get(
-                "https://httpbin.org/ip",
-                proxy=proxy.clean_url,
-                proxy_auth=basic_auth
-            ) as response:
-                print(f"AioHttp测试成功!")
-                print(f"状态码: {response.status}")
-                content = await response.text()
-                print(f"响应内容: {content[:200]}...")
-                
-    except Exception as e:
-        print(f"AioHttp测试失败: {e}")
-        import traceback
-        traceback.print_exc()
-
-
-def test_proxy_with_httpx():
-    """测试HttpX与认证代理"""
-    print("\n=== 测试HttpX与认证代理 ===")
-    
-    # 代理配置
-    proxy_config = {
-        "http": "http://dwe20241014:Dwe0101014@182.201.243.186:58111",
-        "https": "http://dwe20241014:Dwe0101014@182.201.243.186:58111"
-    }
-    
-    # 使用httpx直接测试
-    try:
-        # HttpX可以直接使用带认证的URL作为proxy参数
-        proxy_url = proxy_config["http"]
-        
-        with httpx.Client(proxy=proxy_url) as client:
-            response = client.get("https://httpbin.org/ip")
-            print(f"HttpX测试成功!")
-            print(f"状态码: {response.status_code}")
-            print(f"响应内容: {response.text[:200]}...")
-                
-    except Exception as e:
-        print(f"HttpX测试失败: {e}")
-        import traceback
-        traceback.print_exc()
-
-
-async def test_proxy_with_curl_cffi():
-    """测试CurlCffi与认证代理"""
-    print("\n=== 测试CurlCffi与认证代理 ===")
-    
-    # 代理配置
-    proxy_config = {
-        "http": "http://dwe20241014:Dwe0101014@182.201.243.186:58111",
-        "https": "http://dwe20241014:Dwe0101014@182.201.243.186:58111"
-    }
-    
-    # 创建代理对象
-    proxy_url = proxy_config["http"]
-    proxy = AuthenticatedProxy(proxy_url)
-    
-    print(f"原始代理URL: {proxy_url}")
-    print(f"代理字典: {proxy.proxy_dict}")
-    print(f"认证头: {proxy.get_auth_header()}")
-    
-    # 使用curl-cffi直接测试
-    try:
-        from curl_cffi import requests as curl_requests
-        
-        # 设置代理和认证头
-        proxies = proxy.proxy_dict
-        headers = {}
-        auth_header = proxy.get_auth_header()
-        if auth_header:
-            headers["Proxy-Authorization"] = auth_header
-            
-        response = curl_requests.get(
-            "https://httpbin.org/ip",
-            proxies=proxies,
-            headers=headers
-        )
-        
-        print(f"CurlCffi测试成功!")
-        print(f"状态码: {response.status_code}")
-        print(f"响应内容: {response.text[:200]}...")
-                
-    except Exception as e:
-        print(f"CurlCffi测试失败: {e}")
-        import traceback
-        traceback.print_exc()
-
-
-async def main():
-    """主测试函数"""
-    print("开始测试带认证代理的功能...\n")
-    
-    # 测试各个库
-    await test_proxy_with_aiohttp()
-    test_proxy_with_httpx()
-    await test_proxy_with_curl_cffi()
-    
-    print("\n所有测试完成!")
-
-
-if __name__ == "__main__":
+#!/usr/bin/python
+# -*- coding: UTF-8 -*-
+"""
+测试带认证代理的功能
+"""
+
+import asyncio
+import aiohttp
+import httpx
+from crawlo.network.request import Request
+from crawlo.tools import AuthenticatedProxy
+
+
+async def test_proxy_with_aiohttp():
+    """测试AioHttp与认证代理"""
+    print("=== 测试AioHttp与认证代理 ===")
+    
+    # 代理配置
+    proxy_config = {
+        "http": "http://dwe20241014:Dwe0101014@182.201.243.186:58111",
+        "https": "http://dwe20241014:Dwe0101014@182.201.243.186:58111"
+    }
+    
+    # 创建代理对象
+    proxy_url = proxy_config["http"]
+    proxy = AuthenticatedProxy(proxy_url)
+    
+    print(f"原始代理URL: {proxy_url}")
+    print(f"清洁URL: {proxy.clean_url}")
+    print(f"认证信息: {proxy.get_auth_credentials()}")
+    
+    # 使用aiohttp直接测试
+    try:
+        auth = proxy.get_auth_credentials()
+        if auth:
+            basic_auth = aiohttp.BasicAuth(auth['username'], auth['password'])
+        else:
+            basic_auth = None
+            
+        async with aiohttp.ClientSession() as session:
+            async with session.get(
+                "https://httpbin.org/ip",
+                proxy=proxy.clean_url,
+                proxy_auth=basic_auth
+            ) as response:
+                print(f"AioHttp测试成功!")
+                print(f"状态码: {response.status}")
+                content = await response.text()
+                print(f"响应内容: {content[:200]}...")
+                
+    except Exception as e:
+        print(f"AioHttp测试失败: {e}")
+        import traceback
+        traceback.print_exc()
+
+
+def test_proxy_with_httpx():
+    """测试HttpX与认证代理"""
+    print("\n=== 测试HttpX与认证代理 ===")
+    
+    # 代理配置
+    proxy_config = {
+        "http": "http://dwe20241014:Dwe0101014@182.201.243.186:58111",
+        "https": "http://dwe20241014:Dwe0101014@182.201.243.186:58111"
+    }
+    
+    # 使用httpx直接测试
+    try:
+        # HttpX可以直接使用带认证的URL作为proxy参数
+        proxy_url = proxy_config["http"]
+        
+        with httpx.Client(proxy=proxy_url) as client:
+            response = client.get("https://httpbin.org/ip")
+            print(f"HttpX测试成功!")
+            print(f"状态码: {response.status_code}")
+            print(f"响应内容: {response.text[:200]}...")
+                
+    except Exception as e:
+        print(f"HttpX测试失败: {e}")
+        import traceback
+        traceback.print_exc()
+
+
+async def test_proxy_with_curl_cffi():
+    """测试CurlCffi与认证代理"""
+    print("\n=== 测试CurlCffi与认证代理 ===")
+    
+    # 代理配置
+    proxy_config = {
+        "http": "http://dwe20241014:Dwe0101014@182.201.243.186:58111",
+        "https": "http://dwe20241014:Dwe0101014@182.201.243.186:58111"
+    }
+    
+    # 创建代理对象
+    proxy_url = proxy_config["http"]
+    proxy = AuthenticatedProxy(proxy_url)
+    
+    print(f"原始代理URL: {proxy_url}")
+    print(f"代理字典: {proxy.proxy_dict}")
+    print(f"认证头: {proxy.get_auth_header()}")
+    
+    # 使用curl-cffi直接测试
+    try:
+        from curl_cffi import requests as curl_requests
+        
+        # 设置代理和认证头
+        proxies = proxy.proxy_dict
+        headers = {}
+        auth_header = proxy.get_auth_header()
+        if auth_header:
+            headers["Proxy-Authorization"] = auth_header
+            
+        response = curl_requests.get(
+            "https://httpbin.org/ip",
+            proxies=proxies,
+            headers=headers
+        )
+        
+        print(f"CurlCffi测试成功!")
+        print(f"状态码: {response.status_code}")
+        print(f"响应内容: {response.text[:200]}...")
+                
+    except Exception as e:
+        print(f"CurlCffi测试失败: {e}")
+        import traceback
+        traceback.print_exc()
+
+
+async def main():
+    """主测试函数"""
+    print("开始测试带认证代理的功能...\n")
+    
+    # 测试各个库
+    await test_proxy_with_aiohttp()
+    test_proxy_with_httpx()
+    await test_proxy_with_curl_cffi()
+    
+    print("\n所有测试完成!")
+
+
+if __name__ == "__main__":
     asyncio.run(main())

tests/test_batch_processor.py

@@ -1,179 +1,179 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-批处理工具测试
-测试 BatchProcessor, RedisBatchProcessor, batch_process
-"""
-import sys
-import os
-import unittest
-from unittest.mock import Mock, patch, MagicMock
-import asyncio
-
-# 添加项目根目录到 Python 路径
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
-
-from crawlo.utils.batch_processor import BatchProcessor, RedisBatchProcessor, batch_process
-
-
-class TestBatchProcessor(unittest.TestCase):
-    """批处理工具测试类"""
-
-    def setUp(self):
-        """测试前准备"""
-        self.batch_processor = BatchProcessor(batch_size=3, max_concurrent_batches=2)
-        
-    def test_batch_processor_initialization(self):
-        """测试批处理器初始化"""
-        self.assertEqual(self.batch_processor.batch_size, 3)
-        self.assertEqual(self.batch_processor.max_concurrent_batches, 2)
-        
-    def sync_process_item(self, item):
-        """同步处理函数"""
-        return item * 2
-        
-    def test_batch_processor_process_batch_sync(self):
-        """测试批处理器同步处理批次"""
-        items = [1, 2, 3]
-        # 使用事件循环运行异步方法
-        results = asyncio.run(self.batch_processor.process_batch(items, self.sync_process_item))
-        self.assertEqual(results, [2, 4, 6])
-        
-    def test_batch_processor_process_in_batches_sync(self):
-        """测试批处理器同步分批处理大量数据"""
-        items = [1, 2, 3, 4, 5, 6, 7]
-        # 使用事件循环运行异步方法
-        results = asyncio.run(self.batch_processor.process_in_batches(items, self.sync_process_item))
-        expected = [2, 4, 6, 8, 10, 12, 14]
-        self.assertEqual(results, expected)
-        
-    def test_batch_processor_with_exception_handling(self):
-        """测试批处理器异常处理"""
-        def failing_processor(item):
-            if item == 2:
-                raise ValueError("处理失败")
-            return item * 2
-            
-        items = [1, 2, 3]
-        # 使用事件循环运行异步方法
-        results = asyncio.run(self.batch_processor.process_batch(items, failing_processor))
-        # 异常项应该被过滤掉
-        self.assertIn(2, results)
-        self.assertIn(6, results)
-        # 检查长度至少为2
-        self.assertGreaterEqual(len(results), 2)
-        
-    def test_batch_processor_decorator(self):
-        """测试批处理器装饰器"""
-        @self.batch_processor.batch_process_decorator(batch_size=2)
-        def process_func(items):
-            return [item * 3 for item in items]
-            
-        items = [1, 2, 3, 4]
-        results = process_func(items)
-        # 检查结果不为空
-        self.assertIsNotNone(results)
-        self.assertIsInstance(results, list)
-
-
-class TestRedisBatchProcessor(unittest.TestCase):
-    """Redis批处理器测试类"""
-
-    def setUp(self):
-        """测试前准备"""
-        self.mock_redis_client = Mock()
-        self.redis_batch_processor = RedisBatchProcessor(self.mock_redis_client, batch_size=3)
-        
-    def test_redis_batch_processor_initialization(self):
-        """测试Redis批处理器初始化"""
-        self.assertEqual(self.redis_batch_processor.batch_size, 3)
-        self.assertEqual(self.redis_batch_processor.redis_client, self.mock_redis_client)
-        
-    def test_redis_batch_processor_batch_set(self):
-        """测试Redis批处理器批量设置"""
-        items = [
-            {'key': 'key1', 'value': 'value1'},
-            {'key': 'key2', 'value': 'value2'},
-            {'key': 'key3', 'value': 'value3'}
-        ]
-        
-        # 模拟pipeline行为
-        mock_pipe = Mock()
-        self.mock_redis_client.pipeline.return_value = mock_pipe
-        mock_pipe.execute.return_value = None  # execute方法返回None
-        mock_pipe.set.return_value = mock_pipe  # set方法返回pipe自身以支持链式调用
-        
-        # 使用事件循环运行异步方法
-        count = asyncio.run(self.redis_batch_processor.batch_set(items))
-        self.assertEqual(count, 3)
-        
-    def test_redis_batch_processor_batch_set_empty(self):
-        """测试Redis批处理器批量设置空列表"""
-        items = []
-        # 使用事件循环运行异步方法
-        count = asyncio.run(self.redis_batch_processor.batch_set(items))
-        self.assertEqual(count, 0)
-        
-    def test_redis_batch_processor_batch_get(self):
-        """测试Redis批处理器批量获取"""
-        keys = ['key1', 'key2', 'key3']
-        
-        # 模拟pipeline行为
-        mock_pipe = Mock()
-        self.mock_redis_client.pipeline.return_value = mock_pipe
-        mock_pipe.get.return_value = mock_pipe  # get方法返回pipe自身以支持链式调用
-        mock_pipe.execute.return_value = ['value1', 'value2', 'value3']
-        
-        # 使用事件循环运行异步方法
-        result = asyncio.run(self.redis_batch_processor.batch_get(keys))
-        expected = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
-        self.assertEqual(result, expected)
-        
-    def test_redis_batch_processor_batch_get_with_none_values(self):
-        """测试Redis批处理器批量获取包含None值"""
-        keys = ['key1', 'key2', 'key3']
-        
-        # 模拟pipeline行为，其中key2返回None
-        mock_pipe = Mock()
-        self.mock_redis_client.pipeline.return_value = mock_pipe
-        mock_pipe.get.return_value = mock_pipe  # get方法返回pipe自身以支持链式调用
-        mock_pipe.execute.return_value = ['value1', None, 'value3']
-        
-        # 使用事件循环运行异步方法
-        result = asyncio.run(self.redis_batch_processor.batch_get(keys))
-        expected = {'key1': 'value1', 'key3': 'value3'}  # key2应该被过滤掉
-        self.assertEqual(result, expected)
-        
-    def test_redis_batch_processor_batch_delete(self):
-        """测试Redis批处理器批量删除"""
-        keys = ['key1', 'key2', 'key3']
-        
-        # 模拟pipeline行为
-        mock_pipe = Mock()
-        self.mock_redis_client.pipeline.return_value = mock_pipe
-        mock_pipe.delete.return_value = mock_pipe  # delete方法返回pipe自身以支持链式调用
-        mock_pipe.execute.return_value = None
-        
-        # 使用事件循环运行异步方法
-        count = asyncio.run(self.redis_batch_processor.batch_delete(keys))
-        self.assertEqual(count, 3)
-
-
-class TestBatchProcessFunction(unittest.TestCase):
-    """批处理便捷函数测试类"""
-
-    def sync_process_item(self, item):
-        """同步处理函数"""
-        return item * 2
-        
-    def test_batch_process_sync_function(self):
-        """测试批处理便捷函数处理同步函数"""
-        items = [1, 2, 3, 4, 5]
-        results = batch_process(items, self.sync_process_item, batch_size=2, max_concurrent_batches=2)
-        expected = [2, 4, 6, 8, 10]
-        self.assertEqual(results, expected)
-
-
-if __name__ == '__main__':
-    # 运行测试
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+批处理工具测试
+测试 BatchProcessor, RedisBatchProcessor, batch_process
+"""
+import sys
+import os
+import unittest
+from unittest.mock import Mock, patch, MagicMock
+import asyncio
+
+# 添加项目根目录到 Python 路径
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+
+from crawlo.utils.batch_processor import BatchProcessor, RedisBatchProcessor, batch_process
+
+
+class TestBatchProcessor(unittest.TestCase):
+    """批处理工具测试类"""
+
+    def setUp(self):
+        """测试前准备"""
+        self.batch_processor = BatchProcessor(batch_size=3, max_concurrent_batches=2)
+        
+    def test_batch_processor_initialization(self):
+        """测试批处理器初始化"""
+        self.assertEqual(self.batch_processor.batch_size, 3)
+        self.assertEqual(self.batch_processor.max_concurrent_batches, 2)
+        
+    def sync_process_item(self, item):
+        """同步处理函数"""
+        return item * 2
+        
+    def test_batch_processor_process_batch_sync(self):
+        """测试批处理器同步处理批次"""
+        items = [1, 2, 3]
+        # 使用事件循环运行异步方法
+        results = asyncio.run(self.batch_processor.process_batch(items, self.sync_process_item))
+        self.assertEqual(results, [2, 4, 6])
+        
+    def test_batch_processor_process_in_batches_sync(self):
+        """测试批处理器同步分批处理大量数据"""
+        items = [1, 2, 3, 4, 5, 6, 7]
+        # 使用事件循环运行异步方法
+        results = asyncio.run(self.batch_processor.process_in_batches(items, self.sync_process_item))
+        expected = [2, 4, 6, 8, 10, 12, 14]
+        self.assertEqual(results, expected)
+        
+    def test_batch_processor_with_exception_handling(self):
+        """测试批处理器异常处理"""
+        def failing_processor(item):
+            if item == 2:
+                raise ValueError("处理失败")
+            return item * 2
+            
+        items = [1, 2, 3]
+        # 使用事件循环运行异步方法
+        results = asyncio.run(self.batch_processor.process_batch(items, failing_processor))
+        # 异常项应该被过滤掉
+        self.assertIn(2, results)
+        self.assertIn(6, results)
+        # 检查长度至少为2
+        self.assertGreaterEqual(len(results), 2)
+        
+    def test_batch_processor_decorator(self):
+        """测试批处理器装饰器"""
+        @self.batch_processor.batch_process_decorator(batch_size=2)
+        def process_func(items):
+            return [item * 3 for item in items]
+            
+        items = [1, 2, 3, 4]
+        results = process_func(items)
+        # 检查结果不为空
+        self.assertIsNotNone(results)
+        self.assertIsInstance(results, list)
+
+
+class TestRedisBatchProcessor(unittest.TestCase):
+    """Redis批处理器测试类"""
+
+    def setUp(self):
+        """测试前准备"""
+        self.mock_redis_client = Mock()
+        self.redis_batch_processor = RedisBatchProcessor(self.mock_redis_client, batch_size=3)
+        
+    def test_redis_batch_processor_initialization(self):
+        """测试Redis批处理器初始化"""
+        self.assertEqual(self.redis_batch_processor.batch_size, 3)
+        self.assertEqual(self.redis_batch_processor.redis_client, self.mock_redis_client)
+        
+    def test_redis_batch_processor_batch_set(self):
+        """测试Redis批处理器批量设置"""
+        items = [
+            {'key': 'key1', 'value': 'value1'},
+            {'key': 'key2', 'value': 'value2'},
+            {'key': 'key3', 'value': 'value3'}
+        ]
+        
+        # 模拟pipeline行为
+        mock_pipe = Mock()
+        self.mock_redis_client.pipeline.return_value = mock_pipe
+        mock_pipe.execute.return_value = None  # execute方法返回None
+        mock_pipe.set.return_value = mock_pipe  # set方法返回pipe自身以支持链式调用
+        
+        # 使用事件循环运行异步方法
+        count = asyncio.run(self.redis_batch_processor.batch_set(items))
+        self.assertEqual(count, 3)
+        
+    def test_redis_batch_processor_batch_set_empty(self):
+        """测试Redis批处理器批量设置空列表"""
+        items = []
+        # 使用事件循环运行异步方法
+        count = asyncio.run(self.redis_batch_processor.batch_set(items))
+        self.assertEqual(count, 0)
+        
+    def test_redis_batch_processor_batch_get(self):
+        """测试Redis批处理器批量获取"""
+        keys = ['key1', 'key2', 'key3']
+        
+        # 模拟pipeline行为
+        mock_pipe = Mock()
+        self.mock_redis_client.pipeline.return_value = mock_pipe
+        mock_pipe.get.return_value = mock_pipe  # get方法返回pipe自身以支持链式调用
+        mock_pipe.execute.return_value = ['value1', 'value2', 'value3']
+        
+        # 使用事件循环运行异步方法
+        result = asyncio.run(self.redis_batch_processor.batch_get(keys))
+        expected = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
+        self.assertEqual(result, expected)
+        
+    def test_redis_batch_processor_batch_get_with_none_values(self):
+        """测试Redis批处理器批量获取包含None值"""
+        keys = ['key1', 'key2', 'key3']
+        
+        # 模拟pipeline行为，其中key2返回None
+        mock_pipe = Mock()
+        self.mock_redis_client.pipeline.return_value = mock_pipe
+        mock_pipe.get.return_value = mock_pipe  # get方法返回pipe自身以支持链式调用
+        mock_pipe.execute.return_value = ['value1', None, 'value3']
+        
+        # 使用事件循环运行异步方法
+        result = asyncio.run(self.redis_batch_processor.batch_get(keys))
+        expected = {'key1': 'value1', 'key3': 'value3'}  # key2应该被过滤掉
+        self.assertEqual(result, expected)
+        
+    def test_redis_batch_processor_batch_delete(self):
+        """测试Redis批处理器批量删除"""
+        keys = ['key1', 'key2', 'key3']
+        
+        # 模拟pipeline行为
+        mock_pipe = Mock()
+        self.mock_redis_client.pipeline.return_value = mock_pipe
+        mock_pipe.delete.return_value = mock_pipe  # delete方法返回pipe自身以支持链式调用
+        mock_pipe.execute.return_value = None
+        
+        # 使用事件循环运行异步方法
+        count = asyncio.run(self.redis_batch_processor.batch_delete(keys))
+        self.assertEqual(count, 3)
+
+
+class TestBatchProcessFunction(unittest.TestCase):
+    """批处理便捷函数测试类"""
+
+    def sync_process_item(self, item):
+        """同步处理函数"""
+        return item * 2
+        
+    def test_batch_process_sync_function(self):
+        """测试批处理便捷函数处理同步函数"""
+        items = [1, 2, 3, 4, 5]
+        results = batch_process(items, self.sync_process_item, batch_size=2, max_concurrent_batches=2)
+        expected = [2, 4, 6, 8, 10]
+        self.assertEqual(results, expected)
+
+
+if __name__ == '__main__':
+    # 运行测试
     unittest.main()