batpak 0.4.0

Event sourcing with causal graphs and policy gates. Sync API, zero async.
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

//! Compile-time assertions that key public types implement Send + Sync.
//! [SPEC:tests/type_assertions.rs]

#[test]
fn store_is_send_and_sync() {
    fn assert_send_sync<T: Send + Sync>() {}
    assert_send_sync::<batpak::store::Store>();
}

#[test]
fn append_receipt_is_send_and_sync() {
    fn assert_send_sync<T: Send + Sync>() {}
    assert_send_sync::<batpak::store::AppendReceipt>();
}

#[test]
fn store_config_is_send_and_sync() {
    fn assert_send_sync<T: Send + Sync>() {}
    assert_send_sync::<batpak::store::StoreConfig>();
}

#[test]
fn notification_is_send_and_sync() {
    fn assert_send_sync<T: Send + Sync>() {}
    assert_send_sync::<batpak::store::Notification>();
}

#[test]
fn coordinate_is_send_and_sync() {
    fn assert_send_sync<T: Send + Sync>() {}
    assert_send_sync::<batpak::coordinate::Coordinate>();
}

#[test]
fn event_kind_is_send_and_sync() {
    fn assert_send_sync<T: Send + Sync>() {}
    assert_send_sync::<batpak::event::EventKind>();
}

#[test]
fn receipt_is_send_and_sync() {
    fn assert_send_sync<T: Send + Sync>() {}
    assert_send_sync::<batpak::guard::Receipt<()>>();
}

#[test]
fn store_error_source_chain_io() {
    use std::error::Error;
    let io_err = std::io::Error::new(std::io::ErrorKind::NotFound, "gone");
    let store_err = batpak::store::StoreError::Io(io_err);
    let source = store_err.source().expect("Io variant should have a source");
    assert!(source.to_string().contains("gone"));
}

#[test]
fn store_error_source_chain_serialization() {
    use std::error::Error;
    let inner: Box<dyn std::error::Error + Send + Sync> = "bad msgpack".into();
    let store_err = batpak::store::StoreError::Serialization(inner);
    let source = store_err
        .source()
        .expect("Serialization variant should have a source");
    assert!(source.to_string().contains("bad msgpack"));
}

#[test]
fn store_error_source_chain_cache_failed() {
    use std::error::Error;
    // (formerly mentioned 'redb' explicitly — neutralized after 0.3.0 removed redb
    // backend support; the stale_terms check would otherwise flag this file)
    let inner: Box<dyn std::error::Error + Send + Sync> = "storage backend error".into();
    let store_err = batpak::store::StoreError::CacheFailed(inner);
    let source = store_err
        .source()
        .expect("CacheFailed variant should have a source");
    assert!(source.to_string().contains("storage backend error"));
}

#[test]
fn store_error_source_none_for_writer_crashed() {
    use std::error::Error;
    let store_err = batpak::store::StoreError::WriterCrashed;
    assert!(store_err.source().is_none());
}

#[test]
fn frame_encode_decode_roundtrip() {
    use serde::{Deserialize, Serialize};

    #[derive(Debug, PartialEq, Serialize, Deserialize)]
    struct Payload {
        x: u32,
        y: String,
    }

    let original = Payload {
        x: 999,
        y: "roundtrip".into(),
    };
    let frame = batpak::store::segment::frame_encode(&original).expect("encode should succeed");
    let (msgpack, consumed) =
        batpak::store::segment::frame_decode(&frame).expect("decode should succeed");
    assert_eq!(consumed, frame.len());
    let decoded: Payload = rmp_serde::from_slice(msgpack).expect("deserialize should succeed");
    assert_eq!(decoded, original);
}