foxhunt/tli/tests/test_monitoring.rs

//! Continuous test monitoring infrastructure for TLI system
//!
//! This module provides comprehensive test monitoring capabilities including:
//! - Automated test execution and reporting
//! - Performance regression detection
//! - Test coverage tracking
//! - Continuous integration support
//! - Test result aggregation and analysis

use std::collections::HashMap;
use std::fs::{File, OpenOptions};
use std::io::{BufWriter, Write};
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};

use serde::{Deserialize, Serialize};
use tokio::sync::RwLock;
use uuid::Uuid;

use tli::error::{TliError, TliResult};
use tli::types::current_unix_nanos;

/// Test execution result
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TestResult {
    /// Test name
    pub test_name: String,
    /// Test category (unit, integration, performance, property)
    pub test_category: TestCategory,
    /// Test execution status
    pub status: TestStatus,
    /// Execution duration
    pub duration: Duration,
    /// Error message if failed
    pub error_message: Option<String>,
    /// Performance metrics
    pub metrics: HashMap<String, f64>,
    /// Timestamp when test was executed
    pub timestamp: i64,
    /// Test environment information
    pub environment: TestEnvironment,
}

/// Test category enumeration
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Hash)]
pub enum TestCategory {
    Unit,
    Integration,
    Performance,
    Property,
    Security,
    Load,
}

/// Test execution status
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
pub enum TestStatus {
    Passed,
    Failed,
    Skipped,
    Timeout,
    Error,
}

/// Test environment information
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TestEnvironment {
    /// Operating system
    pub os: String,
    /// Rust version
    pub rust_version: String,
    /// CPU cores
    pub cpu_cores: usize,
    /// Available memory in MB
    pub memory_mb: u64,
    /// Test runner version
    pub runner_version: String,
    /// Git commit hash
    pub git_commit: Option<String>,
    /// Branch name
    pub git_branch: Option<String>,
}

/// Test suite execution summary
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TestSuiteSummary {
    /// Suite execution ID
    pub execution_id: String,
    /// Total number of tests
    pub total_tests: usize,
    /// Number of passed tests
    pub passed_tests: usize,
    /// Number of failed tests
    pub failed_tests: usize,
    /// Number of skipped tests
    pub skipped_tests: usize,
    /// Total execution duration
    pub total_duration: Duration,
    /// Test coverage percentage
    pub coverage_percentage: Option<f64>,
    /// Performance regression detected
    pub performance_regression: bool,
    /// Timestamp when suite started
    pub start_timestamp: i64,
    /// Test environment
    pub environment: TestEnvironment,
    /// Individual test results
    pub test_results: Vec<TestResult>,
}

/// Performance baseline for regression detection
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PerformanceBaseline {
    /// Test name
    pub test_name: String,
    /// Baseline metrics
    pub baseline_metrics: HashMap<String, PerformanceMetric>,
    /// Last updated timestamp
    pub last_updated: i64,
    /// Number of samples used for baseline
    pub sample_count: usize,
}

/// Performance metric with statistical data
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PerformanceMetric {
    /// Metric name
    pub name: String,
    /// Mean value
    pub mean: f64,
    /// Standard deviation
    pub std_dev: f64,
    /// Minimum value
    pub min: f64,
    /// Maximum value
    pub max: f64,
    /// 95th percentile
    pub p95: f64,
    /// 99th percentile
    pub p99: f64,
}

/// Test monitoring manager
pub struct TestMonitor {
    /// Test results storage
    results_storage: Arc<RwLock<Vec<TestResult>>>,
    /// Performance baselines
    baselines: Arc<RwLock<HashMap<String, PerformanceBaseline>>>,
    /// Output directory for reports
    output_dir: PathBuf,
    /// Current test suite summary
    current_suite: Arc<RwLock<Option<TestSuiteSummary>>>,
    /// Test execution counter
    execution_counter: AtomicU64,
    /// Configuration
    config: TestMonitorConfig,
}

