testlint_sdk/runtime_coverage/

javascript.rs

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

pub struct JavaScriptRuntimeCoverage;

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

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

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

        // Check if process exists and is Node.js
        self.check_nodejs_process(pid)?;

        // Get the inspector port for this process
        let inspector_port = self.find_or_enable_inspector(pid)?;

        println!(
            "🔌 Connected to Node.js inspector on port {}",
            inspector_port
        );

        // Enable coverage via Inspector Protocol
        println!("💉 Enabling coverage collection...");
        self.enable_coverage(inspector_port)?;

        // 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();

        // Collect coverage data
        println!("\n📝 Collecting coverage data...");
        let coverage_file = self.collect_coverage(pid, inspector_port)?;

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

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

    /// Check if process is a Node.js process
    fn check_nodejs_process(&self, pid: u32) -> Result<(), String> {
        use crate::platform::get_process_name;

        if !process_exists(pid)? {
            return Err(format!("Process {} not found", pid));
        }

        let process_name = get_process_name(pid)?;
        if !process_name.to_lowercase().contains("node") {
            return Err(format!("Process {} is not a Node.js process", pid));
        }

        Ok(())
    }

    /// Find existing inspector port or signal process to enable inspector
    fn find_or_enable_inspector(&self, pid: u32) -> Result<u16, String> {
        // First, try to find if inspector is already enabled
        if let Ok(port) = self.find_existing_inspector(pid) {
            return Ok(port);
        }

        // If not, send SIGUSR1 to enable inspector (Unix) or use file trigger (Windows)
        println!("🔧 Enabling Node.js inspector...");

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

            // Wait for inspector to start
            thread::sleep(Duration::from_secs(1));

            // Try to find the inspector port
            self.find_existing_inspector(pid)
        }

        #[cfg(windows)]
        {
            // On Windows, create a trigger file that Node.js process can watch for
            let trigger_file = std::env::temp_dir().join(format!("inspector_trigger_{}.txt", pid));
            fs::write(&trigger_file, "enable")?;
            println!(
                "ℹ️  Created trigger file (Windows alternative to SIGUSR1): {}",
                trigger_file.display()
            );

            thread::sleep(Duration::from_secs(1));
            self.find_existing_inspector(pid)
        }

        #[cfg(not(any(unix, windows)))]
        {
            Err("Inspector detection not supported on this platform".to_string())
        }
    }

    /// Find the inspector port for a running Node.js process
    fn find_existing_inspector(&self, pid: u32) -> Result<u16, String> {
        // Check common inspector ports first (9229 is default)
        for port in [9229, 9230, 9231, 9232, 9233] {
            if self.test_inspector_port(port) {
                return Ok(port);
            }
        }

        // Try to find from process info
        #[cfg(target_os = "linux")]
        {
            // On Linux, check /proc/<pid>/cmdline and /proc/<pid>/fd for websocket
            let cmdline_path = format!("/proc/{}/cmdline", pid);
            if let Ok(cmdline) = fs::read_to_string(&cmdline_path) {
                if let Some(port) = self.extract_inspector_port(&cmdline) {
                    return Ok(port);
                }
            }
        }

        Err(format!(
            "Could not find Node.js inspector port for PID {}. \
            Process may not have inspector enabled. \
            Start your Node.js app with --inspect flag.",
            pid
        ))
    }

    /// Test if an inspector port is active
    fn test_inspector_port(&self, port: u16) -> bool {
        // Try to connect to the inspector WebSocket
        use std::net::TcpStream;
        TcpStream::connect(format!("127.0.0.1:{}", port))
            .map(|_| true)
            .unwrap_or(false)
    }

    /// Extract inspector port from command line
    #[allow(dead_code)]
    fn extract_inspector_port(&self, cmdline: &str) -> Option<u16> {
        // Look for --inspect=<port> or --inspect-brk=<port>
        for arg in cmdline.split('\0') {
            if arg.starts_with("--inspect=") {
                if let Some(port_str) = arg.strip_prefix("--inspect=") {
                    if let Ok(port) = port_str.parse() {
                        return Some(port);
                    }
                }
            }
        }
        None
    }

    /// Enable coverage via Inspector Protocol
    fn enable_coverage(&self, inspector_port: u16) -> Result<(), String> {
        // Create a Node.js script to enable coverage via inspector protocol
        let script = r#"
const inspector = require('inspector');
const session = new inspector.Session();

session.connect();

// Enable Profiler domain
session.post('Profiler.enable');

// Enable precise coverage
session.post('Profiler.startPreciseCoverage', {
  callCount: true,
  detailed: true
});

console.log('[Coverage] Precise coverage enabled');

// Keep the connection alive
setTimeout(() => {}, 1000000);
"#
        .to_string();

        let temp_dir = std::env::temp_dir();
        let script_path = temp_dir.join(format!("enable_coverage_{}.js", inspector_port));
        fs::write(&script_path, script).map_err(|e| format!("Failed to write script: {}", e))?;

        let output = Command::new("node")
            .arg(&script_path)
            .output()
            .map_err(|e| format!("Failed to enable coverage: {}", e))?;

        let _ = fs::remove_file(&script_path);

        if !output.status.success() {
            return Err(format!(
                "Failed to enable coverage: {}",
                String::from_utf8_lossy(&output.stderr)
            ));
        }

        Ok(())
    }

    /// Collect coverage data from the process
    fn collect_coverage(&self, pid: u32, _inspector_port: u16) -> Result<String, String> {
        // Create a Node.js script to collect coverage
        let coverage_file = format!("coverage-{}.json", pid);

        let script = format!(
            r#"
const inspector = require('inspector');
const fs = require('fs');
const session = new inspector.Session();

session.connect();

// Take precise coverage
session.post('Profiler.takePreciseCoverage', (err, {{ result }}) => {{
  if (err) {{
    console.error('Failed to take coverage:', err);
    process.exit(1);
  }}

  // Save coverage to file
  fs.writeFileSync('{}', JSON.stringify(result, null, 2));
  console.log('[Coverage] Saved to {}');

  // Stop coverage
  session.post('Profiler.stopPreciseCoverage');
  session.post('Profiler.disable');

  process.exit(0);
}});
"#,
            coverage_file, coverage_file
        );

        let temp_dir = std::env::temp_dir();
        let script_path = temp_dir.join(format!("collect_coverage_{}.js", pid));
        fs::write(&script_path, script)
            .map_err(|e| format!("Failed to write collection script: {}", e))?;

        let output = Command::new("node")
            .arg(&script_path)
            .output()
            .map_err(|e| format!("Failed to collect coverage: {}", e))?;

        let _ = fs::remove_file(&script_path);

        if !output.status.success() {
            return Err(format!(
                "Failed to collect coverage: {}",
                String::from_utf8_lossy(&output.stderr)
            ));
        }

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

        Ok(coverage_file)
    }

    /// Parse coverage summary from V8 coverage format
    fn parse_coverage_summary(&self, coverage_file: &str) -> Result<CoverageSummary, String> {
        println!("📊 Parsing coverage report...");

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

        let data: serde_json::Value =
            serde_json::from_str(&content).map_err(|e| format!("Failed to parse JSON: {}", e))?;

        let mut total_lines = 0;
        let mut covered_lines = 0;

        // V8 coverage format: array of script coverage objects
        if let Some(scripts) = data.as_array() {
            for script in scripts {
                if let Some(functions) = script["functions"].as_array() {
                    for function in functions {
                        if let Some(ranges) = function["ranges"].as_array() {
                            for range in ranges {
                                if let (Some(count), Some(_start), Some(_end)) = (
                                    range["count"].as_u64(),
                                    range["startOffset"].as_u64(),
                                    range["endOffset"].as_u64(),
                                ) {
                                    total_lines += 1;
                                    if count > 0 {
                                        covered_lines += 1;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

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

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

        Ok(CoverageSummary {
            total_lines,
            covered_lines,
            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 = JavaScriptRuntimeCoverage::new();
        assert_eq!(std::mem::size_of_val(&coverage), 0);
    }

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