validate_files_test.rs

use assert_cmd::prelude::*;
use predicates::prelude::*;
use std::{error::Error, process::Command};

mod common;

use common::*;

#[test]
fn test_validate_with_owned_files() -> Result<(), Box<dyn Error>> {
    run_codeowners(
        "valid_project",
        &["validate", "ruby/app/models/payroll.rb", "ruby/app/models/bank_account.rb"],
        true,
        OutputStream::Stdout,
        predicate::eq(""),
    )?;

    Ok(())
}

#[test]
fn test_validate_with_unowned_file() -> Result<(), Box<dyn Error>> {
    run_codeowners(
        "valid_project",
        &["validate", "ruby/app/unowned.rb"],
        false,
        OutputStream::Stdout,
        predicate::str::contains("ruby/app/unowned.rb").and(predicate::str::contains("Unowned")),
    )?;

    Ok(())
}

#[test]
fn test_validate_with_mixed_files() -> Result<(), Box<dyn Error>> {
    run_codeowners(
        "valid_project",
        &["validate", "ruby/app/models/payroll.rb", "ruby/app/unowned.rb"],
        false,
        OutputStream::Stdout,
        predicate::str::contains("ruby/app/unowned.rb").and(predicate::str::contains("Unowned")),
    )?;

    Ok(())
}

#[test]
fn test_validate_with_no_files() -> Result<(), Box<dyn Error>> {
    // Existing behavior - validates entire project
    run_codeowners("valid_project", &["validate"], true, OutputStream::Stdout, predicate::eq(""))?;

    Ok(())
}

#[test]
fn test_generate_and_validate_with_owned_files() -> Result<(), Box<dyn Error>> {
    let fixture_root = std::path::Path::new("tests/fixtures/valid_project");
    let temp_dir = setup_fixture_repo(fixture_root);
    let project_root = temp_dir.path();
    git_add_all_files(project_root);

    let codeowners_path = project_root.join("tmp/CODEOWNERS");

    Command::cargo_bin("codeowners")?
        .arg("--project-root")
        .arg(project_root)
        .arg("--codeowners-file-path")
        .arg(&codeowners_path)
        .arg("--no-cache")
        .arg("generate-and-validate")
        .arg("ruby/app/models/payroll.rb")
        .arg("ruby/app/models/bank_account.rb")
        .assert()
        .success();

    Ok(())
}

#[test]
fn test_generate_and_validate_with_unowned_file() -> Result<(), Box<dyn Error>> {
    let fixture_root = std::path::Path::new("tests/fixtures/valid_project");
    let temp_dir = setup_fixture_repo(fixture_root);
    let project_root = temp_dir.path();
    git_add_all_files(project_root);

    let codeowners_path = project_root.join("tmp/CODEOWNERS");

    Command::cargo_bin("codeowners")?
        .arg("--project-root")
        .arg(project_root)
        .arg("--codeowners-file-path")
        .arg(&codeowners_path)
        .arg("--no-cache")
        .arg("generate-and-validate")
        .arg("ruby/app/unowned.rb")
        .assert()
        .failure()
        .stdout(predicate::str::contains("ruby/app/unowned.rb"))
        .stdout(predicate::str::contains("Unowned"));

    Ok(())
}

#[test]
fn test_validate_with_absolute_path() -> Result<(), Box<dyn Error>> {
    let fixture_root = std::path::Path::new("tests/fixtures/valid_project");
    let temp_dir = setup_fixture_repo(fixture_root);
    let project_root = temp_dir.path();
    git_add_all_files(project_root);

    let file_absolute_path = project_root.join("ruby/app/models/payroll.rb").canonicalize()?;

    Command::cargo_bin("codeowners")?
        .arg("--project-root")
        .arg(project_root)
        .arg("--no-cache")
        .arg("validate")
        .arg(file_absolute_path.to_str().unwrap())
        .assert()
        .success();

    Ok(())
}

#[test]
fn test_validate_only_checks_codeowners_file() -> Result<(), Box<dyn Error>> {
    // This test demonstrates that `validate` with files only checks the CODEOWNERS file
    // It does NOT check file annotations or other ownership sources
    //
    // If a file has an annotation but is missing from CODEOWNERS, `validate` will report it as unowned
    // This is why `generate-and-validate` should be used for accuracy

    // ruby/app/models/bank_account.rb has @team Payments annotation and is in CODEOWNERS
    run_codeowners(
        "valid_project",
        &["validate", "ruby/app/models/bank_account.rb"],
        true,
        OutputStream::Stdout,
        predicate::eq(""),
    )?;

    Ok(())
}

