crawlo 1.3.2__py3-none-any.whl → 1.3.4__py3-none-any.whl

tests/test_large_scale_helper.py

@@ -0,0 +1,236 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+大规模爬虫辅助工具测试
+测试 LargeScaleHelper, ProgressManager, MemoryOptimizer, DataSourceAdapter, LargeScaleSpiderMixin
+"""
+import sys
+import os
+import unittest
+from unittest.mock import Mock, patch, MagicMock
+import asyncio
+import json
+import tempfile
+
+# 添加项目根目录到 Python 路径
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+
+from crawlo.utils.large_scale_helper import (
+    LargeScaleHelper, 
+    ProgressManager, 
+    MemoryOptimizer, 
+    DataSourceAdapter, 
+    LargeScaleSpiderMixin
+)
+
+
+class TestLargeScaleHelper(unittest.TestCase):
+    """大规模爬虫辅助类测试"""
+
+    def setUp(self):
+        """测试前准备"""
+        self.helper = LargeScaleHelper(batch_size=100, checkpoint_interval=500)
+        
+    def test_helper_initialization(self):
+        """测试辅助类初始化"""
+        self.assertEqual(self.helper.batch_size, 100)
+        self.assertEqual(self.helper.checkpoint_interval, 500)
+        
+    def test_batch_iterator_with_list(self):
+        """测试批次迭代器与列表数据源"""
+        data = list(range(250))  # 250个元素
+        batches = list(self.helper.batch_iterator(data))
+        
+        # 验证批次数量
+        self.assertEqual(len(batches), 3)  # 250/100 = 3批次(向上取整)
+        
+        # 验证每个批次的大小
+        self.assertEqual(len(batches[0]), 100)
+        self.assertEqual(len(batches[1]), 100)
+        self.assertEqual(len(batches[2]), 50)  # 最后一个批次
+        
+        # 验证数据完整性
+        all_data = []
+        for batch in batches:
+            all_data.extend(batch)
+        self.assertEqual(all_data, data)
+        
+    def test_batch_iterator_with_offset(self):
+        """测试批次迭代器与偏移量"""
+        data = list(range(250))  # 250个元素
+        batches = list(self.helper.batch_iterator(data, start_offset=50))
+        
+        # 验证批次数量
+        self.assertEqual(len(batches), 2)  # 剩余200个元素，2个批次
+        
+        # 验证数据正确性
+        all_data = []
+        for batch in batches:
+            all_data.extend(batch)
+        self.assertEqual(all_data, list(range(50, 250)))
+        
+    def test_batch_iterator_invalid_source(self):
+        """测试批次迭代器与无效数据源"""
+        with self.assertRaises(ValueError) as context:
+            list(self.helper.batch_iterator(123))  # 整数不是有效的数据源
+        self.assertIn("不支持的数据源类型", str(context.exception))
+
+
+class TestProgressManager(unittest.TestCase):
+    """进度管理器测试"""
+
+    def setUp(self):
+        """测试前准备"""
+        # 创建临时文件用于测试
+        self.temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.json')
+        self.temp_file.close()
+        self.progress_manager = ProgressManager(self.temp_file.name)
+        
+    def tearDown(self):
+        """测试后清理"""
+        try:
+            os.unlink(self.temp_file.name)
+        except:
+            pass
+            
+    def test_progress_manager_initialization(self):
+        """测试进度管理器初始化"""
+        self.assertEqual(self.progress_manager.progress_file, self.temp_file.name)
+        
+    def test_save_and_load_progress(self):
+        """测试保存和加载进度"""
+        # 保存进度
+        self.progress_manager.save_progress(
+            batch_num=10,
+            processed_count=1000,
+            skipped_count=50
+        )
+        
+        # 加载进度
+        progress = self.progress_manager.load_progress()
+        
+        # 验证进度数据
+        self.assertEqual(progress['batch_num'], 10)
+        self.assertEqual(progress['processed_count'], 1000)
+        self.assertEqual(progress['skipped_count'], 50)
+        self.assertIn('timestamp', progress)
+        self.assertIn('formatted_time', progress)
+        
+    def test_load_progress_file_not_found(self):
+        """测试加载不存在的进度文件"""
+        # 创建一个新的进度管理器与不存在的文件
+        non_existent_file = tempfile.gettempdir() + "/non_existent_progress.json"
+        pm = ProgressManager(non_existent_file)
+        
+        # 加载进度应该返回默认值
+        progress = pm.load_progress()
+        self.assertEqual(progress['batch_num'], 0)
+        self.assertEqual(progress['processed_count'], 0)
+        self.assertEqual(progress['skipped_count'], 0)
+
+
+class TestMemoryOptimizer(unittest.TestCase):
+    """内存优化器测试"""
+
+    def setUp(self):
+        """测试前准备"""
+        self.optimizer = MemoryOptimizer(max_memory_mb=100)
+        
+    def test_optimizer_initialization(self):
+        """测试内存优化器初始化"""
+        self.assertEqual(self.optimizer.max_memory_mb, 100)
+        
+    def test_should_pause_for_memory_without_psutil(self):
+        """测试在没有psutil时的内存检查"""
+        # 在没有psutil的情况下，should_pause_for_memory应该返回False
+        result = self.optimizer.should_pause_for_memory()
+        self.assertFalse(result)
+        
+    def test_force_garbage_collection(self):
+        """测试强制垃圾回收"""
+        # 这个方法应该能正常执行而不抛出异常
+        try:
+            self.optimizer.force_garbage_collection()
+            success = True
+        except:
+            success = False
+        self.assertTrue(success)
+
+
+class TestDataSourceAdapter(unittest.TestCase):
+    """数据源适配器测试"""
+
+    def test_from_file_adapter(self):
+        """测试文件数据源适配器"""
+        # 创建临时文件
+        with tempfile.NamedTemporaryFile(mode='w', delete=False) as f:
+            for i in range(10):
+                f.write(f"line {i}\n")
+            temp_file_name = f.name
+            
+        try:
+            # 创建文件数据源适配器
+            adapter = DataSourceAdapter.from_file(temp_file_name, batch_size=5)
+            
+            # 获取第一批数据
+            batch = adapter(0, 5)
+            self.assertEqual(len(batch), 5)
+            self.assertEqual(batch[0], "line 0")
+            self.assertEqual(batch[4], "line 4")
+            
+            # 获取第二批数据
+            batch = adapter(5, 5)
+            self.assertEqual(len(batch), 5)
+            self.assertEqual(batch[0], "line 5")
+            self.assertEqual(batch[4], "line 9")
+            
+        finally:
+            # 清理临时文件
+            os.unlink(temp_file_name)
+
+
+class TestLargeScaleSpiderMixin(unittest.TestCase):
+    """大规模爬虫混入类测试"""
+
+    def test_mixin_initialization(self):
+        """测试混入类初始化"""
+        # 创建一个模拟的爬虫类
+        class MockSpider:
+            def __init__(self):
+                self.name = "test_spider"
+                
+        class TestSpider(MockSpider, LargeScaleSpiderMixin):
+            def __init__(self):
+                MockSpider.__init__(self)
+                LargeScaleSpiderMixin.__init__(self)
+                
+        spider = TestSpider()
+        
+        # 验证初始化
+        self.assertEqual(spider.name, "test_spider")
+        self.assertIsNotNone(spider.large_scale_helper)
+        self.assertIsNotNone(spider.progress_manager)
+        self.assertIsNotNone(spider.memory_optimizer)
+        
+    def test_mixin_attributes(self):
+        """测试混入类属性"""
+        # 创建一个模拟的爬虫类
+        class MockSpider:
+            def __init__(self):
+                self.name = "test_spider"
+                
+        class TestSpider(MockSpider, LargeScaleSpiderMixin):
+            def __init__(self):
+                MockSpider.__init__(self)
+                LargeScaleSpiderMixin.__init__(self)
+                
+        spider = TestSpider()
+        
+        # 验证属性
+        self.assertIsInstance(spider.large_scale_helper, LargeScaleHelper)
+        self.assertIsInstance(spider.progress_manager, ProgressManager)
+        self.assertIsInstance(spider.memory_optimizer, MemoryOptimizer)
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_mode_change.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+测试运行模式日志级别修改
+"""
+import sys
+import os
+sys.path.insert(0, '/')
+
+def test_mode_log_level():
+    print("=== 测试运行模式日志级别修改 ===")
+    
+    # 删除旧的日志文件
+    test_log_file = '/Users/oscar/projects/Crawlo/test_mode_change.log'
+    if os.path.exists(test_log_file):
+        os.remove(test_log_file)
+    
+    # 准备测试设置
+    test_settings = {
+        'PROJECT_NAME': 'test_mode_change',
+        'LOG_LEVEL': 'INFO',
+        'LOG_FILE': test_log_file,
+        'RUN_MODE': 'standalone'
+    }
+    
+    try:
+        # 初始化框架
+        from crawlo.core.framework_initializer import initialize_framework
+        settings = initialize_framework(test_settings)
+        
+        print(f"设置初始化完成: {settings.get('PROJECT_NAME')}")
+        
+        # 检查日志文件是否包含运行模式信息
+        if os.path.exists(test_log_file):
+            with open(test_log_file, 'r', encoding='utf-8') as f:
+                content = f.read()
+                print(f"日志文件内容长度: {len(content)} 字符")
+                
+                # 检查是否还有INFO级别的运行模式信息
+                info_lines = [line for line in content.split('\n') if 'INFO' in line and '使用单机模式' in line]
+                debug_lines = [line for line in content.split('\n') if 'DEBUG' in line and '使用单机模式' in line]
+                
+                if info_lines:
+                    print("❌ 仍然发现INFO级别的运行模式信息:")
+                    for line in info_lines:
+                        print(f"   {line}")
+                else:
+                    print("✅ 没有发现INFO级别的运行模式信息")
+                
+                if debug_lines:
+                    print("✅ 发现DEBUG级别的运行模式信息:")
+                    for line in debug_lines:
+                        print(f"   {line}")
+                else:
+                    print("❌ 没有发现DEBUG级别的运行模式信息")
+                    
+                print("\n所有日志内容:")
+                lines = content.split('\n')
+                for i, line in enumerate(lines, 1):
+                    if line.strip():
+                        print(f"{i:3d}: {line}")
+        else:
+            print("❌ 日志文件未创建")
+    
+    except Exception as e:
+        print(f"错误: {e}")
+        import traceback
+        traceback.print_exc()
+    
+    print("=== 测试完成 ===")
+
+if __name__ == "__main__":
+    test_mode_log_level()

