dpm-store 0.1.0

SQLite persistence and append-only operation log for DPM
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

use super::*;

#[test]
fn cached_reads_see_external_writes_and_do_not_trust_revision_alone() {
    let dir = tempfile::tempdir().expect("directory");
    let path = dir.path().join("plan.sqlite");
    let mut first = SqliteStore::open_blocking(&path).expect("store");
    let original = fixture();
    first.initialize_blocking(&original).expect("initialize");
    let mut returned = first.load_blocking().expect("load").expect("plan");
    returned.workspace.name = "caller edit".into();
    assert_eq!(
        first.load_blocking().expect("cached"),
        Some(original.clone())
    );
    let mut other = SqliteStore::open_existing_blocking(&path).expect("other");
    let mut updated = original.clone();
    let operation = claim(&mut updated, "other");
    other
        .persist_blocking(&updated, &operation, None)
        .expect("commit");
    assert_eq!(
        first.load_blocking().expect("refresh"),
        Some(updated.clone())
    );
    let connection = Connection::open(&path).expect("external");
    connection
        .execute("UPDATE plan_state SET snapshot_json = '{}'", [])
        .expect("corrupt");
    assert!(
        first.load_blocking().is_err(),
        "same revision must not hide corrupted bytes"
    );
    connection
        .execute(
            "UPDATE plan_state SET snapshot_json = ?1, revision = 2",
            [serde_json::to_string(&updated).expect("json")],
        )
        .expect("row mismatch");
    assert!(matches!(
        first.load_blocking(),
        Err(StoreError::CorruptSnapshot { .. })
    ));
    connection
        .execute("UPDATE plan_state SET revision = 1", [])
        .expect("repair row");
    assert_eq!(first.load_blocking().expect("repaired"), Some(updated));
}

#[test]
fn the_revision_query_reads_rows_without_decoding_the_snapshot() {
    let dir = tempfile::tempdir().expect("directory");
    let path = dir.path().join("plan.sqlite");
    let mut store = SqliteStore::open_blocking(&path).expect("store");
    assert_eq!(store.revision_blocking().expect("empty"), None);
    let mut plan = fixture();
    store.initialize_blocking(&plan).expect("initialize");
    let lineage = store.lineage_blocking().expect("lineage").expect("row");
    let initial = store.revision_blocking().expect("revision").expect("row");
    assert_eq!(
        (initial.revision, initial.lineage),
        (plan.revision, lineage)
    );
    let operation = claim(&mut plan, "owner");
    store
        .persist_blocking(&plan, &operation, None)
        .expect("commit");
    let next = store.revision_blocking().expect("revision").expect("row");
    assert_eq!(next.revision, initial.revision.wrapping_add(1));
    // Damaged snapshot text would fail any decode; the revision row alone still answers.
    Connection::open(&path)
        .expect("external")
        .execute("UPDATE plan_state SET snapshot_json = '{}'", [])
        .expect("damage");
    assert_eq!(store.revision_blocking().expect("revision"), Some(next));
    // A poller that never opened the store (a repointable locator) reads the same two rows.
    assert_eq!(
        crate::store_revision_blocking(&path).expect("path probe"),
        Some(next)
    );
    assert!(store.load_blocking().is_err());
}