crawlo 1.1.8__py3-none-any.whl → 1.2.0__py3-none-any.whl

tests/test_proxy_health_check.py

@@ -1,33 +1,33 @@
-# tests/test_proxy_health_check.py
-import pytest
-from unittest.mock import AsyncMock, patch
-from crawlo.proxy.health_check import check_single_proxy
-import httpx
-
-
-@pytest.mark.asyncio
-@patch('httpx.AsyncClient')
-async def test_health_check_success(mock_client_class):
-    """测试健康检查：成功"""
-    mock_resp = AsyncMock()
-    mock_resp.status_code = 200
-    mock_client_class.return_value.__aenter__.return_value.get.return_value = mock_resp
-
-    proxy_info = {'url': 'http://good:8080', 'healthy': False}
-    await check_single_proxy(proxy_info)
-
-    assert proxy_info['healthy'] is True
-    assert proxy_info['failures'] == 0
-
-
-@pytest.mark.asyncio
-@patch('httpx.AsyncClient')
-async def test_health_check_failure(mock_client_class):
-    """测试健康检查：失败"""
-    mock_client_class.return_value.__aenter__.return_value.get.side_effect = httpx.ConnectError("Failed")
-
-    proxy_info = {'url': 'http://bad:8080', 'healthy': True, 'failures': 0}
-    await check_single_proxy(proxy_info)
-
-    assert proxy_info['healthy'] is False
+# tests/test_proxy_health_check.py
+import pytest
+from unittest.mock import AsyncMock, patch
+from crawlo.proxy.health_check import check_single_proxy
+import httpx
+
+
+@pytest.mark.asyncio
+@patch('httpx.AsyncClient')
+async def test_health_check_success(mock_client_class):
+    """测试健康检查：成功"""
+    mock_resp = AsyncMock()
+    mock_resp.status_code = 200
+    mock_client_class.return_value.__aenter__.return_value.get.return_value = mock_resp
+
+    proxy_info = {'url': 'http://good:8080', 'healthy': False}
+    await check_single_proxy(proxy_info)
+
+    assert proxy_info['healthy'] is True
+    assert proxy_info['failures'] == 0
+
+
+@pytest.mark.asyncio
+@patch('httpx.AsyncClient')
+async def test_health_check_failure(mock_client_class):
+    """测试健康检查：失败"""
+    mock_client_class.return_value.__aenter__.return_value.get.side_effect = httpx.ConnectError("Failed")
+
+    proxy_info = {'url': 'http://bad:8080', 'healthy': True, 'failures': 0}
+    await check_single_proxy(proxy_info)
+
+    assert proxy_info['healthy'] is False
     assert proxy_info['failures'] == 1

tests/test_proxy_middleware_integration.py