tests/test_mode_consistency.py

@@ -22,7 +22,7 @@ class TestSpider(Spider):
         yield Request("https://httpbin.org/get")
     
     def parse(self, response):
-        yield {"url": response.url, "status": response.status}
+        yield {"url": response.url, "status": response.status_code}  # 修复：使用status_code而不是status
 
 
 async def test_mode_consistency():

tests/test_performance_monitor.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+性能监控工具测试
+测试 PerformanceMonitor, PerformanceTimer, performance_monitor_decorator
+"""
+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__), '..'))
+
+# 尝试导入性能监控工具
+try:
+    from crawlo.utils.performance_monitor import PerformanceMonitor, PerformanceTimer, performance_monitor_decorator
+    PSUTIL_AVAILABLE = True
+except ImportError:
+    PSUTIL_AVAILABLE = False
+    PerformanceMonitor = None
+    PerformanceTimer = None
+    performance_monitor_decorator = None
+
+
+class TestPerformanceTimer(unittest.TestCase):
+    """性能计时器测试"""
+
+    @unittest.skipIf(not PSUTIL_AVAILABLE, "psutil not available")
+    def setUp(self):
+        """测试前准备"""
+        self.timer = PerformanceTimer("test_timer")
+        
+    @unittest.skipIf(not PSUTIL_AVAILABLE, "psutil not available")
+    def test_timer_initialization(self):
+        """测试计时器初始化"""
+        self.assertEqual(self.timer.name, "test_timer")
+        self.assertIsNone(self.timer.start_time)
+        self.assertIsNone(self.timer.end_time)
+        
+    @unittest.skipIf(not PSUTIL_AVAILABLE, "psutil not available")
+    def test_timer_context_manager(self):
+        """测试计时器上下文管理器"""
+        with self.timer as t:
+            # 在这里执行一些操作
+            result = 1 + 1
+            
+        self.assertEqual(result, 2)
+        # 验证计时器已启动和停止
+        self.assertIsNotNone(t.start_time)
+        self.assertIsNotNone(t.end_time)
+        
+    @unittest.skipIf(not PSUTIL_AVAILABLE, "psutil not available")
+    def test_timer_start_stop(self):
+        """测试计时器启动和停止"""
+        self.timer.start()
+        self.assertIsNotNone(self.timer.start_time)
+        
+        # 等待一小段时间
+        import time
+        time.sleep(0.01)
+        
+        elapsed = self.timer.stop()
+        self.assertIsNotNone(self.timer.end_time)
+        self.assertIsInstance(elapsed, float)
+        self.assertGreater(elapsed, 0)
+
+
+class TestPerformanceMonitor(unittest.TestCase):
+    """性能监控器测试"""
+
+    @unittest.skipIf(not PSUTIL_AVAILABLE, "psutil not available")
+    def setUp(self):
+        """测试前准备"""
+        self.monitor = PerformanceMonitor("test_monitor")
+        
+    @unittest.skipIf(not PSUTIL_AVAILABLE, "psutil not available")
+    def test_monitor_initialization(self):
+        """测试监控器初始化"""
+        self.assertEqual(self.monitor.start_time, self.monitor.start_time)
+        self.assertIsInstance(self.monitor.metrics, dict)
+        self.assertIn('cpu_usage', self.monitor.metrics)
+        self.assertIn('memory_usage', self.monitor.metrics)
+        self.assertIn('network_io', self.monitor.metrics)
+        self.assertIn('disk_io', self.monitor.metrics)
+
+
+class TestPerformanceMonitorDecorator(unittest.TestCase):
+    """性能监控装饰器测试"""
+
+    @unittest.skipIf(not PSUTIL_AVAILABLE, "psutil not available")
+    def test_performance_monitor_decorator_sync(self):
+        """测试同步函数的性能监控装饰器"""
+        @performance_monitor_decorator(name="test_sync_function")
+        def sync_function():
+            return "test_result"
+            
+        result = sync_function()
+        self.assertEqual(result, "test_result")
+        
+    @unittest.skipIf(not PSUTIL_AVAILABLE, "psutil not available")
+    def test_performance_monitor_decorator_async(self):
+        """测试异步函数的性能监控装饰器"""
+        @performance_monitor_decorator(name="test_async_function")
+        async def async_function():
+            await asyncio.sleep(0.01)  # 模拟异步操作
+            return "async_result"
+            
+        # 使用事件循环运行异步函数
+        result = asyncio.run(async_function())
+        self.assertEqual(result, "async_result")
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_queue_empty_check.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+测试队列空检查功能
+"""
+import asyncio
+import sys
+import os
+
+# 添加项目根目录到Python路径
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+
+from crawlo.queue.pqueue import SpiderPriorityQueue
+
+
+async def test_queue_empty_check():
+    """测试队列空检查功能"""
+    print("🚀 开始测试队列空检查功能...")
+    
+    # 创建队列实例
+    queue = SpiderPriorityQueue()
+    
+    # 检查空队列
+    print(f"空队列大小: {queue.qsize()}")
+    print(f"空队列是否为空: {queue.qsize() == 0}")
+    
+    # 添加一个元素
+    await queue.put((1, "test"))
+    print(f"添加元素后队列大小: {queue.qsize()}")
+    print(f"添加元素后队列是否为空: {queue.qsize() == 0}")
+    
+    # 获取元素
+    item = await queue.get()
+    print(f"获取元素: {item}")
+    print(f"获取元素后队列大小: {queue.qsize()}")
+    print(f"获取元素后队列是否为空: {queue.qsize() == 0}")
+    
+    print("✅ 队列空检查功能测试完成!")
+
+
+if __name__ == '__main__':
+    asyncio.run(test_queue_empty_check())

