crawlo 1.1.4__py3-none-any.whl → 1.1.5__py3-none-any.whl

tests/test_proxy_providers.py

@@ -1,57 +1,57 @@
-# tests/test_proxy_providers.py
-import pytest
-import pytest
-import respx
-from httpx import Response
-from crawlo.proxy.providers import StaticProxyProvider, FileProxyProvider, APIProxyProvider
-import tempfile
-import os
-
-
-@pytest.mark.asyncio
-async def test_static_provider():
-    """测试静态代理提供者"""
-    provider = StaticProxyProvider(['http://1.1.1.1:8080', 'http://2.2.2.2:8080'])
-    proxies = await provider.fetch_proxies()
-    assert len(proxies) == 2
-    assert 'http://1.1.1.1:8080' in proxies
-    assert 'http://2.2.2.2:8080' in proxies
-
-
-@pytest.mark.asyncio
-async def test_file_provider():
-    """测试文件代理提供者"""
-    with tempfile.NamedTemporaryFile(mode='w', delete=False) as f:
-        f.write("http://a.com:8080\nhttp://b.com:8080\n")
-        temp_path = f.name
-    try:
-        provider = FileProxyProvider(temp_path)
-        proxies = await provider.fetch_proxies()
-        assert len(proxies) == 2
-        assert 'http://a.com:8080' in proxies
-        assert 'http://b.com:8080' in proxies
-    finally:
-        os.unlink(temp_path)
-
-
-@pytest.mark.asyncio
-@respx.mock
-async def test_api_provider():
-    """使用 respx 拦截 HTTP 请求，更简洁可靠"""
-    # 拦截 GET 请求
-    respx.get("https://api.example.com").mock(
-        return_value=Response(
-            200,
-            json=[
-                {"ip": "1.1.1.1", "port": 8080},
-                {"ip": "2.2.2.2", "port": 8080}
-            ]
-        )
-    )
-
-    provider = APIProxyProvider(url="https://api.example.com")
-    proxies = await provider.fetch_proxies()
-
-    assert len(proxies) == 2
-    assert "http://1.1.1.1:8080" in proxies
+# tests/test_proxy_providers.py
+import pytest
+import pytest
+import respx
+from httpx import Response
+from crawlo.proxy.providers import StaticProxyProvider, FileProxyProvider, APIProxyProvider
+import tempfile
+import os
+
+
+@pytest.mark.asyncio
+async def test_static_provider():
+    """测试静态代理提供者"""
+    provider = StaticProxyProvider(['http://1.1.1.1:8080', 'http://2.2.2.2:8080'])
+    proxies = await provider.fetch_proxies()
+    assert len(proxies) == 2
+    assert 'http://1.1.1.1:8080' in proxies
+    assert 'http://2.2.2.2:8080' in proxies
+
+
+@pytest.mark.asyncio
+async def test_file_provider():
+    """测试文件代理提供者"""
+    with tempfile.NamedTemporaryFile(mode='w', delete=False) as f:
+        f.write("http://a.com:8080\nhttp://b.com:8080\n")
+        temp_path = f.name
+    try:
+        provider = FileProxyProvider(temp_path)
+        proxies = await provider.fetch_proxies()
+        assert len(proxies) == 2
+        assert 'http://a.com:8080' in proxies
+        assert 'http://b.com:8080' in proxies
+    finally:
+        os.unlink(temp_path)
+
+
+@pytest.mark.asyncio
+@respx.mock
+async def test_api_provider():
+    """使用 respx 拦截 HTTP 请求，更简洁可靠"""
+    # 拦截 GET 请求
+    respx.get("https://api.example.com").mock(
+        return_value=Response(
+            200,
+            json=[
+                {"ip": "1.1.1.1", "port": 8080},
+                {"ip": "2.2.2.2", "port": 8080}
+            ]
+        )
+    )
+
+    provider = APIProxyProvider(url="https://api.example.com")
+    proxies = await provider.fetch_proxies()
+
+    assert len(proxies) == 2
+    assert "http://1.1.1.1:8080" in proxies
     assert "http://2.2.2.2:8080" in proxies

tests/test_proxy_stats.py

