lex-store 0.11.21

Content-addressed on-disk store for Lex stages, branches, and traces.
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

//! `Store::apply_operation` — the only way to advance a branch
//! head's op (post-#129).

use lex_store::{Operation, OperationKind, StageTransition, Store, DEFAULT_BRANCH};
use std::collections::BTreeSet;

fn fresh() -> (Store, tempfile::TempDir) {
    let tmp = tempfile::tempdir().unwrap();
    let s = Store::open(tmp.path()).unwrap();
    (s, tmp)
}

#[test]
fn apply_operation_advances_head_on_main() {
    let (s, _tmp) = fresh();
    let op = Operation::new(
        OperationKind::AddFunction {
            sig_id: "fac".into(),
            stage_id: "stg-1".into(),
            effects: BTreeSet::new(),
            budget_cost: None,
        },
        [],
    );
    let t = StageTransition::Create {
        sig_id: "fac".into(),
        stage_id: "stg-1".into(),
    };
    let op_id = s.apply_operation(DEFAULT_BRANCH, op, t).unwrap();
    let head = s.branch_head(DEFAULT_BRANCH).unwrap();
    assert_eq!(head.get("fac"), Some(&"stg-1".to_string()));

    // The branch file now exists with this head_op.
    let b = s.get_branch(DEFAULT_BRANCH).unwrap().unwrap();
    assert_eq!(b.head_op.as_deref(), Some(op_id.as_str()));
}

#[test]
fn apply_operation_chains_against_existing_head() {
    let (s, _tmp) = fresh();
    let op1 = Operation::new(
        OperationKind::AddFunction {
            sig_id: "fac".into(),
            stage_id: "stg-1".into(),
            effects: BTreeSet::new(),
            budget_cost: None,
        },
        [],
    );
    let op_id1 = s.apply_operation(DEFAULT_BRANCH, op1, StageTransition::Create {
        sig_id: "fac".into(), stage_id: "stg-1".into(),
    }).unwrap();
    let op2 = Operation::new(
        OperationKind::ModifyBody {
            sig_id: "fac".into(),
            from_stage_id: "stg-1".into(),
            to_stage_id: "stg-2".into(),
            from_budget: None,
            to_budget: None,
        },
        [op_id1.clone()],
    );
    let op_id2 = s.apply_operation(DEFAULT_BRANCH, op2, StageTransition::Replace {
        sig_id: "fac".into(), from: "stg-1".into(), to: "stg-2".into(),
    }).unwrap();
    assert_ne!(op_id1, op_id2);
    let head = s.branch_head(DEFAULT_BRANCH).unwrap();
    assert_eq!(head.get("fac"), Some(&"stg-2".to_string()));
}

#[test]
fn apply_operation_with_stale_parent_errors() {
    let (s, _tmp) = fresh();
    let op1 = Operation::new(
        OperationKind::AddFunction {
            sig_id: "fac".into(),
            stage_id: "stg-1".into(),
            effects: BTreeSet::new(),
            budget_cost: None,
        },
        [],
    );
    s.apply_operation(DEFAULT_BRANCH, op1, StageTransition::Create {
        sig_id: "fac".into(), stage_id: "stg-1".into(),
    }).unwrap();
    // Op claims a different parent than the current head.
    let bogus = Operation::new(
        OperationKind::ModifyBody {
            sig_id: "fac".into(),
            from_stage_id: "stg-1".into(),
            to_stage_id: "stg-2".into(),
            from_budget: None,
            to_budget: None,
        },
        ["someone-else".into()],
    );
    let err = s.apply_operation(DEFAULT_BRANCH, bogus, StageTransition::Replace {
        sig_id: "fac".into(), from: "stg-1".into(), to: "stg-2".into(),
    });
    assert!(err.is_err(), "expected stale-parent rejection");
    // Head is unchanged.
    let head = s.branch_head(DEFAULT_BRANCH).unwrap();
    assert_eq!(head.get("fac"), Some(&"stg-1".to_string()));
}

#[test]
fn apply_operation_against_unknown_branch_does_not_persist() {
    let (s, _tmp) = fresh();
    let op = Operation::new(
        OperationKind::AddFunction {
            sig_id: "fac".into(),
            stage_id: "stg-1".into(),
            effects: BTreeSet::new(),
            budget_cost: None,
        },
        [],
    );
    let err = s.apply_operation("ghost", op, StageTransition::Create {
        sig_id: "fac".into(), stage_id: "stg-1".into(),
    });
    assert!(err.is_err(), "expected UnknownBranch");
    // The ops/ directory should be empty — the pre-check refused to
    // persist anything when the branch doesn't exist.
    let ops_dir = _tmp.path().join("ops");
    if ops_dir.exists() {
        let n = std::fs::read_dir(&ops_dir).unwrap()
            .filter_map(|e| e.ok())
            .filter(|e| e.path().extension().is_some_and(|x| x == "json"))
            .count();
        assert_eq!(n, 0, "no op file should be persisted against an unknown branch");
    }
}