tests/untested_features_report.md

@@ -0,0 +1,139 @@
+# 未测试功能报告
+
+## 概述
+
+在对Crawlo框架进行全面分析后，发现以下功能模块缺乏专门的测试用例。这些模块虽然部分功能在其他测试中可能有间接覆盖，但缺乏针对性的单元测试和集成测试。
+
+## 已完成测试的功能模块
+
+### 1. 工厂模式相关模块
+
+**模块路径**: `crawlo/factories/`
+
+**测试文件**: `tests/test_factories.py`
+
+**已测试组件**:
+- `ComponentRegistry` - 组件注册表
+- `ComponentFactory` - 组件工厂基类
+- `DefaultComponentFactory` - 默认组件工厂
+- `CrawlerComponentFactory` - Crawler组件工厂
+
+### 2. 批处理工具
+
+**模块路径**: `crawlo/utils/batch_processor.py`
+
+**测试文件**: `tests/test_batch_processor.py`
+
+**已测试组件**:
+- `BatchProcessor` - 批处理处理器
+- `RedisBatchProcessor` - Redis批处理处理器
+- `batch_process` - 便捷批处理函数
+
+### 3. 受控爬虫混入类
+
+**模块路径**: `crawlo/utils/controlled_spider_mixin.py`
+
+**测试文件**: `tests/test_controlled_spider_mixin.py`
+
+**已测试组件**:
+- `ControlledRequestMixin` - 受控请求生成混入类
+- `AsyncControlledRequestMixin` - 异步受控请求混入类
+
+### 4. 大规模配置工具
+
+**模块路径**: `crawlo/utils/large_scale_config.py`
+
+**测试文件**: `tests/test_large_scale_config.py`
+
+**已测试组件**:
+- `LargeScaleConfig` - 大规模爬虫配置类
+- `apply_large_scale_config` - 应用大规模配置函数
+
+### 5. 大规模爬虫辅助工具
+
+**模块路径**: `crawlo/utils/large_scale_helper.py`
+
+**测试文件**: `tests/test_large_scale_helper.py`
+
+**已测试组件**:
+- `LargeScaleHelper` - 大规模爬虫辅助类
+- `ProgressManager` - 进度管理器
+- `MemoryOptimizer` - 内存优化器
+- `DataSourceAdapter` - 数据源适配器
+- `LargeScaleSpiderMixin` - 大规模爬虫混入类
+
+### 6. 增强错误处理工具
+
+**模块路径**: `crawlo/utils/enhanced_error_handler.py`
+
+**测试文件**: 
+- `tests/test_enhanced_error_handler.py` (基础测试)
+- `tests/test_enhanced_error_handler_comprehensive.py` (综合测试)
+
+**已测试组件**:
+- `ErrorContext` - 错误上下文信息
+- `DetailedException` - 详细异常基类
+- `EnhancedErrorHandler` - 增强错误处理器
+- `handle_exception` 装饰器
+
+## 未测试的功能模块
+
+### 1. 性能监控工具
+
+**模块路径**: `crawlo/utils/performance_monitor.py`
+
+**测试文件**: `tests/test_performance_monitor.py` (部分测试，依赖psutil)
+
+**未充分测试组件**:
+- `PerformanceMonitor` - 性能监控器
+- `PerformanceTimer` - 性能计时器
+- `performance_monitor_decorator` - 性能监控装饰器
+
+**风险**: 性能监控是优化和诊断的重要工具，缺乏测试可能导致监控数据不准确或监控功能失效。
+
+## 建议的测试策略
+
+### 1. 优先级排序
+
+**高优先级** (直接影响核心功能):
+- (已完成)
+
+**中优先级** (影响性能和稳定性):
+- 性能监控工具
+
+**低优先级** (辅助功能):
+- (已完成)
+
+### 2. 测试类型建议
+
+**单元测试**:
+- 针对每个类的方法进行独立测试
+- 验证边界条件和异常情况
+- 测试配置参数的有效性
+
+**集成测试**:
+- 测试模块间的协作
+- 验证与Redis等外部服务的交互
+- 测试在真实爬虫场景中的表现
+
+**性能测试**:
+- 验证批处理工具的性能优势
+- 测试大规模处理工具的内存使用情况
+- 验证性能监控工具的准确性
+
+### 3. 测试覆盖建议
+
+**核心功能覆盖**:
+- 正常流程测试
+- 异常流程测试
+- 边界条件测试
+- 并发安全测试
+
+**配置覆盖**:
+- 不同配置参数的测试
+- 默认配置与自定义配置的对比
+- 配置更新的动态测试
+
+## 结论
+
+已为工厂模式、批处理工具、受控爬虫混入类、大规模配置工具、大规模爬虫辅助工具和增强错误处理工具创建了测试用例，这些核心组件现在有了基本的测试覆盖。建议继续为性能监控工具补充测试用例（在安装psutil后），以确保框架的完整性和稳定性。

