pmat 3.16.0

//! Advanced analysis handlers tests - Part 4: Edge case tests
//! Extracted for file health compliance (CB-040)

use super::*;

#[cfg_attr(coverage_nightly, coverage(off))]
#[cfg(test)]
mod edge_case_tests {
    use super::*;
    use std::fs;
    use tempfile::TempDir;

    #[tokio::test]
    async fn test_handle_deep_context_nonexistent_path() {
        let result = handle_analyze_deep_context(
            PathBuf::from("/nonexistent/path/to/project"),
            None,
            DeepContextOutputFormat::Json,
            false,
            vec![],
            vec![],
            30,
            None,
            None,
            vec![],
            vec![],
            None,
            false,
            false,
            10,
        )
        .await;

        // Should succeed even with nonexistent path (returns empty analysis)
        // or fail gracefully
        let _ = result;
    }

    #[tokio::test]
    async fn test_handle_deep_context_with_special_characters_in_path() {
        let temp_dir = TempDir::new().expect("Failed to create temp dir");
        let special_dir = temp_dir.path().join("project with spaces");
        fs::create_dir_all(&special_dir).expect("Failed to create directory");

        let main_rs = special_dir.join("main.rs");
        fs::write(&main_rs, "fn main() {}").expect("Failed to write file");

        let result = handle_analyze_deep_context(
            special_dir,
            None,
            DeepContextOutputFormat::Json,
            false,
            vec![],
            vec![],
            30,
            None,
            None,
            vec![],
            vec![],
            None,
            false,
            false,
            10,
        )
        .await;

        assert!(result.is_ok());
    }

    #[tokio::test]
    async fn test_handle_deep_context_empty_file() {
        let temp_dir = TempDir::new().expect("Failed to create temp dir");
        let empty_rs = temp_dir.path().join("empty.rs");
        fs::write(&empty_rs, "").expect("Failed to write empty file");

        let result = handle_analyze_deep_context(
            temp_dir.path().to_path_buf(),
            None,
            DeepContextOutputFormat::Json,
            false,
            vec![],
            vec![],
            30,
            None,
            None,
            vec![],
            vec![],
            None,
            false,
            false,
            10,
        )
        .await;

        assert!(result.is_ok());
    }

    #[tokio::test]
    async fn test_handle_deep_context_binary_file() {
        let temp_dir = TempDir::new().expect("Failed to create temp dir");
        let binary_file = temp_dir.path().join("binary.rs");
        fs::write(&binary_file, vec![0u8, 1, 2, 3, 255, 254, 253])
            .expect("Failed to write binary file");

        let result = handle_analyze_deep_context(
            temp_dir.path().to_path_buf(),
            None,
            DeepContextOutputFormat::Json,
            false,
            vec![],
            vec![],
            30,
            None,
            None,
            vec![],
            vec![],
            None,
            false,
            false,
            10,
        )
        .await;

        // Should handle binary files gracefully
        let _ = result;
    }

    #[tokio::test]
    async fn test_handle_deep_context_large_top_files() {
        let temp_dir = TempDir::new().expect("Failed to create temp dir");
        let main_rs = temp_dir.path().join("main.rs");
        fs::write(&main_rs, "fn main() {}").expect("Failed to write file");

        let result = handle_analyze_deep_context(
            temp_dir.path().to_path_buf(),
            None,
            DeepContextOutputFormat::Json,
            false,
            vec![],
            vec![],
            30,
            None,
            None,
            vec![],
            vec![],
            None,
            false,
            false,
            1000, // Large top_files value
        )
        .await;

        assert!(result.is_ok());
    }

    #[tokio::test]
    async fn test_handle_deep_context_zero_period_days() {
        let temp_dir = TempDir::new().expect("Failed to create temp dir");
        let main_rs = temp_dir.path().join("main.rs");
        fs::write(&main_rs, "fn main() {}").expect("Failed to write file");

        // Edge case: 0 period days
        let result = handle_analyze_deep_context(
            temp_dir.path().to_path_buf(),
            None,
            DeepContextOutputFormat::Json,
            false,
            vec![],
            vec![],
            0, // Zero days
            None,
            None,
            vec![],
            vec![],
            None,
            false,
            false,
            10,
        )
        .await;

        // Should handle edge case gracefully
        let _ = result;
    }

    #[tokio::test]
    async fn test_handle_comprehensive_empty_files_list() {
        let temp_dir = TempDir::new().expect("Failed to create temp dir");
        let main_rs = temp_dir.path().join("main.rs");
        fs::write(&main_rs, "fn main() {}").expect("Failed to write file");

        let result = handle_analyze_comprehensive(
            temp_dir.path().to_path_buf(),
            None,
            vec![], // Empty files list
            ComprehensiveOutputFormat::Summary,
            false,
            false,
            false,
            true,
            false,
            0.5,
            100,
            None,
            None,
            None,
            false,
            false,
        )
        .await;

        let _ = result;
    }

    #[tokio::test]
    async fn test_handle_graph_metrics_empty_seeds() {
        let temp_dir = TempDir::new().expect("Failed to create temp dir");
        let main_rs = temp_dir.path().join("main.rs");
        fs::write(&main_rs, "fn main() {}").expect("Failed to write file");

        let result = handle_analyze_graph_metrics(
            temp_dir.path().to_path_buf(),
            vec![GraphMetricType::PageRank],
            vec![], // Empty seeds
            0.85,
            100,
            1e-6,
            false,
            GraphMetricsOutputFormat::Summary,
            None,
            None,
            None,
            false,
            10,
            0.0,
        )
        .await;

        let _ = result;
    }

    #[tokio::test]
    async fn test_handle_symbol_table_empty_include_exclude() {
        let temp_dir = TempDir::new().expect("Failed to create temp dir");
        let main_rs = temp_dir.path().join("main.rs");
        fs::write(&main_rs, "fn main() {}").expect("Failed to write file");

        let result = handle_analyze_symbol_table(
            temp_dir.path().to_path_buf(),
            SymbolTableOutputFormat::Summary,
            None,
            None,
            vec![], // Empty include
            vec![], // Empty exclude
            false,
            false,
            None,
            false,
        )
        .await;

        let _ = result;
    }
}