/// Test monitoring configuration
#[derive(Debug, Clone)]
pub struct TestMonitorConfig {
    /// Enable performance regression detection
    pub enable_performance_regression: bool,
    /// Performance regression threshold (multiplier)
    pub regression_threshold: f64,
    /// Maximum number of stored test results
    pub max_stored_results: usize,
    /// Enable detailed logging
    pub enable_detailed_logging: bool,
    /// Output format for reports
    pub output_format: OutputFormat,
    /// Enable real-time monitoring
    pub enable_real_time_monitoring: bool,
}

/// Output format for test reports
#[derive(Debug, Clone, Copy)]
pub enum OutputFormat {
    Json,
    Xml,
    Html,
    Csv,
}

impl Default for TestMonitorConfig {
    fn default() -> Self {
        Self {
            enable_performance_regression: true,
            regression_threshold: 1.5, // 50% slower triggers regression
            max_stored_results: 10000,
            enable_detailed_logging: true,
            output_format: OutputFormat::Json,
            enable_real_time_monitoring: true,
        }
    }
}

impl TestMonitor {
    /// Create a new test monitor
    pub fn new<P: AsRef<Path>>(output_dir: P, config: TestMonitorConfig) -> TliResult<Self> {
        let output_path = output_dir.as_ref().to_path_buf();

        // Create output directory if it doesn't exist
        if !output_path.exists() {
            std::fs::create_dir_all(&output_path).map_err(|e| {
                TliError::ConfigurationError(format!("Failed to create output directory: {}", e))
            })?;
        }

        Ok(Self {
            results_storage: Arc::new(RwLock::new(Vec::new())),
            baselines: Arc::new(RwLock::new(HashMap::new())),
            output_dir: output_path,
            current_suite: Arc::new(RwLock::new(None)),
            execution_counter: AtomicU64::new(0),
            config,
        })
    }

    /// Start a new test suite execution
    pub async fn start_test_suite(&self, environment: TestEnvironment) -> String {
        let execution_id = Uuid::new_v4().to_string();
        let start_timestamp = current_unix_nanos();

        let suite = TestSuiteSummary {
            execution_id: execution_id.clone(),
            total_tests: 0,
            passed_tests: 0,
            failed_tests: 0,
            skipped_tests: 0,
            total_duration: Duration::new(0, 0),
            coverage_percentage: None,
            performance_regression: false,
            start_timestamp,
            environment,
            test_results: Vec::new(),
        };

        *self.current_suite.write().await = Some(suite);

        if self.config.enable_detailed_logging {
            println!("Started test suite execution: {}", execution_id);
        }

        execution_id
    }

    /// Record a test result
    pub async fn record_test_result(&self, mut result: TestResult) -> TliResult<()> {
        // Set timestamp if not already set
        if result.timestamp == 0 {
            result.timestamp = current_unix_nanos();
        }

        // Update current suite summary
        if let Some(ref mut suite) = self.current_suite.write().await.as_mut() {
            suite.test_results.push(result.clone());
            suite.total_tests += 1;

            match result.status {
                TestStatus::Passed => suite.passed_tests += 1,
                TestStatus::Failed => suite.failed_tests += 1,
                TestStatus::Skipped => suite.skipped_tests += 1,
                _ => {}
            }

            suite.total_duration += result.duration;
        }

        // Check for performance regression
        if self.config.enable_performance_regression
            && result.test_category == TestCategory::Performance
        {
            let regression = self.check_performance_regression(&result).await?;
            if regression && let Some(ref mut suite) = self.current_suite.write().await.as_mut() {
                suite.performance_regression = true;
            }
        }

        // Store result
        {
            let mut storage = self.results_storage.write().await;
            storage.push(result.clone());

            // Limit storage size
            if storage.len() > self.config.max_stored_results {
                storage.drain(0..1000); // Remove oldest 1000 results
            }
        }

        // Real-time monitoring output
        if self.config.enable_real_time_monitoring {
            self.output_real_time_result(&result).await?;
        }

        Ok(())
    }

