amethystate 0.26.0

A state manager for Rust applications
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

#![cfg(feature = "sqlite")]

use amethystate::store::builder::{Backend, StoreBuilder};
use amethystate_core::test_utils::TempPath;

fn user_version(path: &std::path::Path) -> i32 {
    let conn = rusqlite::Connection::open(path).unwrap();
    conn.pragma_query_value(None, "user_version", |row| row.get(0))
        .unwrap()
}

fn set_user_version(path: &std::path::Path, value: i32) {
    let conn = rusqlite::Connection::open(path).unwrap();
    conn.pragma_update(None, "user_version", value).unwrap();
}

#[test]
fn a_new_store_records_the_floor_it_needs() -> anyhow::Result<()> {
    let path = TempPath::new("sqlite_floor_new");
    let store = StoreBuilder::new(path.path())
        .backend(Backend::Sqlite)
        .build()?;
    store.close()?;

    let file = path.path().with_extension("db");
    assert_eq!(
        user_version(&file),
        3_007_000,
        "WAL is where the floor comes from, and it is in the header"
    );

    Ok(())
}

#[test]
fn a_store_needing_a_newer_sqlite_is_refused_by_name() {
    let path = TempPath::new("sqlite_floor_high");
    let file = path.path().with_extension("db");

    {
        let store = StoreBuilder::new(path.path())
            .backend(Backend::Sqlite)
            .build()
            .unwrap();
        store.close().unwrap();
    }

    set_user_version(&file, 9_099_000);

    let refused = StoreBuilder::new(path.path())
        .backend(Backend::Sqlite)
        .build()
        .expect_err("the header asks for a sqlite this build does not link");

    let printed = format!("{refused:?}");
    assert!(
        printed.contains("9099000"),
        "the refusal names the version the store needs: {printed}"
    );
    assert!(
        !printed.contains("malformed database schema"),
        "and it is our message rather than sqlite's: {printed}"
    );
}

#[test]
fn a_store_written_before_the_floor_existed_still_opens() -> anyhow::Result<()> {
    let path = TempPath::new("sqlite_floor_zero");
    let file = path.path().with_extension("db");

    {
        let store = StoreBuilder::new(path.path())
            .backend(Backend::Sqlite)
            .build()?;
        store.close()?;
    }

    set_user_version(&file, 0);

    let store = StoreBuilder::new(path.path())
        .backend(Backend::Sqlite)
        .build()?;
    store.close()?;

    assert_eq!(
        user_version(&file),
        3_007_000,
        "and the floor is written on the way through"
    );

    Ok(())
}