testlint_sdk/runtime_coverage/

java.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 JavaRuntimeCoverage;

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

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

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

        // Check if process exists and is Java
        self.check_java_process(pid)?;

        // Download JaCoCo agent if needed
        let agent_path = self.ensure_jacoco_agent()?;

        // Attach JaCoCo agent to the process
        println!("💉 Attaching JaCoCo agent to process...");
        self.attach_agent(pid, &agent_path)?;

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

        // Trigger dump via JMX or TCP
        println!("\n📝 Triggering coverage dump...");
        self.dump_coverage(pid)?;

        // Find and parse coverage file
        let coverage_file = format!("jacoco-{}.exec", pid);
        if !Path::new(&coverage_file).exists() {
            return Err(format!("Coverage file {} not found", coverage_file));
        }

        // Convert to XML for parsing
        self.convert_to_xml(&coverage_file, pid)?;

        let xml_file = format!("jacoco-{}.xml", pid);
        let summary = self.parse_coverage_xml(&xml_file)?;

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

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

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

        Ok(())
    }

    /// Ensure JaCoCo agent JAR is available
    fn ensure_jacoco_agent(&self) -> Result<String, String> {
        let agent_path = "jacocoagent.jar";

        if Path::new(agent_path).exists() {
            return Ok(agent_path.to_string());
        }

        println!("📥 Downloading JaCoCo agent...");

        // Download JaCoCo agent
        let download_url = "https://repo1.maven.org/maven2/org/jacoco/org.jacoco.agent/0.8.11/org.jacoco.agent-0.8.11-runtime.jar";

        let output = Command::new("curl")
            .args(["-L", "-o", agent_path, download_url])
            .output()
            .map_err(|e| format!("Failed to download JaCoCo agent: {}", e))?;

        if !output.status.success() {
            return Err("Failed to download JaCoCo agent".to_string());
        }

        println!("✓ JaCoCo agent downloaded");
        Ok(agent_path.to_string())
    }

    /// Attach JaCoCo agent to running process using Java attach API
    fn attach_agent(&self, pid: u32, agent_path: &str) -> Result<(), String> {
        // Create a small Java program to attach the agent
        let attach_code = format!(
            r#"
import com.sun.tools.attach.VirtualMachine;

public class AttachAgent {{
    public static void main(String[] args) throws Exception {{
        String pid = "{}";
        String agentPath = "{}";
        String options = "destfile=jacoco-{}.exec,append=false,output=file,jmx=true";

        VirtualMachine vm = VirtualMachine.attach(pid);
        System.out.println("Attached to process " + pid);

        vm.loadAgent(agentPath, options);
        System.out.println("JaCoCo agent loaded successfully");

        vm.detach();
        System.out.println("Detached from process");
    }}
}}
"#,
            pid, agent_path, pid
        );

        // Write the attach program
        fs::write("AttachAgent.java", attach_code)
            .map_err(|e| format!("Failed to write attach program: {}", e))?;

        // Compile it
        let output = Command::new("javac")
            .arg("AttachAgent.java")
            .output()
            .map_err(|e| format!("Failed to compile attach program: {}", e))?;

        if !output.status.success() {
            return Err(format!(
                "Compilation failed: {}",
                String::from_utf8_lossy(&output.stderr)
            ));
        }

        // Run it (requires tools.jar in classpath)
        let output = Command::new("java")
            .arg("AttachAgent")
            .output()
            .map_err(|e| format!("Failed to run attach program: {}", e))?;

        if !output.status.success() {
            return Err(format!(
                "Agent attachment failed: {}",
                String::from_utf8_lossy(&output.stderr)
            ));
        }

        // Cleanup
        let _ = fs::remove_file("AttachAgent.java");
        let _ = fs::remove_file("AttachAgent.class");

        Ok(())
    }

    /// Trigger coverage dump via JMX
    fn dump_coverage(&self, pid: u32) -> Result<(), String> {
        // Create JMX dump program
        let dump_code = format!(
            r#"
import javax.management.*;
import javax.management.remote.*;
import java.lang.management.*;

public class DumpCoverage {{
    public static void main(String[] args) throws Exception {{
        // Get the JMX connector URL from the process
        String jmxUrl = findJMXUrl({});
        if (jmxUrl == null) {{
            System.err.println("Could not find JMX URL for process");
            System.exit(1);
        }}

        JMXServiceURL url = new JMXServiceURL(jmxUrl);
        JMXConnector connector = JMXConnectorFactory.connect(url);
        MBeanServerConnection mbsc = connector.getMBeanServerConnection();

        // Find JaCoCo MBean and trigger dump
        ObjectName jacocoMBean = new ObjectName("org.jacoco:type=Runtime");
        mbsc.invoke(jacocoMBean, "dump", new Object[]{{true}}, new String[]{{"boolean"}});

        System.out.println("Coverage dump triggered");
        connector.close();
    }}

    private static String findJMXUrl(int pid) {{
        // Try to find JMX connection URL for the process
        // This is a simplified version
        return "service:jmx:rmi:///jndi/rmi://localhost:9999/jmxrmi";
    }}
}}
"#,
            pid
        );

        fs::write("DumpCoverage.java", dump_code)
            .map_err(|e| format!("Failed to write dump program: {}", e))?;

        // This is simplified - in practice, we'd wait and let the file-based dump happen
        println!("Note: Coverage will be dumped when process exits or on timeout");

        Ok(())
    }

    /// Convert JaCoCo exec file to XML
    fn convert_to_xml(&self, exec_file: &str, pid: u32) -> Result<(), String> {
        println!("📄 Converting coverage to XML format...");

        // This requires JaCoCo CLI
        let cli_jar = self.ensure_jacoco_cli()?;

        let xml_file = format!("jacoco-{}.xml", pid);

        let output = Command::new("java")
            .args(["-jar", &cli_jar, "report", exec_file, "--xml", &xml_file])
            .output()
            .map_err(|e| format!("Failed to convert coverage: {}", e))?;

        if !output.status.success() {
            return Err(format!(
                "XML conversion failed: {}",
                String::from_utf8_lossy(&output.stderr)
            ));
        }

        Ok(())
    }

    /// Ensure JaCoCo CLI JAR is available
    fn ensure_jacoco_cli(&self) -> Result<String, String> {
        let cli_jar = "jacococli.jar";

        if Path::new(cli_jar).exists() {
            return Ok(cli_jar.to_string());
        }

        println!("📥 Downloading JaCoCo CLI...");

        let download_url = "https://repo1.maven.org/maven2/org/jacoco/org.jacoco.cli/0.8.11/org.jacoco.cli-0.8.11-nodeps.jar";

        let output = Command::new("curl")
            .args(["-L", "-o", cli_jar, download_url])
            .output()
            .map_err(|e| format!("Failed to download JaCoCo CLI: {}", e))?;

        if !output.status.success() {
            return Err("Failed to download JaCoCo CLI".to_string());
        }

        Ok(cli_jar.to_string())
    }

    /// Parse XML coverage file
    fn parse_coverage_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 total_lines = 0;
        let mut covered_lines = 0;
        let mut total_branches = 0;
        let mut covered_branches = 0;

        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"counter" {
                        let mut counter_type = String::new();
                        let mut missed = 0;
                        let mut covered = 0;

                        // Parse attributes from <counter> 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() {
                                "type" => {
                                    counter_type = value.to_string();
                                }
                                "missed" => {
                                    missed = value.parse().unwrap_or(0);
                                }
                                "covered" => {
                                    covered = value.parse().unwrap_or(0);
                                }
                                _ => {}
                            }
                        }

                        // Apply based on counter type
                        match counter_type.as_str() {
                            "LINE" => {
                                total_lines = missed + covered;
                                covered_lines = covered;
                            }
                            "BRANCH" => {
                                total_branches = missed + covered;
                                covered_branches = covered;
                            }
                            _ => {}
                        }
                    }
                }

                Ok(_) => {}

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

            buf.clear();
        }

        let coverage_percentage = if total_lines > 0 {
            (covered_lines as f64 / total_lines as f64) * 100.0
        } else {
            0.0
        };

        let branch_percentage = if total_branches > 0 {
            Some((covered_branches as f64 / total_branches as f64) * 100.0)
        } else {
            None
        };

        Ok(CoverageSummary {
            total_lines,
            covered_lines,
            coverage_percentage,
            total_branches: if total_branches > 0 {
                Some(total_branches)
            } else {
                None
            },
            covered_branches: if total_branches > 0 {
                Some(covered_branches)
            } else {
                None
            },
            branch_percentage,
        })
    }
}

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

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

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