    /// Finish the current test suite and generate report
    pub async fn finish_test_suite(&self) -> TliResult<TestSuiteSummary> {
        let mut suite = self
            .current_suite
            .write()
            .await
            .take()
            .ok_or_else(|| TliError::ConfigurationError("No active test suite".to_string()))?;

        // Calculate final duration
        let finish_timestamp = current_unix_nanos();
        let actual_duration =
            Duration::from_nanos((finish_timestamp - suite.start_timestamp) as u64);
        suite.total_duration = actual_duration;

        // Generate and save report
        self.generate_test_report(&suite).await?;

        // Update performance baselines
        self.update_performance_baselines(&suite).await?;

        if self.config.enable_detailed_logging {
            println!("Finished test suite execution: {}", suite.execution_id);
            println!(
                "Results: {} passed, {} failed, {} skipped",
                suite.passed_tests, suite.failed_tests, suite.skipped_tests
            );
        }

        Ok(suite)
    }

    /// Check for performance regression
    async fn check_performance_regression(&self, result: &TestResult) -> TliResult<bool> {
        let baselines = self.baselines.read().await;

        if let Some(baseline) = baselines.get(&result.test_name) {
            for (metric_name, current_value) in &result.metrics {
                if let Some(baseline_metric) = baseline.baseline_metrics.get(metric_name) {
                    // Check if current value exceeds threshold
                    let threshold = baseline_metric.mean * self.config.regression_threshold;

                    if *current_value > threshold {
                        if self.config.enable_detailed_logging {
                            println!("Performance regression detected in {}: {} = {} (baseline: {}, threshold: {})",
                                     result.test_name, metric_name, current_value, baseline_metric.mean, threshold);
                        }
                        return Ok(true);
                    }
                }
            }
        }

        Ok(false)
    }

    /// Update performance baselines with new results
    async fn update_performance_baselines(&self, suite: &TestSuiteSummary) -> TliResult<()> {
        let mut baselines = self.baselines.write().await;

        for result in &suite.test_results {
            if result.test_category == TestCategory::Performance
                && result.status == TestStatus::Passed
            {
                let baseline = baselines
                    .entry(result.test_name.clone())
                    .or_insert_with(|| PerformanceBaseline {
                        test_name: result.test_name.clone(),
                        baseline_metrics: HashMap::new(),
                        last_updated: result.timestamp,
                        sample_count: 0,
                    });

                for (metric_name, metric_value) in &result.metrics {
                    let performance_metric = baseline
                        .baseline_metrics
                        .entry(metric_name.clone())
                        .or_insert_with(|| PerformanceMetric {
                            name: metric_name.clone(),
                            mean: *metric_value,
                            std_dev: 0.0,
                            min: *metric_value,
                            max: *metric_value,
                            p95: *metric_value,
                            p99: *metric_value,
                        });

                    // Update statistics (simple moving average for now)
                    let new_count = baseline.sample_count + 1;
                    performance_metric.mean =
                        (performance_metric.mean * baseline.sample_count as f64 + metric_value)
                            / new_count as f64;
                    performance_metric.min = performance_metric.min.min(*metric_value);
                    performance_metric.max = performance_metric.max.max(*metric_value);
                }

                baseline.sample_count += 1;
                baseline.last_updated = result.timestamp;
            }
        }

        // Save baselines to disk
        self.save_baselines().await?;

        Ok(())
    }

    /// Generate comprehensive test report
    async fn generate_test_report(&self, suite: &TestSuiteSummary) -> TliResult<()> {
        match self.config.output_format {
            OutputFormat::Json => self.generate_json_report(suite).await,
            OutputFormat::Xml => self.generate_xml_report(suite).await,
            OutputFormat::Html => self.generate_html_report(suite).await,
            OutputFormat::Csv => self.generate_csv_report(suite).await,
        }
    }

    /// Generate JSON test report
    async fn generate_json_report(&self, suite: &TestSuiteSummary) -> TliResult<()> {
        let report_path = self
            .output_dir
            .join(format!("test_report_{}.json", suite.execution_id));

        let json_content = serde_json::to_string_pretty(suite).map_err(|e| {
            TliError::ConfigurationError(format!("Failed to serialize report: {}", e))
        })?;

        std::fs::write(&report_path, json_content)
            .map_err(|e| TliError::ConfigurationError(format!("Failed to write report: {}", e)))?;

        if self.config.enable_detailed_logging {
            println!("Generated JSON report: {}", report_path.display());
        }

        Ok(())
    }

