wfe-core 1.9.2

Core traits, models, builder, and executor for the WFE workflow engine
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

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
/// Commandname.
pub enum CommandName {
    /// Processworkflow.
    ProcessWorkflow,
    /// Processevent.
    ProcessEvent,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
/// Scheduledcommand.
pub struct ScheduledCommand {
    /// Command name.
    pub command_name: CommandName,
    /// Data.
    pub data: String,
    /// Epoch milliseconds when the command should execute.
    pub execute_time: i64,
}

impl ScheduledCommand {
    pub fn process_workflow(workflow_id: impl Into<String>, execute_time: i64) -> Self {
        Self {
            command_name: CommandName::ProcessWorkflow,
            data: workflow_id.into(),
            execute_time,
        }
    }

    pub fn process_event(event_id: impl Into<String>, execute_time: i64) -> Self {
        Self {
            command_name: CommandName::ProcessEvent,
            data: event_id.into(),
            execute_time,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use pretty_assertions::assert_eq;

    #[test]
    fn process_workflow_factory() {
        let cmd = ScheduledCommand::process_workflow("wf-123", 1000);
        assert_eq!(cmd.command_name, CommandName::ProcessWorkflow);
        assert_eq!(cmd.data, "wf-123");
        assert_eq!(cmd.execute_time, 1000);
    }

    #[test]
    fn process_event_factory() {
        let cmd = ScheduledCommand::process_event("evt-456", 2000);
        assert_eq!(cmd.command_name, CommandName::ProcessEvent);
        assert_eq!(cmd.data, "evt-456");
        assert_eq!(cmd.execute_time, 2000);
    }

    #[test]
    fn serde_round_trip() {
        let cmd = ScheduledCommand::process_workflow("wf-1", 500);
        let json = serde_json::to_string(&cmd).unwrap();
        let deserialized: ScheduledCommand = serde_json::from_str(&json).unwrap();
        assert_eq!(cmd.command_name, deserialized.command_name);
        assert_eq!(cmd.data, deserialized.data);
        assert_eq!(cmd.execute_time, deserialized.execute_time);
    }
}