arcature 0.1.0

Arcature: an opinionated full-stack Rust web framework. One package, batteries included.
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

//! Tests for the events Dispatcher (in-process typed dispatch).

#![cfg(feature = "events")]

use std::sync::Arc;
use std::sync::atomic::{AtomicUsize, Ordering};

use arcature::events::{DispatchError, Dispatcher};
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize, arcature::Event)]
struct UserRegistered {
    user_id: u64,
    email: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, arcature::Event)]
struct OrderShipped {
    order_id: u64,
}

#[test]
fn dispatch_with_no_listeners_is_a_noop() {
    let rt = tokio::runtime::Runtime::new().unwrap();
    let dispatcher = Dispatcher::new();
    rt.block_on(async {
        let result = dispatcher
            .dispatch(&UserRegistered {
                user_id: 1,
                email: "a@b.com".into(),
            })
            .await;
        assert!(result.is_ok());
    });
}

#[test]
fn dispatch_runs_all_listeners_in_registration_order() {
    let rt = tokio::runtime::Runtime::new().unwrap();
    let call_count = Arc::new(AtomicUsize::new(0));
    let cc1 = call_count.clone();
    let cc2 = call_count.clone();

    let dispatcher = Dispatcher::new()
        .register(move |event: UserRegistered| {
            let cc = cc1.clone();
            async move {
                assert_eq!(event.user_id, 1);
                cc.fetch_add(1, Ordering::SeqCst);
                Ok(())
            }
        })
        .register(move |_event: UserRegistered| {
            let cc = cc2.clone();
            async move {
                cc.fetch_add(1, Ordering::SeqCst);
                Ok(())
            }
        });

    rt.block_on(async {
        let result = dispatcher
            .dispatch(&UserRegistered {
                user_id: 1,
                email: "a@b.com".into(),
            })
            .await;
        assert!(result.is_ok());
    });
    assert_eq!(call_count.load(Ordering::SeqCst), 2);
}

#[test]
fn dispatch_returns_first_error_but_all_listeners_run() {
    let rt = tokio::runtime::Runtime::new().unwrap();
    let ran = Arc::new(AtomicUsize::new(0));
    let ran2 = ran.clone();

    let dispatcher = Dispatcher::new()
        .register(move |_event: UserRegistered| async move {
            Err(DispatchError::Listener("first".into()))
        })
        .register(move |_event: UserRegistered| {
            let ran2 = ran2.clone();
            async move {
                ran2.fetch_add(1, Ordering::SeqCst);
                Ok(())
            }
        });

    rt.block_on(async {
        let result = dispatcher
            .dispatch(&UserRegistered {
                user_id: 1,
                email: "a@b.com".into(),
            })
            .await;
        assert!(result.is_err());
        let err = result.unwrap_err();
        match err {
            DispatchError::Listener(msg) => assert_eq!(msg, "first"),
            _ => panic!("expected Listener error"),
        }
    });
    assert_eq!(ran.load(Ordering::SeqCst), 1);
}

#[test]
fn recording_dispatcher_tracks_dispatched_events() {
    let rt = tokio::runtime::Runtime::new().unwrap();
    let dispatcher = Dispatcher::recording();
    rt.block_on(async {
        dispatcher
            .dispatch(&UserRegistered {
                user_id: 1,
                email: "a@b.com".into(),
            })
            .await
            .unwrap();
        dispatcher
            .dispatch(&OrderShipped { order_id: 1 })
            .await
            .unwrap();
    });
    assert!(dispatcher.was_dispatched("UserRegistered"));
    assert!(dispatcher.was_dispatched("OrderShipped"));
    assert!(!dispatcher.was_dispatched("Unknown"));
    assert_eq!(dispatcher.dispatched_events().len(), 2);
}

#[test]
fn dispatcher_listener_count() {
    let dispatcher = Dispatcher::new()
        .register(|_e: UserRegistered| async { Ok(()) })
        .register(|_e: UserRegistered| async { Ok(()) })
        .register(|_e: OrderShipped| async { Ok(()) });
    assert_eq!(dispatcher.listener_count("UserRegistered"), 2);
    assert_eq!(dispatcher.listener_count("OrderShipped"), 1);
    assert_eq!(dispatcher.listener_count("Unknown"), 0);
}

#[test]
fn dispatcher_debug_does_not_leak_closures() {
    let dispatcher = Dispatcher::new().register(|_e: UserRegistered| async { Ok(()) });
    let debug = format!("{dispatcher:?}");
    assert!(!debug.contains("0x"));
    assert!(!debug.contains("closure"));
}