shallguard 0.1.2

ShallGuard requirement traceability, executable coverage, and review tooling
Documentation
//! Unit tests for the check cross-checks and baseline policy.

use super::*;
use crate::config::{AreaConfig, ArtifactConfig, ReviewConfig};

fn requirement(id: &str, area: &str, retired: bool) -> Requirement {
    Requirement {
        id: id.to_string(),
        area: area.to_string(),
        title: "Test requirement".to_string(),
        statement: "Test requirement SHALL hold.".to_string(),
        enforced_text: "src/lib.rs".to_string(),
        verified_text: "code review".to_string(),
        doc: "crate/docs/requirements.md".to_string(),
        line: 12,
        enforced_paths: Vec::new(),
        not_implemented: false,
        retired,
        automated: false,
        evidence: Vec::new(),
        e2e: false,
        review_only: true,
        pending: false,
    }
}

fn analysis(req: Requirement, kind: Option<GapKind>) -> Analysis {
    let mut gaps = BTreeMap::new();
    if let Some(kind) = kind {
        gaps.insert(
            GapKey::new(&req.id, kind),
            TraceabilityGap {
                area: req.area.clone(),
                findings: vec![Finding {
                    file: req.doc.clone(),
                    line: req.line,
                    message: "gap detail".to_string(),
                }],
            },
        );
    }
    Analysis {
        errors: Vec::new(),
        warnings: Vec::new(),
        requirements: vec![req],
        gaps,
        stats: BTreeMap::new(),
        anchors: Anchors {
            references: HashMap::new(),
            enforcement: Vec::new(),
            verification: Vec::new(),
            invalid: Vec::new(),
        },
    }
}

fn baseline(id: &str, kind: GapKind) -> Baseline {
    Baseline::from_entries(vec![BaselineEntry {
        requirement: id.to_string(),
        kind,
    }])
}

fn config(hard_area: Option<&str>) -> RepositoryConfig {
    RepositoryConfig {
        schema: 1,
        minimum_requirements: 1,
        baseline: PathBuf::from(".shallguard/baseline.toml"),
        verify_outlier_threshold: 6,
        documents: Vec::new(),
        prefixes: BTreeMap::new(),
        areas: hard_area
            .map(|area| {
                BTreeMap::from([(
                    area.to_string(),
                    AreaConfig {
                        label: "Test".to_string(),
                        hard_enforcement: true,
                        hard_verification: true,
                    },
                )])
            })
            .unwrap_or_default(),
        allow_missing_paths: Default::default(),
        artifacts: ArtifactConfig {
            root: PathBuf::from("target/shallguard"),
        },
        review: ReviewConfig::default(),
    }
}

#[shallguard::verifies("REQ-TRACE-006")]
#[test]
fn requires_an_anchor_in_every_documented_enforcement_file() {
    let anchored = Path::new("src/anchored.rs");
    let missing = Path::new("src/missing.rs");
    let files = HashSet::from([anchored]);

    assert!(enforced_path_has_anchor(anchored, Some(&files)));
    assert!(!enforced_path_has_anchor(missing, Some(&files)));
    assert!(!enforced_path_has_anchor(anchored, None));
}

#[shallguard::verifies("REQ-BASE-002")]
#[test]
fn exact_baseline_gap_is_known_warning() {
    let kind = GapKind::EnforcementAnchor;
    let mut analysis = analysis(requirement("REQ-ZZ-001", "ZZ", false), Some(kind));
    let stats = apply_baseline(
        &mut analysis,
        &baseline("REQ-ZZ-001", kind),
        true,
        true,
        &config(None),
    );
    assert!(analysis.errors.is_empty());
    assert_eq!(analysis.warnings.len(), 1);
    assert!(analysis.warnings[0].message.contains("grandfathered"));
    assert_eq!(stats.known, 1);
}

#[shallguard::verifies("REQ-BASE-002")]
#[test]
fn unbaselined_gap_is_a_regression() {
    let kind = GapKind::VerificationAnchor;
    let mut analysis = analysis(requirement("REQ-ZZ-001", "ZZ", false), Some(kind));
    let stats = apply_baseline(
        &mut analysis,
        &Baseline::from_entries(Vec::new()),
        true,
        true,
        &config(None),
    );
    assert_eq!(analysis.errors.len(), 1);
    assert!(analysis.errors[0].message.contains("new regression"));
    assert_eq!(stats.new, 1);
}

#[shallguard::verifies("REQ-BASE-004")]
#[test]
fn fixed_gap_makes_entry_stale() {
    let kind = GapKind::EvidenceCitation;
    let mut analysis = analysis(requirement("REQ-ZZ-001", "ZZ", false), None);
    let stats = apply_baseline(
        &mut analysis,
        &baseline("REQ-ZZ-001", kind),
        true,
        true,
        &config(None),
    );
    assert_eq!(analysis.errors.len(), 1);
    assert!(analysis.errors[0].message.contains("gap is resolved"));
    assert_eq!(stats.resolved, 1);
}

#[shallguard::verifies("REQ-BASE-004")]
#[test]
fn prune_mode_accepts_resolved_entry_for_removal() {
    let kind = GapKind::EvidenceCitation;
    let mut analysis = analysis(requirement("REQ-ZZ-001", "ZZ", true), None);
    let stats = apply_baseline(
        &mut analysis,
        &baseline("REQ-ZZ-001", kind),
        true,
        false,
        &config(None),
    );
    assert!(analysis.errors.is_empty());
    assert_eq!(stats.resolved, 1);
}

#[shallguard::verifies("REQ-BASE-003")]
#[test]
fn hard_area_cannot_be_baselined() {
    let kind = GapKind::EnforcementAnchor;
    let area = "SAFE";
    let mut analysis = analysis(requirement("REQ-SAFE-999", area, false), Some(kind));
    apply_baseline(
        &mut analysis,
        &baseline("REQ-SAFE-999", kind),
        true,
        true,
        &config(Some(area)),
    );
    assert!(analysis.errors.len() >= 2);
    assert!(
        analysis
            .errors
            .iter()
            .any(|finding| finding.message.contains("forbidden"))
    );
}