exspec_core/

output.rs

use std::collections::HashSet;

use crate::hints::Hint;
use crate::metrics::ProjectMetrics;
use crate::rules::{Diagnostic, Severity};

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum OutputFormat {
    Terminal,
    Json,
    Sarif,
    AiPrompt,
}

/// Count unique violated functions by (file, line) pairs.
/// Only per-function diagnostics (line=Some) are counted.
fn count_violated_functions(diagnostics: &[Diagnostic]) -> usize {
    diagnostics
        .iter()
        .filter_map(|d| d.line.map(|l| (d.file.as_str(), l)))
        .collect::<HashSet<_>>()
        .len()
}

pub fn format_terminal(
    diagnostics: &[Diagnostic],
    file_count: usize,
    function_count: usize,
    metrics: &ProjectMetrics,
    hints: &[Hint],
) -> String {
    let mut lines = Vec::new();

    lines.push(format!(
        "exspec v{} -- {} test files, {} test functions",
        env!("CARGO_PKG_VERSION"),
        file_count,
        function_count,
    ));

    if file_count == 0 {
        lines.push("No test files found. Check --lang filter or run from a directory containing test files.".to_string());
    }

    for d in diagnostics {
        let line_str = d.line.map(|l| format!(":{l}")).unwrap_or_default();
        lines.push(format!(
            "{} {}{} {} {}",
            d.severity, d.file, line_str, d.rule, d.message,
        ));
    }

    // Metrics section
    lines.push("Metrics:".to_string());
    lines.push(format!(
        "  Mock density:      {:.1}/test (avg), {} distinct classes/test (max)",
        metrics.mock_density_avg, metrics.mock_class_max,
    ));

    let total_functions_for_param = if function_count > 0 {
        let count = (metrics.parameterized_ratio * function_count as f64).round() as usize;
        format!("{count}/{function_count}")
    } else {
        "0/0".to_string()
    };
    lines.push(format!(
        "  Parameterized:     {:.0}% ({})",
        metrics.parameterized_ratio * 100.0,
        total_functions_for_param,
    ));

    let pbt_files = (metrics.pbt_ratio * file_count as f64).round() as usize;
    lines.push(format!(
        "  PBT usage:         {:.0}% ({}/{} files)",
        metrics.pbt_ratio * 100.0,
        pbt_files,
        file_count,
    ));

    lines.push(format!(
        "  Assertion density: {:.1}/test (avg)",
        metrics.assertion_density_avg,
    ));

    let contract_files = (metrics.contract_coverage * file_count as f64).round() as usize;
    lines.push(format!(
        "  Contract coverage: {:.0}% ({}/{} files)",
        metrics.contract_coverage * 100.0,
        contract_files,
        file_count,
    ));

    // Score section
    let block_count = diagnostics
        .iter()
        .filter(|d| d.severity == Severity::Block)
        .count();
    let warn_count = diagnostics
        .iter()
        .filter(|d| d.severity == Severity::Warn)
        .count();
    let info_count = diagnostics
        .iter()
        .filter(|d| d.severity == Severity::Info)
        .count();
    let violated = count_violated_functions(diagnostics);
    let pass_count = function_count.saturating_sub(violated);
    lines.push(format!(
        "Score: BLOCK {block_count} | WARN {warn_count} | INFO {info_count} | PASS {pass_count}",
    ));

    for hint in hints {
        lines.push(format!("Hint [{}] {}", hint.rule, hint.title));
        lines.push(format!("  {}", hint.message));
    }

    lines.join("\n")
}

pub fn format_json(
    diagnostics: &[Diagnostic],
    file_count: usize,
    function_count: usize,
    metrics: &ProjectMetrics,
    unfiltered_summary: Option<&SummaryStats>,
    hints: &[Hint],
) -> String {
    let (block_count, warn_count, info_count, pass_count) = if let Some(stats) = unfiltered_summary
    {
        (
            stats.block_count,
            stats.warn_count,
            stats.info_count,
            stats.pass_count,
        )
    } else {
        let block_count = diagnostics
            .iter()
            .filter(|d| d.severity == Severity::Block)
            .count();
        let warn_count = diagnostics
            .iter()
            .filter(|d| d.severity == Severity::Warn)
            .count();
        let info_count = diagnostics
            .iter()
            .filter(|d| d.severity == Severity::Info)
            .count();
        let violated = count_violated_functions(diagnostics);
        let pass_count = function_count.saturating_sub(violated);
        (block_count, warn_count, info_count, pass_count)
    };

    let mut output = serde_json::json!({
        "version": env!("CARGO_PKG_VERSION"),
        "summary": {
            "files": file_count,
            "functions": function_count,
            "block": block_count,
            "warn": warn_count,
            "info": info_count,
            "pass": pass_count,
        },
        "diagnostics": diagnostics,
        "metrics": serde_json::to_value(metrics).unwrap_or_default(),
    });

    if file_count == 0 {
        output["guidance"] = serde_json::json!("No test files found. Check --lang filter or run from a directory containing test files.");
    }
    if !hints.is_empty() {
        output["hints"] = serde_json::to_value(hints).unwrap_or_default();
    }
    serde_json::to_string_pretty(&output).unwrap_or_else(|_| "{}".to_string())
}

