testlint_sdk/runtime_coverage/

php.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 PhpRuntimeCoverage;

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

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

    /// Attach to a running PHP process and collect coverage
    /// Note: PHP requires Xdebug/PCOV loaded at startup, so this uses graceful restart
    pub fn attach_and_collect(&self, pid: u32) -> Result<RuntimeCoverageResult, String> {
        println!(
            "🐘 Attempting to collect coverage from PHP process PID: {}",
            pid
        );
        println!();
        println!("⚠️  IMPORTANT: PHP coverage requires Xdebug or PCOV extension");
        println!("   loaded at process startup. This tool will:");
        println!("   1. Check if PHP-FPM/Apache is running");
        println!("   2. Enable Xdebug in php.ini if not already");
        println!("   3. Trigger graceful reload");
        println!("   4. Monitor coverage output");
        println!();

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

        // Detect PHP process type (FPM, Apache, CLI)
        let process_type = self.detect_php_process_type(pid)?;
        println!("📦 Detected PHP process type: {}", process_type);

        // Check if Xdebug is already loaded
        if !self.check_xdebug_loaded(pid)? {
            println!("⚠️  Xdebug not detected in running process");
            println!("   This typically requires process restart with Xdebug enabled");
            println!();

            // Provide instructions
            return Err(self.get_xdebug_instructions(&process_type));
        }

        println!("✓ Xdebug appears to be loaded");
        println!();

        // For CLI scripts, we can't really attach mid-execution
        if process_type == "cli" {
            return Err("Cannot attach to PHP CLI scripts mid-execution.\n\
                \n\
                PHP CLI coverage must be enabled from the start:\n\
                php -d xdebug.mode=coverage -d xdebug.start_with_request=yes script.php\n\
                \n\
                Or use the Coverage Orchestrator to wrap script execution."
                .to_string());
        }

        // For FPM/Apache, monitor existing coverage
        let start_time = std::time::Instant::now();

        println!("⏳ Monitoring PHP coverage... Press Ctrl+C to collect");

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

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

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

        println!("\n📝 Looking for PHP coverage files...");

        // Find coverage file
        let coverage_file = self.find_coverage_file()?;

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

        Ok(RuntimeCoverageResult {
            language: "PHP".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(())
    }

    /// Detect type of PHP process (FPM, Apache mod_php, CLI)
    fn detect_php_process_type(&self, pid: u32) -> Result<String, String> {
        let process_name = get_process_name(pid)?.to_lowercase();

        if process_name.contains("php-fpm") {
            return Ok("fpm".to_string());
        } else if process_name.contains("apache") || process_name.contains("httpd") {
            return Ok("apache".to_string());
        } else if process_name.contains("php") {
            return Ok("cli".to_string());
        }

        Ok("unknown".to_string())
    }

    /// Check if Xdebug is loaded in the process
    fn check_xdebug_loaded(&self, _pid: u32) -> Result<bool, String> {
        // Try to check if Xdebug is loaded via phpinfo or php -m
        let output = Command::new("php")
            .args(["-m"])
            .output()
            .map_err(|_| "Failed to run php -m")?;

        let modules = String::from_utf8_lossy(&output.stdout);

        Ok(modules.contains("Xdebug") || modules.contains("PCOV"))
    }

    /// Get instructions for enabling Xdebug based on process type
    fn get_xdebug_instructions(&self, process_type: &str) -> String {
        let temp_coverage = std::env::temp_dir().join("php-coverage");
        let temp_coverage_str = temp_coverage.display();

        match process_type {
            "fpm" => format!(
                "PHP-FPM process does not have Xdebug loaded.\n\
                \n\
                To enable coverage:\n\
                \n\
                1. Edit php.ini (usually /etc/php/fpm/php.ini):\n\
                   zend_extension=xdebug.so\n\
                   xdebug.mode=coverage\n\
                   xdebug.output_dir={}\n\
                \n\
                2. Restart PHP-FPM:\n\
                   sudo systemctl restart php-fpm\n\
                   # or\n\
                   sudo service php8.1-fpm restart\n\
                \n\
                3. Re-run this tool to monitor coverage\n\
                \n\
                Note: Xdebug significantly impacts performance in production!",
                temp_coverage_str
            ),
            "apache" => format!(
                "Apache/mod_php process does not have Xdebug loaded.\n\
                \n\
                To enable coverage:\n\
                \n\
                1. Edit php.ini (usually /etc/php/apache2/php.ini):\n\
                   zend_extension=xdebug.so\n\
                   xdebug.mode=coverage\n\
                   xdebug.output_dir={}\n\
                \n\
                2. Restart Apache:\n\
                   sudo systemctl restart apache2\n\
                   # or\n\
                   sudo apachectl restart\n\
                \n\
                3. Re-run this tool to monitor coverage\n\
                \n\
                Warning: Xdebug slows down PHP significantly!",
                temp_coverage_str
            ),
            _ => "PHP process does not have Xdebug loaded.\n\
                \n\
                For CLI scripts:\n\
                   php -d zend_extension=xdebug.so -d xdebug.mode=coverage script.php\n\
                \n\
                For servers:\n\
                   Install Xdebug: pecl install xdebug\n\
                   Enable in php.ini and restart server\n\
                \n\
                Or use Coverage Orchestrator to wrap execution automatically."
                .to_string(),
        }
    }

    /// Find PHP coverage file (Clover XML or serialized format)
    fn find_coverage_file(&self) -> Result<String, String> {
        // Common locations for PHP coverage
        let temp_coverage = std::env::temp_dir().join("php-coverage");
        let temp_coverage_str = temp_coverage.to_string_lossy().to_string();
        let possible_paths = vec![
            temp_coverage_str.as_str(),
            "./coverage",
            "./build/logs",
            ".",
        ];

        let possible_files = vec![
            "clover.xml",
            "coverage.xml",
            "coverage.clover",
            ".coverage.dat",
        ];

        for dir in &possible_paths {
            for file in &possible_files {
                let full_path = format!("{}/{}", dir, file);
                if Path::new(&full_path).exists() {
                    return Ok(full_path);
                }
            }
        }

        let temp_coverage = std::env::temp_dir().join("php-coverage");
        Err(format!(
            "PHP coverage file not found.\n\
            \n\
            Coverage files are typically generated by:\n\
            - PHPUnit with --coverage-clover flag\n\
            - Xdebug with xdebug.coverage_output_dir set\n\
            - PCOV with pcov.directory configured\n\
            \n\
            Expected locations:\n\
            - {}/\n\
            - ./coverage/\n\
            - ./build/logs/\n\
            \n\
            Tip: Use Coverage Orchestrator instead:\n\
               ./target/release/run_with_coverage php vendor/bin/phpunit",
            temp_coverage.display()
        ))
    }

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

        let content = fs::read_to_string(coverage_file)
            .map_err(|e| format!("Failed to read coverage file: {}", 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_statements = 0;
        let mut covered_statements = 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"metrics" {
                        // Parse attributes from <metrics> 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() {
                                "statements" => {
                                    total_statements = value.parse().unwrap_or(0);
                                }
                                "coveredstatements" => {
                                    covered_statements = value.parse().unwrap_or(0);
                                }
                                "elements" => {
                                    let elements: usize = value.parse().unwrap_or(0);
                                    if elements > total_lines {
                                        total_lines = elements;
                                    }
                                }
                                "coveredelements" => {
                                    let covered: usize = value.parse().unwrap_or(0);
                                    if covered > covered_lines {
                                        covered_lines = covered;
                                    }
                                }
                                _ => {}
                            }
                        }
                    }
                }

                Ok(_) => {}

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

            buf.clear();
        }

        // Use statements if available, otherwise lines
        if total_statements > 0 {
            total_lines = total_statements;
            covered_lines = covered_statements;
        }

        if total_lines == 0 {
            return Err("No coverage data found in file".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 = PhpRuntimeCoverage::new();
        assert_eq!(std::mem::size_of_val(&coverage), 0);
    }

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