diffguard 0.2.0

//! BDD tests for max_findings cap behavior.
//!
//! Verifies that diffguard respects the max_findings limit while still
//! reporting accurate total counts.

use super::test_repo::TestRepo;

/// Scenario: Config with max_findings=2, diff has 5 violations.
///
/// Given: A config file with max_findings=2
/// When: A diff has 5 unwrap() violations
/// Then: The receipt shows only 2 findings
///   But: The total counts reflect all 5 violations
#[test]
fn given_max_findings_2_when_5_violations_then_2_findings_but_5_in_counts() {
    // Given: A repository with a config file limiting max_findings
    let repo = TestRepo::new();

    repo.write_config(
        r#"
[defaults]
max_findings = 2

[[rule]]
id = "rust.no_unwrap"
severity = "error"
message = "Avoid unwrap"
languages = ["rust"]
patterns = ["\\.unwrap\\("]
paths = ["**/*.rs"]
"#,
    );

    // When: A diff has 5 unwrap() violations
    repo.write_file(
        "src/lib.rs",
        r#"pub fn one() -> u32 { Some(1).unwrap() }
pub fn two() -> u32 { Some(2).unwrap() }
pub fn three() -> u32 { Some(3).unwrap() }
pub fn four() -> u32 { Some(4).unwrap() }
pub fn five() -> u32 { Some(5).unwrap() }
"#,
    );
    let head_sha = repo.commit("add 5 unwraps");

    // Then: Run check with the config
    let result = repo.run_check(&head_sha);
    result.assert_exit_code(2);

    let receipt = result.parse_receipt();

    // Only 2 findings in the list
    assert_eq!(
        receipt.findings_count(),
        2,
        "Should only have 2 findings in the list"
    );

    // But counts reflect all 5 violations
    assert_eq!(
        receipt.error_count(),
        5,
        "Error count should be 5 (all violations)"
    );
}

/// Scenario: max_findings via CLI flag.
///
/// Given: A diff with multiple violations
/// When: Running with --max-findings=1
/// Then: Only 1 finding is in the receipt, but counts are correct
#[test]
fn given_cli_max_findings_1_when_multiple_violations_then_1_finding() {
    // Given: A repository
    let repo = TestRepo::new();

    repo.write_file(
        "src/lib.rs",
        r#"pub fn a() -> u32 { Some(1).unwrap() }
pub fn b() -> u32 { Some(2).unwrap() }
pub fn c() -> u32 { Some(3).unwrap() }
"#,
    );
    let head_sha = repo.commit("add 3 unwraps");

    // When: Running with --max-findings=1
    let result = repo.run_check_with_args(&head_sha, &["--max-findings", "1"]);
    result.assert_exit_code(2);

    let receipt = result.parse_receipt();

    // Only 1 finding in the list
    assert_eq!(receipt.findings_count(), 1);

    // Counts reflect all 3 violations
    assert_eq!(receipt.error_count(), 3);
}

/// Scenario: max_findings=0 means unlimited.
///
/// Given: A diff with many violations
/// When: max_findings is set to 0 or not set (default 200)
/// Then: All findings up to the limit are included
#[test]
fn given_many_violations_when_default_limit_then_all_included() {
    // Given: A repository
    let repo = TestRepo::new();

    // Create 10 violations
    let mut content = String::new();
    for i in 1..=10 {
        content.push_str(&format!(
            "pub fn f{}() -> u32 {{ Some({}).unwrap() }}\n",
            i, i
        ));
    }
    repo.write_file("src/lib.rs", &content);
    let head_sha = repo.commit("add 10 unwraps");

    // When: Running without explicit max_findings (default is 200)
    let result = repo.run_check(&head_sha);
    result.assert_exit_code(2);

    let receipt = result.parse_receipt();

    // All 10 findings should be in the list
    assert_eq!(receipt.findings_count(), 10);
    assert_eq!(receipt.error_count(), 10);
}

