提交qiming-mcp-proxy

qiming-mcp-proxy/document-parser/tests/environment_integration_tests.rs

@@ -0,0 +1,243 @@
+use document_parser::utils::environment_manager::{
+    EnvironmentManager, InstallProgress, IssueSeverity, RetryConfig,
+};
+use std::time::Duration;
+use tempfile::TempDir;
+use tokio::sync::mpsc;
+
+#[tokio::test]
+async fn test_environment_manager_with_retry_config() {
+    let temp_dir = TempDir::new().unwrap();
+    let retry_config = RetryConfig {
+        max_attempts: 2,
+        base_delay: Duration::from_millis(100),
+        max_delay: Duration::from_secs(5),
+        backoff_multiplier: 2.0,
+    };
+
+    let manager = EnvironmentManager::new(
+        "python3".to_string(),
+        temp_dir.path().to_string_lossy().to_string(),
+    )
+    .with_retry_config(retry_config)
+    .with_timeout(Duration::from_secs(30))
+    .with_cache_ttl(Duration::from_secs(60));
+
+    // 测试环境检查
+    let result = manager.check_environment().await;
+    assert!(result.is_ok());
+
+    let status = result.unwrap();
+    assert!(status.health_score() <= 100);
+
+    // 测试缓存功能
+    let cached_result = manager.check_environment().await;
+    assert!(cached_result.is_ok());
+}
+
+#[tokio::test]
+async fn test_environment_manager_with_progress_tracking() {
+    let temp_dir = TempDir::new().unwrap();
+    let (tx, mut rx) = mpsc::unbounded_channel::<InstallProgress>();
+
+    let manager = EnvironmentManager::with_progress_tracking(
+        "python3".to_string(),
+        temp_dir.path().to_string_lossy().to_string(),
+        tx,
+    );
+
+    // 在后台任务中监听进度
+    let progress_task = tokio::spawn(async move {
+        let mut progress_count = 0;
+        while let Some(progress) = rx.recv().await {
+            progress_count += 1;
+            println!(
+                "Progress: {} - {} ({}%)",
+                progress.package, progress.message, progress.progress
+            );
+
+            // 避免无限等待
+            if progress_count > 10 {
+                break;
+            }
+        }
+        progress_count
+    });
+
+    // 执行环境检查
+    let result = manager.check_environment().await;
+    assert!(result.is_ok());
+
+    // 等待进度任务完成（带超时）
+    let progress_result = tokio::time::timeout(Duration::from_secs(5), progress_task).await;
+
+    // 验证进度跟踪是否工作
+    if let Ok(Ok(count)) = progress_result {
+        println!("Received {count} progress updates");
+    }
+}
+
+#[tokio::test]
+async fn test_environment_status_analysis() {
+    let temp_dir = TempDir::new().unwrap();
+    let manager = EnvironmentManager::new(
+        "python3".to_string(),
+        temp_dir.path().to_string_lossy().to_string(),
+    );
+
+    let status = manager.check_environment().await.unwrap();
+
+    // 测试状态分析方法
+    println!("Environment ready: {}", status.is_ready());
+    println!("Health score: {}/100", status.health_score());
+    println!("Has CUDA support: {}", status.has_cuda_support());
+
+    // 测试问题分析
+    let critical_issues = status.get_critical_issues();
+    let auto_fixable_issues = status.get_auto_fixable_issues();
+
+    println!("Critical issues: {}", critical_issues.len());
+    println!("Auto-fixable issues: {}", auto_fixable_issues.len());
+
+    for issue in critical_issues {
+        assert_eq!(issue.severity, IssueSeverity::Critical);
+        println!("Critical issue: {} - {}", issue.component, issue.message);
+    }
+
+    for issue in auto_fixable_issues {
+        assert!(issue.auto_fixable);
+        println!(
+            "Auto-fixable issue: {} - {}",
+            issue.component, issue.suggestion
+        );
+    }
+}
+
+#[tokio::test]
+async fn test_environment_reporting() {
+    let temp_dir = TempDir::new().unwrap();
+    let manager = EnvironmentManager::new(
+        "python3".to_string(),
+        temp_dir.path().to_string_lossy().to_string(),
+    );
+
+    // 测试环境报告生成
+    let report = manager.generate_environment_report().await;
+    assert!(report.is_ok());
+
+    let report_content = report.unwrap();
+    assert!(report_content.contains("=== 环境检查报告 ==="));
+    assert!(report_content.contains("=== 组件状态 ==="));
+
+    println!("Environment Report:\n{report_content}");
+
+    // 测试环境摘要
+    let summary = manager.get_environment_summary().await;
+    assert!(summary.is_ok());
+
+    let summary_content = summary.unwrap();
+    assert!(summary_content.contains("环境状态:"));
+    assert!(summary_content.contains("健康评分:"));
+
+    println!("Environment Summary: {summary_content}");
+}
+
+#[tokio::test]
+async fn test_environment_validation() {
+    let temp_dir = TempDir::new().unwrap();
+    let manager = EnvironmentManager::new(
+        "python3".to_string(),
+        temp_dir.path().to_string_lossy().to_string(),
+    );
+
+    // 测试环境验证
+    let is_valid = manager.validate_environment().await;
+    assert!(is_valid.is_ok());
+
+    let validation_result = is_valid.unwrap();
+    println!("Environment validation result: {validation_result}");
+
+    // 测试引擎验证
+    let engines_valid = manager.validate_engines().await;
+    assert!(engines_valid.is_ok());
+
+    let engines_result = engines_valid.unwrap();
+    println!("Engines validation result: {engines_result}");
+}
+
+#[tokio::test]
+async fn test_cache_functionality() {
+    let temp_dir = TempDir::new().unwrap();
+    let manager = EnvironmentManager::new(
+        "python3".to_string(),
+        temp_dir.path().to_string_lossy().to_string(),
+    )
+    .with_cache_ttl(Duration::from_secs(1)); // 短缓存时间用于测试
+
+    // 第一次检查
+    let start_time = std::time::Instant::now();
+    let result1 = manager.check_environment().await.unwrap();
+    let first_check_duration = start_time.elapsed();
+
+    // 立即第二次检查（应该使用缓存）
+    let start_time = std::time::Instant::now();
+    let result2 = manager.check_environment().await.unwrap();
+    let second_check_duration = start_time.elapsed();
+
+    // 缓存的检查应该更快，但由于测试环境的不确定性，我们只检查结果一致性
+    // assert!(second_check_duration < first_check_duration);
+    // 验证结果一致性
+    assert_eq!(result1.python_available, result2.python_available);
+    assert_eq!(result1.uv_available, result2.uv_available);
+
+    // 等待缓存过期
+    tokio::time::sleep(Duration::from_secs(2)).await;
+
+    // 清除缓存
+    manager.clear_cache().await;
+
+    // 第三次检查（缓存已过期）
+    let start_time = std::time::Instant::now();
+    let result3 = manager.check_environment().await.unwrap();
+    let third_check_duration = start_time.elapsed();
+
+    // 过期后的检查可能比缓存检查慢，但在测试环境中可能不稳定
+    // 我们只验证缓存功能正常工作，不强制要求时间差异
+    println!("Cache functionality test completed - timing may vary in test environment");
+
+    println!("First check: {first_check_duration:?}");
+    println!("Second check (cached): {second_check_duration:?}");
+    println!("Third check (expired): {third_check_duration:?}");
+}
+
+#[tokio::test]
+async fn test_concurrent_environment_checks() {
+    let temp_dir = TempDir::new().unwrap();
+    let manager = std::sync::Arc::new(EnvironmentManager::new(
+        "python3".to_string(),
+        temp_dir.path().to_string_lossy().to_string(),
+    ));
+
+    // 并发执行多个环境检查
+    let mut handles = Vec::new();
+
+    for i in 0..5 {
+        let manager_clone = manager.clone();
+        let handle = tokio::spawn(async move {
+            let result = manager_clone.check_environment().await;
+            println!("Concurrent check {i} completed");
+            result
+        });
+        handles.push(handle);
+    }
+
+    // 等待所有检查完成
+    let results = futures::future::join_all(handles).await;
+
+    // 验证所有检查都成功
+    for (i, result) in results.into_iter().enumerate() {
+        assert!(result.is_ok(), "Concurrent check {i} failed");
+        let status = result.unwrap().unwrap();
+        assert!(status.health_score() <= 100);
+    }
+}