factstr-sqlite 0.4.0

Embedded SQLite store for FACTSTR with append, query, streams, and durable streams.
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

mod support;

use factstr::{EventFilter, EventQuery, EventStore, EventStoreError, NewEvent};
use factstr_conformance as store_conformance;
use factstr_sqlite::SqliteStore;
use serde_json::json;

use support::TemporaryDatabaseFile;

#[test]
fn conditional_append_succeeds_for_matching_payload_filtered_context_version() {
    support::run_store_test(
        store_conformance::conditional_append_succeeds_for_matching_payload_filtered_context_version,
    );
}

#[test]
fn conditional_append_fails_for_stale_payload_filtered_context_version() {
    support::run_store_test(
        store_conformance::conditional_append_fails_for_stale_payload_filtered_context_version,
    );
}

#[test]
fn failed_conditional_append_does_not_append_any_part_of_the_batch() {
    support::run_store_test(
        store_conformance::failed_conditional_append_does_not_append_any_part_of_the_batch,
    );
}

#[test]
fn failed_conditional_append_does_not_consume_sequence_numbers_for_later_commits() {
    support::run_store_test(
        store_conformance::failed_conditional_append_does_not_consume_sequence_numbers_for_later_commits,
    );
}

#[test]
fn successful_conditional_append_persists_across_reopen() {
    let database_file = TemporaryDatabaseFile::new("conditional-append-reopen-success");
    let first_store = SqliteStore::open(database_file.path()).expect("sqlite store should open");

    first_store
        .append(vec![NewEvent::new(
            "account-opened",
            json!({ "accountId": "a1" }),
        )])
        .expect("append should succeed");

    let append_result = first_store
        .append_if(
            vec![NewEvent::new(
                "account-renamed",
                json!({ "accountId": "a1", "name": "Rico" }),
            )],
            &EventQuery::all().with_filters([
                EventFilter::default().with_payload_predicates([json!({ "accountId": "a1" })])
            ]),
            Some(1),
        )
        .expect("conditional append should succeed");
    drop(first_store);

    assert_eq!(append_result.first_sequence_number, 2);
    assert_eq!(append_result.last_sequence_number, 2);

    let reopened_store =
        SqliteStore::open(database_file.path()).expect("sqlite store should reopen");
    let query_result = reopened_store
        .query(&EventQuery::all())
        .expect("query should succeed after reopen");

    assert_eq!(query_result.event_records.len(), 2);
    assert_eq!(query_result.event_records[0].sequence_number, 1);
    assert_eq!(query_result.event_records[1].sequence_number, 2);
}

#[test]
fn failed_conditional_append_leaves_database_unchanged_across_reopen() {
    let database_file = TemporaryDatabaseFile::new("conditional-append-reopen-conflict");
    let first_store = SqliteStore::open(database_file.path()).expect("sqlite store should open");

    first_store
        .append(vec![NewEvent::new(
            "account-opened",
            json!({ "accountId": "a1" }),
        )])
        .expect("append should succeed");

    let conflict = first_store
        .append_if(
            vec![
                NewEvent::new("account-renamed", json!({ "accountId": "a1" })),
                NewEvent::new("account-credited", json!({ "accountId": "a1" })),
            ],
            &EventQuery::all()
                .with_filters([
                    EventFilter::default().with_payload_predicates([json!({ "accountId": "a1" })])
                ])
                .with_min_sequence_number(1),
            None,
        )
        .expect_err("conditional append should fail");
    drop(first_store);

    assert_eq!(
        conflict,
        EventStoreError::ConditionalAppendConflict {
            expected: None,
            actual: Some(1),
        }
    );

    let reopened_store =
        SqliteStore::open(database_file.path()).expect("sqlite store should reopen");
    let query_result = reopened_store
        .query(&EventQuery::all())
        .expect("query should succeed after reopen");

    assert_eq!(query_result.event_records.len(), 1);
    assert_eq!(query_result.event_records[0].sequence_number, 1);

    let later_append = reopened_store
        .append(vec![NewEvent::new(
            "account-credited",
            json!({ "accountId": "a1" }),
        )])
        .expect("later append should succeed");

    assert_eq!(later_append.first_sequence_number, 2);
    assert_eq!(later_append.last_sequence_number, 2);
}