emitbrown 0.1.9

event emitter based on google swisstable
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

extern crate hashbrown;

use emitbrown::{Emitter, Events};
use hashbrown::HashMap;

#[test]
fn must_register_an_event_and_call_callback_passing_data() {
    let (test, data_inside) = ("TEST".to_owned(), "DATA INSIDE".to_owned());

    let (mut emitter, callback) = (
        Emitter::new(),
        Box::new(
            |event: &mut HashMap<String, String>| match event.get(&test) {
                Some(thing) => {
                    if *thing != data_inside {
                        panic!("the data inside the event is not what is expected, expected {}, get {}", data_inside, *thing);
                    }
                }
                None => panic!("the data expected wasn't found"),
            },
        ),
    );

    emitter.on(&test, callback);

    let mut data: HashMap<String, String> = HashMap::new();
    data.insert(test.clone(), data_inside.clone());
    emitter.emit(&test, &mut data);
}

#[test]
fn must_register_multiple_events_and_call_all_the_callback_passing_a_copy_of_the_same_data() {
    let (test, data_inside) = ("TEST".to_string(), "DATA INSIDE".to_string());
    let (mut emitter, callback, second_callback) = (
        Emitter::new(),
        Box::new(
            |event: &mut HashMap<String, String>| match event.get(&test) {
                Some(thing) => {
                    if *thing != data_inside {
                        panic!(
                        "the data inside the event is not what is expected, expected {}, get {}",
                        data_inside, *thing
                    );
                    }
                }
                None => panic!("the data expected wasn't found"),
            },
        ),
        Box::new(
            |event: &mut HashMap<String, String>| match event.get(&test) {
                Some(thing) => {
                    if *thing != data_inside {
                        panic!(
                        "the data inside the event is not what is expected, expected {}, get {}",
                        data_inside, *thing
                    );
                    }
                }
                None => panic!("the data expected wasn't found"),
            },
        ),
    );

    emitter.on(&test, callback);

    emitter.on(&test, second_callback);

    let mut data: HashMap<String, String> = HashMap::new();
    data.insert(test.clone(), data_inside.clone());
    emitter.emit(&test, &mut data);
}

#[test]
fn must_unregister_an_event() {
    let (test, data_inside) = ("TEST".to_string(), "DATA INSIDE".to_string());
    let (mut emitter, callback) = (
        Emitter::new(),
        Box::new(|event: &mut HashMap<String, String>| {
            panic!(
                "the emitter must never be called instead has been called with {} parameters",
                event.capacity()
            );
        }),
    );

    emitter.on(&test, callback);

    let mut data: HashMap<String, String> = HashMap::new();
    data.insert(test.clone(), data_inside.clone());
    emitter.off(&test);
    emitter.emit(&test, &mut data);
}

#[test]
fn must_work_with_a_custom_event_data_and_allow_the_callback_to_modified_it() {
    struct Foo {
        bar: String,
    };

    let (test, data_inside) = ("TEST".to_string(), "DATA INSIDE".to_string());

    let (mut emitter, callback) = (
        Emitter::new(),
        Box::new(|event: &mut HashMap<String, Foo>| {
            match event.get(&test) {
                Some(thing) => {
                    if (*thing).bar != data_inside {
                        panic!(
                        "the data inside the event is not what is expected, expected {}, get {}",
                        data_inside,
                        (*thing).bar
                    );
                    }
                }
                None => panic!("the data expected wasn't found"),
            }
            event.insert(
                "Result".to_string(),
                Foo {
                    bar: "HAHAHA".to_string(),
                },
            );
        }),
    );

    emitter.on(&test, callback);

    let mut data: HashMap<String, Foo> = HashMap::new();
    data.insert(
        test.clone(),
        Foo {
            bar: data_inside.clone(),
        },
    );
    emitter.emit(&test, &mut data);
    match data.get(&"Result".to_string()) {
        Some(ref data) => {
            if data.bar != "HAHAHA".to_string() {
                panic!("Doesn't pass back values")
            }
        }
        _ => panic!("Doesn't pass back values"),
    }
}