pmat 3.11.0

//! TDD Tests for CLI Dead Code Handler
//! 
//! Sprint 62: Ensures CLI handler uses cargo-based analyzer for accurate detection
//! Following Toyota Way TDD principles with comprehensive coverage

#[cfg_attr(coverage_nightly, coverage(off))]
#[cfg(test)]
mod cli_dead_code_handler_tests {
    use super::super::*;
    use crate::services::cargo_dead_code_analyzer::CargoDeadCodeAnalyzer;
    use std::path::PathBuf;
    use tempfile::TempDir;
    use std::fs;

    /// Test that CLI handler returns accurate results matching cargo
    #[tokio::test]
    async fn test_cli_handler_uses_cargo_analyzer() {
        let temp_dir = TempDir::new().unwrap();
        let project_path = temp_dir.path();
        
        // Create a test project with known dead code
        create_test_rust_project(project_path);
        
        // Call the CLI handler
        let result = handle_analyze_dead_code_with_cargo(
            project_path.to_path_buf(),
            DeadCodeOutputFormat::Json,
            None,
            false,
            5,
            false,
            None,
            false,
            100.0,
            60,
            8, // max_depth
        ).await;
        
        assert!(result.is_ok(), "Handler should succeed");
        
        // The result should show minimal dead code (only what cargo reports)
        // Not the false 40-50% that the old analyzer reported
    }

    /// Test that dead code percentage matches cargo's assessment
    #[tokio::test]
    async fn test_dead_code_percentage_accuracy() {
        let temp_dir = TempDir::new().unwrap();
        let project_path = temp_dir.path();
        
        // Create project with no dead code
        create_rust_project_no_dead_code(project_path);
        
        // Use the cargo analyzer directly
        let analyzer = CargoDeadCodeAnalyzer::new(project_path);
        let report = analyzer.analyze().await.unwrap();
        
        // Should be 0% or very close to 0%
        assert!(
            report.dead_code_percentage < 1.0,
            "Dead code should be <1% for project with no unused code, got {}%",
            report.dead_code_percentage
        );
    }

    /// Test that public API is not marked as dead
    #[tokio::test]
    async fn test_public_api_not_dead() {
        let temp_dir = TempDir::new().unwrap();
        let project_path = temp_dir.path();
        
        // Create a library project
        create_library_project(project_path);
        
        let analyzer = CargoDeadCodeAnalyzer::new(project_path);
        let report = analyzer.analyze().await.unwrap();
        
        // Public functions should not be in dead code report
        for file in &report.files_with_dead_code {
            for item in &file.dead_items {
                assert!(
                    !item.name.starts_with("pub"),
                    "Public item {} should not be marked as dead",
                    item.name
                );
            }
        }
    }

    /// Test CLI handler with different output formats
    #[tokio::test]
    async fn test_cli_output_formats() {
        let temp_dir = TempDir::new().unwrap();
        let project_path = temp_dir.path();
        
        create_test_rust_project(project_path);
        
        // Test JSON format
        let json_result = handle_analyze_dead_code_with_cargo(
            project_path.to_path_buf(),
            DeadCodeOutputFormat::Json,
            None,
            false,
            5,
            false,
            None,
            false,
            100.0,
            60,
            8, // max_depth
        ).await;
        assert!(json_result.is_ok());
        
        // Test Human format
        let human_result = handle_analyze_dead_code_with_cargo(
            project_path.to_path_buf(),
            DeadCodeOutputFormat::Human,
            None,
            false,
            5,
            false,
            None,
            false,
            100.0,
            60,
            8, // max_depth
        ).await;
        assert!(human_result.is_ok());
    }

    /// Test that handler respects timeout
    #[tokio::test]
    async fn test_handler_timeout() {
        let temp_dir = TempDir::new().unwrap();
        let project_path = temp_dir.path();
        
        create_large_project(project_path);
        
        // Use very short timeout
        let result = handle_analyze_dead_code_with_cargo(
            project_path.to_path_buf(),
            DeadCodeOutputFormat::Json,
            None,
            false,
            5,
            false,
            None,
            false,
            100.0,
            1, // 1 second timeout
            8, // max_depth
        ).await;
        
        // Should complete or timeout gracefully
        assert!(result.is_ok() || result.is_err());
    }

