aector 0.1.1

Dynamic implementation of the actor model with a smart built-in testing 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
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

use std::any::Any;
use std::collections::VecDeque;
use std::time::Duration;
use aector::actor::{Actor, MailboxType};
use aector::actor_system::ActorSystem;
use aector::behavior::{ActorManageMessage, Behavior, BehaviorBuilder, BehaviorAction, StateCheckMessage};
use aector::{Addr, Message};
use aector::testing::{MessageType, Response, TestActor, ActorTestBuilder};
use crate::Direction::{DOWN, UP};

fn main() {}

#[derive(PartialEq)]
enum Direction {
    UP, DOWN
}

struct SimpleState {
    state: Direction
}

enum SimpleMessage {
    SetUp, SetDown
}

#[cfg(test)]
mod tests {
    use aector::actor::MailboxType;
    use super::*;

    // tests have to be tagged with tokio::test such that those are run with an async runtime
    #[tokio::test]
    async fn main2() {

        // define simple example actor for showing testing functions
        let simple_state = SimpleState {
            state: UP
        };

        let simple_behavior = BehaviorBuilder::new()
            .on_start(|state: &mut SimpleState, ctx| {
                state.state = DOWN;
            })
            .on_ask::<SimpleMessage>(|msg, state, reply_to, ctx| -> BehaviorAction<SimpleState> {
                match msg {
                    SimpleMessage::SetUp => {
                        state.state = UP;
                    }
                    SimpleMessage::SetDown => {
                        state.state = DOWN;
                    }
                }

                reply_to.tell("OK".to_string());

                Behavior::keep()
            })
            .on_ask::<String>(|msg, state, reply_to, ctx| -> BehaviorAction<SimpleState> {

                if msg == "ECHO" {
                    reply_to.tell("ECHO ECHO".to_string());
                } else {
                    reply_to.tell(msg);
                }

                Behavior::keep()
            })
            .enable_state_checks()
            .build();


        let actor = Actor::new(simple_state, simple_behavior, MailboxType::Unbounded);
        let addr = actor.get_addr();

        let sys = ActorSystem::new();
        sys.spawn(actor, "actor to be tested".to_string());

        // define test actor
        let test_actor = ActorTestBuilder::new(addr)
            .check(|state: &SimpleState| state.state == DOWN)
            .ask(SimpleMessage::SetUp, Response::Tell(|msg: String| msg == "OK".to_string()))
            .check(|state: &SimpleState| state.state == UP)
            .ask("ECHO".to_string(), Response::Tell(|msg: String| msg == "ECHO ECHO".to_string()))
            .ask("RANDOM".to_string(), Response::Tell(|msg: String| msg == "RANDOM".to_string()))
            .tell(ActorManageMessage::Kill)
            .build();

        // get test result: true = test passed, false = test failed
        let test_res = sys.spawn_test(test_actor).await;
        assert_eq!(test_res, true);

        sys.start().await;

    }

}

#[tokio::test]
async fn simple_actor_test() {
    // define a simple behavior for an i32 state
    let behavior = BehaviorBuilder::new()
        .on_tell::<i32>(|msg, state, ctx| -> BehaviorAction<i32> {
            *state += msg;
            Behavior::keep()
        })
        .enable_state_checks()
        .build();
    let actor = Actor::new(0, behavior, MailboxType::Unbounded);
    let addr = actor.get_addr();

    // create an empty actorsystem
    let sys = ActorSystem::new();
    sys.spawn(actor, "actor to be tested".to_string());

    // define test
    let test_actor = ActorTestBuilder::new(addr)
        .check(|state: &i32| *state == 0)
        .tell(10)
        .check(|state| *state == 10)
        .tell(ActorManageMessage::Kill)
        .build();

    let test_res = sys.spawn_test(test_actor).await;
    assert_eq!(test_res, true);

    // start actorsystem to run actors
    sys.start().await;
}