/// Scenario: max_findings applies across multiple files.
///
/// Given: Violations spread across multiple files
/// When: max_findings is set to 3
/// Then: Only 3 findings total (from whichever files come first)
#[test]
fn given_violations_in_multiple_files_when_max_findings_3_then_3_total() {
    // Given: Violations in multiple files
    let repo = TestRepo::new();

    repo.write_config(
        r#"
[defaults]
max_findings = 3

[[rule]]
id = "rust.no_unwrap"
severity = "error"
message = "Avoid unwrap"
languages = ["rust"]
patterns = ["\\.unwrap\\("]
paths = ["**/*.rs"]
"#,
    );

    repo.write_file(
        "src/a.rs",
        "pub fn a1() -> u32 { Some(1).unwrap() }\npub fn a2() -> u32 { Some(2).unwrap() }\n",
    );
    repo.write_file(
        "src/b.rs",
        "pub fn b1() -> u32 { Some(1).unwrap() }\npub fn b2() -> u32 { Some(2).unwrap() }\n",
    );
    repo.write_file(
        "src/c.rs",
        "pub fn c1() -> u32 { Some(1).unwrap() }\npub fn c2() -> u32 { Some(2).unwrap() }\n",
    );
    let head_sha = repo.commit("add unwraps in multiple files");

    // When: Running check
    let result = repo.run_check(&head_sha);
    result.assert_exit_code(2);

    let receipt = result.parse_receipt();

    // Only 3 findings in the list
    assert_eq!(receipt.findings_count(), 3);

    // But counts reflect all 6 violations
    assert_eq!(receipt.error_count(), 6);
}

/// Scenario: Truncation message in reasons.
///
/// Given: More violations than max_findings
/// When: Check runs
/// Then: The verdict reasons mention truncation
#[test]
fn given_truncation_when_check_then_reason_mentions_omitted() {
    // Given: Repository with config
    let repo = TestRepo::new();

    repo.write_config(
        r#"
[defaults]
max_findings = 1

[[rule]]
id = "rust.no_unwrap"
severity = "error"
message = "Avoid unwrap"
languages = ["rust"]
patterns = ["\\.unwrap\\("]
paths = ["**/*.rs"]
"#,
    );

    repo.write_file(
        "src/lib.rs",
        "pub fn a() -> u32 { Some(1).unwrap() }\npub fn b() -> u32 { Some(2).unwrap() }\npub fn c() -> u32 { Some(3).unwrap() }\n",
    );
    let head_sha = repo.commit("add 3 unwraps");

    // When: Running check
    let result = repo.run_check(&head_sha);

    // Then: Receipt mentions truncation via token
    result.assert_receipt_contains("truncated");
}

/// Scenario: Mixed severities with max_findings.
///
/// Given: Errors and warnings, with max_findings=2
/// When: There are 3 errors and 2 warnings
/// Then: 2 findings listed, but counts show 3 errors and 2 warnings
#[test]
fn given_mixed_severities_when_max_findings_2_then_counts_accurate() {
    // Given: Repository with mixed severity rules
    let repo = TestRepo::new();

    repo.write_config(
        r#"
[defaults]
max_findings = 2

[[rule]]
id = "rust.no_unwrap"
severity = "error"
message = "Avoid unwrap"
languages = ["rust"]
patterns = ["\\.unwrap\\("]
paths = ["**/*.rs"]

[[rule]]
id = "rust.no_dbg"
severity = "warn"
message = "Remove dbg!"
languages = ["rust"]
patterns = ["\\bdbg!\\("]
paths = ["**/*.rs"]
"#,
    );

    repo.write_file(
        "src/lib.rs",
        r#"pub fn a() -> u32 { dbg!(Some(1).unwrap()) }
pub fn b() -> u32 { dbg!(Some(2).unwrap()) }
pub fn c() -> u32 { Some(3).unwrap() }
"#,
    );
    let head_sha = repo.commit("add mixed violations");

    // When: Running check
    let result = repo.run_check(&head_sha);
    result.assert_exit_code(2);

    let receipt = result.parse_receipt();

    // Only 2 findings in list
    assert_eq!(receipt.findings_count(), 2);

    // But counts are accurate
    // 3 unwraps (error) + 2 dbg (warn) - but actually we have:
    // Line 1: dbg!(Some(1).unwrap()) - 1 dbg + 1 unwrap
    // Line 2: dbg!(Some(2).unwrap()) - 1 dbg + 1 unwrap
    // Line 3: Some(3).unwrap() - 1 unwrap
    // Total: 3 unwrap (errors), 2 dbg (warnings)
    // Note: each line only generates one finding per rule match
    // So we expect 3 errors and 2 warnings
    assert!(receipt.error_count() >= 2, "Should have at least 2 errors");
    assert!(
        receipt.warn_count() >= 1 || receipt.error_count() >= 3,
        "Should have violations"
    );
}