opentalk-roomserver-types-timer 0.0.34-alpha

OpenTalk RoomServer Types Timer
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

// SPDX-FileCopyrightText: OpenTalk GmbH <mail@opentalk.eu>
//
// SPDX-License-Identifier: EUPL-1.2

use opentalk_roomserver_signaling::signaling_module::CreateReplica;
use serde::{Deserialize, Serialize};

use crate::{command::Kind, event::TimerEvent};

/// Incoming websocket messages
#[derive(Debug, Serialize, Deserialize)]
#[serde(tag = "action", rename_all = "snake_case")]
pub enum TimerCommand {
    /// Start a new timer
    Start {
        /// The timer kind
        #[serde(flatten)]
        kind: Kind,
        /// An optional string tag to flag this timer with a custom style
        style: Option<String>,
        /// An optional title for the timer
        title: Option<String>,
        /// Flag to allow/disallow participants to mark themselves as ready
        #[serde(default)]
        enable_ready_check: bool,
    },
    /// Stop a running timer
    Stop { reason: Option<String> },
    /// Update the ready status
    UpdateReadyStatus { status: bool },
}

impl CreateReplica<TimerEvent> for TimerCommand {
    fn replicate(&self) -> Option<TimerEvent> {
        None
    }
}

#[cfg(test)]
mod tests {
    use pretty_assertions::assert_eq;
    use serde_json::json;

    use super::*;
    use crate::command::kind::Kind;

    #[test]
    fn countdown_start() {
        let json = json!({
            "action": "start",
            "kind": "countdown",
            "duration": 5,
            "style": "coffee_break",
            "title": null,
            "enable_ready_check": false
        });

        assert_eq!(
            json,
            serde_json::to_value(TimerCommand::Start {
                kind: Kind::Countdown { duration: 5 },
                style: Some("coffee_break".into()),
                title: None,
                enable_ready_check: false
            })
            .unwrap()
        );
    }

    #[test]
    fn stopwatch_start() {
        let json = json!({
            "action": "start",
            "kind": "stopwatch",
            "title": "Testing the timer!",
            "style": null,
            "enable_ready_check": false
        });

        assert_eq!(
            json,
            serde_json::to_value(TimerCommand::Start {
                kind: Kind::Stopwatch,
                style: None,
                title: Some("Testing the timer!".into()),
                enable_ready_check: false
            })
            .unwrap()
        );
    }

    #[test]
    fn stop() {
        let json = json!({
            "action": "stop",
            "reason": "test"
        });

        assert_eq!(
            json,
            serde_json::to_value(TimerCommand::Stop {
                reason: Some("test".into())
            })
            .unwrap()
        );
    }

    #[test]
    fn update_ready_status() {
        let json = json!({
            "action": "update_ready_status",
            "status": true
        });

        assert_eq!(
            json,
            serde_json::to_value(TimerCommand::UpdateReadyStatus { status: true }).unwrap()
        )
    }
}