    /// Generate XML test report (JUnit format)
    async fn generate_xml_report(&self, suite: &TestSuiteSummary) -> TliResult<()> {
        let report_path = self
            .output_dir
            .join(format!("test_report_{}.xml", suite.execution_id));
        let mut file = BufWriter::new(File::create(&report_path).map_err(|e| {
            TliError::ConfigurationError(format!("Failed to create XML report: {}", e))
        })?);

        writeln!(file, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>")?;
        writeln!(file, "<testsuite name=\"TLI Test Suite\" tests=\"{}\" failures=\"{}\" skipped=\"{}\" time=\"{:.3}\">",
                 suite.total_tests, suite.failed_tests, suite.skipped_tests, suite.total_duration.as_secs_f64())?;

        for result in &suite.test_results {
            writeln!(
                file,
                "  <testcase name=\"{}\" classname=\"{}\" time=\"{:.3}\">",
                result.test_name,
                format!("{:?}", result.test_category),
                result.duration.as_secs_f64()
            )?;

            match result.status {
                TestStatus::Failed => {
                    writeln!(
                        file,
                        "    <failure message=\"{}\">",
                        result.error_message.as_deref().unwrap_or("Test failed")
                    )?;
                    writeln!(file, "    </failure>")?;
                }
                TestStatus::Skipped => {
                    writeln!(file, "    <skipped/>")?;
                }
                TestStatus::Error => {
                    writeln!(
                        file,
                        "    <error message=\"{}\">",
                        result.error_message.as_deref().unwrap_or("Test error")
                    )?;
                    writeln!(file, "    </error>")?;
                }
                _ => {}
            }

            writeln!(file, "  </testcase>")?;
        }

        writeln!(file, "</testsuite>")?;

        if self.config.enable_detailed_logging {
            println!("Generated XML report: {}", report_path.display());
        }

        Ok(())
    }

    /// Generate HTML test report
    async fn generate_html_report(&self, suite: &TestSuiteSummary) -> TliResult<()> {
        let report_path = self
            .output_dir
            .join(format!("test_report_{}.html", suite.execution_id));
        let mut file = BufWriter::new(File::create(&report_path).map_err(|e| {
            TliError::ConfigurationError(format!("Failed to create HTML report: {}", e))
        })?);

        writeln!(file, "<!DOCTYPE html>")?;
        writeln!(file, "<html><head><title>TLI Test Report</title>")?;
        writeln!(file, "<style>")?;
        writeln!(
            file,
            "body {{ font-family: Arial, sans-serif; margin: 20px; }}"
        )?;
        writeln!(file, ".passed {{ color: green; }}")?;
        writeln!(file, ".failed {{ color: red; }}")?;
        writeln!(file, ".skipped {{ color: orange; }}")?;
        writeln!(file, "table {{ border-collapse: collapse; width: 100%; }}")?;
        writeln!(
            file,
            "th, td {{ border: 1px solid #ddd; padding: 8px; text-align: left; }}"
        )?;
        writeln!(file, "th {{ background-color: #f2f2f2; }}")?;
        writeln!(file, "</style></head><body>")?;

        writeln!(file, "<h1>TLI Test Report</h1>")?;
        writeln!(file, "<h2>Summary</h2>")?;
        writeln!(file, "<p>Execution ID: {}</p>", suite.execution_id)?;
        writeln!(file, "<p>Total Tests: {}</p>", suite.total_tests)?;
        writeln!(
            file,
            "<p>Passed: <span class=\"passed\">{}</span></p>",
            suite.passed_tests
        )?;
        writeln!(
            file,
            "<p>Failed: <span class=\"failed\">{}</span></p>",
            suite.failed_tests
        )?;
        writeln!(
            file,
            "<p>Skipped: <span class=\"skipped\">{}</span></p>",
            suite.skipped_tests
        )?;
        writeln!(
            file,
            "<p>Total Duration: {:.3} seconds</p>",
            suite.total_duration.as_secs_f64()
        )?;

        if suite.performance_regression {
            writeln!(file, "<p style=\"color: red; font-weight: bold;\">⚠️ Performance Regression Detected</p>")?;
        }

        writeln!(file, "<h2>Test Results</h2>")?;
        writeln!(file, "<table>")?;
        writeln!(file, "<tr><th>Test Name</th><th>Category</th><th>Status</th><th>Duration</th><th>Error</th></tr>")?;

        for result in &suite.test_results {
            let status_class = match result.status {
                TestStatus::Passed => "passed",
                TestStatus::Failed => "failed",
                TestStatus::Skipped => "skipped",
                _ => "",
            };

            writeln!(file, "<tr>")?;
            writeln!(file, "<td>{}</td>", result.test_name)?;
            writeln!(file, "<td>{:?}</td>", result.test_category)?;
            writeln!(
                file,
                "<td class=\"{}\">{:?}</td>",
                status_class, result.status
            )?;
            writeln!(file, "<td>{:.3}s</td>", result.duration.as_secs_f64())?;
            writeln!(
                file,
                "<td>{}</td>",
                result.error_message.as_deref().unwrap_or("")
            )?;
            writeln!(file, "</tr>")?;
        }

        writeln!(file, "</table>")?;
        writeln!(file, "</body></html>")?;

        if self.config.enable_detailed_logging {
            println!("Generated HTML report: {}", report_path.display());
        }

        Ok(())
    }

    /// Generate CSV test report
    async fn generate_csv_report(&self, suite: &TestSuiteSummary) -> TliResult<()> {
        let report_path = self
            .output_dir
            .join(format!("test_report_{}.csv", suite.execution_id));
        let mut file = BufWriter::new(File::create(&report_path).map_err(|e| {
            TliError::ConfigurationError(format!("Failed to create CSV report: {}", e))
        })?);

        writeln!(
            file,
            "Test Name,Category,Status,Duration (ms),Error Message,Timestamp"
        )?;

        for result in &suite.test_results {
            writeln!(
                file,
                "\"{}\",{:?},{:?},{},{},{}",
                result.test_name,
                result.test_category,
                result.status,
                result.duration.as_millis(),
                result.error_message.as_deref().unwrap_or(""),
                result.timestamp
            )?;
        }

        if self.config.enable_detailed_logging {
            println!("Generated CSV report: {}", report_path.display());
        }

        Ok(())
    }

    /// Output real-time test result
    async fn output_real_time_result(&self, result: &TestResult) -> TliResult<()> {
        let status_emoji = match result.status {
            TestStatus::Passed => "✅",
            TestStatus::Failed => "❌",
            TestStatus::Skipped => "⏭️",
            TestStatus::Timeout => "⏰",
            TestStatus::Error => "💥",
        };

        println!(
            "{} [{:?}] {} ({:.3}s)",
            status_emoji,
            result.test_category,
            result.test_name,
            result.duration.as_secs_f64()
        );

        if let Some(ref error) = result.error_message {
            println!("   Error: {}", error);
        }

        if !result.metrics.is_empty() {
            print!("   Metrics: ");
            for (name, value) in &result.metrics {
                print!("{}={:.3} ", name, value);
            }
            println!();
        }

        Ok(())
    }

    /// Save performance baselines to disk
    async fn save_baselines(&self) -> TliResult<()> {
        let baselines_path = self.output_dir.join("performance_baselines.json");
        let baselines = self.baselines.read().await;

        let json_content = serde_json::to_string_pretty(&*baselines).map_err(|e| {
            TliError::ConfigurationError(format!("Failed to serialize baselines: {}", e))
        })?;

        std::fs::write(&baselines_path, json_content).map_err(|e| {
            TliError::ConfigurationError(format!("Failed to write baselines: {}", e))
        })?;

        Ok(())
    }

    /// Load performance baselines from disk
    pub async fn load_baselines(&self) -> TliResult<()> {
        let baselines_path = self.output_dir.join("performance_baselines.json");

        if !baselines_path.exists() {
            return Ok(()); // No baselines file yet
        }

        let json_content = std::fs::read_to_string(&baselines_path).map_err(|e| {
            TliError::ConfigurationError(format!("Failed to read baselines: {}", e))
        })?;

        let loaded_baselines: HashMap<String, PerformanceBaseline> =
            serde_json::from_str(&json_content).map_err(|e| {
                TliError::ConfigurationError(format!("Failed to parse baselines: {}", e))
            })?;

        *self.baselines.write().await = loaded_baselines;

        if self.config.enable_detailed_logging {
            println!(
                "Loaded {} performance baselines",
                self.baselines.read().await.len()
            );
        }

        Ok(())
    }

    /// Get test statistics
    pub async fn get_test_statistics(&self) -> TestStatistics {
        let results = self.results_storage.read().await;
        let mut stats = TestStatistics::default();

        for result in results.iter() {
            stats.total_tests += 1;

            match result.status {
                TestStatus::Passed => stats.passed_tests += 1,
                TestStatus::Failed => stats.failed_tests += 1,
                TestStatus::Skipped => stats.skipped_tests += 1,
                _ => {}
            }

            let category_stats = stats.by_category.entry(result.test_category).or_default();
            category_stats.total += 1;

            match result.status {
                TestStatus::Passed => category_stats.passed += 1,
                TestStatus::Failed => category_stats.failed += 1,
                TestStatus::Skipped => category_stats.skipped += 1,
                _ => {}
            }

            stats.total_duration += result.duration;
        }

        if stats.total_tests > 0 {
            stats.average_duration = stats.total_duration / stats.total_tests as u32;
            stats.pass_rate = stats.passed_tests as f64 / stats.total_tests as f64;
        }

        stats
    }
}

/// Test statistics summary
#[derive(Debug, Default)]
pub struct TestStatistics {
    pub total_tests: usize,
    pub passed_tests: usize,
    pub failed_tests: usize,
    pub skipped_tests: usize,
    pub total_duration: Duration,
    pub average_duration: Duration,
    pub pass_rate: f64,
    pub by_category: HashMap<TestCategory, CategoryStatistics>,
}

/// Statistics for a specific test category
#[derive(Debug, Default)]
pub struct CategoryStatistics {
    pub total: usize,
    pub passed: usize,
    pub failed: usize,
    pub skipped: usize,
}

impl TestEnvironment {
    /// Create test environment from current system
    pub fn current() -> Self {
        Self {
            os: std::env::consts::OS.to_string(),
            rust_version: env!("CARGO_PKG_RUST_VERSION").to_string(),
            cpu_cores: num_cpus::get(),
            memory_mb: get_available_memory_mb(),
            runner_version: env!("CARGO_PKG_VERSION").to_string(),
            git_commit: std::env::var("GIT_COMMIT").ok(),
            git_branch: std::env::var("GIT_BRANCH").ok(),
        }
    }
}

/// Get available system memory in MB
fn get_available_memory_mb() -> u64 {
    // Simple implementation - in real system would use proper system calls
    if let Ok(meminfo) = std::fs::read_to_string("/proc/meminfo") {
        for line in meminfo.lines() {
            if line.starts_with("MemTotal:") {
                if let Some(kb_str) = line.split_whitespace().nth(1) {
                    if let Ok(kb) = kb_str.parse::<u64>() {
                        return kb / 1024; // Convert KB to MB
                    }
                }
            }
        }
    }

    // Fallback for non-Linux systems
    8192 // Assume 8GB
}

// Utility macro for easy test monitoring integration
#[macro_export]
macro_rules! monitor_test {
    ($monitor:expr, $test_name:expr, $category:expr, $test_fn:expr) => {{
        let start_time = std::time::Instant::now();
        let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| $test_fn));
        let duration = start_time.elapsed();

        let test_result = match result {
            Ok(_) => TestResult {
                test_name: $test_name.to_string(),
                test_category: $category,
                status: TestStatus::Passed,
                duration,
                error_message: None,
                metrics: HashMap::new(),
                timestamp: 0,
                environment: TestEnvironment::current(),
            },
            Err(err) => TestResult {
                test_name: $test_name.to_string(),
                test_category: $category,
                status: TestStatus::Failed,
                duration,
                error_message: Some(format!("{:?}", err)),
                metrics: HashMap::new(),
                timestamp: 0,
                environment: TestEnvironment::current(),
            },
        };

        $monitor.record_test_result(test_result).await.unwrap();
        result
    }};
}

