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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
mod session;
pub use session::parse_session_json;
mod data;
pub use data::{parse_statedata_json, statedata_from_jsonval_obj, json_value_from_statedata, json_value_from_val};
mod error;
pub use error::StepFlowParseError;
mod json;
mod step;
mod action;
#[cfg(test)]
mod tests {
use std::collections::HashMap;
use tinyjson::JsonValue;
use stepflow_test_util::test_id;
use stepflow::data::{StringVar, StringValue};
use stepflow::{Session, SessionId, AdvanceBlockedOn};
use stepflow::prelude::*;
use super::{ parse_session_json, statedata_from_jsonval_obj, StepFlowParseError };
const JSON: &str = r#"
{
"vars": {
"first_name": "String",
"last_name": "String",
"email": "Email",
"email_waited": "True",
"nothing": "Bool"
},
"steps": {
"$root": {
"substeps": ["name", "email"],
"outputs": ["first_name","last_name","email", "email_waited"]
},
"name": {
"outputs": ["first_name","last_name"]
},
"email": {
"outputs": ["email", "email_waited"]
}
},
"actions": {
"$all": {
"type": "UriStringTemplate",
"template": "/base-path/{{step}}"
},
"email": {
"type": "SetData",
"stateData": {
"email_waited": "true"
},
"afterAttempt": 2
}
}
}"#;
pub fn create_session(json: &str, allow_implicit_var: bool) -> Result<Session, StepFlowParseError> {
let mut session = Session::new(test_id!(SessionId));
parse_session_json(&mut session, json, allow_implicit_var)?;
Ok(session)
}
#[test]
fn deserialize() {
let mut session = create_session(JSON, false).unwrap();
let name_stepid = session.step_store().get_by_name("name").unwrap().id().clone();
let email_stepid = session.step_store().get_by_name("email").unwrap().id().clone();
let _firstname_var_id = session.var_store().get_by_name("first_name").unwrap().id().clone();
let _email_waited_varid = session.var_store().get_by_name("email_waited").unwrap().id().clone();
let uri_action_id = session.action_store().id_from_name("$all").unwrap().clone();
let name_advance = session.advance(None).unwrap();
assert_eq!(name_advance, AdvanceBlockedOn::ActionStartWith(uri_action_id.clone(), "/base-path/name".parse::<StringValue>().unwrap().boxed()));
let name_advance_fail = session.advance(None).unwrap();
assert_eq!(
name_advance_fail,
AdvanceBlockedOn::ActionStartWith(uri_action_id.clone(), "/base-path/name".parse::<StringValue>().unwrap().boxed()));
let mut data_name = HashMap::new();
data_name.insert("first_name".to_owned(), JsonValue::String("billy".to_owned()));
data_name.insert("last_name".to_owned(), JsonValue::String("bob".to_owned()));
let statedata_name = statedata_from_jsonval_obj(&data_name, session.var_store()).unwrap();
let name_advance_success = session.advance(Some((&name_stepid, statedata_name))).unwrap();
assert_eq!(name_advance_success, AdvanceBlockedOn::ActionStartWith(uri_action_id.clone(), "/base-path/email".parse::<StringValue>().unwrap().boxed()));
let mut data_email = HashMap::new();
data_email.insert("email".to_owned(), JsonValue::String("a@b.com".to_owned()));
let statedata_email = statedata_from_jsonval_obj(&data_email, session.var_store()).unwrap();
let name_advance_success = session.advance(Some((&email_stepid, statedata_email))).unwrap();
assert_eq!(name_advance_success, AdvanceBlockedOn::ActionStartWith(uri_action_id.clone(), "/base-path/email".parse::<StringValue>().unwrap().boxed()));
let name_advance_success = session.advance(None).unwrap();
assert_eq!(name_advance_success, AdvanceBlockedOn::FinishedAdvancing);
}
#[test]
fn session_ids() {
let session1 = create_session(JSON, false).unwrap();
let session2 = create_session(JSON, false).unwrap();
assert_ne!(session1.id(), session2.id());
}
#[test]
fn implicit_vars() {
let json = r#"
{
"steps": {
"$root": {
"substeps": ["step1"],
"outputs": ["test_output"]
},
"step1": { "inputs": ["test_input"], "outputs": ["test_output"] }
},
"actions": {
"$all": { "type": "HtmlForm" }
}
}
"#;
let json = json.to_string();
assert!(matches!(create_session(&json[..], false), Err(_)));
let session = create_session(&json[..], true).unwrap();
assert_eq!(session.var_store().iter_names().count(), 2);
let input_var = session.var_store().get_by_name("test_input").unwrap();
assert!(input_var.is::<StringVar>());
let output_var = session.var_store().get_by_name("test_output").unwrap();
assert!(output_var.is::<StringVar>());
}
}