    // Helper functions to create test projects

    fn create_test_rust_project(path: &std::path::Path) {
        let src_dir = path.join("src");
        fs::create_dir_all(&src_dir).unwrap();
        
        // Main file with one unused function
        fs::write(src_dir.join("main.rs"), r#"
            fn unused_helper() -> i32 {
                42
            }
            
            fn used_function() -> i32 {
                100
            }
            
            fn main() {
                println!("Result: {}", used_function());
            }
        "#).unwrap();
        
        // Cargo.toml
        fs::write(path.join("Cargo.toml"), r#"
[package]
name = "test_project"
version = "0.1.0"
edition = "2021"
        "#).unwrap();
    }

    fn create_rust_project_no_dead_code(path: &std::path::Path) {
        let src_dir = path.join("src");
        fs::create_dir_all(&src_dir).unwrap();
        
        // All code is used
        fs::write(src_dir.join("main.rs"), r#"
            fn helper() -> i32 {
                42
            }
            
            fn calculate() -> i32 {
                helper() * 2
            }
            
            fn main() {
                println!("Result: {}", calculate());
            }
        "#).unwrap();
        
        fs::write(path.join("Cargo.toml"), r#"
[package]
name = "test_project"
version = "0.1.0"
edition = "2021"
        "#).unwrap();
    }

    fn create_library_project(path: &std::path::Path) {
        let src_dir = path.join("src");
        fs::create_dir_all(&src_dir).unwrap();
        
        // Library with public API
        fs::write(src_dir.join("lib.rs"), r#"
            /// Public API function
            pub fn public_api() -> String {
                "Public".to_string()
            }
            
            /// Another public function
            pub fn another_api() -> i32 {
                42
            }
            
            // Private unused function
            fn private_unused() -> i32 {
                100
            }
        "#).unwrap();
        
        fs::write(path.join("Cargo.toml"), r#"
[package]
name = "test_library"
version = "0.1.0"
edition = "2021"

[lib]
name = "test_library"
        "#).unwrap();
    }

    fn create_large_project(path: &std::path::Path) {
        let src_dir = path.join("src");
        fs::create_dir_all(&src_dir).unwrap();
        
        // Create many files for timeout test
        for i in 0..20 {
            fs::write(src_dir.join(format!("mod{}.rs", i)), format!(r#"
                pub fn func_{}() -> i32 {{
                    {}
                }}
            "#, i, i)).unwrap();
        }
        
        fs::write(src_dir.join("main.rs"), r#"
            fn main() {
                println!("Large project");
            }
        "#).unwrap();
        
        fs::write(path.join("Cargo.toml"), r#"
[package]
name = "large_project"
version = "0.1.0"
edition = "2021"
        "#).unwrap();
    }
}

// Temporary implementation for testing - will be replaced with actual fix
async fn handle_analyze_dead_code_with_cargo(
    path: PathBuf,
    _format: DeadCodeOutputFormat,
    _top_files: Option<usize>,
    _include_unreachable: bool,
    _min_dead_lines: usize,
    _include_tests: bool,
    _output: Option<PathBuf>,
    _fail_on_violation: bool,
    _max_percentage: f64,
    _timeout: u64,
    max_depth: usize,
) -> Result<(), anyhow::Error> {
    use crate::services::cargo_dead_code_analyzer::CargoDeadCodeAnalyzer;
    
    // Use the cargo-based analyzer
    let analyzer = CargoDeadCodeAnalyzer::new(&path).with_max_depth(max_depth);
    let report = analyzer.analyze().await?;
    
    // For now, just check that it works
    println!("Dead code: {:.2}%", report.dead_code_percentage);
    
    Ok(())
}

#[derive(Debug, Clone)]
enum DeadCodeOutputFormat {
    Json,
    Human,
    Yaml,
}