forjar 1.4.2

Rust-native Infrastructure as Code — bare-metal first, BLAKE3 state, provenance tracing
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

//! Tests for FJ-1325/FJ-1326: GC roots and mark-and-sweep.

use super::gc::{collect_roots, mark_and_sweep};
use super::meta::{new_meta, write_meta};
use std::collections::BTreeSet;
use std::path::Path;

const HASH_A: &str = "blake3:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
const HASH_B: &str = "blake3:bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
const HASH_C: &str = "blake3:cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc";

fn setup_store_entry(store_dir: &Path, hash: &str, references: &[&str]) {
    let hex = hash.strip_prefix("blake3:").unwrap();
    let entry_dir = store_dir.join(hex);
    std::fs::create_dir_all(&entry_dir).unwrap();
    let mut meta = new_meta(hash, "blake3:recipe", &[], "x86_64", "test");
    meta.references = references.iter().map(|r| r.to_string()).collect();
    write_meta(&entry_dir, &meta).unwrap();
}

#[test]
fn test_fj1325_collect_roots_profiles() {
    let roots = collect_roots(&[HASH_A.to_string(), HASH_B.to_string()], &[], None);
    assert_eq!(roots.len(), 2);
    assert!(roots.contains(HASH_A));
    assert!(roots.contains(HASH_B));
}

#[test]
fn test_fj1325_collect_roots_lockfile() {
    let roots = collect_roots(&[], &[HASH_A.to_string()], None);
    assert_eq!(roots.len(), 1);
    assert!(roots.contains(HASH_A));
}

#[test]
fn test_fj1325_collect_roots_deduplicates() {
    let roots = collect_roots(&[HASH_A.to_string()], &[HASH_A.to_string()], None);
    assert_eq!(roots.len(), 1);
}

#[test]
#[cfg(unix)]
fn test_fj1325_collect_roots_gc_dir() {
    let dir = tempfile::tempdir().unwrap();
    let gc_dir = dir.path().join(".gc-roots");
    std::fs::create_dir(&gc_dir).unwrap();
    let hex = HASH_A.strip_prefix("blake3:").unwrap();
    let target = format!("/var/forjar/store/{hex}/content");
    std::os::unix::fs::symlink(&target, gc_dir.join("my-root")).unwrap();

    let roots = collect_roots(&[], &[], Some(&gc_dir));
    assert_eq!(roots.len(), 1);
    assert!(roots.contains(HASH_A));
}

#[test]
fn test_fj1325_collect_roots_empty() {
    let roots = collect_roots(&[], &[], None);
    assert!(roots.is_empty());
}

#[test]
fn test_fj1326_mark_sweep_all_live() {
    let dir = tempfile::tempdir().unwrap();
    let store = dir.path().join("store");
    std::fs::create_dir(&store).unwrap();
    setup_store_entry(&store, HASH_A, &[]);
    setup_store_entry(&store, HASH_B, &[]);

    let roots: BTreeSet<String> = [HASH_A, HASH_B].iter().map(|s| s.to_string()).collect();
    let report = mark_and_sweep(&roots, &store).unwrap();
    assert_eq!(report.live.len(), 2);
    assert!(report.dead.is_empty());
    assert_eq!(report.total, 2);
}

#[test]
fn test_fj1326_mark_sweep_dead_entry() {
    let dir = tempfile::tempdir().unwrap();
    let store = dir.path().join("store");
    std::fs::create_dir(&store).unwrap();
    setup_store_entry(&store, HASH_A, &[]);
    setup_store_entry(&store, HASH_B, &[]); // B is not a root

    let roots: BTreeSet<String> = [HASH_A].iter().map(|s| s.to_string()).collect();
    let report = mark_and_sweep(&roots, &store).unwrap();
    assert_eq!(report.live.len(), 1);
    assert_eq!(report.dead.len(), 1);
    assert!(report.dead.contains(HASH_B));
}

#[test]
fn test_fj1326_mark_sweep_follows_references() {
    let dir = tempfile::tempdir().unwrap();
    let store = dir.path().join("store");
    std::fs::create_dir(&store).unwrap();
    setup_store_entry(&store, HASH_A, &[HASH_B]); // A references B
    setup_store_entry(&store, HASH_B, &[HASH_C]); // B references C
    setup_store_entry(&store, HASH_C, &[]);

    let roots: BTreeSet<String> = [HASH_A].iter().map(|s| s.to_string()).collect();
    let report = mark_and_sweep(&roots, &store).unwrap();
    // All three are live via reference chain
    assert_eq!(report.live.len(), 3);
    assert!(report.dead.is_empty());
}

#[test]
fn test_fj1326_mark_sweep_empty_store() {
    let dir = tempfile::tempdir().unwrap();
    let store = dir.path().join("store");
    std::fs::create_dir(&store).unwrap();

    let roots = BTreeSet::new();
    let report = mark_and_sweep(&roots, &store).unwrap();
    assert!(report.live.is_empty());
    assert!(report.dead.is_empty());
    assert_eq!(report.total, 0);
}

#[test]
fn test_fj1326_mark_sweep_store_not_found() {
    let roots = BTreeSet::new();
    let result = mark_and_sweep(&roots, Path::new("/no/such/store"));
    assert!(result.is_err());
}

#[test]
fn test_fj1326_mark_sweep_missing_meta_still_works() {
    let dir = tempfile::tempdir().unwrap();
    let store = dir.path().join("store");
    std::fs::create_dir(&store).unwrap();
    // Create entry directory without meta.yaml
    let hex = HASH_A.strip_prefix("blake3:").unwrap();
    std::fs::create_dir(store.join(hex)).unwrap();

    let roots: BTreeSet<String> = [HASH_A].iter().map(|s| s.to_string()).collect();
    let report = mark_and_sweep(&roots, &store).unwrap();
    // A is live (it's a root), just no references to follow
    assert_eq!(report.live.len(), 1);
}

#[test]
#[cfg(unix)]
fn test_fj1325_gc_root_from_symlink_integration() {
    // Integration test: symlink target → collected root → mark live
    let dir = tempfile::tempdir().unwrap();
    let store = dir.path().join("store");
    std::fs::create_dir(&store).unwrap();
    setup_store_entry(&store, HASH_A, &[]);

    let gc_dir = dir.path().join(".gc-roots");
    std::fs::create_dir(&gc_dir).unwrap();
    let hex_a = HASH_A.strip_prefix("blake3:").unwrap();
    let target = format!("/var/forjar/store/{hex_a}/content");
    std::os::unix::fs::symlink(&target, gc_dir.join("root")).unwrap();

    let roots = collect_roots(&[], &[], Some(&gc_dir));
    let report = mark_and_sweep(&roots, &store).unwrap();
    assert!(report.live.contains(HASH_A));
}