crawlo 1.4.4__py3-none-any.whl → 1.4.6__py3-none-any.whl

tests/test_proxy_middleware.py

@@ -49,25 +49,27 @@ class TestProxyMiddleware(unittest.TestCase):
     @patch('crawlo.utils.log.get_logger')
     def test_middleware_initialization_without_api_url(self, mock_get_logger):
         """测试没有配置API URL时中间件初始化"""
-        self.settings.set('PROXY_ENABLED', True)
+        # 不再需要 PROXY_ENABLED，只要不配置 PROXY_API_URL 就会禁用
         self.settings.set('PROXY_API_URL', None)
         self.settings.set('LOG_LEVEL', 'INFO')
         
         mock_get_logger.return_value = MockLogger('ProxyMiddleware')
         
-        # 应该抛出NotConfiguredError异常
-        with self.assertRaises(NotConfiguredError):
-            ProxyMiddleware.create_instance(self.crawler)
+        # 应该正常创建实例，但会禁用
+        middleware = ProxyMiddleware.create_instance(self.crawler)
+        self.assertIsInstance(middleware, ProxyMiddleware)
+        self.assertFalse(middleware.enabled)
 
     @patch('crawlo.utils.log.get_logger')
     def test_middleware_initialization_with_disabled_proxy(self, mock_get_logger):
         """测试禁用代理时中间件初始化"""
-        self.settings.set('PROXY_ENABLED', False)
+        # 不再需要 PROXY_ENABLED，只要不配置 PROXY_API_URL 就会禁用
+        self.settings.set('PROXY_API_URL', None)
         self.settings.set('LOG_LEVEL', 'INFO')
         
         mock_get_logger.return_value = MockLogger('ProxyMiddleware')
         
-        # 应该正常创建实例
+        # 应该正常创建实例，但会禁用
         middleware = ProxyMiddleware.create_instance(self.crawler)
         self.assertIsInstance(middleware, ProxyMiddleware)
         self.assertFalse(middleware.enabled)
@@ -75,18 +77,48 @@ class TestProxyMiddleware(unittest.TestCase):
     @patch('crawlo.utils.log.get_logger')
     def test_middleware_initialization_with_api_url(self, mock_get_logger):
         """测试配置API URL时中间件初始化"""
-        self.settings.set('PROXY_ENABLED', True)
+        # 不再需要 PROXY_ENABLED，只要配置了 PROXY_API_URL 就会启用
         self.settings.set('PROXY_API_URL', 'http://proxy-api.example.com')
         self.settings.set('LOG_LEVEL', 'INFO')
         
         mock_get_logger.return_value = MockLogger('ProxyMiddleware')
         
-        # 应该正常创建实例
+        # 应该正常创建实例并启用
         middleware = ProxyMiddleware.create_instance(self.crawler)
         self.assertIsInstance(middleware, ProxyMiddleware)
         self.assertTrue(middleware.enabled)
         self.assertEqual(middleware.api_url, 'http://proxy-api.example.com')
 
+    def test_middleware_initialization(self):
+        """测试中间件初始化"""
+        # 配置代理API URL以启用中间件
+        self.settings.set('PROXY_API_URL', 'http://proxy-api.example.com')
+        middleware = ProxyMiddleware(self.settings, "DEBUG")
+        self.assertIsInstance(middleware, ProxyMiddleware)
+        self.assertTrue(middleware.enabled)
+        self.assertEqual(middleware.api_url, 'http://proxy-api.example.com')
+
+    def test_middleware_enabled_with_api_url(self):
+        """测试配置了代理API URL时中间件启用"""
+        self.settings.set('PROXY_API_URL', 'http://proxy-api.example.com')
+        # 不再需要显式设置 PROXY_ENABLED = True
+        middleware = ProxyMiddleware(self.settings, "DEBUG")
+        self.assertTrue(middleware.enabled)
+        self.assertEqual(middleware.api_url, 'http://proxy-api.example.com')
+
+    def test_middleware_disabled_without_api_url(self):
+        """测试未配置代理API URL时中间件禁用"""
+        # 不设置 PROXY_API_URL 或设置为空
+        self.settings.set('PROXY_API_URL', '')
+        middleware = ProxyMiddleware(self.settings, "DEBUG")
+        self.assertFalse(middleware.enabled)
+        
+    def test_middleware_disabled_explicitly(self):
+        """测试显式禁用中间件（通过不配置API URL）"""
+        # 不配置 PROXY_API_URL
+        middleware = ProxyMiddleware(self.settings, "DEBUG")
+        self.assertFalse(middleware.enabled)
+
     def test_is_https_with_https_url(self):
         """测试HTTPS URL判断"""
         # 创建中间件实例
