testlint_sdk/runtime_coverage/

go.rs

use crate::platform::{process_exists, signal_process, ProcessSignal};
use crate::runtime_coverage::{CoverageSummary, RuntimeCoverageResult};
use std::fs;
use std::path::Path;
use std::thread;
use std::time::Duration;

pub struct GoRuntimeCoverage;

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

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

    /// Attach to a running Go process and collect coverage continuously
    /// REQUIRES: Process must be built with -cover flag
    pub fn attach_and_collect(&self, pid: u32) -> Result<RuntimeCoverageResult, String> {
        println!("🐹 Attaching coverage to Go process PID: {}", pid);
        println!("📊 Collecting coverage continuously (press Ctrl+C to stop)...");
        println!();
        println!("⚠️  IMPORTANT: This only works if the Go process was built with:");
        println!("   go build -cover -o myapp");
        println!("   or");
        println!("   go run -cover myapp.go");
        println!();

        // Check if process exists
        self.check_process_exists(pid)?;

        // Try to detect if coverage is enabled
        self.detect_coverage_support(pid)?;

        // Set environment variable to tell Go to write coverage on signal
        // Go processes built with -cover respond to SIGINT/SIGTERM by writing coverage
        println!("💡 Go coverage works by signaling the process to dump coverage.");
        println!("   The process must be built with -cover and -coverprofile flags.");
        println!();

        // 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!("⏳ Monitoring process... Press Ctrl+C to trigger coverage dump");

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

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

        // Signal the process to exit gracefully (triggers coverage write)
        println!("\n📝 Sending SIGINT to process to trigger coverage dump...");

        #[cfg(unix)]
        {
            signal_process(pid, ProcessSignal::Interrupt)?;
        }

        #[cfg(windows)]
        {
            // On Windows, create a trigger file for graceful shutdown
            let trigger_file = std::env::temp_dir().join(format!("coverage_trigger_{}.txt", pid));
            fs::write(&trigger_file, "dump")?;
            println!(
                "ℹ️  Created trigger file (Windows alternative to SIGINT): {}",
                trigger_file.display()
            );
            println!("   Note: Go process must watch for this file to trigger coverage dump");
        }

        // Wait for process to write coverage and exit
        println!("⏳ Waiting for process to write coverage file...");
        thread::sleep(Duration::from_secs(3));

        // Look for coverage files
        let coverage_file = self.find_coverage_file(pid)?;

        println!("✓ Found coverage file: {}", coverage_file);

        // Parse the coverage file
        let summary = self.parse_coverage_file(&coverage_file)?;

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

    /// Check if the process exists
    fn check_process_exists(&self, pid: u32) -> Result<(), String> {
        if !process_exists(pid)? {
            return Err(format!("Process {} not found", pid));
        }
        Ok(())
    }

    /// Try to detect if the Go process was built with coverage support
    #[allow(unused_variables)]
    fn detect_coverage_support(&self, pid: u32) -> Result<(), String> {
        // Check command line for -cover flag
        #[cfg(target_os = "linux")]
        {
            let cmdline_path = format!("/proc/{}/cmdline", pid);
            if let Ok(cmdline) = fs::read_to_string(&cmdline_path) {
                if cmdline.contains("-cover") || cmdline.contains("coverprofile") {
                    println!("✓ Process appears to be built with coverage support");
                    return Ok(());
                }
            }
        }

        println!("⚠️  Could not verify if process has coverage enabled.");
        println!("   If the process was NOT built with -cover, this will not work.");
        println!();

        Ok(())
    }

    /// Find the coverage file written by the Go process
    fn find_coverage_file(&self, pid: u32) -> Result<String, String> {
        // Common coverage file names
        let possible_files = vec![
            format!("coverage-{}.out", pid),
            "coverage.out".to_string(),
            format!("cover-{}.out", pid),
            "cover.out".to_string(),
            // Check current directory for any recent .out files
        ];

        for file in &possible_files {
            if Path::new(file).exists() {
                return Ok(file.clone());
            }
        }

        // Search for recent .out files in current directory
        if let Ok(entries) = fs::read_dir(".") {
            for entry in entries.flatten() {
                if let Ok(file_name) = entry.file_name().into_string() {
                    if file_name.ends_with(".out") && file_name.contains("cov") {
                        if let Ok(metadata) = entry.metadata() {
                            if let Ok(modified) = metadata.modified() {
                                // Check if file was modified in last 10 seconds
                                if let Ok(elapsed) = modified.elapsed() {
                                    if elapsed.as_secs() < 10 {
                                        return Ok(file_name);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        Err(format!(
            "Coverage file not found. \n\
            \n\
            The Go process may not have been built with coverage support.\n\
            \n\
            To enable coverage in your Go application:\n\
            1. Build with: go build -cover -coverprofile=coverage.out -o myapp\n\
            2. Or run with: go run -cover -coverprofile=coverage.out myapp.go\n\
            \n\
            Common coverage file names checked: {:?}",
            possible_files
        ))
    }

    /// Parse Go coverage file format
    fn parse_coverage_file(&self, coverage_file: &str) -> Result<CoverageSummary, String> {
        println!("📊 Parsing Go coverage file...");

        let content = fs::read_to_string(coverage_file)
            .map_err(|e| format!("Failed to read coverage file: {}", e))?;

        // Go coverage format:
        // mode: set (or count, atomic)
        // file.go:line.col,line.col statements count
        // example.go:10.2,12.3 2 1

        let mut total_statements = 0;
        let mut covered_statements = 0;

        for line in content.lines().skip(1) {
            // Skip the "mode:" line
            if line.is_empty() || line.starts_with("mode:") {
                continue;
            }

            // Parse: file.go:start,end num_statements covered_count
            let parts: Vec<&str> = line.split_whitespace().collect();
            if parts.len() >= 3 {
                if let Ok(num_stmts) = parts[1].parse::<usize>() {
                    if let Ok(count) = parts[2].parse::<usize>() {
                        total_statements += num_stmts;
                        if count > 0 {
                            covered_statements += num_stmts;
                        }
                    }
                }
            }
        }

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

        let coverage_percentage = (covered_statements as f64 / total_statements as f64) * 100.0;

        // Note: Go's coverage is statement-based, not line-based
        // We report statements as "lines" for consistency
        Ok(CoverageSummary {
            total_lines: total_statements,
            covered_lines: covered_statements,
            coverage_percentage,
            total_branches: None,
            covered_branches: None,
            branch_percentage: None,
        })
    }
}

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

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

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