@@ -1,20 +1,20 @@
-# tests/test_proxy_stats.py
-from crawlo.proxy.stats import ProxyStats
-
-
-def test_proxy_stats():
-    """测试代理统计功能"""
-    stats = ProxyStats()
-    url = 'http://proxy1:8080'
-
-    stats.record(url, 'success')
-    stats.record(url, 'success')
-    stats.record(url, 'failure')
-
-    assert stats.get(url)['success'] == 2
-    assert stats.get(url)['failure'] == 1
-    assert stats.get(url)['total'] == 3
-
-    all_data = stats.all()
-    assert url in all_data
+# tests/test_proxy_stats.py
+from crawlo.proxy.stats import ProxyStats
+
+
+def test_proxy_stats():
+    """测试代理统计功能"""
+    stats = ProxyStats()
+    url = 'http://proxy1:8080'
+
+    stats.record(url, 'success')
+    stats.record(url, 'success')
+    stats.record(url, 'failure')
+
+    assert stats.get(url)['success'] == 2
+    assert stats.get(url)['failure'] == 1
+    assert stats.get(url)['total'] == 3
+
+    all_data = stats.all()
+    assert url in all_data
     assert all_data[url]['success'] == 2

tests/test_proxy_strategies.py

@@ -1,60 +1,60 @@
-# tests/test_proxy_strategies.py
-import pytest
-from crawlo import Request
-from crawlo.proxy.strategies import STRATEGIES
-
-
-@pytest.fixture
-def mock_proxies():
-    """提供测试用的代理列表"""
-    return [
-        {'url': 'http://p1:8080'},
-        {'url': 'http://p2:8080'},
-        {'url': 'http://p3:8080'},
-    ]
-
-
-@pytest.fixture
-def mock_stats():
-    """提供测试用的统计信息"""
-    return {
-        'http://p1:8080': {'total': 10},
-        'http://p2:8080': {'total': 5},
-        'http://p3:8080': {'total': 1},
-    }
-
-
-@pytest.fixture
-def mock_request():
-    """提供测试用的请求对象"""
-    return Request("https://example.com")
-
-
-def test_random_strategy(mock_proxies, mock_request, mock_stats):
-    """测试随机策略"""
-    strategy = STRATEGIES['random']
-    chosen = strategy(mock_proxies, mock_request, mock_stats)
-    assert chosen in [p['url'] for p in mock_proxies]
-
-
-def test_least_used_strategy(mock_proxies, mock_request, mock_stats):
-    """测试最少使用策略"""
-    strategy = STRATEGIES['least_used']
-    chosen = strategy(mock_proxies, mock_request, mock_stats)
-    assert chosen == 'http://p3:8080'  # total=1
-
-
-def test_domain_rule_strategy(mock_proxies, mock_request, mock_stats):
-    """测试域名规则策略"""
-    from crawlo.proxy.strategies.domain_rule import domain_rule_strategy
-    request = Request("https://taobao.com/item/123")
-    rules = {'taobao.com': 'http://special:8080'}
-
-    # Monkey patch 确保有回退策略
-    old_strategy = STRATEGIES['least_used']
-    try:
-        STRATEGIES['least_used'] = lambda p, r, s: 'http://fallback:8080'
-        chosen = domain_rule_strategy(mock_proxies, request, mock_stats, rules)
-        assert chosen == 'http://special:8080'
-    finally:
+# tests/test_proxy_strategies.py
+import pytest
+from crawlo import Request
+from crawlo.proxy.strategies import STRATEGIES
+
+
+@pytest.fixture
+def mock_proxies():
+    """提供测试用的代理列表"""
+    return [
+        {'url': 'http://p1:8080'},
+        {'url': 'http://p2:8080'},
+        {'url': 'http://p3:8080'},
+    ]
+
+
+@pytest.fixture
+def mock_stats():
+    """提供测试用的统计信息"""
+    return {
+        'http://p1:8080': {'total': 10},
+        'http://p2:8080': {'total': 5},
+        'http://p3:8080': {'total': 1},
+    }
+
+
+@pytest.fixture
+def mock_request():
+    """提供测试用的请求对象"""
+    return Request("https://example.com")
+
+
+def test_random_strategy(mock_proxies, mock_request, mock_stats):
+    """测试随机策略"""
+    strategy = STRATEGIES['random']
+    chosen = strategy(mock_proxies, mock_request, mock_stats)
+    assert chosen in [p['url'] for p in mock_proxies]
+
+
+def test_least_used_strategy(mock_proxies, mock_request, mock_stats):
+    """测试最少使用策略"""
+    strategy = STRATEGIES['least_used']
+    chosen = strategy(mock_proxies, mock_request, mock_stats)
+    assert chosen == 'http://p3:8080'  # total=1
+
+
+def test_domain_rule_strategy(mock_proxies, mock_request, mock_stats):
+    """测试域名规则策略"""
+    from crawlo.proxy.strategies.domain_rule import domain_rule_strategy
+    request = Request("https://taobao.com/item/123")
+    rules = {'taobao.com': 'http://special:8080'}
+
+    # Monkey patch 确保有回退策略
+    old_strategy = STRATEGIES['least_used']
+    try:
+        STRATEGIES['least_used'] = lambda p, r, s: 'http://fallback:8080'
+        chosen = domain_rule_strategy(mock_proxies, request, mock_stats, rules)
+        assert chosen == 'http://special:8080'
+    finally:
         STRATEGIES['least_used'] = old_strategy