#[cfg(test)]
mod test_monitoring_tests {
    use super::*;
    use tempfile::TempDir;

    #[tokio::test]
    async fn test_monitor_basic_functionality() {
        let temp_dir = TempDir::new().expect("Failed to create temp directory");
        let config = TestMonitorConfig::default();
        let monitor = TestMonitor::new(temp_dir.path(), config).unwrap();

        let environment = TestEnvironment::current();
        let execution_id = monitor.start_test_suite(environment.clone()).await;

        // Record some test results
        let test_results = vec![
            TestResult {
                test_name: "test_order_validation".to_string(),
                test_category: TestCategory::Unit,
                status: TestStatus::Passed,
                duration: Duration::from_millis(50),
                error_message: None,
                metrics: HashMap::new(),
                timestamp: current_unix_nanos(),
                environment: environment.clone(),
            },
            TestResult {
                test_name: "test_database_connection".to_string(),
                test_category: TestCategory::Integration,
                status: TestStatus::Failed,
                duration: Duration::from_millis(1000),
                error_message: Some("Connection timeout".to_string()),
                metrics: HashMap::new(),
                timestamp: current_unix_nanos(),
                environment: environment.clone(),
            },
        ];

        for result in test_results {
            monitor.record_test_result(result).await.unwrap();
        }

        let suite_summary = monitor.finish_test_suite().await.unwrap();

        assert_eq!(suite_summary.execution_id, execution_id);
        assert_eq!(suite_summary.total_tests, 2);
        assert_eq!(suite_summary.passed_tests, 1);
        assert_eq!(suite_summary.failed_tests, 1);
        assert_eq!(suite_summary.skipped_tests, 0);
    }

