Skip to content

Commit e244469

Browse files
cdavernascdavernas
committed
Implement missing builders
Signed-off-by: Charles d'Avernas <charles.davernas@neuroglia.io>
1 parent 8d199db commit e244469

File tree

10 files changed

+1225
-66
lines changed

10 files changed

+1225
-66
lines changed

‎Cargo.lock

Lines changed: 2 additions & 0 deletions
Some generated files are not rendered by default. Learn more about customizing how changed files appear on GitHub.

‎builders/Cargo.toml

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -4,4 +4,6 @@ version = "0.1.0"
44
edition = "2021"
55

66
[dependencies]
7-
serverless_workflow_core = { path = "../core" }
7+
serverless_workflow_core = { path = "../core" }
8+
serde_json = "1.0"
9+
serde_yaml = "0.9"

‎builders/src/lib.rs

Lines changed: 232 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -10,6 +10,7 @@ mod unit_tests {
1010
use serverless_workflow_core::models::task::*;
1111
use serverless_workflow_core::models::timeout::*;
1212
use std::collections::HashMap;
13+
use serde_json::json;
1314

1415
#[test]
1516
fn build_workflow_should_work() {
@@ -56,10 +57,50 @@ mod unit_tests {
5657
let raise_error_title = "error-title";
5758
let raise_error_detail = "error-detail";
5859
let raise_error_instance = "error-instance";
59-
let run_task_name = "run-task-name";
60+
let run_container_task_name = "run-container-task-name";
61+
let container_image = "container-image-name";
62+
let container_command = "container-command";
63+
let container_ports: HashMap<u16, u16> = vec![
64+
(8080, 8081),
65+
(8082, 8083)]
66+
.into_iter()
67+
.collect();
68+
let container_volumes: HashMap<String, String> = vec![
69+
("volume-1".to_string(), "/some/fake/path".to_string())]
70+
.into_iter()
71+
.collect();
72+
let container_environment: HashMap<String, String> = vec![
73+
("env1-name".to_string(), "env1-value".to_string()),
74+
("env2-name".to_string(), "env2-value".to_string())]
75+
.into_iter()
76+
.collect();
77+
let run_script_task_name = "run-script-task-name";
78+
let script_code = "script-code";
79+
let run_shell_task_name = "run-shell-task-name";
80+
let shell_command_name = "run-shell-command";
81+
let run_workflow_task_name = "run-workflow-task-name";
82+
let workflow_namespace = "workflow-namespace";
83+
let workflow_name = "workflow-name";
84+
let workflow_version = "workflow-version";
85+
let workflow_input = AnyValue::Json(json!({"hello": "world"}));
6086
let set_task_name = "set-task-name";
87+
let set_task_variables : HashMap<String, AnyValue> = vec![
88+
("var1-name".to_string(), AnyValue::String("var1-value".to_string())),
89+
("var2-name".to_string(), AnyValue::UInt64(69))]
90+
.into_iter()
91+
.collect();
6192
let switch_task_name = "switch-task-name";
93+
let switch_case_name = "switch-case-name";
94+
let switch_case_when = "true";
95+
let switch_case_then = "continue";
6296
let try_task_name = "try-task-name";
97+
let catch_when = "catch-when";
98+
let catch_errors_attributes: HashMap<String, AnyValue> = vec![
99+
("var1-name".to_string(), AnyValue::String("var1-value".to_string())),
100+
("var2-name".to_string(), AnyValue::UInt64(69))]
101+
.into_iter()
102+
.collect();
103+
let retry_except_when = "retry-except-when";
63104
let wait_task_name = "wait-task";
64105
let wait_duration = OneOfDurationOrIso8601Expression::Duration(Duration::from_days(3));
65106

@@ -77,57 +118,128 @@ mod unit_tests {
77118
a.basic()
78119
.with_username(username)
79120
.with_password(password);})
80-
.do_(call_task_name, |t| {
81-
t.call(call_function_name)
121+
.do_(call_task_name, |task| {
122+
task.call(call_function_name)
82123
.with_arguments(call_task_with.clone());
83124
})
84-
.do_(do_task_name, |t| {
85-
t.do_()
125+
.do_(do_task_name, |task| {
126+
task.do_()
86127
.do_("fake-wait-task", |st| {
87128
st.wait(OneOfDurationOrIso8601Expression::Duration(Duration::from_seconds(25)));
88129
});
89130
})
90-
.do_(wait_task_name, |t| {
91-
t.wait(wait_duration.clone());
92-
})
93-
.do_(emit_task_name, |t| {
94-
t.emit(|e|{
131+
.do_(emit_task_name, |task| {
132+
task.emit(|e|{
95133
e.with_attributes(emit_event_attributes.clone());
96134
});
97135
})
98-
.do_(for_task_name, |t| {
99-
t.for_()
136+
.do_(for_task_name, |task| {
137+
task.for_()
100138
.each(for_each)
101139
.in_(for_each_in)
102140
.at(for_each_at)
103141
.do_("fake-wait-task", |st| {
104142
st.wait(OneOfDurationOrIso8601Expression::Duration(Duration::from_seconds(25)));
105143
});
106144
})
107-
.do_(fork_task_name, |t| {
108-
t.fork()
145+
.do_(fork_task_name, |task| {
146+
task.fork()
109147
.branch(|b| {
110148
b.do_("fake-wait-task", |st| {
111149
st.wait(OneOfDurationOrIso8601Expression::Duration(Duration::from_seconds(25)));
112150
});
113151
});
114152
})
115-
.do_(listen_task_name, |t| {
116-
t.listen()
153+
.do_(listen_task_name, |task| {
154+
task.listen()
117155
.to(|e|{
118156
e.one()
119157
.with("key", AnyValue::String("value".to_string()));
120158
});
121159
})
122-
.do_(raise_task_name, |t| {
123-
t.raise()
160+
.do_(raise_task_name, |task| {
161+
task.raise()
124162
.error()
125163
.with_type(raise_error_type)
126164
.with_status(raise_error_status)
127165
.with_title(raise_error_title)
128166
.with_detail(raise_error_detail)
129167
.with_instance(raise_error_instance);
130168
})
169+
.do_(run_container_task_name, |task|{
170+
task.run()
171+
.container()
172+
.with_image(container_image)
173+
.with_command(container_command)
174+
.with_ports(container_ports.clone())
175+
.with_volumes(container_volumes.clone())
176+
.with_environment_variables(container_environment.clone());
177+
})
178+
.do_(run_script_task_name, |task|{
179+
task.run()
180+
.script()
181+
.with_code(script_code);
182+
})
183+
.do_(run_shell_task_name, |task|{
184+
task.run()
185+
.shell()
186+
.with_command(shell_command_name);
187+
})
188+
.do_(run_workflow_task_name, |task|{
189+
task.run()
190+
.workflow()
191+
.with_namespace(workflow_namespace)
192+
.with_name(workflow_name)
193+
.with_version(workflow_version)
194+
.with_input(workflow_input.clone());
195+
})
196+
.do_(set_task_name, |task|{
197+
task.set()
198+
.variables(set_task_variables.clone());
199+
})
200+
.do_(switch_task_name, |task|{
201+
task.switch()
202+
.case(switch_case_name, |case|{
203+
case.when(switch_case_when)
204+
.then(switch_case_then);
205+
});
206+
207+
})
208+
.do_(try_task_name, |task|{
209+
task.try_()
210+
.do_(|tasks|{
211+
tasks
212+
.do_("fake-wait-task", |subtask|{
213+
subtask.wait(OneOfDurationOrIso8601Expression::Duration(Duration::from_seconds(5)));
214+
});
215+
})
216+
.catch(|catch| {
217+
catch
218+
.errors(|errors|{
219+
errors
220+
.with_attributes(catch_errors_attributes.clone());
221+
})
222+
.when(catch_when)
223+
.retry(|retry|{
224+
retry
225+
.except_when(retry_except_when)
226+
.delay(Duration::from_seconds(1))
227+
.backoff(|backoff|{
228+
backoff
229+
.linear()
230+
.with_increment(Duration::from_milliseconds(500));
231+
})
232+
.jitter(|jitter|{
233+
jitter
234+
.from(Duration::from_seconds(1))
235+
.to(Duration::from_seconds(3));
236+
});
237+
});
238+
});
239+
})
240+
.do_(wait_task_name, |task| {
241+
task.wait(wait_duration.clone());
242+
})
131243
.build();
132244

133245
//assert
@@ -262,6 +374,108 @@ mod unit_tests {
262374
raise_error_title,
263375
raise_error_detail,
264376
raise_error_instance);
377+
assert!(
378+
workflow
379+
.do_
380+
.entries
381+
.iter()
382+
.any(|entry| entry.get(&run_container_task_name.to_string()).map_or(false, |task| {
383+
if let TaskDefinition::Run(run_task) = task {
384+
if let Some(container) = &run_task.run.container {
385+
container.image == container_image
386+
&& container.command == Some(container_command.to_string())
387+
&& container.ports == Some(container_ports.clone())
388+
&& container.volumes == Some(container_volumes.clone())
389+
&& container.environment == Some(container_environment.clone())
390+
} else {
391+
false
392+
}
393+
} else {
394+
false
395+
}
396+
})),
397+
"Expected a task with key '{}' and a RunTaskDefinition with 'container.image'={}, 'container.command'={}, 'container.ports'={:?}, 'container.volumes'={:?}, and 'container.environment'={:?}",
398+
run_container_task_name,
399+
container_image,
400+
container_command,
401+
container_ports,
402+
container_volumes,
403+
container_environment);
404+
assert!(
405+
workflow
406+
.do_
407+
.entries
408+
.iter()
409+
.any(|entry| entry.get(&run_workflow_task_name.to_string()).map_or(false, |task| {
410+
if let TaskDefinition::Run(run_task) = task {
411+
if let Some(subflow) = &run_task.run.workflow{
412+
subflow.namespace == workflow_namespace.to_string()
413+
&& subflow.name == workflow_name.to_string()
414+
&& subflow.version == workflow_version.to_string()
415+
&& subflow.input == Some(workflow_input.clone())
416+
}
417+
else{
418+
false
419+
}
420+
} else {
421+
false
422+
}
423+
})),
424+
"Expected a task with key '{}' and a RunTaskDefinition with 'workflow.namespace'={}, 'workflow.name'={}, 'workflow.version'={}, and 'workflow.input'={:?}",
425+
run_container_task_name,
426+
workflow_namespace,
427+
workflow_name,
428+
workflow_version,
429+
workflow_input);
430+
assert!(
431+
workflow
432+
.do_
433+
.entries
434+
.iter()
435+
.any(|entry| entry.get(&set_task_name.to_string()).map_or(false, |task|{
436+
if let TaskDefinition::Set(set_task) = task {
437+
set_task.set == set_task_variables.clone()
438+
}
439+
else{
440+
false
441+
}
442+
})),
443+
"Expected a task with key '{}' and a SetTaskDefinition with specified variables",
444+
set_task_name);
445+
assert!(
446+
workflow
447+
.do_
448+
.entries
449+
.iter()
450+
.any(|entry| entry.get(&switch_task_name.to_string()).map_or(false, |task|{
451+
if let TaskDefinition::Switch(switch_task) = task{
452+
switch_task
453+
.switch
454+
.entries
455+
.iter()
456+
.any(|case| case.contains_key(switch_case_name))
457+
}
458+
else{
459+
false
460+
}
461+
})),
462+
"Expected a task with key '{}' and a SwitchTaskDefinition with a case named '{}'",
463+
set_task_name,
464+
switch_case_name);
465+
assert!(
466+
workflow.do_
467+
.entries
468+
.iter()
469+
.any(|entry| entry.get(&try_task_name.to_string()).map_or(false, |task| {
470+
if let TaskDefinition::Try(try_task) = task {
471+
try_task.catch.when == Some(catch_when.to_string())
472+
} else {
473+
false
474+
}
475+
})),
476+
"Expected a task with key '{}' and a TryTaskDefinition with 'catch.when'={}",
477+
try_task_name,
478+
catch_when);
265479
assert!(
266480
workflow.do_
267481
.entries

0 commit comments

Comments
 (0)
pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy