ergo_runtime/trigger/implementations/emit_if_event_and_true/
impl.rs

1use std::collections::HashMap;
2
3use crate::trigger::{TriggerEvent, TriggerPrimitive, TriggerPrimitiveManifest, TriggerValue};
4
5use super::manifest::emit_if_event_and_true_manifest;
6
7pub struct EmitIfEventAndTrue {
8    manifest: TriggerPrimitiveManifest,
9}
10
11impl EmitIfEventAndTrue {
12    pub fn new() -> Self {
13        Self {
14            manifest: emit_if_event_and_true_manifest(),
15        }
16    }
17}
18
19impl Default for EmitIfEventAndTrue {
20    fn default() -> Self {
21        Self::new()
22    }
23}
24
25impl TriggerPrimitive for EmitIfEventAndTrue {
26    fn manifest(&self) -> &TriggerPrimitiveManifest {
27        &self.manifest
28    }
29
30    fn evaluate(
31        &self,
32        inputs: &HashMap<String, TriggerValue>,
33        _parameters: &HashMap<String, crate::trigger::ParameterValue>,
34    ) -> HashMap<String, TriggerValue> {
35        let event = inputs
36            .get("event")
37            .and_then(|v| v.as_event())
38            .expect("missing required event input 'event'");
39        let condition = inputs
40            .get("condition")
41            .and_then(|v| v.as_bool())
42            .expect("missing required bool input 'condition'");
43
44        let gated_event = if matches!(event, TriggerEvent::Emitted) && condition {
45            TriggerEvent::Emitted
46        } else {
47            TriggerEvent::NotEmitted
48        };
49
50        HashMap::from([("event".to_string(), TriggerValue::Event(gated_event))])
51    }
52}
53
54#[cfg(test)]
55mod tests {
56    use super::*;
57
58    fn expect_panic<F: FnOnce() -> R + std::panic::UnwindSafe, R>(f: F) {
59        assert!(std::panic::catch_unwind(f).is_err());
60    }
61
62    #[test]
63    fn emits_when_event_emitted_and_condition_true() {
64        let trigger = EmitIfEventAndTrue::new();
65        let outputs = trigger.evaluate(
66            &HashMap::from([
67                (
68                    "event".to_string(),
69                    TriggerValue::Event(TriggerEvent::Emitted),
70                ),
71                ("condition".to_string(), TriggerValue::Bool(true)),
72            ]),
73            &HashMap::new(),
74        );
75        assert_eq!(
76            outputs.get("event"),
77            Some(&TriggerValue::Event(TriggerEvent::Emitted))
78        );
79    }
80
81    #[test]
82    fn suppresses_when_event_not_emitted() {
83        let trigger = EmitIfEventAndTrue::new();
84        let outputs = trigger.evaluate(
85            &HashMap::from([
86                (
87                    "event".to_string(),
88                    TriggerValue::Event(TriggerEvent::NotEmitted),
89                ),
90                ("condition".to_string(), TriggerValue::Bool(true)),
91            ]),
92            &HashMap::new(),
93        );
94        assert_eq!(
95            outputs.get("event"),
96            Some(&TriggerValue::Event(TriggerEvent::NotEmitted))
97        );
98    }
99
100    #[test]
101    fn suppresses_when_condition_false() {
102        let trigger = EmitIfEventAndTrue::new();
103        let outputs = trigger.evaluate(
104            &HashMap::from([
105                (
106                    "event".to_string(),
107                    TriggerValue::Event(TriggerEvent::Emitted),
108                ),
109                ("condition".to_string(), TriggerValue::Bool(false)),
110            ]),
111            &HashMap::new(),
112        );
113        assert_eq!(
114            outputs.get("event"),
115            Some(&TriggerValue::Event(TriggerEvent::NotEmitted))
116        );
117    }
118
119    #[test]
120    fn missing_event_panics() {
121        let trigger = EmitIfEventAndTrue::new();
122        expect_panic(|| {
123            trigger.evaluate(
124                &HashMap::from([("condition".to_string(), TriggerValue::Bool(true))]),
125                &HashMap::new(),
126            );
127        });
128    }
129
130    #[test]
131    fn missing_condition_panics() {
132        let trigger = EmitIfEventAndTrue::new();
133        expect_panic(|| {
134            trigger.evaluate(
135                &HashMap::from([(
136                    "event".to_string(),
137                    TriggerValue::Event(TriggerEvent::Emitted),
138                )]),
139                &HashMap::new(),
140            );
141        });
142    }
143
144    #[test]
145    fn wrong_event_type_panics() {
146        let trigger = EmitIfEventAndTrue::new();
147        expect_panic(|| {
148            trigger.evaluate(
149                &HashMap::from([
150                    ("event".to_string(), TriggerValue::Bool(true)),
151                    ("condition".to_string(), TriggerValue::Bool(true)),
152                ]),
153                &HashMap::new(),
154            );
155        });
156    }
157
158    #[test]
159    fn wrong_condition_type_panics() {
160        let trigger = EmitIfEventAndTrue::new();
161        expect_panic(|| {
162            trigger.evaluate(
163                &HashMap::from([
164                    (
165                        "event".to_string(),
166                        TriggerValue::Event(TriggerEvent::Emitted),
167                    ),
168                    (
169                        "condition".to_string(),
170                        TriggerValue::Event(TriggerEvent::Emitted),
171                    ),
172                ]),
173                &HashMap::new(),
174            );
175        });
176    }
177}
ergo_runtime/trigger/implementations/emit_if_event_and_true/impl.rs

ergo_runtime/trigger/implementations/emit_if_event_and_true/
impl.rs
