speare 0.4.3

actor-like thin abstraction over tokio::task and flume channels
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

mod sync_vec;
use speare::{Actor, Ctx, Node};
use sync_vec::SyncVec;
use tokio::task;

#[derive(Debug, PartialEq, Clone, Copy)]
enum TestMsg {
    Foo,
    Bar,
}

struct Foo;

impl Actor for Foo {
    type Props = SyncVec<TestMsg>;
    type Msg = TestMsg;
    type Err = ();

    async fn init(_: &mut Ctx<Self>) -> Result<Self, Self::Err> {
        Ok(Foo)
    }

    async fn handle(&mut self, msg: Self::Msg, ctx: &mut Ctx<Self>) -> Result<(), Self::Err> {
        ctx.props().push(msg).await;
        Ok(())
    }
}

struct Bar;

impl Actor for Bar {
    type Props = SyncVec<TestMsg>;
    type Msg = TestMsg;
    type Err = ();

    async fn init(_: &mut Ctx<Self>) -> Result<Self, Self::Err> {
        Ok(Bar)
    }

    async fn handle(&mut self, msg: Self::Msg, ctx: &mut Ctx<Self>) -> Result<(), Self::Err> {
        ctx.props().push(msg).await;
        Ok(())
    }
}

#[tokio::test]
async fn sends_msgs_in_correct_order() {
    // Arrange
    let mut node = Node::default();
    let recvd: SyncVec<_> = Default::default();
    let foo = node.actor::<Foo>(recvd.clone()).spawn();
    let bar = node.actor::<Bar>(recvd.clone()).spawn();

    // Act
    foo.send(TestMsg::Foo);
    bar.send(TestMsg::Bar);
    task::yield_now().await;

    // Assert
    assert_eq!(vec![TestMsg::Foo, TestMsg::Bar], recvd.clone_vec().await)
}

#[tokio::test]
async fn send_returns_true_when_actor_alive() {
    let mut node = Node::default();
    let recvd: SyncVec<_> = Default::default();
    let foo = node.actor::<Foo>(recvd).spawn();

    assert!(foo.send(TestMsg::Foo));
}

#[tokio::test]
async fn send_returns_false_when_actor_stopped() {
    let mut node = Node::default();
    let recvd: SyncVec<_> = Default::default();
    let foo = node.actor::<Foo>(recvd).spawn();

    foo.stop();
    task::yield_now().await;
    assert!(!foo.send(TestMsg::Foo));
}