#[test]
fn test_validate_files_respects_owned_globs_with_excluded_extensions() -> Result<(), Box<dyn Error>> {
    // Validates that files not matching owned_globs are silently skipped when
    // validate is called with an explicit file list.
    //
    // valid_project owned_globs: "{gems,config,javascript,ruby,components}/**/*.{rb,tsx,erb}"
    // .rbi files (Sorbet interface files) do NOT match this pattern and should be filtered.

    // Setup: Create a temporary copy of valid_project fixture
    let fixture_root = std::path::Path::new("tests/fixtures/valid_project");
    let temp_dir = setup_fixture_repo(fixture_root);
    let project_root = temp_dir.path();

    // Create .rbi files (Sorbet interface files) that do NOT match owned_globs
    // These files should be ignored by validate when specified in the file list
    let bank_account_rbi = project_root.join("ruby/app/models/bank_account.rbi");
    let payroll_rbi = project_root.join("ruby/app/models/payroll.rbi");

    std::fs::write(
        &bank_account_rbi,
        "# typed: strict\n# RBI file for BankAccount\nclass BankAccount; end\n",
    )?;
    std::fs::write(&payroll_rbi, "# typed: strict\n# RBI file for Payroll\nclass Payroll; end\n")?;

    git_add_all_files(project_root);

    // Step 1: Generate CODEOWNERS
    // This should ONLY include .rb files (not .rbi) because .rbi doesn't match owned_globs
    let codeowners_path = project_root.join("tmp/CODEOWNERS");
    Command::cargo_bin("codeowners")?
        .arg("--project-root")
        .arg(project_root)
        .arg("--codeowners-file-path")
        .arg(&codeowners_path)
        .arg("--no-cache")
        .arg("generate")
        .assert()
        .success();

    // Verify: CODEOWNERS contains .rb files but NOT .rbi files
    let codeowners_content = std::fs::read_to_string(&codeowners_path)?;
    assert!(
        codeowners_content.contains("bank_account.rb"),
        "CODEOWNERS should contain .rb files (they match owned_globs)"
    );
    assert!(
        !codeowners_content.contains("bank_account.rbi"),
        "CODEOWNERS should NOT contain .rbi files (they don't match owned_globs)"
    );

    // Step 2: Run validate with BOTH .rb and .rbi files in the list.
    // .rbi files should be silently filtered; only .rb files validated; command succeeds.
    Command::cargo_bin("codeowners")?
        .arg("--project-root")
        .arg(project_root)
        .arg("--codeowners-file-path")
        .arg(&codeowners_path)
        .arg("--no-cache")
        .arg("validate")
        // Mix .rb and .rbi files in the argument list
        .arg("ruby/app/models/bank_account.rb") // Should be validated (matches owned_globs)
        .arg("ruby/app/models/bank_account.rbi") // Should be SKIPPED (doesn't match)
        .arg("ruby/app/models/payroll.rb") // Should be validated (matches owned_globs)
        .arg("ruby/app/models/payroll.rbi") // Should be SKIPPED (doesn't match)
        .assert()
        .success()
        .stdout(predicate::eq(""));

    Ok(())
}

// ============================================================================
// GLOB FILTERING TESTS: Verify validate with files respects owned_globs
// ============================================================================
//
// These tests ensure that when validate is called with explicit file paths,
// it correctly filters files based on owned_globs configuration. Files that
// don't match owned_globs should be silently skipped, not reported as unowned.

#[test]
fn test_validate_filters_multiple_non_matching_extensions() -> Result<(), Box<dyn Error>> {
    // Test that various file types not in owned_globs are filtered out
    // valid_project owned_globs: "{gems,config,javascript,ruby,components}/**/*.{rb,tsx,erb}"
    let fixture_root = std::path::Path::new("tests/fixtures/valid_project");
    let temp_dir = setup_fixture_repo(fixture_root);
    let project_root = temp_dir.path();

    // Create files with extensions NOT in owned_globs
    std::fs::write(project_root.join("ruby/app/models/test.rbi"), "# Sorbet RBI file")?;
    std::fs::write(project_root.join("ruby/app/models/test.md"), "# Markdown doc")?;
    std::fs::write(project_root.join("ruby/app/models/test.txt"), "Plain text")?;
    std::fs::write(project_root.join("ruby/app/models/test.json"), "{}")?;

    git_add_all_files(project_root);

    let codeowners_path = project_root.join("tmp/CODEOWNERS");

    // Generate CODEOWNERS (will only include .rb, .tsx, .erb files)
    Command::cargo_bin("codeowners")?
        .arg("--project-root")
        .arg(project_root)
        .arg("--codeowners-file-path")
        .arg(&codeowners_path)
        .arg("--no-cache")
        .arg("generate")
        .assert()
        .success();

    // Validate with a mix of matching and non-matching files
    // All non-matching should be filtered, matching ones should succeed
    Command::cargo_bin("codeowners")?
        .arg("--project-root")
        .arg(project_root)
        .arg("--codeowners-file-path")
        .arg(&codeowners_path)
        .arg("--no-cache")
        .arg("validate")
        .arg("ruby/app/models/payroll.rb") // matches owned_globs, is owned
        .arg("ruby/app/models/test.rbi") // doesn't match owned_globs
        .arg("ruby/app/models/test.md") // doesn't match owned_globs
        .arg("ruby/app/models/test.txt") // doesn't match owned_globs
        .arg("ruby/app/models/test.json") // doesn't match owned_globs
        .assert()
        .success()
        .stdout(predicate::eq(""));

    Ok(())
}