    #[tokio::test]
    async fn test_performance_regression_detection() {
        let temp_dir = TempDir::new().expect("Failed to create temp directory");
        let mut config = TestMonitorConfig::default();
        config.regression_threshold = 1.5; // 50% slower triggers regression

        let monitor = TestMonitor::new(temp_dir.path(), config).unwrap();

        // Establish baseline
        let baseline_result = TestResult {
            test_name: "performance_test".to_string(),
            test_category: TestCategory::Performance,
            status: TestStatus::Passed,
            duration: Duration::from_millis(100),
            error_message: None,
            metrics: HashMap::from([("latency_ms".to_string(), 10.0)]),
            timestamp: current_unix_nanos(),
            environment: TestEnvironment::current(),
        };

        let environment = TestEnvironment::current();
        monitor.start_test_suite(environment.clone()).await;
        monitor.record_test_result(baseline_result).await.unwrap();
        monitor.finish_test_suite().await.unwrap();

        // Test with regression
        let regression_result = TestResult {
            test_name: "performance_test".to_string(),
            test_category: TestCategory::Performance,
            status: TestStatus::Passed,
            duration: Duration::from_millis(200),
            error_message: None,
            metrics: HashMap::from([("latency_ms".to_string(), 20.0)]), // 2x slower
            timestamp: current_unix_nanos(),
            environment: environment.clone(),
        };

        monitor.start_test_suite(environment).await;
        monitor.record_test_result(regression_result).await.unwrap();
        let suite_with_regression = monitor.finish_test_suite().await.unwrap();

        assert!(suite_with_regression.performance_regression);
    }

