testlint_sdk/runtime_coverage/

csharp.rs

use crate::platform::{get_process_name, process_exists};
use crate::runtime_coverage::{CoverageSummary, RuntimeCoverageResult};
use quick_xml::events::Event;
use quick_xml::Reader;
use std::fs;
use std::path::Path;
use std::process::Command;
use std::thread;
use std::time::Duration;

pub struct CSharpRuntimeCoverage;

impl Default for CSharpRuntimeCoverage {
    fn default() -> Self {
        Self::new()
    }
}

impl CSharpRuntimeCoverage {
    pub fn new() -> Self {
        CSharpRuntimeCoverage
    }

    /// Attach coverage to a running .NET process
    pub fn attach_and_collect(&self, pid: u32) -> Result<RuntimeCoverageResult, String> {
        println!("🔷 Attaching coverage to .NET process PID: {}", pid);
        println!("📊 Collecting coverage continuously (press Ctrl+C to stop)...");

        // Check if process exists and is .NET
        self.check_dotnet_process(pid)?;

        // Ensure dotnet-coverage tool is installed
        self.ensure_dotnet_coverage()?;

        // Start collecting coverage
        println!("💉 Starting coverage collection...");
        let coverage_file = format!("coverage-{}.cobertura.xml", pid);

        let mut cmd = Command::new("dotnet-coverage");
        cmd.args([
            "collect",
            "--process-id",
            &pid.to_string(),
            "--output",
            &coverage_file,
            "--output-format",
            "cobertura",
        ]);

        // Start coverage collection in background
        let mut child = cmd
            .spawn()
            .map_err(|e| format!("Failed to start dotnet-coverage: {}", e))?;

        // Wait for Ctrl+C
        use std::sync::atomic::{AtomicBool, Ordering};
        use std::sync::Arc;

        let running = Arc::new(AtomicBool::new(true));
        let r = running.clone();

        ctrlc::set_handler(move || {
            r.store(false, Ordering::SeqCst);
        })
        .expect("Error setting Ctrl-C handler");

        let start_time = std::time::Instant::now();

        println!("⏳ Collecting coverage... Press Ctrl+C to stop");

        while running.load(Ordering::SeqCst) {
            thread::sleep(Duration::from_millis(100));
        }

        let duration_secs = start_time.elapsed().as_secs();

        // Stop coverage collection
        println!("\n📝 Stopping coverage collection...");
        child
            .kill()
            .map_err(|e| format!("Failed to stop coverage: {}", e))?;

        // Wait for process to finish writing
        thread::sleep(Duration::from_secs(2));

        // Check if coverage file was created
        if !Path::new(&coverage_file).exists() {
            return Err(format!("Coverage file {} not found", coverage_file));
        }

        // Parse coverage summary
        let summary = self.parse_cobertura_xml(&coverage_file)?;

        Ok(RuntimeCoverageResult {
            language: "C#".to_string(),
            pid,
            duration_secs,
            coverage_file,
            summary,
        })
    }

    /// Check if process is a .NET process
    fn check_dotnet_process(&self, pid: u32) -> Result<(), String> {
        if !process_exists(pid)? {
            return Err(format!("Process {} not found", pid));
        }

        let process_name = get_process_name(pid)?;
        let process_name_lower = process_name.to_lowercase();
        if !process_name_lower.contains("dotnet") && !process_name_lower.contains(".net") {
            println!("Warning: Process {} may not be a .NET process", pid);
        }

        Ok(())
    }

    /// Ensure dotnet-coverage tool is installed
    fn ensure_dotnet_coverage(&self) -> Result<(), String> {
        // Check if dotnet-coverage is installed
        let check = Command::new("dotnet-coverage").arg("--version").output();

        if check.is_ok() && check.unwrap().status.success() {
            return Ok(());
        }

        println!("📥 Installing dotnet-coverage...");

        let output = Command::new("dotnet")
            .args(["tool", "install", "-g", "dotnet-coverage"])
            .output()
            .map_err(|e| format!("Failed to install dotnet-coverage: {}", e))?;

        if !output.status.success() {
            // May already be installed
            let stderr = String::from_utf8_lossy(&output.stderr);
            if !stderr.contains("already installed") {
                return Err(format!("Failed to install dotnet-coverage: {}", stderr));
            }
        }

        println!("✓ dotnet-coverage installed");
        Ok(())
    }

    /// Parse Cobertura XML coverage file
    fn parse_cobertura_xml(&self, xml_file: &str) -> Result<CoverageSummary, String> {
        let content =
            fs::read_to_string(xml_file).map_err(|e| format!("Failed to read XML: {}", e))?;

        let mut reader = Reader::from_str(&content);
        reader.config_mut().trim_text(true);

        let mut buf = Vec::new();
        let mut line_rate = 0.0;
        let mut branch_rate: Option<f64> = None;
        let mut total_lines = 0;
        let mut total_branches: Option<usize> = None;

        loop {
            match reader.read_event_into(&mut buf) {
                Ok(Event::Eof) => break,

                Ok(Event::Start(e)) | Ok(Event::Empty(e)) => {
                    if e.name().as_ref() == b"coverage" {
                        // Parse attributes from <coverage> element
                        for attr in e.attributes().flatten() {
                            let key = String::from_utf8_lossy(attr.key.as_ref());
                            let value = String::from_utf8_lossy(&attr.value);

                            match key.as_ref() {
                                "line-rate" => {
                                    line_rate = value.parse().unwrap_or(0.0);
                                }
                                "branch-rate" => {
                                    branch_rate = value.parse().ok();
                                }
                                "lines-valid" => {
                                    total_lines = value.parse().unwrap_or(0);
                                }
                                "branches-valid" => {
                                    total_branches = value.parse().ok();
                                }
                                _ => {}
                            }
                        }
                    }
                }

                Ok(_) => {}

                Err(e) => {
                    return Err(format!(
                        "Error parsing XML at position {}: {:?}",
                        reader.buffer_position(),
                        e
                    ));
                }
            }

            buf.clear();
        }

        if total_lines == 0 {
            return Err("No coverage data found in XML".to_string());
        }

        let covered_lines = (total_lines as f64 * line_rate) as usize;
        let coverage_percentage = line_rate * 100.0;

        let (covered_branches, branch_percentage) =
            if let (Some(total_b), Some(rate)) = (total_branches, branch_rate) {
                (Some((total_b as f64 * rate) as usize), Some(rate * 100.0))
            } else {
                (None, None)
            };

        Ok(CoverageSummary {
            total_lines,
            covered_lines,
            coverage_percentage,
            total_branches,
            covered_branches,
            branch_percentage,
        })
    }
}

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

    #[test]
    fn test_runtime_coverage_new() {
        let coverage = CSharpRuntimeCoverage::new();
        assert_eq!(std::mem::size_of_val(&coverage), 0);
    }

    #[test]
    fn test_runtime_coverage_default() {
        let coverage = CSharpRuntimeCoverage;
        assert_eq!(std::mem::size_of_val(&coverage), 0);
    }
}