aedb 0.3.0

Embedded Rust storage engine with transactional commits, WAL durability, and snapshot-consistent reads
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

//! End-to-end fault-injection tests: arm a durability-path fail point, drive a
//! real commit through it, and assert the failure is surfaced and the store
//! stays recoverable and consistent.
//!
//! These tests mutate a process-global fault registry, so they are serialized
//! with a shared mutex and always `reset()` in teardown.
//!
//! The serial guard is intentionally held across `.await` points to keep the
//! whole test body in one critical section; that is safe here because the test
//! runtime is single-threaded per test.
#![allow(clippy::await_holding_lock)]

use aedb::commit::validation::Mutation;
use aedb::config::{AedbConfig, DurabilityMode, RecoveryMode};
use aedb::faults::{self, FaultPlan};
use aedb::offline;
use aedb::{AedbInstance, CommitFinality};
use std::sync::Mutex;
use tempfile::tempdir;

static SERIAL: Mutex<()> = Mutex::new(());

fn durable_config() -> AedbConfig {
    AedbConfig {
        durability_mode: DurabilityMode::Full,
        recovery_mode: RecoveryMode::Permissive,
        hash_chain_required: false,
        ..AedbConfig::default()
    }
}

async fn seed(db: &AedbInstance) {
    db.create_project("p").await.expect("project");
    db.kv_set("p", "app", b"k0".to_vec(), b"v0".to_vec())
        .await
        .expect("seed kv");
}

#[tokio::test]
async fn injected_wal_sync_failure_aborts_commit_and_store_stays_consistent() {
    let _guard = SERIAL.lock().unwrap();
    faults::reset();

    let dir = tempdir().expect("temp");
    let config = durable_config();
    let db = AedbInstance::open_anonymous(config.clone(), dir.path()).expect("open");
    seed(&db).await;

    // Fail every WAL fsync. The commit that needs durability must error.
    faults::arm("wal_sync", FaultPlan::Always);
    let result = db
        .commit_with_finality(
            Mutation::KvSet {
                project_id: "p".into(),
                scope_id: "app".into(),
                key: b"k1".to_vec(),
                value: b"v1".to_vec(),
            },
            CommitFinality::Durable,
        )
        .await;
    assert!(
        result.is_err(),
        "commit must fail when the WAL sync fault fires"
    );

    // Clear the fault; subsequent commits succeed again.
    faults::reset();
    db.kv_set("p", "app", b"k2".to_vec(), b"v2".to_vec())
        .await
        .expect("commit after fault clears");

    db.shutdown().await.expect("shutdown");
    drop(db);

    // The store must verify cleanly regardless of the mid-flight failure.
    let report = offline::verify_database(dir.path(), &config);
    assert!(report.ok, "store must stay consistent: {report:?}");

    faults::reset();
}

#[tokio::test]
async fn injected_manifest_write_failure_surfaces_on_checkpoint() {
    let _guard = SERIAL.lock().unwrap();
    faults::reset();

    let dir = tempdir().expect("temp");
    let config = durable_config();
    let db = AedbInstance::open_anonymous(config.clone(), dir.path()).expect("open");
    seed(&db).await;

    faults::arm("manifest_write", FaultPlan::Once);
    let checkpoint = db.checkpoint_now().await;
    assert!(
        checkpoint.is_err(),
        "checkpoint must fail when manifest write fault fires"
    );
    faults::reset();

    // After clearing the fault, a checkpoint and verification both succeed.
    db.checkpoint_now().await.expect("checkpoint after clear");
    db.shutdown().await.expect("shutdown");
    drop(db);
    let report = offline::verify_database(dir.path(), &config);
    assert!(report.ok, "store must stay consistent: {report:?}");

    faults::reset();
}