picante 2.0.0

An async incremental query runtime
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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

use picante::Revision;
use picante::ingredient::InputIngredient;
use picante::key::QueryKindId;
use picante::runtime::{HasRuntime, Runtime, RuntimeEvent};
use tokio::sync::broadcast::error::TryRecvError;

fn init_tracing() {
    static ONCE: std::sync::OnceLock<()> = std::sync::OnceLock::new();
    ONCE.get_or_init(|| {
        let _ = tracing_subscriber::fmt()
            .with_test_writer()
            .with_max_level(tracing::Level::TRACE)
            .try_init();
    });
}

#[derive(Default)]
struct TestDb {
    runtime: Runtime,
}

impl HasRuntime for TestDb {
    fn runtime(&self) -> &Runtime {
        &self.runtime
    }
}

#[tokio_test_lite::test]
async fn revision_watch_updates_on_input_set() {
    init_tracing();

    let db = TestDb::default();
    let mut revisions = db.runtime().subscribe_revisions();

    assert_eq!(*revisions.borrow(), Revision(0));

    let input: InputIngredient<String, String> = InputIngredient::new(QueryKindId(1), "Text");
    input.set(&db, "a".into(), "hello".into());

    revisions.changed().await.unwrap();
    assert_eq!(*revisions.borrow(), Revision(1));
}

#[tokio_test_lite::test]
async fn input_set_and_remove_emit_events() {
    init_tracing();

    let db = TestDb::default();
    let mut events = db.runtime().subscribe_events();

    let input: InputIngredient<String, String> = InputIngredient::new(QueryKindId(1), "Text");

    input.set(&db, "a".into(), "hello".into());

    match events.recv().await.unwrap() {
        RuntimeEvent::RevisionBumped { revision } => assert_eq!(revision, Revision(1)),
        other => panic!("expected RevisionBumped, got {other:?}"),
    }

    match events.recv().await.unwrap() {
        RuntimeEvent::InputSet {
            revision,
            kind,
            key,
            ..
        } => {
            assert_eq!(revision, Revision(1));
            assert_eq!(kind, QueryKindId(1));
            assert_eq!(key.decode_facet::<String>().unwrap(), "a");
        }
        other => panic!("expected InputSet, got {other:?}"),
    }

    input.remove(&db, &"a".into());

    match events.recv().await.unwrap() {
        RuntimeEvent::RevisionBumped { revision } => assert_eq!(revision, Revision(2)),
        other => panic!("expected RevisionBumped, got {other:?}"),
    }

    match events.recv().await.unwrap() {
        RuntimeEvent::InputRemoved {
            revision,
            kind,
            key,
            ..
        } => {
            assert_eq!(revision, Revision(2));
            assert_eq!(kind, QueryKindId(1));
            assert_eq!(key.decode_facet::<String>().unwrap(), "a");
        }
        other => panic!("expected InputRemoved, got {other:?}"),
    }
}

#[tokio_test_lite::test]
async fn input_set_same_value_is_noop() {
    init_tracing();

    let db = TestDb::default();
    let mut events = db.runtime().subscribe_events();

    let input: InputIngredient<String, String> = InputIngredient::new(QueryKindId(1), "Text");

    let r1 = input.set(&db, "a".into(), "hello".into());
    assert_eq!(r1, Revision(1));

    // Drain the first set's events.
    let _ = events.recv().await.unwrap();
    let _ = events.recv().await.unwrap();

    let rev_before = db.runtime().current_revision();

    let r2 = input.set(&db, "a".into(), "hello".into());
    assert_eq!(r2, r1);
    assert_eq!(db.runtime().current_revision(), rev_before);
    assert!(matches!(events.try_recv(), Err(TryRecvError::Empty)));
}

#[tokio_test_lite::test]
async fn input_remove_missing_is_noop() {
    init_tracing();

    let db = TestDb::default();
    let mut events = db.runtime().subscribe_events();

    let input: InputIngredient<String, String> = InputIngredient::new(QueryKindId(1), "Text");

    let r1 = input.remove(&db, &"a".into());
    assert_eq!(r1, Revision(0));
    assert_eq!(db.runtime().current_revision(), Revision(0));
    assert!(matches!(events.try_recv(), Err(TryRecvError::Empty)));
}

#[tokio_test_lite::test]
async fn input_remove_twice_second_is_noop() {
    init_tracing();

    let db = TestDb::default();
    let mut events = db.runtime().subscribe_events();

    let input: InputIngredient<String, String> = InputIngredient::new(QueryKindId(1), "Text");

    input.set(&db, "a".into(), "hello".into());

    // Drain the first set's events.
    let _ = events.recv().await.unwrap();
    let _ = events.recv().await.unwrap();

    input.remove(&db, &"a".into());

    // Drain the first remove's events.
    let _ = events.recv().await.unwrap();
    let _ = events.recv().await.unwrap();

    let rev_before = db.runtime().current_revision();

    let r2 = input.remove(&db, &"a".into());
    assert_eq!(r2, rev_before);
    assert_eq!(db.runtime().current_revision(), rev_before);
    assert!(matches!(events.try_recv(), Err(TryRecvError::Empty)));
}