acts-next 0.15.5

a fast, tiny, extensiable 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
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

mod acts;
mod catch;
mod setup;
mod timeout;

use crate::{Act, Step, Workflow};
use serde_json::json;

#[test]
fn model_step_yml_simple() {
    let text = r#"
    name: workflow
    id: m1
    steps:
        - id: act1
    "#;
    let m = Workflow::from_yml(text).unwrap();
    assert_eq!(m.steps.len(), 1);
    assert_eq!(m.steps.first().unwrap().id, "act1");
}

#[test]
fn model_step_yml_inputs() {
    let text = r#"
    name: workflow
    id: m1
    steps:
        - id: act1
          inputs:
            p1: 5
    "#;
    let m = Workflow::from_yml(text).unwrap();
    assert_eq!(m.steps.len(), 1);
    assert_eq!(m.steps.first().unwrap().id, "act1");

    let step = m.steps.first().unwrap();
    assert_eq!(step.inputs.len(), 1);
    assert_eq!(step.inputs.get_value("p1"), Some(&json!(5)));
}

#[test]
fn model_step_yml_outputs() {
    let text = r#"
    name: workflow
    id: m1
    steps:
        - id: act1
          outputs:
            p1:
    "#;
    let m = Workflow::from_yml(text).unwrap();
    assert_eq!(m.steps.len(), 1);
    assert_eq!(m.steps.first().unwrap().id, "act1");

    let step = m.steps.first().unwrap();
    assert_eq!(step.outputs.len(), 1);
    assert_eq!(step.outputs.get_value("p1"), Some(&json!(null)));
}

#[test]
fn model_step_id() {
    let step = Step::new().with_id("step1");
    assert_eq!(step.id, "step1");
}

#[test]
fn model_step_name() {
    let step = Step::new().with_name("my name");
    assert_eq!(step.name, "my name");
}

#[test]
fn model_step_inputs() {
    let step = Step::new().with_input("p1", json!(5));
    assert_eq!(step.inputs.len(), 1);
    assert_eq!(step.inputs.get_value("p1"), Some(&json!(5)));
}

#[test]
fn model_step_outputs() {
    let step = Step::new().with_output("p1", json!(5));
    assert_eq!(step.outputs.len(), 1);
    assert!(step.outputs.get_value("p1").is_some());
}

#[test]
fn model_step_tag() {
    let step = Step::new().with_tag("tag1");
    assert_eq!(step.tag, "tag1");
}

#[test]
fn model_step_run() {
    let step = Step::new().with_run(r#"print("run")"#);
    assert!(step.run.is_some());
}

#[test]
fn model_step_next() {
    let mut step = Step::new();
    assert!(step.next.is_none());

    step = step.with_next("step1");
    assert_eq!(step.next.unwrap(), "step1");
}

#[test]
fn model_step_branches() {
    let mut step = Step::new();
    assert_eq!(step.branches.len(), 0);

    step = step
        .with_branch(|b| b.with_id("b1"))
        .with_branch(|b| b.with_id("b2"));
    assert_eq!(step.branches.len(), 2);
}

#[test]
fn model_step_acts() {
    let mut step = Step::new();
    assert_eq!(step.acts.len(), 0);

    step = step
        .with_act(Act::irq(|act| act.with_key("act1")))
        .with_act(Act::irq(|act| act.with_key("act2")));
    assert_eq!(step.acts.len(), 2);
}

#[test]
fn model_step_uses() {
    let step = Step::new().with_uses("p1");
    assert_eq!(step.uses.unwrap(), "p1");
}