elfo-test 0.2.0-alpha.21

Test utils for the elfo system
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

use elfo_core::{msg, Envelope, Message, Request, ResponseToken};

/// Extracts message with the provided type from [`Envelope`], panics otherwise.
#[track_caller]
pub fn extract_message<M: Message>(envelope: Envelope) -> M {
    msg!(match envelope {
        msg @ M => msg,
        msg => panic!(
            r#"expected {}, got {:#?}"#,
            elfo_core::dumping::extract_name_by_type::<M>(),
            msg.message()
        ),
    })
}

/// Extracts request message with the provided type from [`Envelope`], panics
/// otherwise.
#[track_caller]
pub fn extract_request<R: Request>(envelope: Envelope) -> (R, ResponseToken<R>) {
    msg!(match envelope {
        (req @ R, token) => (req, token),
        msg => panic!(
            r#"expected {}, got {:#?}"#,
            elfo_core::dumping::extract_name_by_type::<R>(),
            msg.message()
        ),
    })
}

#[cfg(test)]
mod tests {
    use elfo_core::{_priv::MessageKind, message, scope::Scope, ActorMeta, Addr};

    use super::*;

    #[message]
    #[derive(PartialEq)]
    struct TestMessage;

    #[message(ret = ())]
    #[derive(PartialEq)]
    struct TestRequest;

    #[test]
    fn extract_message_test() {
        create_scope().sync_within(|| {
            let envelop = Envelope::new(TestMessage, MessageKind::regular(Addr::NULL));
            let resp = extract_message::<TestMessage>(envelop);
            assert_eq!(resp, TestMessage);
        });
    }

    #[test]
    #[should_panic(expected = "expected TestMessage, got TestRequest")]
    fn extract_message_panic_test() {
        create_scope().sync_within(|| {
            let envelop = Envelope::new(TestRequest, MessageKind::regular(Addr::NULL));
            extract_message::<TestMessage>(envelop);
        });
    }

    #[test]
    fn extract_request_test() {
        create_scope().sync_within(|| {
            let envelop = Envelope::new(TestRequest, MessageKind::regular(Addr::NULL));
            let (resp, _token) = extract_request::<TestRequest>(envelop);
            assert_eq!(resp, TestRequest);
        });
    }

    fn create_scope() -> Scope {
        Scope::test(
            Addr::NULL,
            ActorMeta {
                group: "group".into(),
                key: "key".into(),
            }
            .into(),
        )
    }
}