tests/test_queue_manager_redis_key.py

@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+QueueManager Redis Key 测试脚本
+用于验证QueueManager在创建RedisPriorityQueue时是否正确传递module_name参数
+"""
+import asyncio
+import sys
+import os
+import traceback
+
+# 添加项目根目录到路径
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+
+from crawlo.queue.queue_manager import QueueManager, QueueConfig, QueueType
+
+
+class MockSettings:
+    """模拟设置类"""
+    def __init__(self, project_name="test_project"):
+        self.project_name = project_name
+        self.REDIS_URL = "redis://127.0.0.1:6379/15"  # 使用测试数据库
+        self.REDIS_TTL = 0
+        self.CLEANUP_FP = 0
+        self.FILTER_DEBUG = True
+        self.LOG_LEVEL = "INFO"
+        self.DECODE_RESPONSES = True
+    
+    def get(self, key, default=None):
+        if key == 'PROJECT_NAME':
+            return self.project_name
+        elif key == 'REDIS_URL':
+            return self.REDIS_URL
+        elif key == 'FILTER_DEBUG':
+            return self.FILTER_DEBUG
+        elif key == 'LOG_LEVEL':
+            return self.LOG_LEVEL
+        elif key == 'DECODE_RESPONSES':
+            return self.DECODE_RESPONSES
+        return default
+    
+    def get_bool(self, key, default=False):
+        if key == 'FILTER_DEBUG':
+            return self.FILTER_DEBUG
+        elif key == 'DECODE_RESPONSES':
+            return self.DECODE_RESPONSES
+        elif key == 'CLEANUP_FP':
+            return self.CLEANUP_FP
+        return default
+    
+    def get_int(self, key, default=0):
+        if key == 'REDIS_TTL':
+            return self.REDIS_TTL
+        elif key == 'REDIS_PORT':
+            return 6379
+        elif key == 'REDIS_DB':
+            return 0
+        elif key == 'SCHEDULER_MAX_QUEUE_SIZE':
+            return 1000
+        elif key == 'QUEUE_MAX_RETRIES':
+            return 3
+        elif key == 'QUEUE_TIMEOUT':
+            return 300
+        return default
+
+
+async def test_queue_manager_redis_key():
+    """测试QueueManager创建Redis队列时的key命名"""
+    print("🔍 测试QueueManager创建Redis队列时的key命名...")
+    
+    try:
+        # 测试不同的队列名称配置
+        test_cases = [
+            {
+                "queue_name": "crawlo:books_distributed:queue:requests",
+                "expected_module_name": "books_distributed",
+                "description": "标准项目名称"
+            },
+            {
+                "queue_name": "crawlo:api_data_collection:queue:requests",
+                "expected_module_name": "api_data_collection",
+                "description": "API数据采集项目"
+            },
+            {
+                "queue_name": "crawlo:test_project:queue:requests",
+                "expected_module_name": "test_project",
+                "description": "测试项目"
+            },
+            {
+                "queue_name": "simple_queue_name",
+                "expected_module_name": "simple_queue_name",
+                "description": "简单队列名称"
+            },
+            {
+                "queue_name": "",
+                "expected_module_name": "default",
+                "description": "空队列名称"
+            }
+        ]
+        
+        for i, test_case in enumerate(test_cases, 1):
+            print(f"   {i}. 测试 {test_case['description']}...")
+            
+            # 创建QueueConfig
+            config = QueueConfig(
+                queue_type=QueueType.REDIS,
+                redis_url="redis://127.0.0.1:6379/15",
+                queue_name=test_case["queue_name"],
+                max_queue_size=1000,
+                max_retries=3,
+                timeout=300
+            )
+            
+            # 创建QueueManager
+            queue_manager = QueueManager(config)
+            
+            # 创建队列实例
+            queue = await queue_manager._create_queue(QueueType.REDIS)
+            
+            # 验证module_name是否正确设置
+            assert hasattr(queue, 'module_name'), "RedisPriorityQueue缺少module_name属性"
+            assert queue.module_name == test_case["expected_module_name"], \
+                f"module_name不匹配: {queue.module_name} != {test_case['expected_module_name']}"
+            
+            # 验证队列名称是否符合规范
+            expected_queue_name = f"crawlo:{queue.module_name}:queue:requests"
+            expected_processing_queue = f"crawlo:{queue.module_name}:queue:processing"
+            expected_failed_queue = f"crawlo:{queue.module_name}:queue:failed"
+            
+            assert queue.queue_name == expected_queue_name, \
+                f"队列名称不匹配: {queue.queue_name} != {expected_queue_name}"
+            assert queue.processing_queue == expected_processing_queue, \
+                f"处理中队列名称不匹配: {queue.processing_queue} != {expected_processing_queue}"
+            assert queue.failed_queue == expected_failed_queue, \
+                f"失败队列名称不匹配: {queue.failed_queue} != {expected_failed_queue}"
+            
+            print(f"      ✅ module_name: {queue.module_name}")
+            print(f"      ✅ 队列名称: {queue.queue_name}")
+            print(f"      ✅ 处理中队列名称: {queue.processing_queue}")
+            print(f"      ✅ 失败队列名称: {queue.failed_queue}")
+        
+        print("✅ QueueManager Redis key命名测试通过！")
+        return True
+        
+    except Exception as e:
+        print(f"❌ QueueManager Redis key命名测试失败: {e}")
+        traceback.print_exc()
+        return False
+
+
+async def main():
+    """主测试函数"""
+    print("🚀 开始QueueManager Redis key命名测试...")
+    print("=" * 50)
+    
+    try:
+        success = await test_queue_manager_redis_key()
+        
+        print("=" * 50)
+        if success:
+            print("🎉 所有测试通过！QueueManager正确传递module_name参数")
+        else:
+            print("❌ 测试失败，请检查实现")
+            return 1
+            
+    except Exception as e:
+        print("=" * 50)
+        print(f"❌ 测试过程中发生异常: {e}")
+        traceback.print_exc()
+        return 1
+    
+    return 0
+
+
+if __name__ == "__main__":
+    exit_code = asyncio.run(main())
+    sys.exit(exit_code)

tests/test_redis_config.py

@@ -1,29 +1,29 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-快速测试 Redis 连接配置修复
-"""
-import asyncio
-from crawlo.queue.redis_priority_queue import RedisPriorityQueue
-from crawlo.settings.default_settings import REDIS_URL
-
-async def test_redis_config():
-    """测试修复后的 Redis 配置"""
-    print(f"🔍 测试 Redis 配置: {REDIS_URL}")
-    
-    try:
-        queue = RedisPriorityQueue(redis_url=REDIS_URL)
-        await queue.connect()
-        print("✅ Redis 连接成功！")
-        await queue.close()
-        return True
-    except Exception as e:
-        print(f"❌ Redis 连接失败: {e}")
-        return False
-
-if __name__ == "__main__":
-    success = asyncio.run(test_redis_config())
-    if success:
-        print("🎉 配置修复成功！现在可以运行你的爬虫了。")
-    else:
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+快速测试 Redis 连接配置修复
+"""
+import asyncio
+from crawlo.queue.redis_priority_queue import RedisPriorityQueue
+from crawlo.settings.default_settings import REDIS_URL
+
+async def test_redis_config():
+    """测试修复后的 Redis 配置"""
+    print(f"🔍 测试 Redis 配置: {REDIS_URL}")
+    
+    try:
+        queue = RedisPriorityQueue(redis_url=REDIS_URL)
+        await queue.connect()
+        print("✅ Redis 连接成功！")
+        await queue.close()
+        return True
+    except Exception as e:
+        print(f"❌ Redis 连接失败: {e}")
+        return False
+
+if __name__ == "__main__":
+    success = asyncio.run(test_redis_config())
+    if success:
+        print("🎉 配置修复成功！现在可以运行你的爬虫了。")
+    else:
         print("❌ 配置仍有问题，请检查 Redis 服务状态。")