boardwalk 0.2.0

Hypermedia server framework with reverse-tunnel federation
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

//! Smoke test for the #[device] macro.

use boardwalk::{Device, DeviceConfig, DeviceError, TransitionInput};

pub struct Led {
    pub on: bool,
}

#[boardwalk::device]
impl Led {
    fn config(&self, cfg: &mut DeviceConfig) {
        cfg.type_("led")
            .state(self.state())
            .when("off", &["turn-on"])
            .when("on", &["turn-off"]);
    }

    fn state(&self) -> &str {
        if self.on { "on" } else { "off" }
    }

    #[boardwalk::transition]
    async fn turn_on(&mut self) -> Result<(), DeviceError> {
        self.on = true;
        Ok(())
    }

    #[boardwalk::transition]
    async fn turn_off(&mut self) -> Result<(), DeviceError> {
        self.on = false;
        Ok(())
    }
}

#[tokio::test]
async fn macro_generates_device_impl() {
    let mut led = Led { on: false };
    let mut cfg = DeviceConfig::default();
    led.config(&mut cfg);
    assert_eq!(cfg.type_.as_deref(), Some("led"));
    assert_eq!(<Led as Device>::state(&led), "off");

    led.transition("turn-on", TransitionInput::default())
        .await
        .unwrap();
    assert_eq!(<Led as Device>::state(&led), "on");

    let err = led
        .transition("nope", TransitionInput::default())
        .await
        .unwrap_err();
    assert!(matches!(err, DeviceError::Invalid(_)));
}