struct RuleMeta {
    id: &'static str,
    name: &'static str,
    short_description: &'static str,
    guidance: &'static str,
}

const RULE_REGISTRY: &[RuleMeta] = &[
    RuleMeta {
        id: "T001",
        name: "assertion-free",
        short_description: "Test function has no assertions",
        guidance: "This test does not express a specification -- it only verifies \"no crash.\" Ask: what observable outcome should this function guarantee? Assert the return value, state change, or side effect instead.",
    },
    RuleMeta {
        id: "T002",
        name: "mock-overuse",
        short_description: "Test function uses too many mocks",
        guidance: "Too many mocks can make the test fragile and coupled to implementation. Consider using fewer mocks and testing through real collaborators where possible. Extract the core logic into a pure function that can be tested without mocks.",
    },
    RuleMeta {
        id: "T003",
        name: "giant-test",
        short_description: "Test function exceeds line count threshold",
        guidance: "A large test is hard to understand and maintain. Split it into smaller, focused tests -- each verifying one behavior. Use helper functions or parameterized tests to reduce repetition.",
    },
    RuleMeta {
        id: "T004",
        name: "no-parameterized",
        short_description: "Low ratio of parameterized tests",
        guidance: "Repeated tests with different inputs can be consolidated using parameterized/table-driven tests. This improves coverage while reducing code volume and making the test suite easier to extend.",
    },
    RuleMeta {
        id: "T005",
        name: "pbt-missing",
        short_description: "No property-based testing library imported",
        guidance: "Property-based testing (PBT) can find edge cases that example-based tests miss. Consider adding a PBT library (e.g., Hypothesis, fast-check, proptest) for functions with wide input domains.",
    },
    RuleMeta {
        id: "T006",
        name: "low-assertion-density",
        short_description: "Low assertion count per test function",
        guidance: "A test with few assertions may not fully verify the behavior under test. Ensure the test checks all relevant aspects of the output -- return values, state changes, and side effects.",
    },
    RuleMeta {
        id: "T007",
        name: "test-source-ratio",
        short_description: "Test file to source file ratio",
        guidance: "The test-to-source file ratio is outside the expected range. Consider whether test files are missing for some source modules, or whether test files are over-concentrated.",
    },
    RuleMeta {
        id: "T008",
        name: "no-contract",
        short_description: "No contract testing library used in tests",
        guidance: "Contract tests verify that API boundaries (HTTP, message queues, etc.) behave as agreed. Consider adding a contract testing library (e.g., Pact) if this project has service-to-service communication.",
    },
    RuleMeta {
        id: "T101",
        name: "how-not-what",
        short_description: "Test verifies implementation rather than behavior",
        guidance: "This test accesses private/internal members, coupling it to implementation details. Test the public interface instead -- assert on observable outputs rather than internal state.",
    },
    RuleMeta {
        id: "T102",
        name: "fixture-sprawl",
        short_description: "Test depends on too many fixtures",
        guidance: "This test depends on many fixtures, making it hard to understand what is actually being tested. Reduce fixture dependencies by inlining setup or using builder patterns.",
    },
    RuleMeta {
        id: "T103",
        name: "missing-error-test",
        short_description: "No error/exception test found in file",
        guidance: "No test verifies error/exception behavior in this file. Add tests for invalid inputs, boundary conditions, and expected failure modes.",
    },
    RuleMeta {
        id: "T105",
        name: "deterministic-no-metamorphic",
        short_description: "All assertions use exact equality, no relational checks",
        guidance: "All assertions use exact equality (==). Consider adding relational assertions (>, <, contains, matches) to express behavioral properties rather than specific outputs.",
    },
    RuleMeta {
        id: "T106",
        name: "duplicate-literal-assertion",
        short_description: "Same literal appears multiple times in assertions",
        guidance: "The same literal value appears in multiple assertions, creating a maintenance burden. Extract it into a named constant or verify the underlying relationship instead.",
    },
    RuleMeta {
        id: "T107",
        name: "assertion-roulette",
        short_description: "Multiple assertions without failure messages",
        guidance: "Multiple assertions without descriptive messages make failures hard to diagnose. Add a failure message to each assertion explaining what was expected and why.",
    },
    RuleMeta {
        id: "T108",
        name: "wait-and-see",
        short_description: "Test uses sleep/delay causing flaky tests",
        guidance: "Using sleep/delay in tests causes flakiness and slow execution. Use polling with timeouts, event-based synchronization, or dependency injection to control timing.",
    },
    RuleMeta {
        id: "T109",
        name: "undescriptive-test-name",
        short_description: "Test name does not describe behavior",
        guidance: "The test name does not describe the expected behavior. Rename it to follow the pattern: given_[context]_when_[action]_then_[outcome] or a similar descriptive convention.",
    },
    RuleMeta {
        id: "T110",
        name: "skip-only-test",
        short_description: "Test skips or marks incomplete without assertions",
        guidance: "This test is skipped or marked incomplete without assertions. Either implement the test or remove the skip marker. Dead test code erodes trust in the suite.",
    },
];

