testlint_sdk/test_orchestrator/

mod.rs

use std::fs;
use std::path::{Path, PathBuf};
use std::process::{Command, Stdio};
use std::time::{Duration, SystemTime};

use crate::common::Language;

// Module declarations
mod cpp;
mod csharp;
mod go;
mod java;
mod javascript;
mod php;
mod python;
mod ruby;
mod rust_lang;
mod utils;

// Re-exports

#[derive(Debug, Clone)]
pub struct TestConfig {
    pub language: Language,
    pub source_paths: Vec<String>,
    pub output_dir: PathBuf,
    pub output_format: CoverageFormat,
    pub include_patterns: Vec<String>,
    pub exclude_patterns: Vec<String>,
    pub branch_coverage: bool,
    pub tool_version: Option<String>, // e.g., "7.4.0" for coverage.py
    pub command_timeout_secs: Option<u64>, // Timeout for external commands (default: 300s / 5min)
    pub retry_attempts: u32,          // Number of retry attempts for operations (default: 3)
}

#[derive(Debug, Clone)]
pub enum CoverageFormat {
    Json,
    Xml,
    Lcov,
    Html,
}

impl Default for TestConfig {
    fn default() -> Self {
        Self {
            language: Language::Python,
            source_paths: vec![],
            output_dir: PathBuf::from("coverage"),
            output_format: CoverageFormat::Json,
            include_patterns: vec![],
            exclude_patterns: vec![
                // Language-agnostic test directories
                "*/tests/*".to_string(),
                "*/test/*".to_string(),
                "*/__tests__/*".to_string(),
                // Language-agnostic IDE/tool directories
                "*/.git/*".to_string(),
                "*/.idea/*".to_string(),
                "*/.vscode/*".to_string(),
            ],
            branch_coverage: true,
            tool_version: None,              // Use latest version
            command_timeout_secs: Some(300), // 5 minutes default
            retry_attempts: 3,               // 3 attempts default
        }
    }
}

pub struct TestOrchestrator {
    pub(crate) config: TestConfig,
}

impl TestOrchestrator {
    pub fn new(config: TestConfig) -> Self {
        Self { config }
    }

    /// Run a command with coverage collection
    pub fn run_with_coverage(
        &self,
        command: &str,
        args: &[&str],
    ) -> Result<CoverageResult, String> {
        // Create output directory
        fs::create_dir_all(&self.config.output_dir)
            .map_err(|e| format!("Failed to create output directory: {}", e))?;

        let start_time = SystemTime::now();

        let result = match self.config.language {
            Language::Python => self.run_python_coverage(command, args)?,
            Language::Java => self.run_java_coverage(command, args)?,
            Language::JavaScript | Language::TypeScript => {
                self.run_javascript_coverage(command, args)?
            }
            Language::Go => self.run_go_coverage(command, args)?,
            Language::Rust => self.run_rust_coverage(command, args)?,
            Language::CSharp => self.run_csharp_coverage(command, args)?,
            Language::Ruby => self.run_ruby_coverage(command, args)?,
            Language::Php => self.run_php_coverage(command, args)?,
            Language::Cpp => self.run_cpp_coverage(command, args)?,
        };

        let duration = start_time
            .elapsed()
            .unwrap_or(Duration::from_secs(0))
            .as_secs();

        Ok(CoverageResult {
            language: self.config.language.clone(),
            coverage_file: result,
            duration_secs: duration,
            timestamp: chrono::Utc::now().to_rfc3339(),
        })
    }

