mnesis-macros 0.2.2

Derive macros for the Mnesis event-sourcing framework
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

#![allow(clippy::unwrap_used, reason = "tests")]
#![allow(clippy::expect_used, reason = "tests")]

use mnesis::Version;
use mnesis_store::upcasting::EventMorsel;

#[derive(Debug)]
struct TestError;
impl std::fmt::Display for TestError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "test error")
    }
}
impl std::error::Error for TestError {}

#[allow(dead_code, reason = "referenced by macro attribute only")]
struct TestAggregate;

#[mnesis_macros::transforms(aggregate = TestAggregate, error = TestError)]
impl TestTransforms {
    #[transform(event = "OrderCreated", from = 1, to = 2)]
    fn created_v1_to_v2(payload: &[u8]) -> Result<Vec<u8>, TestError> {
        let mut data = payload.to_vec();
        data.extend_from_slice(b",v2");
        Ok(data)
    }

    #[transform(event = "OrderCreated", from = 2, to = 3)]
    fn created_v2_to_v3(payload: &[u8]) -> Result<Vec<u8>, TestError> {
        let mut data = payload.to_vec();
        data.extend_from_slice(b",v3");
        Ok(data)
    }

    #[transform(event = "OrderCancelled", from = 1, to = 2, rename = "OrderVoided")]
    fn cancelled_to_voided(payload: &[u8]) -> Result<Vec<u8>, TestError> {
        Ok(payload.to_vec())
    }
}

#[test]
fn transforms_multi_step_upcast() {
    let morsel = EventMorsel::borrowed("OrderCreated", Version::INITIAL, b"data");
    let result = TestTransforms::upcast(morsel).unwrap();
    assert_eq!(result.schema_version(), Version::new(3).unwrap());
    assert_eq!(result.payload(), b"data,v2,v3");
    assert_eq!(result.event_type(), "OrderCreated");
}

#[test]
fn transforms_rename() {
    let morsel = EventMorsel::borrowed("OrderCancelled", Version::INITIAL, b"data");
    let result = TestTransforms::upcast(morsel).unwrap();
    assert_eq!(result.event_type(), "OrderVoided");
    assert_eq!(result.schema_version(), Version::new(2).unwrap());
}

#[test]
fn transforms_passthrough_current_version() {
    let morsel = EventMorsel::borrowed("OrderCreated", Version::new(3).unwrap(), b"data");
    let result = TestTransforms::upcast(morsel).unwrap();
    assert!(result.is_borrowed(), "current version should pass through");
}

#[test]
fn transforms_unknown_event_passthrough() {
    let morsel = EventMorsel::borrowed("Unknown", Version::INITIAL, b"data");
    let result = TestTransforms::upcast(morsel).unwrap();
    assert!(result.is_borrowed());
}

#[test]
fn transforms_current_version_lookup() {
    assert_eq!(
        TestTransforms::current_version("OrderCreated"),
        Some(Version::new(3).unwrap())
    );
    assert_eq!(
        TestTransforms::current_version("OrderCancelled"),
        Some(Version::new(2).unwrap())
    );
    assert_eq!(TestTransforms::current_version("Unknown"), None);
}

#[test]
fn transforms_upcast_is_static_fn_pointer() {
    // The macro emits `pub fn upcast(...)` as an associated function with
    // no `self`, so it can be coerced to a function pointer and passed
    // directly to `EventStore::load_with` (which requires a `'static`
    // closure/fn).
    let _: for<'a> fn(EventMorsel<'a>) -> Result<EventMorsel<'a>, TestError> =
        TestTransforms::upcast;
    let _: fn(&str) -> Option<Version> = TestTransforms::current_version;
}