jorm 0.1.1

A lightweight DAG execution engine with natural language processing
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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

#[cfg(test)]
mod executor_tests {
    use crate::core::{
        dag::Dag,
        task::{Task, TaskType},
    };
    use crate::executor::TaskExecutor;
    use std::collections::HashMap;

    #[tokio::test]
    async fn test_dependency_resolution_simple() {
        let executor = TaskExecutor::new();
        let mut dag = Dag::new("test_dag".to_string());

        // Create tasks: task_a -> task_b -> task_c
        let task_a = Task {
            name: "task_a".to_string(),
            task_type: TaskType::Shell {
                command: "echo 'task a'".to_string(),
                working_dir: None,
            },
            parameters: HashMap::new(),
        };

        let task_b = Task {
            name: "task_b".to_string(),
            task_type: TaskType::Shell {
                command: "echo 'task b'".to_string(),
                working_dir: None,
            },
            parameters: HashMap::new(),
        };

        let task_c = Task {
            name: "task_c".to_string(),
            task_type: TaskType::Shell {
                command: "echo 'task c'".to_string(),
                working_dir: None,
            },
            parameters: HashMap::new(),
        };

        dag.add_task(task_a);
        dag.add_task(task_b);
        dag.add_task(task_c);

        // task_b depends on task_a, task_c depends on task_b
        dag.add_dependency("task_b".to_string(), vec!["task_a".to_string()]);
        dag.add_dependency("task_c".to_string(), vec!["task_b".to_string()]);

        let execution_order = executor.resolve_execution_order(&dag).unwrap();

        assert_eq!(execution_order, vec!["task_a", "task_b", "task_c"]);
    }

    #[tokio::test]
    async fn test_dependency_resolution_no_dependencies() {
        let executor = TaskExecutor::new();
        let mut dag = Dag::new("test_dag".to_string());

        // Create independent tasks
        let task_a = Task {
            name: "task_a".to_string(),
            task_type: TaskType::Shell {
                command: "echo 'task a'".to_string(),
                working_dir: None,
            },
            parameters: HashMap::new(),
        };

        let task_b = Task {
            name: "task_b".to_string(),
            task_type: TaskType::Shell {
                command: "echo 'task b'".to_string(),
                working_dir: None,
            },
            parameters: HashMap::new(),
        };

        dag.add_task(task_a);
        dag.add_task(task_b);

        let execution_order = executor.resolve_execution_order(&dag).unwrap();

        // Both tasks should be included, order doesn't matter for independent tasks
        assert_eq!(execution_order.len(), 2);
        assert!(execution_order.contains(&"task_a".to_string()));
        assert!(execution_order.contains(&"task_b".to_string()));
    }

    #[tokio::test]
    async fn test_dependency_resolution_parallel_branches() {
        let executor = TaskExecutor::new();
        let mut dag = Dag::new("test_dag".to_string());

        // Create diamond dependency: root -> (branch_a, branch_b) -> final
        let root = Task {
            name: "root".to_string(),
            task_type: TaskType::Shell {
                command: "echo 'root'".to_string(),
                working_dir: None,
            },
            parameters: HashMap::new(),
        };

        let branch_a = Task {
            name: "branch_a".to_string(),
            task_type: TaskType::Shell {
                command: "echo 'branch a'".to_string(),
                working_dir: None,
            },
            parameters: HashMap::new(),
        };

        let branch_b = Task {
            name: "branch_b".to_string(),
            task_type: TaskType::Shell {
                command: "echo 'branch b'".to_string(),
                working_dir: None,
            },
            parameters: HashMap::new(),
        };

        let final_task = Task {
            name: "final".to_string(),
            task_type: TaskType::Shell {
                command: "echo 'final'".to_string(),
                working_dir: None,
            },
            parameters: HashMap::new(),
        };

        dag.add_task(root);
        dag.add_task(branch_a);
        dag.add_task(branch_b);
        dag.add_task(final_task);

        dag.add_dependency("branch_a".to_string(), vec!["root".to_string()]);
        dag.add_dependency("branch_b".to_string(), vec!["root".to_string()]);
        dag.add_dependency(
            "final".to_string(),
            vec!["branch_a".to_string(), "branch_b".to_string()],
        );

        let execution_order = executor.resolve_execution_order(&dag).unwrap();

        // Root should be first, final should be last
        assert_eq!(execution_order[0], "root");
        assert_eq!(execution_order[3], "final");

        // branch_a and branch_b should be in the middle (order doesn't matter)
        let middle_tasks: std::collections::HashSet<_> = execution_order[1..3].iter().collect();
        assert!(middle_tasks.contains(&&"branch_a".to_string()));
        assert!(middle_tasks.contains(&&"branch_b".to_string()));
    }
}