pub fn format_sarif(diagnostics: &[Diagnostic]) -> String {
    use serde_sarif::sarif;

    let rules: Vec<sarif::ReportingDescriptor> = RULE_REGISTRY
        .iter()
        .map(|r| {
            sarif::ReportingDescriptor::builder()
                .id(r.id)
                .name(r.name)
                .short_description(&String::from(r.short_description))
                .build()
        })
        .collect();

    let results: Vec<sarif::Result> = diagnostics
        .iter()
        .map(|d| {
            let level = match d.severity {
                Severity::Block => sarif::ResultLevel::Error,
                Severity::Warn => sarif::ResultLevel::Warning,
                Severity::Info => sarif::ResultLevel::Note,
            };
            let start_line = d.line.unwrap_or(1) as i64;
            let location = sarif::Location::builder()
                .physical_location(
                    sarif::PhysicalLocation::builder()
                        .artifact_location(sarif::ArtifactLocation::builder().uri(&d.file).build())
                        .region(sarif::Region::builder().start_line(start_line).build())
                        .build(),
                )
                .build();

            sarif::Result::builder()
                .rule_id(&d.rule.0)
                .message(sarif::Message::builder().text(&d.message).build())
                .level(level)
                .locations(vec![location])
                .build()
        })
        .collect();

    let tool_component = sarif::ToolComponent::builder()
        .name("exspec")
        .version(env!("CARGO_PKG_VERSION"))
        .rules(rules)
        .build();

    let invocation = sarif::Invocation::builder()
        .execution_successful(true)
        .build();

    let run = sarif::Run::builder()
        .tool(tool_component)
        .results(results)
        .invocations(vec![invocation])
        .build();

    let sarif_doc = sarif::Sarif::builder()
        .version(sarif::Version::V2_1_0.to_string())
        .schema(sarif::SCHEMA_URL)
        .runs(vec![run])
        .build();

    serde_json::to_string_pretty(&sarif_doc).unwrap_or_else(|_| "{}".to_string())
}

pub fn format_ai_prompt(
    diagnostics: &[Diagnostic],
    file_count: usize,
    function_count: usize,
    metrics: &ProjectMetrics,
    hints: &[Hint],
) -> String {
    let _ = (file_count, metrics, hints);

    let block_count = diagnostics
        .iter()
        .filter(|d| d.severity == Severity::Block)
        .count();
    let warn_count = diagnostics
        .iter()
        .filter(|d| d.severity == Severity::Warn)
        .count();
    let info_count = diagnostics
        .iter()
        .filter(|d| d.severity == Severity::Info)
        .count();
    let violated = count_violated_functions(diagnostics);
    let pass_count = function_count.saturating_sub(violated);

    let mut lines = Vec::new();
    lines.push("# exspec -- Test Quality Report".to_string());
    lines.push(String::new());

    // BLOCK section
    let block_diags: Vec<&Diagnostic> = diagnostics
        .iter()
        .filter(|d| d.severity == Severity::Block)
        .collect();
    if !block_diags.is_empty() {
        lines.push("## BLOCK (must fix)".to_string());
        lines.push(String::new());
        for d in block_diags {
            let line_str = d.line.map(|l| format!(":{l}")).unwrap_or_default();
            lines.push(format!("### {}{}", d.file, line_str));
            lines.push(String::new());
            lines.push(format!("**{}**: {}", d.rule, d.message));
            lines.push(String::new());
            if let Some(meta) = RULE_REGISTRY.iter().find(|m| m.id == d.rule.0) {
                for guidance_line in meta.guidance.lines() {
                    lines.push(format!("> {guidance_line}"));
                }
                lines.push(String::new());
            }
        }
    }

    // WARN section
    let warn_diags: Vec<&Diagnostic> = diagnostics
        .iter()
        .filter(|d| d.severity == Severity::Warn)
        .collect();
    if !warn_diags.is_empty() {
        lines.push("## WARN (should fix)".to_string());
        lines.push(String::new());
        for d in warn_diags {
            let line_str = d.line.map(|l| format!(":{l}")).unwrap_or_default();
            lines.push(format!("### {}{}", d.file, line_str));
            lines.push(String::new());
            lines.push(format!("**{}**: {}", d.rule, d.message));
            lines.push(String::new());
            if let Some(meta) = RULE_REGISTRY.iter().find(|m| m.id == d.rule.0) {
                for guidance_line in meta.guidance.lines() {
                    lines.push(format!("> {guidance_line}"));
                }
                lines.push(String::new());
            }
        }
    }

    // INFO section
    let info_diags: Vec<&Diagnostic> = diagnostics
        .iter()
        .filter(|d| d.severity == Severity::Info)
        .collect();
    if !info_diags.is_empty() {
        lines.push("## INFO (consider)".to_string());
        lines.push(String::new());
        for d in info_diags {
            let line_str = d.line.map(|l| format!(":{l}")).unwrap_or_default();
            lines.push(format!(
                "- {}{} {}: {}",
                d.file, line_str, d.rule, d.message
            ));
        }
        lines.push(String::new());
    }

    lines.push(format!(
        "Score: BLOCK {block_count} | WARN {warn_count} | INFO {info_count} | PASS {pass_count}",
    ));

    lines.join("\n")
}