    #[tokio::test]
    async fn test_report_generation() {
        let temp_dir = TempDir::new().expect("Failed to create temp directory");
        let config = TestMonitorConfig {
            output_format: OutputFormat::Json,
            ..Default::default()
        };

        let monitor = TestMonitor::new(temp_dir.path(), config).unwrap();

        let environment = TestEnvironment::current();
        let execution_id = monitor.start_test_suite(environment.clone()).await;

        let test_result = TestResult {
            test_name: "test_example".to_string(),
            test_category: TestCategory::Unit,
            status: TestStatus::Passed,
            duration: Duration::from_millis(25),
            error_message: None,
            metrics: HashMap::new(),
            timestamp: current_unix_nanos(),
            environment,
        };

        monitor.record_test_result(test_result).await.unwrap();
        monitor.finish_test_suite().await.unwrap();

        // Check that report file was created
        let report_path = temp_dir
            .path()
            .join(format!("test_report_{}.json", execution_id));
        assert!(report_path.exists());

        // Verify report content
        let report_content = std::fs::read_to_string(&report_path).unwrap();
        let parsed_report: TestSuiteSummary = serde_json::from_str(&report_content).unwrap();
        assert_eq!(parsed_report.execution_id, execution_id);
        assert_eq!(parsed_report.total_tests, 1);
    }
}