"""性能测试 - 验证系统性能指标。 测试内容： 1. 数据理解阶段性能（< 30秒） 2. 完整分析流程性能（< 30分钟） 3. 大数据集处理（100万行） 4. 内存使用 需求：NFR-1.1, NFR-1.2 """ import pytest import time import pandas as pd import numpy as np import psutil import os from pathlib import Path from typing import Dict, Any from src.main import run_analysis from src.data_access import DataAccessLayer from src.engines.data_understanding import understand_data class TestDataUnderstandingPerformance: """测试数据理解阶段的性能。""" def test_small_dataset_performance(self, tmp_path): """测试小数据集（1000行）的性能。""" # 生成测试数据 data_file = tmp_path / "small_data.csv" df = self._generate_test_data(rows=1000, cols=10) df.to_csv(data_file, index=False) # 测试性能 start_time = time.time() dal = DataAccessLayer.load_from_file(str(data_file)) profile = understand_data(dal) elapsed = time.time() - start_time # 验证：应该在5秒内完成 assert elapsed < 5, f"小数据集理解耗时 {elapsed:.2f}秒，超过5秒限制" assert profile.row_count == 1000 assert profile.column_count == 10 def test_medium_dataset_performance(self, tmp_path): """测试中等数据集（10万行）的性能。""" # 生成测试数据 data_file = tmp_path / "medium_data.csv" df = self._generate_test_data(rows=100000, cols=20) df.to_csv(data_file, index=False) # 测试性能 start_time = time.time() dal = DataAccessLayer.load_from_file(str(data_file)) profile = understand_data(dal) elapsed = time.time() - start_time # 验证：应该在15秒内完成 assert elapsed < 15, f"中等数据集理解耗时 {elapsed:.2f}秒，超过15秒限制" assert profile.row_count == 100000 assert profile.column_count == 20 def test_large_dataset_performance(self, tmp_path): """测试大数据集（100万行）的性能。 需求：NFR-1.1 - 数据理解阶段 < 30秒 需求：NFR-1.2 - 支持最大100万行数据 """ # 生成测试数据 data_file = tmp_path / "large_data.csv" df = self._generate_test_data(rows=1000000, cols=30) df.to_csv(data_file, index=False) # 测试性能 start_time = time.time() dal = DataAccessLayer.load_from_file(str(data_file)) profile = understand_data(dal) elapsed = time.time() - start_time # 验证：应该在30秒内完成 assert elapsed < 30, f"大数据集理解耗时 {elapsed:.2f}秒，超过30秒限制" assert profile.row_count == 1000000 assert profile.column_count == 30 print(f"✓ 大数据集（100万行）理解耗时: {elapsed:.2f}秒") def _generate_test_data(self, rows: int, cols: int) -> pd.DataFrame: """生成测试数据。""" data = {} # 生成不同类型的列 for i in range(cols): col_type = i % 4 if col_type == 0: # 数值列 data[f'numeric_{i}'] = np.random.randn(rows) elif col_type == 1: # 分类列 categories = ['A', 'B', 'C', 'D', 'E'] data[f'category_{i}'] = np.random.choice(categories, rows) elif col_type == 2: # 日期列 start_date = pd.Timestamp('2020-01-01') data[f'date_{i}'] = pd.date_range(start_date, periods=rows, freq='H') else: # 文本列 data[f'text_{i}'] = [f'text_{j}' for j in range(rows)] return pd.DataFrame(data) class TestFullAnalysisPerformance: """测试完整分析流程的性能。""" @pytest.mark.slow def test_small_dataset_full_analysis(self, tmp_path): """测试小数据集的完整分析流程。""" # 生成测试数据 data_file = tmp_path / "test_data.csv" df = self._generate_ticket_data(rows=1000) df.to_csv(data_file, index=False) # 设置输出目录 output_dir = tmp_path / "output" # 测试性能 start_time = time.time() result = run_analysis( data_file=str(data_file), user_requirement="分析工单数据", output_dir=str(output_dir) ) elapsed = time.time() - start_time # 验证：应该在5分钟内完成 assert elapsed < 300, f"小数据集完整分析耗时 {elapsed:.2f}秒，超过5分钟限制" assert result['success'] is True print(f"✓ 小数据集（1000行）完整分析耗时: {elapsed:.2f}秒") @pytest.mark.slow @pytest.mark.skipif( os.getenv('SKIP_LONG_TESTS') == '1', reason="跳过长时间运行的测试" ) def test_large_dataset_full_analysis(self, tmp_path): """测试大数据集的完整分析流程。 需求：NFR-1.1 - 完整分析流程 < 30分钟 """ # 生成测试数据 data_file = tmp_path / "large_test_data.csv" df = self._generate_ticket_data(rows=100000) df.to_csv(data_file, index=False) # 设置输出目录 output_dir = tmp_path / "output" # 测试性能 start_time = time.time() result = run_analysis( data_file=str(data_file), user_requirement="分析工单健康度", output_dir=str(output_dir) ) elapsed = time.time() - start_time # 验证：应该在30分钟内完成 assert elapsed < 1800, f"大数据集完整分析耗时 {elapsed:.2f}秒，超过30分钟限制" assert result['success'] is True print(f"✓ 大数据集（10万行）完整分析耗时: {elapsed:.2f}秒") def _generate_ticket_data(self, rows: int) -> pd.DataFrame: """生成工单测试数据。""" statuses = ['待处理', '处理中', '已关闭', '已解决'] priorities = ['低', '中', '高', '紧急'] types = ['故障', '咨询', '投诉', '建议'] models = ['Model A', 'Model B', 'Model C', 'Model D'] data = { 'ticket_id': [f'T{i:06d}' for i in range(rows)], 'status': np.random.choice(statuses, rows), 'priority': np.random.choice(priorities, rows), 'type': np.random.choice(types, rows), 'model': np.random.choice(models, rows), 'created_at': pd.date_range('2023-01-01', periods=rows, freq='5min'), 'closed_at': pd.date_range('2023-01-01', periods=rows, freq='5min') + pd.Timedelta(hours=24), 'duration_hours': np.random.randint(1, 100, rows), } return pd.DataFrame(data) class TestMemoryUsage: """测试内存使用。""" def test_data_loading_memory(self, tmp_path): """测试数据加载的内存使用。""" # 生成测试数据 data_file = tmp_path / "memory_test.csv" df = self._generate_test_data(rows=100000, cols=50) df.to_csv(data_file, index=False) # 记录初始内存 process = psutil.Process() initial_memory = process.memory_info().rss / 1024 / 1024 # MB # 加载数据 dal = DataAccessLayer.load_from_file(str(data_file)) profile = understand_data(dal) # 记录最终内存 final_memory = process.memory_info().rss / 1024 / 1024 # MB memory_increase = final_memory - initial_memory # 验证：内存增长应该合理（不超过500MB） assert memory_increase < 500, f"内存增长 {memory_increase:.2f}MB，超过500MB限制" print(f"✓ 数据加载内存增长: {memory_increase:.2f}MB") def test_large_dataset_memory(self, tmp_path): """测试大数据集的内存使用。 需求：NFR-1.2 - 支持最大100MB的CSV文件 """ # 生成测试数据（约100MB） data_file = tmp_path / "large_memory_test.csv" df = self._generate_test_data(rows=500000, cols=50) df.to_csv(data_file, index=False) # 检查文件大小 file_size = os.path.getsize(data_file) / 1024 / 1024 # MB print(f"测试文件大小: {file_size:.2f}MB") # 记录初始内存 process = psutil.Process() initial_memory = process.memory_info().rss / 1024 / 1024 # MB # 加载数据 dal = DataAccessLayer.load_from_file(str(data_file)) profile = understand_data(dal) # 记录最终内存 final_memory = process.memory_info().rss / 1024 / 1024 # MB memory_increase = final_memory - initial_memory # 验证：内存增长应该合理（不超过1GB） assert memory_increase < 1024, f"内存增长 {memory_increase:.2f}MB，超过1GB限制" print(f"✓ 大数据集内存增长: {memory_increase:.2f}MB") def _generate_test_data(self, rows: int, cols: int) -> pd.DataFrame: """生成测试数据。""" data = {} for i in range(cols): col_type = i % 4 if col_type == 0: data[f'col_{i}'] = np.random.randn(rows) elif col_type == 1: data[f'col_{i}'] = np.random.choice(['A', 'B', 'C', 'D'], rows) elif col_type == 2: data[f'col_{i}'] = pd.date_range('2020-01-01', periods=rows, freq='H') else: data[f'col_{i}'] = [f'text_{j % 1000}' for j in range(rows)] return pd.DataFrame(data) class TestStagePerformance: """测试各阶段的性能指标。""" def test_data_understanding_stage(self, tmp_path): """测试数据理解阶段的性能。""" # 生成测试数据 data_file = tmp_path / "stage_test.csv" df = self._generate_test_data(rows=50000, cols=30) df.to_csv(data_file, index=False) # 测试性能 start_time = time.time() dal = DataAccessLayer.load_from_file(str(data_file)) profile = understand_data(dal) elapsed = time.time() - start_time # 验证：应该在20秒内完成 assert elapsed < 20, f"数据理解阶段耗时 {elapsed:.2f}秒，超过20秒限制" print(f"✓ 数据理解阶段（5万行）耗时: {elapsed:.2f}秒") def _generate_test_data(self, rows: int, cols: int) -> pd.DataFrame: """生成测试数据。""" data = {} for i in range(cols): if i % 3 == 0: data[f'col_{i}'] = np.random.randn(rows) elif i % 3 == 1: data[f'col_{i}'] = np.random.choice(['A', 'B', 'C'], rows) else: data[f'col_{i}'] = pd.date_range('2020-01-01', periods=rows, freq='min') return pd.DataFrame(data) @pytest.fixture def performance_report(tmp_path): """生成性能测试报告。""" report_file = tmp_path / "performance_report.txt" yield report_file # 测试结束后，如果报告文件存在，打印内容 if report_file.exists(): print("\n" + "="*60) print("性能测试报告") print("="*60) print(report_file.read_text()) print("="*60) class TestOptimizationEffectiveness: """测试性能优化的有效性。""" def test_memory_optimization(self, tmp_path): """测试内存优化的效果。""" # 生成测试数据 data_file = tmp_path / "optimization_test.csv" df = self._generate_test_data(rows=100000, cols=30) df.to_csv(data_file, index=False) # 不优化内存 dal_no_opt = DataAccessLayer.load_from_file(str(data_file), optimize_memory=False) memory_no_opt = dal_no_opt._data.memory_usage(deep=True).sum() / 1024 / 1024 # 优化内存 dal_opt = DataAccessLayer.load_from_file(str(data_file), optimize_memory=True) memory_opt = dal_opt._data.memory_usage(deep=True).sum() / 1024 / 1024 # 验证：优化后内存应该减少 memory_saved = memory_no_opt - memory_opt savings_percent = (memory_saved / memory_no_opt) * 100 print(f"✓ 内存优化效果: {memory_no_opt:.2f}MB -> {memory_opt:.2f}MB") print(f"✓ 节省内存: {memory_saved:.2f}MB ({savings_percent:.1f}%)") # 验证：至少节省10%的内存 assert memory_saved > 0, "内存优化应该减少内存使用" def test_cache_effectiveness(self, tmp_path): """测试缓存的有效性。""" from src.performance_optimization import LLMCache cache_dir = tmp_path / "cache" cache = LLMCache(str(cache_dir)) # 第一次调用（未缓存） prompt = "测试提示" response = {"result": "测试响应"} # 设置缓存 cache.set(prompt, response) # 第二次调用（应该命中缓存） cached_response = cache.get(prompt) assert cached_response is not None assert cached_response == response print("✓ 缓存功能正常工作") def test_batch_processing(self): """测试批处理的效果。""" from src.performance_optimization import BatchProcessor processor = BatchProcessor(batch_size=10) # 测试数据 items = list(range(100)) # 批处理函数 def process_item(item): return item * 2 # 执行批处理 start_time = time.time() results = processor.process_batch(items, process_item) elapsed = time.time() - start_time # 验证结果 assert len(results) == 100 assert results[0] == 0 assert results[50] == 100 print(f"✓ 批处理100个项目耗时: {elapsed:.3f}秒") def _generate_test_data(self, rows: int, cols: int) -> pd.DataFrame: """生成测试数据。""" data = {} for i in range(cols): if i % 3 == 0: data[f'col_{i}'] = np.random.randint(0, 100, rows) elif i % 3 == 1: data[f'col_{i}'] = np.random.choice(['A', 'B', 'C', 'D'], rows) else: data[f'col_{i}'] = [f'text_{j % 100}' for j in range(rows)] return pd.DataFrame(data) class TestPerformanceMonitoring: """测试性能监控功能。""" def test_performance_monitor(self): """测试性能监控器。""" from src.performance_optimization import PerformanceMonitor monitor = PerformanceMonitor() # 记录一些指标 monitor.record("test_metric", 1.5) monitor.record("test_metric", 2.0) monitor.record("test_metric", 1.8) # 获取统计信息 stats = monitor.get_stats("test_metric") assert stats['count'] == 3 assert stats['mean'] == pytest.approx(1.767, rel=0.01) assert stats['min'] == 1.5 assert stats['max'] == 2.0 print("✓ 性能监控器正常工作") def test_timed_decorator(self): """测试计时装饰器。""" from src.performance_optimization import timed, PerformanceMonitor monitor = PerformanceMonitor() @timed(metric_name="test_function", monitor=monitor) def slow_function(): time.sleep(0.1) return "done" # 执行函数 result = slow_function() assert result == "done" # 检查是否记录了性能指标 stats = monitor.get_stats("test_function") assert stats['count'] == 1 assert stats['mean'] >= 0.1 print("✓ 计时装饰器正常工作") class TestEndToEndPerformance: """端到端性能测试。""" def test_performance_report_generation(self, tmp_path): """测试性能报告生成。""" from src.performance_optimization import get_global_monitor # 生成测试数据 data_file = tmp_path / "e2e_test.csv" df = self._generate_ticket_data(rows=5000) df.to_csv(data_file, index=False) # 获取性能监控器 monitor = get_global_monitor() monitor.clear() # 执行数据理解 dal = DataAccessLayer.load_from_file(str(data_file)) profile = understand_data(dal) # 获取性能统计 stats = monitor.get_all_stats() print("\n性能统计:") for metric_name, metric_stats in stats.items(): if metric_stats: print(f" {metric_name}: {metric_stats['mean']:.3f}秒") assert profile is not None def _generate_ticket_data(self, rows: int) -> pd.DataFrame: """生成工单测试数据。""" statuses = ['待处理', '处理中', '已关闭'] types = ['故障', '咨询', '投诉'] data = { 'ticket_id': [f'T{i:06d}' for i in range(rows)], 'status': np.random.choice(statuses, rows), 'type': np.random.choice(types, rows), 'created_at': pd.date_range('2023-01-01', periods=rows, freq='5min'), 'duration': np.random.randint(1, 100, rows), } return pd.DataFrame(data) class TestPerformanceBenchmarks: """性能基准测试。""" def test_data_loading_benchmark(self, tmp_path, benchmark_report): """数据加载性能基准。""" sizes = [1000, 10000, 100000] results = [] for size in sizes: data_file = tmp_path / f"benchmark_{size}.csv" df = self._generate_test_data(rows=size, cols=20) df.to_csv(data_file, index=False) start_time = time.time() dal = DataAccessLayer.load_from_file(str(data_file)) elapsed = time.time() - start_time results.append({ 'size': size, 'time': elapsed, 'rows_per_second': size / elapsed }) # 打印基准结果 print("\n数据加载性能基准:") print(f"{'行数':<10} {'耗时(秒)':<12} {'行/秒':<15}") print("-" * 40) for r in results: print(f"{r['size']:<10} {r['time']:<12.3f} {r['rows_per_second']:<15.0f}") def test_data_understanding_benchmark(self, tmp_path): """数据理解性能基准。""" sizes = [1000, 10000, 50000] results = [] for size in sizes: data_file = tmp_path / f"understanding_{size}.csv" df = self._generate_test_data(rows=size, cols=20) df.to_csv(data_file, index=False) dal = DataAccessLayer.load_from_file(str(data_file)) start_time = time.time() profile = understand_data(dal) elapsed = time.time() - start_time results.append({ 'size': size, 'time': elapsed, 'rows_per_second': size / elapsed }) # 打印基准结果 print("\n数据理解性能基准:") print(f"{'行数':<10} {'耗时(秒)':<12} {'行/秒':<15}") print("-" * 40) for r in results: print(f"{r['size']:<10} {r['time']:<12.3f} {r['rows_per_second']:<15.0f}") def _generate_test_data(self, rows: int, cols: int) -> pd.DataFrame: """生成测试数据。""" data = {} for i in range(cols): if i % 3 == 0: data[f'col_{i}'] = np.random.randn(rows) elif i % 3 == 1: data[f'col_{i}'] = np.random.choice(['A', 'B', 'C'], rows) else: data[f'col_{i}'] = pd.date_range('2020-01-01', periods=rows, freq='min') return pd.DataFrame(data) @pytest.fixture def benchmark_report(): """基准测试报告fixture。""" yield # 可以在这里生成报告文件