@@ -117,6 +149,70 @@ class TestProxyMiddleware(unittest.TestCase):
         # 应该返回False
         self.assertFalse(middleware._is_https(request))
 
+    def test_proxy_extractor_field(self):
+        """测试字段名提取方式"""
+        self.settings.set('PROXY_API_URL', 'http://test.api/proxy')
+        self.settings.set('PROXY_EXTRACTOR', 'data')  # 从data字段提取
+        
+        middleware = ProxyMiddleware(self.settings, "DEBUG")
+        self.assertEqual(middleware.proxy_extractor, 'data')
+        
+        # 测试提取逻辑
+        data = {'data': 'http://proxy-from-data:8080'}
+        proxy = middleware._extract_proxy_from_data(data)
+        self.assertEqual(proxy, 'http://proxy-from-data:8080')
+
+    def test_proxy_extractor_dict_field(self):
+        """测试字典字段提取方式"""
+        self.settings.set('PROXY_API_URL', 'http://test.api/proxy')
+        self.settings.set('PROXY_EXTRACTOR', {'type': 'field', 'value': 'result'})
+        
+        middleware = ProxyMiddleware(self.settings, "DEBUG")
+        self.assertEqual(middleware.proxy_extractor['type'], 'field')
+        self.assertEqual(middleware.proxy_extractor['value'], 'result')
+        
+        # 测试提取逻辑
+        data = {'result': 'http://proxy-from-result:8080'}
+        proxy = middleware._extract_proxy_from_data(data)
+        self.assertEqual(proxy, 'http://proxy-from-result:8080')
+
+    def test_proxy_extractor_custom_function(self):
+        """测试自定义函数提取方式"""
+        def custom_extractor(data):
+            return data.get('custom_proxy')
+            
+        self.settings.set('PROXY_API_URL', 'http://test.api/proxy')
+        self.settings.set('PROXY_EXTRACTOR', {'type': 'custom', 'function': custom_extractor})
+        
+        middleware = ProxyMiddleware(self.settings, "DEBUG")
+        
+        # 测试提取逻辑
+        data = {'custom_proxy': 'http://proxy-from-custom:8080'}
+        proxy = middleware._extract_proxy_from_data(data)
+        self.assertEqual(proxy, 'http://proxy-from-custom:8080')
+
+    def test_proxy_extractor_callable(self):
+        """测试直接函数提取方式"""
+        def direct_extractor(data):
+            return data.get('direct_proxy')
+            
+        self.settings.set('PROXY_API_URL', 'http://test.api/proxy')
+        self.settings.set('PROXY_EXTRACTOR', direct_extractor)
+        
+        middleware = ProxyMiddleware(self.settings, "DEBUG")
+        
+        # 测试提取逻辑
+        data = {'direct_proxy': 'http://proxy-from-direct:8080'}
+        proxy = middleware._extract_proxy_from_data(data)
+        self.assertEqual(proxy, 'http://proxy-from-direct:8080')
+
+    def test_middleware_disabled_without_list(self):
+        """测试未配置代理列表时代理中间件禁用"""
+        # 不设置 PROXY_LIST 或设置为空列表
+        self.settings.set('PROXY_LIST', [])
+        from crawlo.middleware.proxy import ProxyMiddleware
+        middleware = ProxyMiddleware(self.settings, "DEBUG")
+        self.assertFalse(middleware.enabled)
 
 if __name__ == '__main__':
     unittest.main()

