mnesis 0.2.1

A zero-compromise event-sourcing and CQRS kernel for Rust with maximum compile-time type safety
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

use mnesis::Events;
use mnesis::*;

#[derive(Debug, Clone, PartialEq)]
struct Created;
#[derive(Debug, Clone, PartialEq)]
struct Activated;

#[derive(Debug, Clone, PartialEq)]
enum TestEvent {
    Created(Created),
    Activated(Activated),
}
impl Message for TestEvent {}
impl DomainEvent for TestEvent {
    fn name(&self) -> &'static str {
        match self {
            Self::Created(_) => "Created",
            Self::Activated(_) => "Activated",
        }
    }
}

#[test]
fn versioned_event_holds_version_and_event() {
    let v1 = Version::new(1).unwrap();
    let ve = VersionedEvent::new(v1, TestEvent::Created(Created));
    assert_eq!(ve.version(), v1);
    assert_eq!(ve.event(), &TestEvent::Created(Created));
}

#[test]
fn events_guarantees_non_empty() {
    let events: Events<_, 0> = Events::new(TestEvent::Created(Created));
    assert_eq!(events.len(), 1);
    assert!(!events.is_empty());
}

#[test]
fn events_add_increases_len() {
    let mut events: Events<_, 1> = Events::new(TestEvent::Created(Created));
    events.add(TestEvent::Activated(Activated));
    assert_eq!(events.len(), 2);
}

#[test]
fn events_into_iter() {
    let mut events: Events<_, 1> = Events::new(TestEvent::Created(Created));
    events.add(TestEvent::Activated(Activated));
    let collected: Vec<_> = events.into_iter().collect();
    assert_eq!(collected.len(), 2);
    assert_eq!(collected[0], TestEvent::Created(Created));
    assert_eq!(collected[1], TestEvent::Activated(Activated));
}

#[test]
fn events_from_single() {
    let events: Events<_, 0> = Events::from(TestEvent::Created(Created));
    assert_eq!(events.len(), 1);
}

#[test]
fn events_macro_single() {
    let events: Events<_, 0> = mnesis::events![TestEvent::Created(Created)];
    assert_eq!(events.len(), 1);
}

#[test]
fn events_macro_multiple() {
    let events: Events<_, 1> =
        mnesis::events![TestEvent::Created(Created), TestEvent::Activated(Activated),];
    assert_eq!(events.len(), 2);
}

#[test]
#[should_panic(expected = "Events capacity exceeded")]
fn add_panics_on_capacity_overflow() {
    let mut events: Events<_, 0> = Events::new(TestEvent::Created(Created));
    events.add(TestEvent::Activated(Activated)); // N=0, no room for additional events
}

// `Events` is non-empty by construction; `first`/`rest` expose that split so a
// downstream non-empty collection can be built with no runtime check and no
// unprovable `unwrap` (#330 — the store's `PendingBatch` is built this way).
#[test]
fn first_is_the_head_event_of_a_single_event_collection() {
    let events: Events<TestEvent> = Events::new(TestEvent::Created(Created));

    assert_eq!(events.first(), &TestEvent::Created(Created));
    assert!(events.rest().is_empty());
}

#[test]
fn first_and_rest_partition_the_collection_in_order() {
    let mut events: Events<TestEvent, 2> = Events::new(TestEvent::Created(Created));
    events.add(TestEvent::Activated(Activated));
    events.add(TestEvent::Created(Created));

    assert_eq!(events.first(), &TestEvent::Created(Created));
    assert_eq!(
        events.rest(),
        &[TestEvent::Activated(Activated), TestEvent::Created(Created)]
    );
    assert_eq!(events.len(), 3, "first + rest is the whole collection");
}

// ── PartialEq distinguishes first, rest, AND equal (kills all 5 eq mutants) ──
// `eq` is `self.first == other.first && self.rest == other.rest`. Three
// assertions pin every operand: an identical pair must be equal (kills `-> false`
// and each `==` -> `!=`), a first-only difference must be unequal (kills `-> true`
// and the first `==` -> `!=`), and a rest-only difference must be unequal (kills
// the `&&` -> `||`, which would call two differing collections equal).
#[test]
fn events_eq_distinguishes_first_rest_and_equal() {
    let mk = |a, b| {
        let mut e: Events<TestEvent, 1> = Events::new(a);
        e.add(b);
        e
    };
    let base = mk(TestEvent::Created(Created), TestEvent::Activated(Activated));
    let same = mk(TestEvent::Created(Created), TestEvent::Activated(Activated));
    let diff_first = mk(
        TestEvent::Activated(Activated),
        TestEvent::Activated(Activated),
    );
    let diff_rest = mk(TestEvent::Created(Created), TestEvent::Created(Created));

    assert_eq!(base, same);
    assert_ne!(base, diff_first);
    assert_ne!(base, diff_rest);
}