tests/verify_debug.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+验证运行模式日志级别修改的简单测试
+"""
+import os
+
+# 删除旧日志文件
+log_file = 'verify_debug.log'
+if os.path.exists(log_file):
+    os.remove(log_file)
+
+# 简单测试日志级别
+from crawlo.utils.log import LoggerManager
+
+# 配置日志系统
+LoggerManager.configure(
+    LOG_LEVEL='INFO',
+    LOG_FILE=log_file
+)
+
+from crawlo.utils.log import get_logger
+
+# 创建测试logger
+test_logger = get_logger('crawlo.framework')
+
+# 测试输出
+test_logger.info("这是INFO级别的测试信息")
+test_logger.debug("这是DEBUG级别的测试信息（不应该在INFO级别的日志中出现）")
+test_logger.debug("使用单机模式 - 简单快速，适合开发和中小规模爬取")
+
+print("测试完成")
+
+# 检查日志文件
+if os.path.exists(log_file):
+    with open(log_file, 'r', encoding='utf-8') as f:
+        content = f.read()
+        print(f"日志文件内容（{len(content)} 字符）:")
+        print(content)
+        
+        # 检查是否包含不应该出现的DEBUG信息
+        if "DEBUG" in content:
+            print("❌ 发现DEBUG级别信息（不应该出现）")
+        else:
+            print("✅ 没有发现DEBUG级别信息（正确）")
+            
+        if "使用单机模式" in content:
+            print("❌ 发现运行模式信息（不应该出现在INFO级别）")
+        else:
+            print("✅ 没有发现运行模式信息（正确）")
+else:
+    print("❌ 日志文件未创建")