#[test]
fn test_validate_filters_files_outside_owned_directories() -> Result<(), Box<dyn Error>> {
    // Test that files in directories not matching owned_globs are filtered
    // valid_project owned_globs: "{gems,config,javascript,ruby,components}/**/*.{rb,tsx,erb}"
    let fixture_root = std::path::Path::new("tests/fixtures/valid_project");
    let temp_dir = setup_fixture_repo(fixture_root);
    let project_root = temp_dir.path();

    // Create .rb files OUTSIDE the owned directories
    std::fs::create_dir_all(project_root.join("scripts"))?;
    std::fs::write(project_root.join("scripts/deploy.rb"), "# Deploy script")?;
    std::fs::create_dir_all(project_root.join("bin"))?;
    std::fs::write(project_root.join("bin/run.rb"), "# Run script")?;

    git_add_all_files(project_root);

    let codeowners_path = project_root.join("tmp/CODEOWNERS");

    // Generate CODEOWNERS
    Command::cargo_bin("codeowners")?
        .arg("--project-root")
        .arg(project_root)
        .arg("--codeowners-file-path")
        .arg(&codeowners_path)
        .arg("--no-cache")
        .arg("generate")
        .assert()
        .success();

    // Validate with files both inside and outside owned directories
    Command::cargo_bin("codeowners")?
        .arg("--project-root")
        .arg(project_root)
        .arg("--codeowners-file-path")
        .arg(&codeowners_path)
        .arg("--no-cache")
        .arg("validate")
        .arg("ruby/app/models/payroll.rb") // inside ruby/, matches owned_globs
        .arg("scripts/deploy.rb") // outside owned dirs, filtered
        .arg("bin/run.rb") // outside owned dirs, filtered
        .assert()
        .success()
        .stdout(predicate::eq(""));

    Ok(())
}

#[test]
fn test_validate_respects_unowned_globs() -> Result<(), Box<dyn Error>> {
    // Test that files matching unowned_globs are filtered out even if they match owned_globs
    let fixture_root = std::path::Path::new("tests/fixtures/valid_project");
    let temp_dir = setup_fixture_repo(fixture_root);
    let project_root = temp_dir.path();

    // Read and modify the config to add unowned_globs
    let config_path = project_root.join("config/code_ownership.yml");
    let config_content = std::fs::read_to_string(&config_path)?;
    let updated_config = config_content.replace("unowned_globs:", "unowned_globs:\n  - ruby/app/models/ignored_*.rb");
    std::fs::write(&config_path, updated_config)?;

    // Create a file that matches owned_globs but also matches unowned_globs
    std::fs::write(
        project_root.join("ruby/app/models/ignored_test.rb"),
        "# This file should be ignored via unowned_globs",
    )?;

    git_add_all_files(project_root);

    let codeowners_path = project_root.join("tmp/CODEOWNERS");

    // Generate CODEOWNERS (ignored_test.rb should NOT be included)
    Command::cargo_bin("codeowners")?
        .arg("--project-root")
        .arg(project_root)
        .arg("--codeowners-file-path")
        .arg(&codeowners_path)
        .arg("--no-cache")
        .arg("generate")
        .assert()
        .success();

    // Verify the ignored file is NOT in CODEOWNERS
    let codeowners_content = std::fs::read_to_string(&codeowners_path)?;
    assert!(
        !codeowners_content.contains("ignored_test.rb"),
        "ignored_test.rb should not be in CODEOWNERS"
    );

    // Validate with the ignored file - should be filtered by unowned_globs
    Command::cargo_bin("codeowners")?
        .arg("--project-root")
        .arg(project_root)
        .arg("--codeowners-file-path")
        .arg(&codeowners_path)
        .arg("--no-cache")
        .arg("validate")
        .arg("ruby/app/models/payroll.rb") // owned, should validate
        .arg("ruby/app/models/ignored_test.rb") // matches unowned_globs, should be filtered
        .assert()
        .success()
        .stdout(predicate::eq(""));

    Ok(())
}