minigraf 1.0.0

Zero-config, single-file, embedded graph database with bi-temporal Datalog queries
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

//! Edge case integration tests for Phase 6.4a.
//!
//! Covers:
//! - Oversized fact rejected at insertion (file-backed, both execute() and commit() paths)
//! - Oversized fact accepted in-memory (no page size constraint)
//! - Stale WAL after checkpoint is replayed idempotently (no duplicate facts)
#![cfg(not(target_arch = "wasm32"))]

use minigraf::{Minigraf, OpenOptions, QueryResult};

// ── Oversized fact — file-backed, execute() path ──────────────────────────────

#[test]
fn test_oversized_fact_rejected_at_insertion_file_backed() {
    let dir = tempfile::tempdir().unwrap();
    let path = dir.path().join("test.graph");
    let db = OpenOptions::new()
        .path(path.to_str().unwrap())
        .open()
        .unwrap();

    let large_value = "x".repeat(8192); // well above MAX_FACT_BYTES = 4080
    let cmd = format!("(transact [[:e :attr \"{}\"]])", large_value);
    let result = db.execute(&cmd);

    assert!(
        result.is_err(),
        "oversized fact must be rejected at insertion for file-backed DB"
    );
    let msg = format!("{}", result.unwrap_err());
    assert!(
        msg.contains("4080"),
        "error message must cite the 4080-byte limit; got: {}",
        msg
    );
}

// ── Oversized fact — explicit WriteTransaction path ────────────────────────────

#[test]
fn test_oversized_fact_rejected_via_write_transaction() {
    let dir = tempfile::tempdir().unwrap();
    let path = dir.path().join("test.graph");
    let db = OpenOptions::new()
        .path(path.to_str().unwrap())
        .open()
        .unwrap();

    let large_value = "x".repeat(8192);
    let cmd = format!("(transact [[:e :attr \"{}\"]])", large_value);

    let mut tx = db.begin_write().unwrap();
    tx.execute(&cmd).unwrap(); // buffered in-memory — not yet validated
    let result = tx.commit(); // size check fires here

    assert!(
        result.is_err(),
        "oversized fact must be rejected at commit for file-backed DB"
    );
    let msg = format!("{}", result.unwrap_err());
    assert!(
        msg.contains("4080"),
        "error message must cite the 4080-byte limit; got: {}",
        msg
    );
}

// ── Oversized fact — in-memory (no constraint) ────────────────────────────────

#[test]
fn test_oversized_fact_accepted_in_memory() {
    let db = Minigraf::in_memory().unwrap();
    let large_value = "x".repeat(8192);
    let cmd = format!("(transact [[:e :attr \"{}\"]])", large_value);
    assert!(
        db.execute(&cmd).is_ok(),
        "oversized fact must be accepted in an in-memory database (no page size constraint)"
    );
}

// ── Checkpoint-during-crash: stale WAL replay is idempotent ───────────────────

#[test]
fn test_stale_wal_after_checkpoint_is_idempotent() {
    let dir = tempfile::tempdir().unwrap();
    let path = dir.path().join("test.graph");
    let path = path.to_str().unwrap();
    let wal_path = format!("{}.wal", path);

    // Phase 1: insert alice with checkpoint suppressed; save WAL bytes
    {
        let db = OpenOptions {
            wal_checkpoint_threshold: usize::MAX,
            ..Default::default()
        }
        .path(path)
        .open()
        .unwrap();
        db.execute("(transact [[:alice :age 30]])").unwrap();
        // Drop without checkpointing — WAL exists
    }
    let stale_wal = std::fs::read(&wal_path).expect("WAL must exist after insert");

    // Phase 2: reopen (replays WAL → alice loaded), insert bob, checkpoint
    {
        let db = OpenOptions::new().path(path).open().unwrap();
        db.execute("(transact [[:bob :age 40]])").unwrap();
        db.checkpoint().unwrap(); // alice + bob → packed pages; WAL deleted
    }
    assert!(
        !std::path::Path::new(&wal_path).exists(),
        "WAL must be deleted after checkpoint"
    );

    // Phase 3: simulate crash — restore stale WAL (alice only, tx_count=1)
    std::fs::write(&wal_path, &stale_wal).unwrap();

    // Phase 4: reopen — WAL replay must skip alice (tx_count=1 ≤ last_checkpointed_tx_count)
    let db = OpenOptions::new().path(path).open().unwrap();

    let alice_result = db
        .execute("(query [:find ?age :where [:alice :age ?age]])")
        .unwrap();
    let alice_rows = match alice_result {
        QueryResult::QueryResults { results, .. } => results,
        _ => panic!("expected QueryResults variant"),
    };
    assert_eq!(
        alice_rows.len(),
        1,
        "alice:age must appear exactly once — stale WAL replay must be idempotent"
    );

    let bob_result = db
        .execute("(query [:find ?age :where [:bob :age ?age]])")
        .unwrap();
    let bob_rows = match bob_result {
        QueryResult::QueryResults { results, .. } => results,
        _ => panic!("expected QueryResults variant"),
    };
    assert_eq!(bob_rows.len(), 1, "bob:age must survive the checkpoint");
}