/// Filter diagnostics to only include those at or above the given minimum severity.
pub fn filter_by_severity(diagnostics: &[Diagnostic], min: Severity) -> Vec<Diagnostic> {
    diagnostics
        .iter()
        .filter(|d| d.severity >= min)
        .cloned()
        .collect()
}

/// Summary statistics from unfiltered diagnostics, for JSON/SARIF output.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SummaryStats {
    pub block_count: usize,
    pub warn_count: usize,
    pub info_count: usize,
    pub pass_count: usize,
}

impl SummaryStats {
    pub fn from_diagnostics(diagnostics: &[Diagnostic], function_count: usize) -> Self {
        let block_count = diagnostics
            .iter()
            .filter(|d| d.severity == Severity::Block)
            .count();
        let warn_count = diagnostics
            .iter()
            .filter(|d| d.severity == Severity::Warn)
            .count();
        let info_count = diagnostics
            .iter()
            .filter(|d| d.severity == Severity::Info)
            .count();
        let violated = count_violated_functions(diagnostics);
        let pass_count = function_count.saturating_sub(violated);
        Self {
            block_count,
            warn_count,
            info_count,
            pass_count,
        }
    }
}

pub fn compute_exit_code(diagnostics: &[Diagnostic], strict: bool) -> i32 {
    for d in diagnostics {
        if d.severity == Severity::Block {
            return 1;
        }
    }
    if strict {
        for d in diagnostics {
            if d.severity == Severity::Warn {
                return 1;
            }
        }
    }
    0
}

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

    fn block_diag() -> Diagnostic {
        Diagnostic {
            rule: RuleId::new("T001"),
            severity: Severity::Block,
            file: "test.py".to_string(),
            line: Some(10),
            message: "assertion-free: test has no assertions".to_string(),
            details: None,
        }
    }

    fn warn_diag() -> Diagnostic {
        Diagnostic {
            rule: RuleId::new("T003"),
            severity: Severity::Warn,
            file: "test.py".to_string(),
            line: Some(5),
            message: "giant-test: 73 lines, threshold: 50".to_string(),
            details: None,
        }
    }

    // --- Terminal format ---

    #[test]
    fn terminal_format_has_summary_header() {
        let output = format_terminal(&[block_diag()], 1, 1, &ProjectMetrics::default(), &[]);
        assert!(output.starts_with("exspec v"));
        assert!(output.contains("1 test files"));
        assert!(output.contains("1 test functions"));
    }

    #[test]
    fn terminal_format_has_score_footer() {
        let output = format_terminal(&[block_diag()], 1, 1, &ProjectMetrics::default(), &[]);
        assert!(output.contains("Score: BLOCK 1 | WARN 0 | INFO 0 | PASS 0"));
    }

    #[test]
    fn terminal_format_block() {
        let output = format_terminal(&[block_diag()], 1, 1, &ProjectMetrics::default(), &[]);
        assert!(output.contains("BLOCK test.py:10 T001 assertion-free: test has no assertions"));
    }

    #[test]
    fn terminal_format_warn() {
        let output = format_terminal(&[warn_diag()], 1, 1, &ProjectMetrics::default(), &[]);
        assert!(output.contains("WARN test.py:5 T003 giant-test: 73 lines, threshold: 50"));
    }

    #[test]
    fn terminal_format_multiple() {
        let output = format_terminal(
            &[block_diag(), warn_diag()],
            2,
            2,
            &ProjectMetrics::default(),
            &[],
        );
        assert!(output.contains("BLOCK"));
        assert!(output.contains("WARN"));
    }

    #[test]
    fn terminal_format_empty_has_header_and_footer() {
        let output = format_terminal(&[], 0, 0, &ProjectMetrics::default(), &[]);
        assert!(output.contains("exspec v"));
        assert!(output.contains("Score:"));
    }

    // --- JSON format ---

    #[test]
    fn json_format_has_version_and_summary() {
        let output = format_json(&[block_diag()], 1, 1, &ProjectMetrics::default(), None, &[]);
        let parsed: serde_json::Value = serde_json::from_str(&output).unwrap();
        assert!(parsed["version"].is_string());
        assert!(parsed["summary"].is_object());
        assert_eq!(parsed["summary"]["files"], 1);
        assert_eq!(parsed["summary"]["functions"], 1);
        assert_eq!(parsed["summary"]["block"], 1);
        assert_eq!(parsed["summary"]["warn"], 0);
        assert_eq!(parsed["summary"]["pass"], 0);
    }

    #[test]
    fn json_format_has_diagnostics_and_metrics() {
        let output = format_json(&[block_diag()], 1, 1, &ProjectMetrics::default(), None, &[]);
        let parsed: serde_json::Value = serde_json::from_str(&output).unwrap();
        assert!(parsed["diagnostics"].is_array());
        assert!(parsed["metrics"].is_object());
        assert_eq!(parsed["diagnostics"].as_array().unwrap().len(), 1);
    }

    #[test]
    fn json_format_empty() {
        let output = format_json(&[], 0, 0, &ProjectMetrics::default(), None, &[]);
        let parsed: serde_json::Value = serde_json::from_str(&output).unwrap();
        assert_eq!(parsed["diagnostics"].as_array().unwrap().len(), 0);
        assert_eq!(parsed["summary"]["functions"], 0);
    }

    // --- Exit code ---

    // --- Empty result UX ---

    #[test]
    fn terminal_format_zero_files_shows_guidance() {
        let output = format_terminal(&[], 0, 0, &ProjectMetrics::default(), &[]);
        assert!(
            output.contains("No test files found"),
            "expected guidance message, got: {output}"
        );
    }

    #[test]
    fn json_format_zero_files_has_guidance() {
        let output = format_json(&[], 0, 0, &ProjectMetrics::default(), None, &[]);
        let parsed: serde_json::Value = serde_json::from_str(&output).unwrap();
        assert!(parsed["guidance"].is_string());
    }

    // --- pass_count multi-violation ---

    #[test]
    fn pass_count_with_multi_violation_function() {
        let d1 = Diagnostic {
            rule: RuleId::new("T001"),
            severity: Severity::Block,
            file: "test.py".to_string(),
            line: Some(10),
            message: "assertion-free".to_string(),
            details: None,
        };
        let d2 = Diagnostic {
            rule: RuleId::new("T003"),
            severity: Severity::Warn,
            file: "test.py".to_string(),
            line: Some(10),
            message: "giant-test".to_string(),
            details: None,
        };
        let output = format_terminal(&[d1, d2], 1, 2, &ProjectMetrics::default(), &[]);
        assert!(output.contains("PASS 1"), "expected PASS 1, got: {output}");
    }

    #[test]
    fn pass_count_excludes_file_level_diagnostics() {
        let d1 = Diagnostic {
            rule: RuleId::new("T004"),
            severity: Severity::Info,
            file: "test.py".to_string(),
            line: None,
            message: "no-parameterized".to_string(),
            details: None,
        };
        let output = format_terminal(&[d1], 1, 1, &ProjectMetrics::default(), &[]);
        assert!(output.contains("PASS 1"), "expected PASS 1, got: {output}");
    }

    #[test]
    fn terminal_format_nonzero_files_no_guidance() {
        let output = format_terminal(&[], 1, 0, &ProjectMetrics::default(), &[]);
        assert!(!output.contains("No test files found"));
    }

    #[test]
    fn exit_code_block_returns_1() {
        assert_eq!(compute_exit_code(&[block_diag()], false), 1);
    }

    #[test]
    fn exit_code_warn_only_returns_0() {
        assert_eq!(compute_exit_code(&[warn_diag()], false), 0);
    }

    #[test]
    fn exit_code_strict_warn_returns_1() {
        assert_eq!(compute_exit_code(&[warn_diag()], true), 1);
    }

    #[test]
    fn exit_code_empty_returns_0() {
        assert_eq!(compute_exit_code(&[], false), 0);
    }

    // --- Metrics display ---

    #[test]
    fn terminal_metrics_section_between_diagnostics_and_score() {
        let metrics = ProjectMetrics {
            mock_density_avg: 2.3,
            mock_class_max: 4,
            parameterized_ratio: 0.15,
            pbt_ratio: 0.4,
            assertion_density_avg: 1.8,
            contract_coverage: 0.2,
            ..Default::default()
        };
        let output = format_terminal(&[block_diag()], 5, 187, &metrics, &[]);
        let metrics_pos = output.find("Metrics:").expect("Metrics section missing");
        let diag_pos = output.find("BLOCK test.py").expect("diagnostic missing");
        let score_pos = output.find("Score:").expect("Score missing");
        assert!(
            diag_pos < metrics_pos,
            "Metrics should come after diagnostics"
        );
        assert!(metrics_pos < score_pos, "Metrics should come before Score");
    }

    #[test]
    fn terminal_metrics_mock_density_line() {
        let metrics = ProjectMetrics {
            mock_density_avg: 2.3,
            mock_class_max: 4,
            ..Default::default()
        };
        let output = format_terminal(&[], 1, 1, &metrics, &[]);
        assert!(
            output.contains("2.3/test (avg)"),
            "mock density avg: {output}"
        );
        assert!(
            output.contains("4 distinct classes/test (max)"),
            "mock class max: {output}"
        );
    }

    #[test]
    fn terminal_metrics_parameterized_line() {
        let metrics = ProjectMetrics {
            parameterized_ratio: 0.15,
            ..Default::default()
        };
        let output = format_terminal(&[], 5, 20, &metrics, &[]);
        assert!(output.contains("15%"), "parameterized pct: {output}");
        assert!(output.contains("3/20"), "parameterized fraction: {output}");
    }

    #[test]
    fn terminal_metrics_pbt_and_contract_file_count() {
        let metrics = ProjectMetrics {
            pbt_ratio: 0.4,
            contract_coverage: 0.2,
            ..Default::default()
        };
        let output = format_terminal(&[], 5, 1, &metrics, &[]);
        assert!(output.contains("2/5 files"), "pbt files: {output}");
        assert!(output.contains("1/5 files"), "contract files: {output}");
    }

    #[test]
    fn json_metrics_has_all_fields() {
        let metrics = ProjectMetrics {
            mock_density_avg: 1.5,
            mock_class_max: 2,
            parameterized_ratio: 0.3,
            pbt_ratio: 0.5,
            assertion_density_avg: 2.0,
            contract_coverage: 0.1,
            test_source_ratio: 0.8,
        };
        let output = format_json(&[], 1, 1, &metrics, None, &[]);
        let parsed: serde_json::Value = serde_json::from_str(&output).unwrap();
        let m = &parsed["metrics"];
        assert_eq!(m["mock_density_avg"], 1.5);
        assert_eq!(m["mock_class_max"], 2);
        assert_eq!(m["parameterized_ratio"], 0.3);
        assert_eq!(m["pbt_ratio"], 0.5);
        assert_eq!(m["assertion_density_avg"], 2.0);
        assert_eq!(m["contract_coverage"], 0.1);
        assert_eq!(m["test_source_ratio"], 0.8);
    }

    #[test]
    fn json_metrics_values_are_numbers() {
        let metrics = ProjectMetrics {
            mock_density_avg: 1.0,
            mock_class_max: 3,
            ..Default::default()
        };
        let output = format_json(&[], 1, 1, &metrics, None, &[]);
        let parsed: serde_json::Value = serde_json::from_str(&output).unwrap();
        assert!(parsed["metrics"]["mock_density_avg"].is_number());
        assert!(parsed["metrics"]["mock_class_max"].is_number());
    }

    // --- SARIF format ---

    fn info_diag() -> Diagnostic {
        Diagnostic {
            rule: RuleId::new("T005"),
            severity: Severity::Info,
            file: "test.py".to_string(),
            line: None,
            message: "pbt-missing".to_string(),
            details: None,
        }
    }

    fn parse_sarif(output: &str) -> serde_json::Value {
        serde_json::from_str(output).expect("SARIF should be valid JSON")
    }

    #[test]
    fn sarif_valid_json() {
        let output = format_sarif(&[block_diag()]);
        parse_sarif(&output);
    }

    #[test]
    fn sarif_has_schema_url() {
        let output = format_sarif(&[]);
        let parsed = parse_sarif(&output);
        assert!(parsed["$schema"].is_string());
        assert!(parsed["$schema"].as_str().unwrap().contains("sarif"));
    }

    #[test]
    fn sarif_version_2_1_0() {
        let output = format_sarif(&[]);
        let parsed = parse_sarif(&output);
        assert_eq!(parsed["version"], "2.1.0");
    }

    #[test]
    fn sarif_tool_driver_name() {
        let output = format_sarif(&[]);
        let parsed = parse_sarif(&output);
        assert_eq!(parsed["runs"][0]["tool"]["driver"]["name"], "exspec");
    }

    #[test]
    fn sarif_tool_driver_version() {
        let output = format_sarif(&[]);
        let parsed = parse_sarif(&output);
        assert_eq!(
            parsed["runs"][0]["tool"]["driver"]["version"],
            env!("CARGO_PKG_VERSION")
        );
    }

    #[test]
    fn sarif_rules_match_registry_count() {
        let output = format_sarif(&[]);
        let parsed = parse_sarif(&output);
        let rules = parsed["runs"][0]["tool"]["driver"]["rules"]
            .as_array()
            .unwrap();
        assert_eq!(rules.len(), RULE_REGISTRY.len());
    }

    #[test]
    fn sarif_rules_have_short_description() {
        let output = format_sarif(&[]);
        let parsed = parse_sarif(&output);
        let rule0 = &parsed["runs"][0]["tool"]["driver"]["rules"][0];
        assert!(rule0["shortDescription"].is_object());
        assert!(rule0["shortDescription"]["text"].is_string());
    }

    #[test]
    fn sarif_rules_include_all_registry_entries() {
        let output = format_sarif(&[]);
        let parsed = parse_sarif(&output);
        let rules = parsed["runs"][0]["tool"]["driver"]["rules"]
            .as_array()
            .unwrap();
        for meta in RULE_REGISTRY {
            assert!(
                rules.iter().any(|rule| rule["id"] == meta.id),
                "SARIF rules array should include {} metadata",
                meta.id
            );
        }
    }

    #[test]
    fn sarif_block_maps_to_error() {
        let output = format_sarif(&[block_diag()]);
        let parsed = parse_sarif(&output);
        assert_eq!(parsed["runs"][0]["results"][0]["level"], "error");
    }

    #[test]
    fn sarif_warn_maps_to_warning() {
        let output = format_sarif(&[warn_diag()]);
        let parsed = parse_sarif(&output);
        assert_eq!(parsed["runs"][0]["results"][0]["level"], "warning");
    }

    #[test]
    fn sarif_info_maps_to_note() {
        let output = format_sarif(&[info_diag()]);
        let parsed = parse_sarif(&output);
        assert_eq!(parsed["runs"][0]["results"][0]["level"], "note");
    }

    #[test]
    fn sarif_file_level_diag_start_line_1() {
        let output = format_sarif(&[info_diag()]);
        let parsed = parse_sarif(&output);
        let region = &parsed["runs"][0]["results"][0]["locations"][0]["physicalLocation"]["region"];
        assert_eq!(region["startLine"], 1);
    }

    #[test]
    fn sarif_result_has_location_and_uri() {
        let output = format_sarif(&[block_diag()]);
        let parsed = parse_sarif(&output);
        let loc = &parsed["runs"][0]["results"][0]["locations"][0]["physicalLocation"];
        assert_eq!(loc["artifactLocation"]["uri"], "test.py");
        assert_eq!(loc["region"]["startLine"], 10);
    }

    #[test]
    fn sarif_empty_diagnostics_empty_results() {
        let output = format_sarif(&[]);
        let parsed = parse_sarif(&output);
        let results = parsed["runs"][0]["results"].as_array().unwrap();
        assert!(results.is_empty());
        let rules = parsed["runs"][0]["tool"]["driver"]["rules"]
            .as_array()
            .unwrap();
        assert_eq!(rules.len(), RULE_REGISTRY.len());
    }

    // --- #59: filter_by_severity ---

    #[test]
    fn filter_by_severity_block_keeps_only_block() {
        let diags = vec![block_diag(), warn_diag(), info_diag()];
        let filtered = filter_by_severity(&diags, Severity::Block);
        assert_eq!(filtered.len(), 1);
        assert_eq!(filtered[0].severity, Severity::Block);
    }

    #[test]
    fn filter_by_severity_warn_keeps_block_and_warn() {
        let diags = vec![block_diag(), warn_diag(), info_diag()];
        let filtered = filter_by_severity(&diags, Severity::Warn);
        assert_eq!(filtered.len(), 2);
    }

    #[test]
    fn filter_by_severity_info_keeps_all() {
        let diags = vec![block_diag(), warn_diag(), info_diag()];
        let filtered = filter_by_severity(&diags, Severity::Info);
        assert_eq!(filtered.len(), 3);
    }

    #[test]
    fn filter_by_severity_empty_input() {
        let filtered = filter_by_severity(&[], Severity::Block);
        assert!(filtered.is_empty());
    }

    // --- #59: SummaryStats ---

    #[test]
    fn summary_stats_from_diagnostics() {
        let diags = vec![block_diag(), warn_diag(), info_diag()];
        let stats = SummaryStats::from_diagnostics(&diags, 5);
        assert_eq!(stats.block_count, 1);
        assert_eq!(stats.warn_count, 1);
        assert_eq!(stats.info_count, 1);
        // 3 distinct (file,line) violated out of 5 → pass=3 except info_diag has line=None
        // block_diag line=10, warn_diag line=5, info_diag line=None → 2 violated → pass=3
        assert_eq!(stats.pass_count, 3);
    }

    // --- #59: Terminal filtered score ---

    #[test]
    fn terminal_format_filtered_shows_filtered_counts() {
        let filtered = vec![block_diag()]; // original had block+warn+info but filtered to block only
        let output = format_terminal(&filtered, 1, 3, &ProjectMetrics::default(), &[]);
        assert!(
            output.contains("BLOCK 1 | WARN 0 | INFO 0"),
            "score should reflect filtered diagnostics: {output}"
        );
        assert!(!output.contains("WARN test.py"));
    }

    // --- #59: JSON filtered array + unfiltered summary ---

    #[test]
    fn json_filtered_diagnostics_with_unfiltered_summary() {
        let filtered = vec![block_diag()];
        let stats = SummaryStats {
            block_count: 1,
            warn_count: 1,
            info_count: 1,
            pass_count: 2,
        };
        let output = format_json(
            &filtered,
            1,
            5,
            &ProjectMetrics::default(),
            Some(&stats),
            &[],
        );
        let parsed: serde_json::Value = serde_json::from_str(&output).unwrap();
        assert_eq!(
            parsed["diagnostics"].as_array().unwrap().len(),
            1,
            "diagnostics should be filtered"
        );
        assert_eq!(parsed["summary"]["warn"], 1, "summary should be unfiltered");
        assert_eq!(parsed["summary"]["info"], 1, "summary should be unfiltered");
    }

    #[test]
    fn sarif_invocations_execution_successful() {
        let output = format_sarif(&[]);
        let parsed = parse_sarif(&output);
        assert_eq!(
            parsed["runs"][0]["invocations"][0]["executionSuccessful"],
            true
        );
    }

    // --- AI-FMT-01: BLOCK diagnostic with guidance ---

    #[test]
    fn ai_prompt_block_has_section_and_guidance() {
        // Given: T001 (assertion-free) の BLOCK diagnostic 1件
        let diag = block_diag();
        // When: format_ai_prompt() を呼ぶ
        let output = format_ai_prompt(&[diag], 1, 1, &ProjectMetrics::default(), &[]);
        // Then: "## BLOCK" セクション、file:line + rule + message、guidance (blockquote `>`) が含まれる
        assert!(
            output.contains("## BLOCK"),
            "should contain BLOCK section: {output}"
        );
        assert!(
            output.contains("test.py:10"),
            "should contain file:line: {output}"
        );
        assert!(output.contains("T001"), "should contain rule id: {output}");
        assert!(
            output.contains("assertion-free"),
            "should contain rule name in message: {output}"
        );
        let has_blockquote = output.lines().any(|l| l.starts_with('>'));
        assert!(
            has_blockquote,
            "should contain guidance blockquote: {output}"
        );
    }

    // --- AI-FMT-02: WARN diagnostic with guidance ---

    #[test]
    fn ai_prompt_warn_has_section_and_guidance() {
        // Given: T003 (giant-test) の WARN diagnostic 1件
        let diag = warn_diag();
        // When: format_ai_prompt() を呼ぶ
        let output = format_ai_prompt(&[diag], 1, 1, &ProjectMetrics::default(), &[]);
        // Then: "## WARN" セクション、diagnostic、guidance が含まれる
        assert!(
            output.contains("## WARN"),
            "should contain WARN section: {output}"
        );
        assert!(
            output.contains("test.py:5"),
            "should contain file:line: {output}"
        );
        assert!(output.contains("T003"), "should contain rule id: {output}");
        let has_blockquote = output.lines().any(|l| l.starts_with('>'));
        assert!(
            has_blockquote,
            "should contain guidance blockquote: {output}"
        );
    }

    // --- AI-FMT-03: INFO diagnostic without guidance ---

    #[test]
    fn ai_prompt_info_has_section_no_guidance() {
        // Given: T005 (pbt-missing) の INFO diagnostic 1件
        let diag = info_diag();
        // When: format_ai_prompt() を呼ぶ
        let output = format_ai_prompt(&[diag], 1, 1, &ProjectMetrics::default(), &[]);
        // Then: "## INFO" セクション、`- ` で始まる1行表示、blockquote (`>`) なし
        assert!(
            output.contains("## INFO"),
            "should contain INFO section: {output}"
        );
        let has_bullet = output.lines().any(|l| l.starts_with("- "));
        assert!(
            has_bullet,
            "INFO items should use bullet `- ` format: {output}"
        );
        let has_blockquote = output.lines().any(|l| l.starts_with('>'));
        assert!(
            !has_blockquote,
            "INFO should NOT contain guidance blockquote: {output}"
        );
    }

    // --- AI-FMT-04: Mixed severities grouped correctly ---

    #[test]
    fn ai_prompt_mixed_severities_ordered_block_warn_info() {
        // Given: BLOCK + WARN + INFO の3件
        let diags = [block_diag(), warn_diag(), info_diag()];
        // When: format_ai_prompt() を呼ぶ
        let output = format_ai_prompt(&diags, 1, 3, &ProjectMetrics::default(), &[]);
        // Then: "## BLOCK" < "## WARN" < "## INFO" の順序
        let block_pos = output.find("## BLOCK").expect("## BLOCK not found");
        let warn_pos = output.find("## WARN").expect("## WARN not found");
        let info_pos = output.find("## INFO").expect("## INFO not found");
        assert!(
            block_pos < warn_pos,
            "## BLOCK should appear before ## WARN"
        );
        assert!(warn_pos < info_pos, "## WARN should appear before ## INFO");
    }

    // --- AI-FMT-05: Empty diagnostics ---

    #[test]
    fn ai_prompt_empty_has_header_and_score_no_sections() {
        // Given: 空の diagnostics
        // When: format_ai_prompt() を呼ぶ
        let output = format_ai_prompt(&[], 0, 0, &ProjectMetrics::default(), &[]);
        // Then: "# exspec" ヘッダーと "Score:" 行が含まれ、"## BLOCK/WARN/INFO" は含まれない
        assert!(
            output.contains("# exspec"),
            "should contain # exspec header: {output}"
        );
        assert!(
            output.contains("Score:"),
            "should contain Score: line: {output}"
        );
        assert!(
            !output.contains("## BLOCK"),
            "empty result should not contain ## BLOCK: {output}"
        );
        assert!(
            !output.contains("## WARN"),
            "empty result should not contain ## WARN: {output}"
        );
        assert!(
            !output.contains("## INFO"),
            "empty result should not contain ## INFO: {output}"
        );
    }

    // --- AI-FMT-06: All rules have non-empty guidance ---

    #[test]
    fn all_rules_have_non_empty_guidance() {
        // Given: RULE_REGISTRY の全エントリ
        // When: 各 guidance を検査
        // Then: 全て空文字列でない
        for meta in RULE_REGISTRY {
            assert!(
                !meta.guidance.is_empty(),
                "rule {} ({}) should have non-empty guidance",
                meta.id,
                meta.name
            );
        }
    }

    // --- AI-FMT-08: Score line present ---

    #[test]
    fn ai_prompt_score_line_reflects_counts() {
        // Given: BLOCK 1件 + WARN 1件 の diagnostics
        let diags = [block_diag(), warn_diag()];
        // When: format_ai_prompt() を呼ぶ
        let output = format_ai_prompt(&diags, 1, 2, &ProjectMetrics::default(), &[]);
        // Then: "Score: BLOCK 1 | WARN 1" を含む行が存在
        assert!(
            output.contains("Score: BLOCK 1 | WARN 1"),
            "should contain score summary: {output}"
        );
    }
}