crawlo 1.3.3__py3-none-any.whl → 1.3.5__py3-none-any.whl

tests/test_large_scale_config.py

@@ -0,0 +1,113 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+大规模配置工具测试
+测试 LargeScaleConfig, apply_large_scale_config
+"""
+import sys
+import os
+import unittest
+from unittest.mock import Mock, patch, MagicMock
+
+# 添加项目根目录到 Python 路径
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+
+from crawlo.utils.large_scale_config import LargeScaleConfig, apply_large_scale_config
+
+
+class TestLargeScaleConfig(unittest.TestCase):
+    """大规模配置工具测试"""
+
+    def test_conservative_config(self):
+        """测试保守配置"""
+        config = LargeScaleConfig.conservative_config(concurrency=8)
+        
+        # 验证基本配置
+        self.assertEqual(config['CONCURRENCY'], 8)
+        self.assertEqual(config['SCHEDULER_MAX_QUEUE_SIZE'], 80)  # 8 * 10
+        self.assertEqual(config['DOWNLOAD_DELAY'], 0.2)
+        self.assertEqual(config['MAX_RUNNING_SPIDERS'], 1)
+        
+        # 验证连接池配置
+        self.assertEqual(config['CONNECTION_POOL_LIMIT'], 16)  # 8 * 2
+        
+        # 验证重试配置
+        self.assertEqual(config['MAX_RETRY_TIMES'], 2)
+        
+    def test_balanced_config(self):
+        """测试平衡配置"""
+        config = LargeScaleConfig.balanced_config(concurrency=16)
+        
+        # 验证基本配置
+        self.assertEqual(config['CONCURRENCY'], 16)
+        self.assertEqual(config['SCHEDULER_MAX_QUEUE_SIZE'], 240)  # 16 * 15
+        self.assertEqual(config['DOWNLOAD_DELAY'], 0.1)
+        self.assertEqual(config['MAX_RUNNING_SPIDERS'], 2)
+        
+        # 验证连接池配置
+        self.assertEqual(config['CONNECTION_POOL_LIMIT'], 48)  # 16 * 3
+        
+        # 验证重试配置
+        self.assertEqual(config['MAX_RETRY_TIMES'], 3)
+        
+    def test_aggressive_config(self):
+        """测试激进配置"""
+        config = LargeScaleConfig.aggressive_config(concurrency=32)
+        
+        # 验证基本配置
+        self.assertEqual(config['CONCURRENCY'], 32)
+        self.assertEqual(config['SCHEDULER_MAX_QUEUE_SIZE'], 640)  # 32 * 20
+        self.assertEqual(config['DOWNLOAD_DELAY'], 0.05)
+        self.assertEqual(config['MAX_RUNNING_SPIDERS'], 3)
+        
+        # 验证连接池配置
+        self.assertEqual(config['CONNECTION_POOL_LIMIT'], 128)  # 32 * 4
+        
+        # 验证重试配置
+        self.assertEqual(config['MAX_RETRY_TIMES'], 5)
+        
+    def test_memory_optimized_config(self):
+        """测试内存优化配置"""
+        config = LargeScaleConfig.memory_optimized_config(concurrency=12)
+        
+        # 验证基本配置
+        self.assertEqual(config['CONCURRENCY'], 12)
+        self.assertEqual(config['SCHEDULER_MAX_QUEUE_SIZE'], 60)  # 12 * 5
+        self.assertEqual(config['DOWNLOAD_DELAY'], 0.1)
+        self.assertEqual(config['MAX_RUNNING_SPIDERS'], 1)
+        
+        # 验证连接池配置
+        self.assertEqual(config['CONNECTION_POOL_LIMIT'], 12)  # 12 * 1
+        
+        # 验证内存限制配置
+        self.assertEqual(config['DOWNLOAD_MAXSIZE'], 2 * 1024 * 1024)  # 2MB
+        self.assertEqual(config['DOWNLOAD_WARN_SIZE'], 512 * 1024)  # 512KB
+        
+        # 验证重试配置
+        self.assertEqual(config['MAX_RETRY_TIMES'], 2)
+        
+    def test_apply_large_scale_config(self):
+        """测试应用大规模配置"""
+        settings_dict = {}
+        
+        # 应用平衡配置
+        apply_large_scale_config(settings_dict, "balanced", 16)
+        
+        # 验证配置已应用
+        self.assertEqual(settings_dict['CONCURRENCY'], 16)
+        self.assertEqual(settings_dict['SCHEDULER_MAX_QUEUE_SIZE'], 240)
+        self.assertEqual(settings_dict['DOWNLOAD_DELAY'], 0.1)
+        
+    def test_apply_large_scale_config_invalid_type(self):
+        """测试应用无效的大规模配置类型"""
+        settings_dict = {}
+        
+        # 应用无效配置类型应该抛出异常
+        with self.assertRaises(ValueError) as context:
+            apply_large_scale_config(settings_dict, "invalid_type", 16)
+            
+        self.assertIn("不支持的配置类型", str(context.exception))
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,283 @@
+#!/usr/bin/env python
+# -*- coding: UTF-8 -*-
+"""
+全面测试Crawlo框架日志系统的所有功能
+"""
+
+import os
+import sys
+import tempfile
+import shutil
+from pathlib import Path
+
+# 添加项目根目录到Python路径
+project_root = Path(__file__).parent.parent
+sys.path.insert(0, str(project_root))
+
+from crawlo.logging import configure_logging as configure, get_logger, LogManager
+from crawlo.logging.config import LogConfig
+
+
+def test_basic_logging():
+    """测试基本日志功能"""
+    print("=== 测试基本日志功能 ===")
+    
+    # 1. 测试默认配置
+    print("1. 测试默认配置...")
+    configure()
+    config = LogManager().config
+    print(f"   默认级别: {config.level}")
+    print(f"   默认格式: {config.format}")
+    
+    # 2. 测试获取logger
+    logger = get_logger('test.basic')
+    print(f"   Logger名称: {logger.name}")
+    print(f"   Handlers数量: {len(logger.handlers)}")
+    
+    # 3. 测试日志输出
+    logger.info("这是一条INFO级别日志")
+    logger.warning("这是一条WARNING级别日志")
+    logger.error("这是一条ERROR级别日志")
+    print("   日志输出完成")
+
+
+def test_file_logging():
+    """测试文件日志功能"""
+    print("\n=== 测试文件日志功能 ===")
+    
+    # 创建临时目录
+    temp_dir = tempfile.mkdtemp()
+    log_file = os.path.join(temp_dir, 'test.log')
+    
+    try:
+        # 1. 配置文件日志
+        print("1. 配置文件日志...")
+        configure(
+            LOG_LEVEL='DEBUG',
+            LOG_FILE=log_file,
+            LOG_MAX_BYTES=1024,  # 小的轮转大小用于测试
+            LOG_BACKUP_COUNT=3
+        )
+        
+        config = LogManager().config
+        print(f"   日志文件: {config.file_path}")
+        print(f"   轮转大小: {config.max_bytes}")
+        print(f"   备份数量: {config.backup_count}")
+        
+        # 2. 获取logger并测试输出
+        logger = get_logger('test.file')
+        print("2. 测试日志输出...")
+        
+        # 输出多条日志以触发轮转
+        for i in range(50):
+            logger.debug(f"这是第{i+1}条DEBUG日志，用于测试轮转功能")
+            logger.info(f"这是第{i+1}条INFO日志，用于测试轮转功能")
+        
+        # 3. 检查日志文件
+        print("3. 检查日志文件...")
+        if os.path.exists(log_file):
+            file_size = os.path.getsize(log_file)
+            print(f"   主日志文件大小: {file_size} 字节")
+        else:
+            print("   主日志文件不存在!")
+            
+        # 检查备份文件
+        for i in range(1, 4):
+            backup_file = f"{log_file}.{i}"
+            if os.path.exists(backup_file):
+                backup_size = os.path.getsize(backup_file)
+                print(f"   备份文件 {i} 大小: {backup_size} 字节")
+            else:
+                print(f"   备份文件 {i} 不存在")
+                
+    finally:
+        # 清理临时目录
+        shutil.rmtree(temp_dir, ignore_errors=True)
+
+
+def test_console_logging():
+    """测试控制台日志功能"""
+    print("\n=== 测试控制台日志功能 ===")
+    
+    # 1. 配置仅控制台日志
+    print("1. 配置仅控制台日志...")
+    configure(
+        LOG_LEVEL='INFO',
+        LOG_CONSOLE_ENABLED=True,
+        LOG_FILE_ENABLED=False
+    )
+    
+    config = LogManager().config
+    print(f"   控制台启用: {config.console_enabled}")
+    print(f"   文件日志启用: {config.file_enabled}")
+    
+    # 2. 测试日志输出
+    logger = get_logger('test.console')
+    print("2. 测试日志输出...")
+    logger.info("这条日志应该只在控制台显示")
+    logger.debug("这条DEBUG日志不应该显示（级别低于INFO）")
+
+
+def test_module_level_logging():
+    """测试模块级别日志功能"""
+    print("\n=== 测试模块级别日志功能 ===")
+    
+    # 1. 配置模块级别
+    print("1. 配置模块级别...")
+    configure(
+        LOG_LEVEL='WARNING',
+        LOG_LEVELS={
+            'test.module.high': 'DEBUG',
+            'test.module.low': 'ERROR'
+        }
+    )
+    
+    config = LogManager().config
+    print(f"   默认级别: {config.level}")
+    print(f"   模块级别配置: {config.module_levels}")
+    
+    # 2. 测试不同模块的日志级别
+    print("2. 测试不同模块的日志级别...")
+    
+    # 高级别模块（DEBUG）
+    high_logger = get_logger('test.module.high')
+    print(f"   high_logger 级别: {logging.getLevelName(high_logger.handlers[0].level)}")
+    high_logger.debug("这条DEBUG日志应该显示")
+    high_logger.info("这条INFO日志应该显示")
+    
+    # 低级别模块（ERROR）
+    low_logger = get_logger('test.module.low')
+    print(f"   low_logger 级别: {logging.getLevelName(low_logger.handlers[0].level)}")
+    low_logger.info("这条INFO日志不应该显示")
+    low_logger.error("这条ERROR日志应该显示")
+    
+    # 默认级别模块（WARNING）
+    default_logger = get_logger('test.module.default')
+    print(f"   default_logger 级别: {logging.getLevelName(default_logger.handlers[0].level)}")
+    default_logger.info("这条INFO日志不应该显示")
+    default_logger.warning("这条WARNING日志应该显示")
+
+
+def test_log_config_from_settings():
+    """测试从settings对象创建配置"""
+    print("\n=== 测试从settings对象创建配置 ===")
+    
+    # 1. 创建模拟settings对象
+    class MockSettings:
+        def __init__(self):
+            self.LOG_LEVEL = 'DEBUG'
+            self.LOG_FILE = 'test_settings.log'
+            self.LOG_MAX_BYTES = 5 * 1024 * 1024
+            self.LOG_BACKUP_COUNT = 2
+            self.LOG_ENCODING = 'utf-8'
+            self.LOG_CONSOLE_ENABLED = True
+            self.LOG_FILE_ENABLED = True
+            self.LOG_LEVELS = {'test.custom': 'INFO'}
+    
+    # 2. 从settings创建配置
+    print("2. 从settings创建配置...")
+    settings = MockSettings()
+    config = LogConfig.from_settings(settings)
+    
+    print(f"   级别: {config.level}")
+    print(f"   文件: {config.file_path}")
+    print(f"   轮转大小: {config.max_bytes}")
+    print(f"   备份数量: {config.backup_count}")
+    print(f"   编码: {config.encoding}")
+    print(f"   控制台启用: {config.console_enabled}")
+    print(f"   文件启用: {config.file_enabled}")
+    print(f"   模块级别: {config.module_levels}")
+
+
+def test_log_config_validation():
+    """测试日志配置验证功能"""
+    print("\n=== 测试日志配置验证功能 ===")
+    
+    # 1. 测试有效配置
+    print("1. 测试有效配置...")
+    valid_config = LogConfig(
+        level='INFO',
+        file_path='test_valid.log'
+    )
+    is_valid = valid_config.validate()
+    print(f"   有效配置验证结果: {is_valid}")
+    
+    # 2. 测试无效级别
+    print("2. 测试无效级别...")
+    invalid_config = LogConfig(
+        level='INVALID',
+        file_path='test_invalid.log'
+    )
+    is_valid = invalid_config.validate()
+    print(f"   无效级别验证结果: {is_valid}")
+    
+    # 3. 测试目录创建
+    print("3. 测试目录创建...")
+    temp_dir = tempfile.mkdtemp()
+    nested_log_file = os.path.join(temp_dir, 'subdir', 'test.log')
+    
+    config = LogConfig(
+        level='INFO',
+        file_path=nested_log_file
+    )
+    is_valid = config.validate()
+    print(f"   目录创建验证结果: {is_valid}")
+    
+    # 清理
+    shutil.rmtree(temp_dir, ignore_errors=True)
+
+
+def test_logger_caching():
+    """测试Logger缓存功能"""
+    print("\n=== 测试Logger缓存功能 ===")
+    
+    # 重置配置以确保测试环境干净
+    LogManager().reset()
+    
+    # 1. 获取同一个logger多次
+    print("1. 测试缓存...")
+    logger1 = get_logger('test.cache')
+    logger2 = get_logger('test.cache')
+    
+    print(f"   第一次获取: {id(logger1)}")
+    print(f"   第二次获取: {id(logger2)}")
+    print(f"   是否为同一对象: {logger1 is logger2}")
+    
+    # 2. 测试配置更新后缓存刷新
+    print("2. 测试配置更新...")
+    configure(LOG_LEVEL='ERROR')
+    logger3 = get_logger('test.cache')
+    print(f"   更新配置后获取: {id(logger3)}")
+    print(f"   是否与之前相同: {logger1 is logger3}")
+
+
+def main():
+    """主测试函数"""
+    print("开始全面测试Crawlo框架日志系统...")
+    
+    try:
+        # 运行所有测试
+        test_basic_logging()
+        test_file_logging()
+        test_console_logging()
+        test_module_level_logging()
+        test_log_config_from_settings()
+        test_log_config_validation()
+        test_logger_caching()
+        
+        print("\n=== 所有测试完成 ===")
+        
+    except Exception as e:
+        print(f"\n测试过程中出现错误: {e}")
+        import traceback
+        traceback.print_exc()
+        return 1
+    
+    return 0
+
+
+# 导入logging模块用于测试
+import logging
+
+if __name__ == '__main__':
+    sys.exit(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()