shallguard 0.1.2

ShallGuard requirement traceability, executable coverage, and review tooling
Documentation
use std::collections::{BTreeMap, BTreeSet};
use std::path::{Path, PathBuf};

use super::*;

fn target(package: &str, kind: TestTargetKind, name: &str) -> CargoTargetIdentity {
    CargoTargetIdentity {
        package: package.to_string(),
        target_kind: kind,
        target_name: name.to_string(),
    }
}

fn candidate(name: &str, syntactic_name: &str) -> SourceCandidate {
    SourceCandidate {
        file: "crate/src/tests.rs".to_string(),
        line: 10,
        function: name.to_string(),
        requirements: vec!["REQ-ZZ-001".to_string()],
        target: Ok(target("crate", TestTargetKind::Lib, "crate")),
        syntactic_name: Some(syntactic_name.to_string()),
    }
}

#[shallguard::verifies("REQ-TRACE-007")]
#[test]
fn merges_repeated_attributes_on_one_test() {
    let mut second = candidate("proves_it", "tests::proves_it");
    second.line = 11;
    second.requirements = vec!["REQ-ZZ-002".to_string(), "REQ-ZZ-001".to_string()];
    let merged = merge_candidates(vec![candidate("proves_it", "tests::proves_it"), second]);
    assert_eq!(merged.len(), 1);
    assert_eq!(merged[0].line, 10);
    assert_eq!(merged[0].requirements, ["REQ-ZZ-001", "REQ-ZZ-002"]);
}

#[shallguard::verifies("REQ-TEST-002")]
#[test]
fn parses_only_tests_and_benchmarks_from_harness_output() {
    let tests =
        parse_harness_list("module::one: test\nmodule::bench: benchmark\n2 tests, 0 benchmarks\n");
    assert_eq!(tests, ["module::bench", "module::one"]);
}

#[shallguard::verifies("REQ-TEST-003")]
#[test]
fn exact_syntactic_name_resolves_before_suffix_matching() {
    let key = target("crate", TestTargetKind::Lib, "crate");
    let catalog = BTreeMap::from([(
        key,
        vec![
            "other::proves_it".to_string(),
            "tests::proves_it".to_string(),
        ],
    )]);
    let mut findings = Vec::new();
    let resolved = resolve_candidate(
        candidate("proves_it", "tests::proves_it"),
        &catalog,
        &mut findings,
    );
    assert_eq!(resolved.status, ResolutionStatus::Resolved);
    assert_eq!(
        resolved.match_kind,
        Some(ResolutionMatch::ExactSyntacticName)
    );
    assert_eq!(
        resolved
            .identity
            .expect("resolved test has identity")
            .fully_qualified_name,
        "tests::proves_it"
    );
    assert!(findings.is_empty());
}

#[shallguard::verifies("REQ-TEST-003")]
#[test]
fn unique_function_suffix_is_accepted() {
    let key = target("crate", TestTargetKind::Lib, "crate");
    let catalog = BTreeMap::from([(key, vec!["actual::nested::proves_it".to_string()])]);
    let mut findings = Vec::new();
    let resolved = resolve_candidate(
        candidate("proves_it", "guessed::proves_it"),
        &catalog,
        &mut findings,
    );
    assert_eq!(resolved.status, ResolutionStatus::Resolved);
    assert_eq!(
        resolved.match_kind,
        Some(ResolutionMatch::UniqueFunctionSuffix)
    );
    assert!(findings.is_empty());
}

#[shallguard::verifies("REQ-TEST-003")]
#[test]
fn ambiguous_function_suffix_is_a_finding() {
    let key = target("crate", TestTargetKind::Lib, "crate");
    let catalog = BTreeMap::from([(
        key,
        vec!["one::proves_it".to_string(), "two::proves_it".to_string()],
    )]);
    let mut findings = Vec::new();
    let resolved = resolve_candidate(
        candidate("proves_it", "unknown::proves_it"),
        &catalog,
        &mut findings,
    );
    assert_eq!(resolved.status, ResolutionStatus::Ambiguous);
    assert_eq!(resolved.candidates.len(), 2);
    assert_eq!(findings[0].code, "harness-test-ambiguous");
}

#[shallguard::verifies("REQ-TEST-001")]
#[test]
fn maps_library_and_integration_source_targets() {
    let package = MetadataPackage {
        name: "crate".to_string(),
        manifest_path: PathBuf::from("/workspace/crate/Cargo.toml"),
        targets: vec![
            MetadataTarget {
                name: "crate".to_string(),
                kind: vec!["lib".to_string()],
                src_path: PathBuf::from("/workspace/crate/src/lib.rs"),
                test: true,
            },
            MetadataTarget {
                name: "basic".to_string(),
                kind: vec!["test".to_string()],
                src_path: PathBuf::from("/workspace/crate/tests/basic.rs"),
                test: true,
            },
        ],
    };
    assert_eq!(
        select_target(Path::new("/workspace/crate/src/router/tests.rs"), &package)
            .expect("library source resolves"),
        target("crate", TestTargetKind::Lib, "crate")
    );
    assert_eq!(
        select_target(Path::new("/workspace/crate/tests/basic.rs"), &package)
            .expect("integration source resolves"),
        target("crate", TestTargetKind::Integration, "basic")
    );
}

#[test]
fn builds_module_name_from_library_file_and_inline_modules() {
    let package = MetadataPackage {
        name: "crate".to_string(),
        manifest_path: PathBuf::from("/workspace/crate/Cargo.toml"),
        targets: vec![MetadataTarget {
            name: "crate".to_string(),
            kind: vec!["lib".to_string()],
            src_path: PathBuf::from("/workspace/crate/src/lib.rs"),
            test: true,
        }],
    };
    let anchor = VerificationAnchor {
        file: PathBuf::from("crate/src/router/config.rs"),
        line: 10,
        test_fn: "proves_it".to_string(),
        inline_modules: vec!["tests".to_string()],
        ids: vec!["REQ-ZZ-001".to_string()],
    };
    assert_eq!(
        static_test_name(
            Path::new("/workspace/crate/src/router/config.rs"),
            &package,
            &target("crate", TestTargetKind::Lib, "crate"),
            &anchor,
        ),
        Some("router::config::tests::proves_it".to_string())
    );
}

#[shallguard::verifies("REQ-TEST-005")]
#[test]
fn validates_requested_package_names() {
    let metadata = CargoMetadata {
        packages: vec![MetadataPackage {
            name: "known".to_string(),
            manifest_path: PathBuf::from("/workspace/known/Cargo.toml"),
            targets: Vec::new(),
        }],
    };
    let error = validate_package_filter(&metadata, &BTreeSet::from(["missing".to_string()]))
        .expect_err("unknown package fails");
    assert!(error.to_string().contains("missing"));
}