Implement missing builders

Signed-off-by: Charles d'Avernas <[email protected]>

Author: cdavernas

Cargo.lock

@@ -4,4 +4,6 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-serverless_workflow_core = { path = "../core" }
+serverless_workflow_core = { path = "../core" }
+serde_json = "1.0" 
+serde_yaml = "0.9"

builders/Cargo.toml

@@ -10,6 +10,7 @@ mod unit_tests {
     use serverless_workflow_core::models::task::*;
     use serverless_workflow_core::models::timeout::*;
     use std::collections::HashMap;
+    use serde_json::json;
 
     #[test]
     fn build_workflow_should_work() {
@@ -56,10 +57,50 @@ mod unit_tests {
         let raise_error_title = "error-title";
         let raise_error_detail = "error-detail";
         let raise_error_instance = "error-instance";
-        let run_task_name = "run-task-name";
+        let run_container_task_name = "run-container-task-name";
+        let container_image = "container-image-name";
+        let container_command = "container-command";
+        let container_ports: HashMap<u16, u16> = vec![
+            (8080, 8081),
+            (8082, 8083)]
+            .into_iter()
+            .collect();
+        let container_volumes: HashMap<String, String> = vec![
+            ("volume-1".to_string(), "/some/fake/path".to_string())]
+            .into_iter()
+            .collect();
+        let container_environment: HashMap<String, String> = vec![
+            ("env1-name".to_string(), "env1-value".to_string()),
+            ("env2-name".to_string(), "env2-value".to_string())]
+            .into_iter()
+            .collect();
+        let run_script_task_name = "run-script-task-name";
+        let script_code = "script-code";
+        let run_shell_task_name = "run-shell-task-name";
+        let shell_command_name = "run-shell-command";
+        let run_workflow_task_name = "run-workflow-task-name";
+        let workflow_namespace = "workflow-namespace";
+        let workflow_name = "workflow-name";
+        let workflow_version = "workflow-version";
+        let workflow_input = AnyValue::Json(json!({"hello": "world"}));
         let set_task_name = "set-task-name";
+        let set_task_variables : HashMap<String, AnyValue> = vec![
+            ("var1-name".to_string(), AnyValue::String("var1-value".to_string())),
+            ("var2-name".to_string(), AnyValue::UInt64(69))]
+            .into_iter()
+            .collect();
         let switch_task_name = "switch-task-name";
+        let switch_case_name = "switch-case-name";
+        let switch_case_when = "true";
+        let switch_case_then = "continue";
         let try_task_name = "try-task-name";
+        let catch_when = "catch-when";
+        let catch_errors_attributes: HashMap<String, AnyValue> = vec![
+            ("var1-name".to_string(), AnyValue::String("var1-value".to_string())),
+            ("var2-name".to_string(), AnyValue::UInt64(69))]
+            .into_iter()
+            .collect();
+        let retry_except_when = "retry-except-when";
         let wait_task_name = "wait-task";
         let wait_duration = OneOfDurationOrIso8601Expression::Duration(Duration::from_days(3));
 
@@ -77,57 +118,128 @@ mod unit_tests {
                 a.basic()
                     .with_username(username)
                     .with_password(password);})
-            .do_(call_task_name, |t| {
-                t.call(call_function_name)
+            .do_(call_task_name, |task| {
+                task.call(call_function_name)
                     .with_arguments(call_task_with.clone());
             })
-            .do_(do_task_name, |t| {
-                t.do_()
+            .do_(do_task_name, |task| {
+                task.do_()
                     .do_("fake-wait-task", |st| {
                         st.wait(OneOfDurationOrIso8601Expression::Duration(Duration::from_seconds(25)));
                     });
             })
-            .do_(wait_task_name, |t| {
-                t.wait(wait_duration.clone());
-            })
-            .do_(emit_task_name, |t| {
-                t.emit(|e|{
+            .do_(emit_task_name, |task| {
+                task.emit(|e|{
                     e.with_attributes(emit_event_attributes.clone());
                 });
             })
-            .do_(for_task_name, |t| {
-                t.for_()
+            .do_(for_task_name, |task| {
+                task.for_()
                     .each(for_each)
                     .in_(for_each_in)
                     .at(for_each_at)
                     .do_("fake-wait-task", |st| {
                         st.wait(OneOfDurationOrIso8601Expression::Duration(Duration::from_seconds(25)));
                     });
             })
-            .do_(fork_task_name, |t| {
-                t.fork()
+            .do_(fork_task_name, |task| {
+                task.fork()
                     .branch(|b| {
                         b.do_("fake-wait-task", |st| {
                             st.wait(OneOfDurationOrIso8601Expression::Duration(Duration::from_seconds(25)));
                         });
                     });
             })
-            .do_(listen_task_name, |t| {
-                t.listen()
+            .do_(listen_task_name, |task| {
+                task.listen()
                     .to(|e|{
                         e.one()
                             .with("key", AnyValue::String("value".to_string()));
                     });
             })
-            .do_(raise_task_name, |t| {
-                t.raise()
+            .do_(raise_task_name, |task| {
+                task.raise()
                     .error()
                         .with_type(raise_error_type)
                         .with_status(raise_error_status)
                         .with_title(raise_error_title)
                         .with_detail(raise_error_detail)
                         .with_instance(raise_error_instance);
             })
+            .do_(run_container_task_name, |task|{
+                task.run()
+                    .container()
+                        .with_image(container_image)
+                        .with_command(container_command)
+                        .with_ports(container_ports.clone())
+                        .with_volumes(container_volumes.clone())
+                        .with_environment_variables(container_environment.clone());
+            })
+            .do_(run_script_task_name, |task|{
+                task.run()
+                    .script()
+                        .with_code(script_code);
+            })
+            .do_(run_shell_task_name, |task|{
+                task.run()
+                    .shell()
+                        .with_command(shell_command_name);
+            })
+            .do_(run_workflow_task_name, |task|{
+                task.run()
+                    .workflow()
+                        .with_namespace(workflow_namespace)
+                        .with_name(workflow_name)
+                        .with_version(workflow_version)
+                        .with_input(workflow_input.clone());
+            })
+            .do_(set_task_name, |task|{
+                task.set()
+                    .variables(set_task_variables.clone());
+            })
+            .do_(switch_task_name, |task|{
+                task.switch()
+                    .case(switch_case_name, |case|{
+                        case.when(switch_case_when)
+                            .then(switch_case_then);
+                    });
+
+            })
+            .do_(try_task_name, |task|{
+                task.try_()
+                    .do_(|tasks|{
+                        tasks
+                            .do_("fake-wait-task", |subtask|{
+                                subtask.wait(OneOfDurationOrIso8601Expression::Duration(Duration::from_seconds(5)));
+                            });
+                    })
+                    .catch(|catch| {
+                        catch
+                            .errors(|errors|{
+                                errors
+                                    .with_attributes(catch_errors_attributes.clone());
+                        })
+                            .when(catch_when)
+                            .retry(|retry|{
+                                retry
+                                    .except_when(retry_except_when)
+                                    .delay(Duration::from_seconds(1))
+                                    .backoff(|backoff|{
+                                        backoff
+                                            .linear()
+                                                .with_increment(Duration::from_milliseconds(500));
+                                    })
+                                    .jitter(|jitter|{
+                                        jitter
+                                            .from(Duration::from_seconds(1))
+                                            .to(Duration::from_seconds(3));
+                                    });
+                                });
+                    });
+            })
+            .do_(wait_task_name, |task| {
+                task.wait(wait_duration.clone());
+            })
             .build();
 
         //assert
@@ -262,6 +374,108 @@ mod unit_tests {
             raise_error_title,
             raise_error_detail,
             raise_error_instance);
+        assert!(
+            workflow
+                .do_
+                .entries
+                .iter()
+                .any(|entry| entry.get(&run_container_task_name.to_string()).map_or(false, |task| {
+                    if let TaskDefinition::Run(run_task) = task {
+                        if let Some(container) = &run_task.run.container {
+                            container.image == container_image
+                                && container.command == Some(container_command.to_string())
+                                && container.ports == Some(container_ports.clone())
+                                && container.volumes == Some(container_volumes.clone())
+                                && container.environment == Some(container_environment.clone())
+                        } else {
+                            false
+                        }
+                    } else {
+                        false
+                    }
+                })),
+            "Expected a task with key '{}' and a RunTaskDefinition with 'container.image'={}, 'container.command'={}, 'container.ports'={:?}, 'container.volumes'={:?}, and 'container.environment'={:?}",
+            run_container_task_name,
+            container_image,
+            container_command,
+            container_ports,
+            container_volumes,
+            container_environment);
+        assert!(
+            workflow
+                .do_
+                .entries
+                .iter()
+                .any(|entry| entry.get(&run_workflow_task_name.to_string()).map_or(false, |task| {
+                    if let TaskDefinition::Run(run_task) = task {
+                        if let Some(subflow) = &run_task.run.workflow{
+                            subflow.namespace == workflow_namespace.to_string()
+                                && subflow.name == workflow_name.to_string()
+                                && subflow.version == workflow_version.to_string()
+                                && subflow.input == Some(workflow_input.clone())
+                        }
+                        else{
+                            false
+                        }
+                    } else {
+                        false
+                    }
+                })),
+            "Expected a task with key '{}' and a RunTaskDefinition with 'workflow.namespace'={}, 'workflow.name'={}, 'workflow.version'={}, and 'workflow.input'={:?}",
+            run_container_task_name,
+            workflow_namespace,
+            workflow_name,
+            workflow_version,
+            workflow_input);
+        assert!(
+            workflow
+                .do_
+                .entries
+                .iter()
+                .any(|entry| entry.get(&set_task_name.to_string()).map_or(false, |task|{
+                    if let TaskDefinition::Set(set_task) = task {
+                        set_task.set == set_task_variables.clone()
+                    }
+                    else{
+                        false
+                    }
+                })),
+            "Expected a task with key '{}' and a SetTaskDefinition with specified variables",
+            set_task_name);
+        assert!(
+            workflow
+                .do_
+                .entries
+                .iter()
+                .any(|entry| entry.get(&switch_task_name.to_string()).map_or(false, |task|{
+                    if let TaskDefinition::Switch(switch_task) = task{
+                        switch_task
+                            .switch
+                            .entries
+                            .iter()
+                            .any(|case| case.contains_key(switch_case_name))
+                    }
+                    else{
+                        false
+                    }
+                })),
+            "Expected a task with key '{}' and a SwitchTaskDefinition with a case named '{}'",
+            set_task_name,
+            switch_case_name);
+        assert!(
+            workflow.do_
+                .entries
+                .iter()
+                .any(|entry| entry.get(&try_task_name.to_string()).map_or(false, |task| {
+                    if let TaskDefinition::Try(try_task) = task {
+                        try_task.catch.when == Some(catch_when.to_string())
+                    } else {
+                        false
+                    }
+                })),
+            "Expected a task with key '{}' and a TryTaskDefinition with 'catch.when'={}",
+            try_task_name,
+            catch_when);
         assert!(
             workflow.do_
                 .entries