tests/test_proxy_middleware_enhanced.py

@@ -52,12 +52,8 @@ def test_proxy_class():
 def create_mock_settings():
     """创建模拟设置"""
     settings = SettingManager()
-    settings.set("PROXY_ENABLED", True)
+    # 不再需要显式设置 PROXY_ENABLED，只要配置了 PROXY_API_URL 就会启用
     settings.set("PROXY_API_URL", "http://test.proxy.api/get")
-    settings.set("PROXY_EXTRACTOR", "proxy")
-    settings.set("PROXY_REFRESH_INTERVAL", 10)
-    settings.set("PROXY_POOL_SIZE", 3)
-    settings.set("PROXY_HEALTH_CHECK_THRESHOLD", 0.5)
     settings.set("LOG_LEVEL", "DEBUG")
     return settings
 

tests/test_proxy_middleware_integration.py

@@ -13,7 +13,12 @@ def crawler():
     class MockSettings:
         def get(self, key, default=None):
             defaults = {
-                'PROXY_ENABLED': True,
+                # 配置代理中间件
+                custom_settings = {
+                    # 高级代理配置（适用于ProxyMiddleware）
+                    # 只要配置了代理API URL，中间件就会自动启用
+                    'PROXY_API_URL': 'http://mock-proxy-service.com/api',
+                }
                 'PROXIES': ['http://p1:8080', 'http://p2:8080'],
                 'PROXY_SELECTION_STRATEGY': 'random',
                 'PROXY_REQUEST_DELAY_ENABLED': False,
@@ -134,4 +139,4 @@ async def test_request_delay(middleware, spider):
 
         mock_sleep.assert_called_once()
         delay = mock_sleep.call_args[0][0]
-        assert 0.04 <= delay <= 0.06
+        assert 0.04 <= delay <= 0.06

tests/test_proxy_middleware_refactored.py

@@ -126,9 +126,8 @@ class TestProxyMiddlewareRefactored(unittest.TestCase):
     @patch('crawlo.utils.log.get_logger')
     def test_update_proxy_pool_with_parsed_data(self, mock_get_logger):
         """测试使用解析后的代理数据更新代理池"""
-        self.settings.set('PROXY_ENABLED', True)
+        # 不再需要 PROXY_ENABLED，只要配置了 PROXY_API_URL 就会启用
         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()
@@ -181,5 +180,29 @@ class TestProxyMiddlewareRefactored(unittest.TestCase):
         healthy_proxy = asyncio.run(middleware._get_healthy_proxy())
         self.assertEqual(healthy_proxy.proxy_str, proxy2.proxy_str)
 
+    def test_proxy_middleware_initialization(self):
+        """测试代理中间件初始化"""
+        # 不再需要 PROXY_ENABLED，只要配置了 PROXY_API_URL 就会启用
+        self.settings.set('PROXY_API_URL', 'http://test-proxy-api.com')
+        middleware = ProxyMiddleware(self.settings, "DEBUG")
+        self.assertIsInstance(middleware, ProxyMiddleware)
+        self.assertTrue(middleware.enabled)
+        self.assertEqual(middleware.api_url, 'http://test-proxy-api.com')
+
+    def test_proxy_middleware_enabled_with_api_url(self):
+        """测试配置了代理API URL时中间件启用"""
+        # 不再需要 PROXY_ENABLED，只要配置了 PROXY_API_URL 就会启用
+        self.settings.set('PROXY_API_URL', 'http://test-proxy-api.com')
+        middleware = ProxyMiddleware(self.settings, "DEBUG")
+        self.assertTrue(middleware.enabled)
+        self.assertEqual(middleware.api_url, 'http://test-proxy-api.com')
+
+    def test_proxy_middleware_disabled_without_api_url(self):
+        """测试未配置代理API URL时中间件禁用"""
+        # 不再需要 PROXY_ENABLED，只要不配置 PROXY_API_URL 就会禁用
+        self.settings.set('PROXY_API_URL', None)
+        middleware = ProxyMiddleware(self.settings, "DEBUG")
+        self.assertFalse(middleware.enabled)
+
 if __name__ == '__main__':
     unittest.main()

tests/test_proxy_only.py

@@ -0,0 +1,84 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+代理中间件测试脚本
+测试指定的代理URL功能
+"""
+
+import asyncio
+import sys
+import os
+
+# 添加项目根目录到Python路径
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+
+from crawlo.settings.setting_manager import SettingManager
+from crawlo.middleware.proxy import ProxyMiddleware
+from crawlo.network import Request
+
+
+async def test_proxy_middleware():
+    """测试代理中间件"""
+    print("=== 测试代理中间件 ===")
+    
+    # 创建设置管理器
+    settings_manager = SettingManager()
+    settings = settings_manager  # SettingManager实例本身就是设置对象
+    
+    # 配置代理
+    settings.set('PROXY_API_URL', 'http://proxy-api.example.com/proxy/getitem/')
+    settings.set('LOG_LEVEL', 'DEBUG')
+    
+    # 创建代理中间件
+    proxy_middleware = ProxyMiddleware(settings, "DEBUG")
+    
+    print(f"代理中间件已创建")
+    print(f"模式: {proxy_middleware.mode}")
+    print(f"是否启用: {proxy_middleware.enabled}")
+    
+    if proxy_middleware.enabled and proxy_middleware.mode == "dynamic":
+        # 测试从API获取代理
+        print("\n尝试从API获取代理...")
+        proxy = await proxy_middleware._fetch_proxy_from_api()
+        print(f"获取到的代理: {proxy}")
+        
+        # 测试代理提取功能
+        if proxy:
+            print(f"代理格式正确: {proxy.startswith('http://') or proxy.startswith('https://')}")
+            
+            # 测试处理请求
+            print("\n测试处理请求...")
+            request = Request(url="https://httpbin.org/ip")
+            
+            class MockSpider:
+                def __init__(self):
+                    self.name = "test_spider"
+            
+            spider = MockSpider()
+            
+            await proxy_middleware.process_request(request, spider)
+            
+            if request.proxy:
+                print(f"请求代理设置成功: {request.proxy}")
+            else:
+                print("请求代理设置失败")
+        else:
+            print("未能从API获取有效代理")
+    else:
+        print("代理中间件未启用或模式不正确")
+        
+    return proxy_middleware
+
+
+async def main():
+    """主测试函数"""
+    print("开始测试代理中间件...")
+    
+    # 测试代理中间件
+    await test_proxy_middleware()
+    
+    print("\n测试完成")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

tests/test_proxy_with_downloader.py

@@ -0,0 +1,153 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+代理中间件与下载器配合测试脚本
+测试指定的代理URL与下载器的兼容性
+"""
+
+import asyncio
+import sys
+import os
+
+# 添加项目根目录到Python路径
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+
+from crawlo.settings.setting_manager import SettingManager
+from crawlo.middleware.proxy import ProxyMiddleware
+from crawlo.downloader.httpx_downloader import HttpXDownloader
+from crawlo.network import Request
+
+
+async def test_proxy_middleware():
+    """测试代理中间件"""
+    print("=== 测试代理中间件 ===")
+    
+    # 创建设置管理器
+    settings_manager = SettingManager()
+    settings = settings_manager  # SettingManager实例本身就是设置对象
+    
+    # 配置代理
+    settings.set('PROXY_API_URL', 'http://proxy-api.example.com/proxy/getitem/')
+    settings.set('LOG_LEVEL', 'DEBUG')
+    
+    # 创建代理中间件
+    proxy_middleware = ProxyMiddleware(settings, "DEBUG")
+    
+    print(f"代理中间件已创建")
+    print(f"模式: {proxy_middleware.mode}")
+    print(f"是否启用: {proxy_middleware.enabled}")
+    
+    if proxy_middleware.enabled and proxy_middleware.mode == "dynamic":
+        # 测试从API获取代理
+        print("\n尝试从API获取代理...")
+        proxy = await proxy_middleware._fetch_proxy_from_api()
+        print(f"获取到的代理: {proxy}")
+        
+    return proxy_middleware
+
+
+async def test_downloader_with_proxy():
+    """测试下载器与代理配合"""
+    print("\n=== 测试下载器与代理配合 ===")
+    
+    # 创建设置管理器
+    settings_manager = SettingManager()
+    settings = settings_manager  # SettingManager实例本身就是设置对象
+    
+    # 配置代理
+    settings.set('PROXY_API_URL', 'http://proxy-api.example.com/proxy/getitem/')
+    settings.set('LOG_LEVEL', 'DEBUG')
+    
+    # 创建代理中间件
+    proxy_middleware = ProxyMiddleware(settings, "DEBUG")
+    
+    # 创建下载器
+    class MockStats:
+        def __init__(self):
+            pass
+            
+        def inc_value(self, key, count=1):
+            pass
+    
+    class MockSubscriber:
+        def __init__(self):
+            pass
+            
+        def subscribe(self, callback, event):
+            pass
+    
+    class MockSpider:
+        def __init__(self):
+            self.name = "test_spider"
+    
+    class MockEngine:
+        def __init__(self):
+            pass
+    
+    class MockCrawler:
+        def __init__(self, settings):
+            self.settings = settings
+            self.spider = MockSpider()  # 添加spider属性
+            self.stats = MockStats()    # 添加stats属性
+            self.subscriber = MockSubscriber()  # 添加subscriber属性
+            self.engine = MockEngine()  # 添加engine属性
+    
+    crawler = MockCrawler(settings)
+    downloader = HttpXDownloader(crawler)
+    downloader.open()
+    
+    # 创建测试请求
+    test_url = "https://httpbin.org/ip"  # 返回客户端IP的测试站点
+    request = Request(url=test_url)
+    
+    # 创建模拟爬虫
+    spider = MockSpider()
+    
+    try:
+        # 通过代理中间件处理请求
+        print("通过代理中间件处理请求...")
+        await proxy_middleware.process_request(request, spider)
+        
+        if request.proxy:
+            print(f"代理已设置: {request.proxy}")
+        else:
+            print("未设置代理")
+            
+        # 使用下载器下载
+        print(f"开始下载: {test_url}")
+        response = await downloader.download(request)
+        
+        if response:
+            print(f"下载成功，状态码: {response.status_code}")
+            print(f"响应内容: {response.text[:200]}...")  # 只显示前200个字符
+        else:
+            print("下载失败，响应为空")
+            
+    except Exception as e:
+        print(f"下载过程中出错: {e}")
+        import traceback
+        traceback.print_exc()
+        
+    finally:
+        # 清理资源
+        try:
+            await downloader.close()
+        except:
+            pass
+
+
+async def main():
+    """主测试函数"""
+    print("开始测试代理中间件与下载器的配合...")
+    
+    # 测试代理中间件
+    await test_proxy_middleware()
+    
+    # 测试下载器与代理配合
+    await test_downloader_with_proxy()
+    
+    print("\n测试完成")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

tests/test_real_scenario_proxy.py

@@ -39,28 +39,28 @@ COOKIES = {
     "Hm_lvt_929f8b362150b1f77b477230541dbbc2": "1758071793",
     "historystock": "600699",
     "spversion": "20130314",
-    "cid": "f9bc812da2c3a7ddf6d5df1fa2d497091758076438",
-    "u_ukey": "A10702B8689642C6BE607730E11E6E4A",
+    "cid": "example_cid_value",
+    "u_ukey": "example_u_ukey_value",
     "u_uver": "1.0.0",
-    "u_dpass": "Qk3U07X7SHGKa0AcRUg1R1DVWbPioD9Eg270bdikvlwWWXexbsXnRsQNt%2B04iXwdHi80LrSsTFH9a%2B6rtRvqGg%3D%3D",
-    "u_did": "E3ED337393E1429DA56E380DD00B3CCD",
+    "u_dpass": "example_u_dpass_value",
+    "u_did": "example_u_did_value",
     "u_ttype": "WEB",
     "user_status": "0",
     "ttype": "WEB",
     "log": "",
-    "Hm_lvt_69929b9dce4c22a060bd22d703b2a280": "1758079404,1758113068,1758157144",
-    "HMACCOUNT": "08DF0D235A291EAA",
-    "Hm_lvt_78c58f01938e4d85eaf619eae71b4ed1": "1758071793,1758113068,1758157144",
-    "user": "MDpteF9lNXRkY3RpdHo6Ok5vbmU6NTAwOjgxNzYyOTAwNDo3LDExMTExMTExMTExLDQwOzQ0LDExLDQwOzYsMSw0MDs1LDEsNDA7MSwxMDEsNDA7MiwxLDQwOzMsMSw0MDs1LDEsNDA7OCwwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMSw0MDsxMDIsMSw0MDoxNjo6OjgwNzYyOTAwNDoxNzU4MTYxNTE0Ojo6MTc1ODA3MjA2MDo2MDQ4MDA6MDoxYTQ0NmFlNDY4M2VmZWY3YmNjYTczY2U3ODZmZTNiODg6ZGVmYXVsdF81OjA%3D",
-    "userid": "807629004",
-    "u_name": "mx_e5tdctitz",
-    "escapename": "mx_e5tdctitz",
-    "ticket": "85eea709becdd924d7eb975351de629e",
-    "utk": "8959c4c6b6f5fb7628864feab15473f4",
-    "sess_tk": "eyJ0eXAiOiJKV1QiLCJhbGciOiJFUzI1NiIsImtpZCI6InNlc3NfdGtfMSIsImJ0eSI6InNlc3NfdGsifQ.eyJqdGkiOiI4ODNiZmU4NmU3M2NhN2NjN2JlZmVmODM0NmFlNDZhNDEiLCJpYXQiOjE3NTgxNjE1MTQsImV4cCI6MTc1ODc2NjMxNCwic3ViIjoiODA3NjI5MDA0IiwiaXNzIjoidXBhc3MuaXdlbmNhaS5jb20iLCJhdWQiOiIyMDIwMTExODUyODg5MDcyIiwiYWN0Ijoib2ZjIiwiY3VocyI6ImIwNTcyZDVjOWNlNDg0MGFlOWYxYTlhYjU3NGZkNjQyYjgzNmExN2E3Y2NhZjk4ZWRiNzI5ZmJkOWFjOGVkYmYifQ.UBNIzxGvQQtXSiIcB_1JJl-EuAc1S9j2LcTLXjwy4ImhDDbh1oJvyRdDUrXdUpwBpIyx5zgYqgt_3FEhY_iayw",
-    "cuc": "ap2eap3gg99g",
-    "Hm_lvt_f79b64788a4e377c608617fba4c736e2": "1758161692",
-    "v": "A1glI4rWhPCQGqh0MvA0ioufKY3vQbzLHqWQT5JJpBNGLfazOlGMW261YNrh",
+    "Hm_lvt_69929b9dce4c22a060bd22d703b2a280": "example_Hm_lvt_value",
+    "HMACCOUNT": "example_HMACCOUNT_value",
+    "Hm_lvt_78c58f01938e4d85eaf619eae71b4ed1": "example_Hm_lvt_value",
+    "user": "example_user_value",
+    "userid": "example_userid_value",
+    "u_name": "example_u_name_value",
+    "escapename": "example_escapename_value",
+    "ticket": "example_ticket_value",
+    "utk": "example_utk_value",
+    "sess_tk": "example_sess_tk_value",
+    "cuc": "example_cuc_value",
+    "Hm_lvt_f79b64788a4e377c608617fba4c736e2": "example_Hm_lvt_value",
+    "v": "example_v_value",
     "Hm_lpvt_78c58f01938e4d85eaf619eae71b4ed1": "1758163145",
     "Hm_lpvt_f79b64788a4e377c608617fba4c736e2": "1758163145",
     "Hm_lpvt_69929b9dce4c22a060bd22d703b2a280": "1758163145"

tests/test_response_follow.py

@@ -0,0 +1,105 @@
+#!/usr/bin/python
+# -*- coding:UTF-8 -*-
+"""
+Response.follow 方法测试
+"""
+import unittest
+from unittest.mock import Mock
+
+# 模拟 Request 类
+class MockRequest:
+    def __init__(self, url, callback=None, **kwargs):
+        self.url = url
+        self.callback = callback
+        self.kwargs = kwargs
+
+# 模拟 crawlo.Request
+import sys
+sys.modules['crawlo'] = Mock()
+sys.modules['crawlo'].Request = MockRequest
+
+from crawlo.network.response import Response
+
+
+class TestResponseFollow(unittest.TestCase):
+    """Response.follow 方法测试类"""
+
+    def setUp(self):
+        """测试前准备"""
+        # 创建一个模拟的HTML响应
+        html_content = """
+        <html>
+        <head>
+            <title>测试页面</title>
+        </head>
+        <body>
+            <div class="content">
+                <h1>主标题</h1>
+                <p class="intro">这是介绍段落</p>
+                <ul class="list">
+                    <li>项目1</li>
+                    <li>项目2</li>
+                    <li>项目3</li>
+                </ul>
+                <a href="https://example.com" class="link">链接文本</a>
+                <a href="/relative/path" class="relative-link">相对链接</a>
+                <img src="image.jpg" alt="图片描述" class="image">
+            </div>
+        </body>
+        </html>
+        """
+        
+        # 创建模拟的请求对象
+        mock_request = Mock()
+        mock_request.callback = None
+        
+        self.response = Response(
+            url="https://example.com/test",
+            body=html_content.encode('utf-8'),
+            headers={"content-type": "text/html; charset=utf-8"},
+            request=mock_request
+        )
+
+    def test_follow_absolute_url(self):
+        """测试处理绝对URL"""
+        request = self.response.follow("https://other.com/page", callback=lambda r: None)
+        self.assertEqual(request.url, "https://other.com/page")
+        self.assertIsNotNone(request.callback)
+
+    def test_follow_relative_url(self):
+        """测试处理相对URL"""
+        request = self.response.follow("/relative/path", callback=lambda r: None)
+        self.assertEqual(request.url, "https://example.com/relative/path")
+        self.assertIsNotNone(request.callback)
+
+    def test_follow_complex_relative_url(self):
+        """测试处理复杂的相对URL"""
+        request = self.response.follow("../other/path", callback=lambda r: None)
+        self.assertEqual(request.url, "https://example.com/other/path")
+        
+        request2 = self.response.follow("./another/path", callback=lambda r: None)
+        self.assertEqual(request2.url, "https://example.com/another/path")
+
+    def test_follow_with_query_params(self):
+        """测试处理带查询参数的URL"""
+        request = self.response.follow("/path?param=value", callback=lambda r: None)
+        self.assertEqual(request.url, "https://example.com/path?param=value")
+        
+        request2 = self.response.follow("/path#section", callback=lambda r: None)
+        self.assertEqual(request2.url, "https://example.com/path#section")
+
+    def test_follow_with_additional_kwargs(self):
+        """测试传递额外参数"""
+        request = self.response.follow(
+            "/path", 
+            callback=lambda r: None,
+            method="POST",
+            headers={"User-Agent": "test"}
+        )
+        self.assertEqual(request.url, "https://example.com/path")
+        self.assertEqual(request.kwargs.get("method"), "POST")
+        self.assertEqual(request.kwargs.get("headers"), {"User-Agent": "test"})
+
+
+if __name__ == '__main__':
+    unittest.main()