    /// Display coverage summary
    pub fn show_summary(&self) -> Result<(), String> {
        match self.config.language {
            Language::Python => {
                println!("\n📈 Coverage Summary:");
                let output = Command::new("coverage")
                    .arg("report")
                    .output()
                    .map_err(|e| format!("Failed to show coverage report: {}", e))?;

                if output.status.success() {
                    println!("{}", String::from_utf8_lossy(&output.stdout));
                }
            }
            Language::JavaScript | Language::TypeScript => {
                println!("\n📈 Coverage Summary:");
                let output = Command::new("nyc")
                    .arg("report")
                    .arg("--reporter=text")
                    .output()
                    .map_err(|e| format!("Failed to show coverage report: {}", e))?;

                if output.status.success() {
                    println!("{}", String::from_utf8_lossy(&output.stdout));
                } else {
                    // NYC might not have cached data, read from report directory
                    println!(
                        "Coverage data generated in: {}",
                        self.config.output_dir.display()
                    );
                }
            }
            Language::Java => {
                println!("\n📈 Coverage Summary:");

                let cli_path = dirs::home_dir()
                    .map(|h| h.join(".jacoco/jacococli.jar"))
                    .ok_or_else(|| "Could not determine JaCoCo CLI path".to_string())?;

                let exec_file = self.config.output_dir.join("jacoco.exec");

                if !exec_file.exists() {
                    println!("JaCoCo execution data not found: {}", exec_file.display());
                    return Ok(());
                }

                let mut cmd = Command::new("java");
                cmd.arg("-jar").arg(&cli_path).arg("report");
                cmd.arg(&exec_file);

                // Try to find class files automatically in common locations
                let class_paths = vec![
                    PathBuf::from("target/classes"),
                    PathBuf::from("build/classes"),
                    PathBuf::from("classes"),
                    PathBuf::from("target"),
                    PathBuf::from("build"),
                    PathBuf::from("out"),
                    PathBuf::from("bin"),
                    PathBuf::from("examples"),
                ];

                for class_path in class_paths {
                    if class_path.exists() && class_path.is_dir() {
                        cmd.arg("--classfiles").arg(&class_path);
                    }
                }

                let output = cmd
                    .output()
                    .map_err(|e| format!("Failed to show coverage report: {}", e))?;

                if output.status.success() {
                    println!("{}", String::from_utf8_lossy(&output.stdout));
                } else {
                    println!(
                        "Coverage data generated in: {}",
                        self.config.output_dir.display()
                    );
                    println!(
                        "View HTML report: open {}/jacoco-html/index.html",
                        self.config.output_dir.display()
                    );
                }
            }
            Language::Go => {
                println!("\n📈 Coverage Summary:");

                let coverage_file = self.config.output_dir.join("coverage.out");

                if !coverage_file.exists() {
                    println!("Go coverage data not found: {}", coverage_file.display());
                    return Ok(());
                }

                // Use go tool cover to display summary
                let output = Command::new("go")
                    .arg("tool")
                    .arg("cover")
                    .arg(format!("-func={}", coverage_file.display()))
                    .output()
                    .map_err(|e| format!("Failed to show coverage report: {}", e))?;

                if output.status.success() {
                    println!("{}", String::from_utf8_lossy(&output.stdout));
                } else {
                    println!(
                        "Coverage data generated in: {}",
                        self.config.output_dir.display()
                    );
                    let html_file = self.config.output_dir.join("coverage.html");
                    if html_file.exists() {
                        println!("View HTML report: open {}", html_file.display());
                    }
                }
            }
            Language::Rust => {
                println!("\n📈 Coverage Summary:");

                // cargo-llvm-cov generates comprehensive output during execution
                // The summary is already displayed during the run
                println!(
                    "Coverage report generated in: {}",
                    self.config.output_dir.display()
                );

                // Show HTML path if applicable
                let html_dir = self.config.output_dir.join("html");
                if html_dir.exists() {
                    println!("View HTML report: open {}/index.html", html_dir.display());
                }

                // Show LCOV path if applicable
                let lcov_file = self.config.output_dir.join("lcov.info");
                if lcov_file.exists() {
                    println!("LCOV file: {}", lcov_file.display());
                }
            }
            Language::CSharp => {
                println!("\n📈 Coverage Summary:");

                // Check if ReportGenerator is available for summary
                let cobertura_file = self.config.output_dir.join("cobertura.xml");
                if cobertura_file.exists() {
                    println!("Coverage report generated: {}", cobertura_file.display());
                }

                // Show HTML path if applicable
                let html_dir = self.config.output_dir.join("html");
                if html_dir.exists() {
                    let index_file = html_dir.join("index.html");
                    if index_file.exists() {
                        println!("View HTML report: open {}", index_file.display());
                    }
                }

                // Show LCOV path if applicable
                let lcov_file = self.config.output_dir.join("lcov.info");
                if lcov_file.exists() {
                    println!("LCOV file: {}", lcov_file.display());
                }

                // Show JSON path if applicable
                let json_file = self.config.output_dir.join("coverage.json");
                if json_file.exists() {
                    println!("JSON file: {}", json_file.display());
                }
            }
            Language::Ruby => {
                println!("\n📈 Coverage Summary:");

                // SimpleCov generates reports in coverage directory
                println!(
                    "Coverage report generated in: {}",
                    self.config.output_dir.display()
                );

                // Show HTML path if applicable
                let html_dir = self.config.output_dir.join("html");
                if html_dir.exists() {
                    let index_file = html_dir.join("index.html");
                    if index_file.exists() {
                        println!("View HTML report: open {}", index_file.display());
                    }
                }

                // Show LCOV path if applicable
                let lcov_file = self.config.output_dir.join("lcov.info");
                if lcov_file.exists() {
                    println!("LCOV file: {}", lcov_file.display());
                }

                // Show JSON path if applicable
                let json_file = self.config.output_dir.join("coverage.json");
                if json_file.exists() {
                    println!("JSON file: {}", json_file.display());
                }

                // Show XML path if applicable
                let xml_file = self.config.output_dir.join("cobertura.xml");
                if xml_file.exists() {
                    println!("XML file: {}", xml_file.display());
                }
            }
            Language::Php => {
                println!("\n📈 Coverage Summary:");

                // PHPUnit generates reports in specified directories
                println!(
                    "Coverage report generated in: {}",
                    self.config.output_dir.display()
                );

                // Show HTML path if applicable
                let html_dir = self.config.output_dir.join("html");
                if html_dir.exists() {
                    let index_file = html_dir.join("index.html");
                    if index_file.exists() {
                        println!("View HTML report: open {}", index_file.display());
                    }
                }

                // Show XML (Clover) path if applicable
                let xml_file = self.config.output_dir.join("coverage.xml");
                if xml_file.exists() {
                    println!("Clover XML file: {}", xml_file.display());
                }

                // Show LCOV path if applicable
                let lcov_file = self.config.output_dir.join("lcov.info");
                if lcov_file.exists() {
                    println!("LCOV file: {}", lcov_file.display());
                }

                // Show JSON path if applicable
                let json_file = self.config.output_dir.join("coverage.json");
                if json_file.exists() {
                    println!("JSON file: {}", json_file.display());
                }
            }
            Language::Cpp => {
                println!("\n📈 Coverage Summary:");

                // C++ coverage can use gcov/lcov or llvm-cov
                println!(
                    "Coverage report generated in: {}",
                    self.config.output_dir.display()
                );

                // Show HTML path if applicable
                let html_dir = self.config.output_dir.join("html");
                if html_dir.exists() {
                    let index_file = html_dir.join("index.html");
                    if index_file.exists() {
                        println!("View HTML report: open {}", index_file.display());
                    }
                }

                // Show LCOV path if applicable
                let lcov_file = self.config.output_dir.join("lcov.info");
                if lcov_file.exists() {
                    println!("LCOV file: {}", lcov_file.display());
                }

                // Show XML path if applicable
                let xml_file = self.config.output_dir.join("coverage.xml");
                if xml_file.exists() {
                    println!("XML file: {}", xml_file.display());
                }

                // Show JSON path if applicable
                let json_file = self.config.output_dir.join("coverage.json");
                if json_file.exists() {
                    println!("JSON file: {}", json_file.display());
                }
            }
        }

        Ok(())
    }
}

#[derive(Debug)]
pub struct CoverageResult {
    pub language: Language,
    pub coverage_file: PathBuf,
    pub duration_secs: u64,
    pub timestamp: String,
}

// Helper functions for improved error handling
use std::process::Output;

/// Format a command error with stderr output for better debugging
pub(crate) fn format_command_error(cmd_name: &str, output: &Output) -> String {
    let stderr = String::from_utf8_lossy(&output.stderr);
    let exit_code = output.status.code().unwrap_or(-1);

    if stderr.trim().is_empty() {
        format!("{} command failed with exit code {}", cmd_name, exit_code)
    } else {
        format!(
            "{} command failed with exit code {}:\n{}",
            cmd_name,
            exit_code,
            stderr.trim()
        )
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_default_config() {
        let config = TestConfig::default();
        assert!(matches!(config.language, Language::Python));
        assert_eq!(config.output_dir, PathBuf::from("coverage"));
        assert!(config.branch_coverage);
    }

    #[test]
    fn test_orchestrator_creation() {
        let config = TestConfig::default();
        let _orchestrator = TestOrchestrator::new(config);
    }
}