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

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_middleware_refactored.py

@@ -1,185 +1,185 @@
-#!/usr/bin/python
-# -*- coding:UTF-8 -*-
-"""
-ProxyMiddleware 重构测试文件
-用于测试重构后的代理中间件功能，特别是修复的重复逻辑
-"""
-
-import asyncio
-import unittest
-from unittest.mock import Mock, patch
-
-from crawlo.middleware.proxy import ProxyMiddleware, Proxy
-from crawlo.exceptions import NotConfiguredError
-from crawlo.settings.setting_manager import SettingManager
-
-
-class TestProxyMiddlewareRefactored(unittest.TestCase):
-    """ProxyMiddleware 重构测试类"""
-
-    def setUp(self):
-        """测试前准备"""
-        # 创建设置管理器
-        self.settings = SettingManager()
-        
-        # 创建爬虫模拟对象
-        self.crawler = Mock()
-        self.crawler.settings = self.settings
-
-    def test_parse_proxy_data_with_string(self):
-        """测试解析字符串代理数据"""
-        middleware = ProxyMiddleware(
-            settings=self.settings,
-            log_level='INFO'
-        )
-        
-        # 测试有效的HTTP代理URL
-        result = middleware._parse_proxy_data("http://proxy.example.com:8080")
-        self.assertEqual(result, ["http://proxy.example.com:8080"])
-        
-        # 测试有效的HTTPS代理URL
-        result = middleware._parse_proxy_data("https://proxy.example.com:8080")
-        self.assertEqual(result, ["https://proxy.example.com:8080"])
-        
-        # 测试无效的代理URL
-        result = middleware._parse_proxy_data("invalid-proxy")
-        self.assertEqual(result, [])
-
-    def test_parse_proxy_data_with_dict(self):
-        """测试解析字典代理数据"""
-        middleware = ProxyMiddleware(
-            settings=self.settings,
-            log_level='INFO'
-        )
-        
-        # 测试包含字符串代理的字典
-        proxy_data = {
-            "proxy": "http://proxy1.example.com:8080"
-        }
-        result = middleware._parse_proxy_data(proxy_data)
-        self.assertEqual(result, ["http://proxy1.example.com:8080"])
-        
-        # 测试包含列表代理的字典
-        proxy_data = {
-            "proxies": [
-                "http://proxy1.example.com:8080",
-                "https://proxy2.example.com:8080"
-            ]
-        }
-        result = middleware._parse_proxy_data(proxy_data)
-        self.assertEqual(result, [
-            "http://proxy1.example.com:8080",
-            "https://proxy2.example.com:8080"
-        ])
-        
-        # 测试混合数据
-        proxy_data = {
-            "proxy": "http://proxy1.example.com:8080",
-            "proxies": [
-                "https://proxy2.example.com:8080",
-                "invalid-proxy"
-            ]
-        }
-        result = middleware._parse_proxy_data(proxy_data)
-        self.assertEqual(result, [
-            "http://proxy1.example.com:8080",
-            "https://proxy2.example.com:8080"
-        ])
-
-    def test_get_healthy_proxies(self):
-        """测试获取健康代理"""
-        middleware = ProxyMiddleware(
-            settings=self.settings,
-            log_level='INFO'
-        )
-        
-        # 创建测试代理
-        proxy1 = Proxy("http://proxy1.example.com:8080")
-        proxy2 = Proxy("http://proxy2.example.com:8080")
-        proxy3 = Proxy("http://proxy3.example.com:8080")
-        
-        # 设置代理池
-        middleware._proxy_pool = [proxy1, proxy2, proxy3]
-        
-        # 所有代理都是健康的
-        healthy_proxies = middleware._get_healthy_proxies()
-        self.assertEqual(len(healthy_proxies), 3)
-        
-        # 标记一个代理为不健康
-        proxy2.is_healthy = False
-        healthy_proxies = middleware._get_healthy_proxies()
-        self.assertEqual(len(healthy_proxies), 2)
-        self.assertIn(proxy1, healthy_proxies)
-        self.assertNotIn(proxy2, healthy_proxies)
-        self.assertIn(proxy3, healthy_proxies)
-        
-        # 标记一个代理成功率低于阈值
-        proxy3.mark_failure()
-        proxy3.mark_failure()
-        proxy3.mark_failure()
-        proxy3.mark_failure()  # 4次失败，0次成功，成功率=0 < 0.5(默认阈值)
-        healthy_proxies = middleware._get_healthy_proxies()
-        self.assertEqual(len(healthy_proxies), 1)
-        self.assertIn(proxy1, healthy_proxies)
-        self.assertNotIn(proxy3, healthy_proxies)
-
-    @patch('crawlo.utils.log.get_logger')
-    def test_update_proxy_pool_with_parsed_data(self, mock_get_logger):
-        """测试使用解析后的代理数据更新代理池"""
-        self.settings.set('PROXY_ENABLED', True)
-        self.settings.set('PROXY_API_URL', 'http://proxy-api.example.com')
-        self.settings.set('PROXY_POOL_SIZE', 2)
-        self.settings.set('LOG_LEVEL', 'INFO')
-        
-        mock_get_logger.return_value = Mock()
-        
-        middleware = ProxyMiddleware.create_instance(self.crawler)
-        
-        # 测试解析字符串代理数据
-        new_proxies = middleware._parse_proxy_data("http://proxy1.example.com:8080")
-        self.assertEqual(new_proxies, ["http://proxy1.example.com:8080"])
-        
-        # 测试解析字典代理数据
-        proxy_data = {
-            "proxies": [
-                "http://proxy1.example.com:8080",
-                "https://proxy2.example.com:8080",
-                "http://proxy3.example.com:8080"
-            ]
-        }
-        new_proxies = middleware._parse_proxy_data(proxy_data)
-        self.assertEqual(new_proxies, [
-            "http://proxy1.example.com:8080",
-            "https://proxy2.example.com:8080",
-            "http://proxy3.example.com:8080"
-        ])
-
-    def test_get_healthy_proxy_with_refactored_logic(self):
-        """测试使用重构后的逻辑获取健康代理"""
-        middleware = ProxyMiddleware(
-            settings=self.settings,
-            log_level='INFO'
-        )
-        
-        # 创建测试代理
-        proxy1 = Proxy("http://proxy1.example.com:8080")
-        proxy2 = Proxy("http://proxy2.example.com:8080")
-        
-        # 设置代理池
-        middleware._proxy_pool = [proxy1, proxy2]
-        middleware._current_proxy_index = 0
-        
-        # 获取第一个健康代理（由于轮询逻辑，第一次调用会得到索引1的代理）
-        healthy_proxy = asyncio.run(middleware._get_healthy_proxy())
-        self.assertEqual(healthy_proxy.proxy_str, proxy2.proxy_str)
-        
-        # 获取第二个健康代理（轮询回到索引0）
-        healthy_proxy = asyncio.run(middleware._get_healthy_proxy())
-        self.assertEqual(healthy_proxy.proxy_str, proxy1.proxy_str)
-        
-        # 再次获取第一个健康代理（轮询到索引1）
-        healthy_proxy = asyncio.run(middleware._get_healthy_proxy())
-        self.assertEqual(healthy_proxy.proxy_str, proxy2.proxy_str)
-
-if __name__ == '__main__':
+#!/usr/bin/python
+# -*- coding:UTF-8 -*-
+"""
+ProxyMiddleware 重构测试文件
+用于测试重构后的代理中间件功能，特别是修复的重复逻辑
+"""
+
+import asyncio
+import unittest
+from unittest.mock import Mock, patch
+
+from crawlo.middleware.proxy import ProxyMiddleware, Proxy
+from crawlo.exceptions import NotConfiguredError
+from crawlo.settings.setting_manager import SettingManager
+
+
+class TestProxyMiddlewareRefactored(unittest.TestCase):
+    """ProxyMiddleware 重构测试类"""
+
+    def setUp(self):
+        """测试前准备"""
+        # 创建设置管理器
+        self.settings = SettingManager()
+        
+        # 创建爬虫模拟对象
+        self.crawler = Mock()
+        self.crawler.settings = self.settings
+
+    def test_parse_proxy_data_with_string(self):
+        """测试解析字符串代理数据"""
+        middleware = ProxyMiddleware(
+            settings=self.settings,
+            log_level='INFO'
+        )
+        
+        # 测试有效的HTTP代理URL
+        result = middleware._parse_proxy_data("http://proxy.example.com:8080")
+        self.assertEqual(result, ["http://proxy.example.com:8080"])
+        
+        # 测试有效的HTTPS代理URL
+        result = middleware._parse_proxy_data("https://proxy.example.com:8080")
+        self.assertEqual(result, ["https://proxy.example.com:8080"])
+        
+        # 测试无效的代理URL
+        result = middleware._parse_proxy_data("invalid-proxy")
+        self.assertEqual(result, [])
+
+    def test_parse_proxy_data_with_dict(self):
+        """测试解析字典代理数据"""
+        middleware = ProxyMiddleware(
+            settings=self.settings,
+            log_level='INFO'
+        )
+        
+        # 测试包含字符串代理的字典
+        proxy_data = {
+            "proxy": "http://proxy1.example.com:8080"
+        }
+        result = middleware._parse_proxy_data(proxy_data)
+        self.assertEqual(result, ["http://proxy1.example.com:8080"])
+        
+        # 测试包含列表代理的字典
+        proxy_data = {
+            "proxies": [
+                "http://proxy1.example.com:8080",
+                "https://proxy2.example.com:8080"
+            ]
+        }
+        result = middleware._parse_proxy_data(proxy_data)
+        self.assertEqual(result, [
+            "http://proxy1.example.com:8080",
+            "https://proxy2.example.com:8080"
+        ])
+        
+        # 测试混合数据
+        proxy_data = {
+            "proxy": "http://proxy1.example.com:8080",
+            "proxies": [
+                "https://proxy2.example.com:8080",
+                "invalid-proxy"
+            ]
+        }
+        result = middleware._parse_proxy_data(proxy_data)
+        self.assertEqual(result, [
+            "http://proxy1.example.com:8080",
+            "https://proxy2.example.com:8080"
+        ])
+
+    def test_get_healthy_proxies(self):
+        """测试获取健康代理"""
+        middleware = ProxyMiddleware(
+            settings=self.settings,
+            log_level='INFO'
+        )
+        
+        # 创建测试代理
+        proxy1 = Proxy("http://proxy1.example.com:8080")
+        proxy2 = Proxy("http://proxy2.example.com:8080")
+        proxy3 = Proxy("http://proxy3.example.com:8080")
+        
+        # 设置代理池
+        middleware._proxy_pool = [proxy1, proxy2, proxy3]
+        
+        # 所有代理都是健康的
+        healthy_proxies = middleware._get_healthy_proxies()
+        self.assertEqual(len(healthy_proxies), 3)
+        
+        # 标记一个代理为不健康
+        proxy2.is_healthy = False
+        healthy_proxies = middleware._get_healthy_proxies()
+        self.assertEqual(len(healthy_proxies), 2)
+        self.assertIn(proxy1, healthy_proxies)
+        self.assertNotIn(proxy2, healthy_proxies)
+        self.assertIn(proxy3, healthy_proxies)
+        
+        # 标记一个代理成功率低于阈值
+        proxy3.mark_failure()
+        proxy3.mark_failure()
+        proxy3.mark_failure()
+        proxy3.mark_failure()  # 4次失败，0次成功，成功率=0 < 0.5(默认阈值)
+        healthy_proxies = middleware._get_healthy_proxies()
+        self.assertEqual(len(healthy_proxies), 1)
+        self.assertIn(proxy1, healthy_proxies)
+        self.assertNotIn(proxy3, healthy_proxies)
+
+    @patch('crawlo.utils.log.get_logger')
+    def test_update_proxy_pool_with_parsed_data(self, mock_get_logger):
+        """测试使用解析后的代理数据更新代理池"""
+        self.settings.set('PROXY_ENABLED', True)
+        self.settings.set('PROXY_API_URL', 'http://proxy-api.example.com')
+        self.settings.set('PROXY_POOL_SIZE', 2)
+        self.settings.set('LOG_LEVEL', 'INFO')
+        
+        mock_get_logger.return_value = Mock()
+        
+        middleware = ProxyMiddleware.create_instance(self.crawler)
+        
+        # 测试解析字符串代理数据
+        new_proxies = middleware._parse_proxy_data("http://proxy1.example.com:8080")
+        self.assertEqual(new_proxies, ["http://proxy1.example.com:8080"])
+        
+        # 测试解析字典代理数据
+        proxy_data = {
+            "proxies": [
+                "http://proxy1.example.com:8080",
+                "https://proxy2.example.com:8080",
+                "http://proxy3.example.com:8080"
+            ]
+        }
+        new_proxies = middleware._parse_proxy_data(proxy_data)
+        self.assertEqual(new_proxies, [
+            "http://proxy1.example.com:8080",
+            "https://proxy2.example.com:8080",
+            "http://proxy3.example.com:8080"
+        ])
+
+    def test_get_healthy_proxy_with_refactored_logic(self):
+        """测试使用重构后的逻辑获取健康代理"""
+        middleware = ProxyMiddleware(
+            settings=self.settings,
+            log_level='INFO'
+        )
+        
+        # 创建测试代理
+        proxy1 = Proxy("http://proxy1.example.com:8080")
+        proxy2 = Proxy("http://proxy2.example.com:8080")
+        
+        # 设置代理池
+        middleware._proxy_pool = [proxy1, proxy2]
+        middleware._current_proxy_index = 0
+        
+        # 获取第一个健康代理（由于轮询逻辑，第一次调用会得到索引1的代理）
+        healthy_proxy = asyncio.run(middleware._get_healthy_proxy())
+        self.assertEqual(healthy_proxy.proxy_str, proxy2.proxy_str)
+        
+        # 获取第二个健康代理（轮询回到索引0）
+        healthy_proxy = asyncio.run(middleware._get_healthy_proxy())
+        self.assertEqual(healthy_proxy.proxy_str, proxy1.proxy_str)
+        
+        # 再次获取第一个健康代理（轮询到索引1）
+        healthy_proxy = asyncio.run(middleware._get_healthy_proxy())
+        self.assertEqual(healthy_proxy.proxy_str, proxy2.proxy_str)
+
+if __name__ == '__main__':
     unittest.main()