@@ -1,137 +1,137 @@
-# tests/test_proxy_middleware_integration.py
-import pytest
-import asyncio
-import time
-from unittest.mock import Mock, AsyncMock, patch
-from crawlo import Request, Response, Spider
-from crawlo.proxy.middleware import ProxyMiddleware
-from crawlo.proxy.stats import ProxyStats
-
-
-@pytest.fixture
-def crawler():
-    class MockSettings:
-        def get(self, key, default=None):
-            defaults = {
-                'PROXY_ENABLED': True,
-                'PROXIES': ['http://p1:8080', 'http://p2:8080'],
-                'PROXY_SELECTION_STRATEGY': 'random',
-                'PROXY_REQUEST_DELAY_ENABLED': False,
-                'PROXY_MAX_RETRY_COUNT': 1,
-            }
-            return defaults.get(key, default)
-
-        def get_bool(self, key, default=None):
-            return self.get(key, default)
-
-        def get_int(self, key, default=None):
-            return self.get(key, default)
-
-        def get_float(self, key, default=None):
-            return self.get(key, default)
-
-        def get_list(self, key, default=None):
-            return self.get(key, default)
-
-    class MockCrawler:
-        def __init__(self):
-            self.settings = MockSettings()
-
-    return MockCrawler()
-
-
-@pytest.fixture
-def middleware(crawler):
-    mw = ProxyMiddleware.create_instance(crawler)
-    mw._load_providers = Mock()
-    mw._update_proxy_pool = AsyncMock()
-    mw._health_check = AsyncMock()
-    mw.scheduler = None
-
-    mw.proxies = [
-        {
-            'url': 'http://p1:8080',
-            'healthy': True,
-            'failures': 0,
-            'last_health_check': 0,
-            'unhealthy_since': 0
-        },
-        {
-            'url': 'http://p2:8080',
-            'healthy': True,
-            'failures': 0,
-            'last_health_check': 0,
-            'unhealthy_since': 0
-        },
-    ]
-    mw.stats = ProxyStats()
-    for p in mw.proxies:
-        mw.stats.record(p['url'], 'total')
-
-    asyncio.get_event_loop().run_until_complete(mw._initial_setup())
-    return mw
-
-
-@pytest.fixture
-def spider():
-    return Mock(spec=Spider, logger=Mock())
-
-
-def test_process_request_sets_proxy(middleware, spider):
-    request = Request("https://example.com")
-    result = asyncio.get_event_loop().run_until_complete(
-        middleware.process_request(request, spider)
-    )
-    assert result is None
-    assert hasattr(request, 'proxy')
-    assert request.proxy in ['http://p1:8080', 'http://p2:8080']
-
-
-def test_process_response_records_success(middleware, spider):
-    request = Request("https://example.com")
-    request.proxy = 'http://p1:8080'
-    response = Response("https://example.com", body=b"ok", headers={})
-    middleware.stats.record(request.proxy, 'total')
-    middleware.process_response(request, response, spider)
-    assert middleware.stats.get(request.proxy)['success'] == 1
-
-
-def test_process_exception_switches_proxy(middleware, spider):
-    request = Request("https://example.com")
-    request.proxy = 'http://p1:8080'
-    request.meta['proxy_retry_count'] = 0
-
-    result = middleware.process_exception(request, Exception("Timeout"), spider)
-    assert result is not None
-    assert result.proxy != 'http://p1:8080'
-    assert result.meta['proxy_retry_count'] == 1
-
-    final = middleware.process_exception(result, Exception("Timeout"), spider)
-    assert final is None
-
-
-def test_mark_failure_disables_proxy(middleware):
-    proxy_url = 'http://p1:8080'
-    p = next(p for p in middleware.proxies if p['url'] == proxy_url)
-    p['failures'] = 2
-
-    middleware._mark_failure(proxy_url)
-    assert p['failures'] == 3
-    assert p['healthy'] is False
-    assert p['unhealthy_since'] > 0
-
-
-@pytest.mark.asyncio
-async def test_request_delay(middleware, spider):
-    """测试请求延迟功能：验证是否调用了 asyncio.sleep"""
-    with patch("crawlo.proxy.middleware.asyncio.sleep", new_callable=AsyncMock) as mock_sleep:
-        middleware.delay_enabled = True  # 注意：这里应该是 delay_enabled 而不是 request_delay_enabled
-        middleware.request_delay = 0.1
-        middleware._last_req_time = time.time() - 0.05  # 50ms 前
-
-        request = Request("https://a.com")
-        await middleware.process_request(request, spider)
-
-        mock_sleep.assert_called_once()
-        delay = mock_sleep.call_args[0][0]
+# tests/test_proxy_middleware_integration.py
+import pytest
+import asyncio
+import time
+from unittest.mock import Mock, AsyncMock, patch
+from crawlo import Request, Response, Spider
+from crawlo.proxy.middleware import ProxyMiddleware
+from crawlo.proxy.stats import ProxyStats
+
+
+@pytest.fixture
+def crawler():
+    class MockSettings:
+        def get(self, key, default=None):
+            defaults = {
+                'PROXY_ENABLED': True,
+                'PROXIES': ['http://p1:8080', 'http://p2:8080'],
+                'PROXY_SELECTION_STRATEGY': 'random',
+                'PROXY_REQUEST_DELAY_ENABLED': False,
+                'PROXY_MAX_RETRY_COUNT': 1,
+            }
+            return defaults.get(key, default)
+
+        def get_bool(self, key, default=None):
+            return self.get(key, default)
+
+        def get_int(self, key, default=None):
+            return self.get(key, default)
+
+        def get_float(self, key, default=None):
+            return self.get(key, default)
+
+        def get_list(self, key, default=None):
+            return self.get(key, default)
+
+    class MockCrawler:
+        def __init__(self):
+            self.settings = MockSettings()
+
+    return MockCrawler()
+
+
+@pytest.fixture
+def middleware(crawler):
+    mw = ProxyMiddleware.create_instance(crawler)
+    mw._load_providers = Mock()
+    mw._update_proxy_pool = AsyncMock()
+    mw._health_check = AsyncMock()
+    mw.scheduler = None
+
+    mw.proxies = [
+        {
+            'url': 'http://p1:8080',
+            'healthy': True,
+            'failures': 0,
+            'last_health_check': 0,
+            'unhealthy_since': 0
+        },
+        {
+            'url': 'http://p2:8080',
+            'healthy': True,
+            'failures': 0,
+            'last_health_check': 0,
+            'unhealthy_since': 0
+        },
+    ]
+    mw.stats = ProxyStats()
+    for p in mw.proxies:
+        mw.stats.record(p['url'], 'total')
+
+    asyncio.get_event_loop().run_until_complete(mw._initial_setup())
+    return mw
+
+
+@pytest.fixture
+def spider():
+    return Mock(spec=Spider, logger=Mock())
+
+
+def test_process_request_sets_proxy(middleware, spider):
+    request = Request("https://example.com")
+    result = asyncio.get_event_loop().run_until_complete(
+        middleware.process_request(request, spider)
+    )
+    assert result is None
+    assert hasattr(request, 'proxy')
+    assert request.proxy in ['http://p1:8080', 'http://p2:8080']
+
+
+def test_process_response_records_success(middleware, spider):
+    request = Request("https://example.com")
+    request.proxy = 'http://p1:8080'
+    response = Response("https://example.com", body=b"ok", headers={})
+    middleware.stats.record(request.proxy, 'total')
+    middleware.process_response(request, response, spider)
+    assert middleware.stats.get(request.proxy)['success'] == 1
+
+
+def test_process_exception_switches_proxy(middleware, spider):
+    request = Request("https://example.com")
+    request.proxy = 'http://p1:8080'
+    request.meta['proxy_retry_count'] = 0
+
+    result = middleware.process_exception(request, Exception("Timeout"), spider)
+    assert result is not None
+    assert result.proxy != 'http://p1:8080'
+    assert result.meta['proxy_retry_count'] == 1
+
+    final = middleware.process_exception(result, Exception("Timeout"), spider)
+    assert final is None
+
+
+def test_mark_failure_disables_proxy(middleware):
+    proxy_url = 'http://p1:8080'
+    p = next(p for p in middleware.proxies if p['url'] == proxy_url)
+    p['failures'] = 2
+
+    middleware._mark_failure(proxy_url)
+    assert p['failures'] == 3
+    assert p['healthy'] is False
+    assert p['unhealthy_since'] > 0
+
+
+@pytest.mark.asyncio
+async def test_request_delay(middleware, spider):
+    """测试请求延迟功能：验证是否调用了 asyncio.sleep"""
+    with patch("crawlo.proxy.middleware.asyncio.sleep", new_callable=AsyncMock) as mock_sleep:
+        middleware.delay_enabled = True  # 注意：这里应该是 delay_enabled 而不是 request_delay_enabled
+        middleware.request_delay = 0.1
+        middleware._last_req_time = time.time() - 0.05  # 50ms 前
+
+        request = Request("https://a.com")
+        await middleware.process_request(request, spider)
+
+        mock_sleep.assert_called_once()
+        delay = mock_sleep.call_args[0][0]
         assert 0.04 <= delay <= 0.06

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