test(designer): add test ut to sequencify

packages/designer/jest.config.js

@@ -20,6 +20,7 @@ const jestConfig = {
   // testMatch: ['**/node.test.ts'],
   // testMatch: ['**/builtin-hotkey.test.ts'],
   // testMatch: ['**/selection.test.ts'],
+  // testMatch: ['**/plugin/sequencify.test.ts'],
   transformIgnorePatterns: [
     `/node_modules/(?!${esModules})/`,
   ],

packages/designer/src/plugin/sequencify.ts

@@ -1,19 +1,50 @@
-function sequence(tasks, names, results, missing, recursive, nest) {
+interface ITaks {
+  [key: string]: {
+    name: string;
+    dep: string[];
+  };
+}
+
+export function sequence({
+  tasks,
+  names,
+  results,
+  missing,
+  recursive,
+  nest,
+  parentName,
+}: {
+  tasks: ITaks;
+  names: string[];
+  results: string[];
+  missing: string[];
+  recursive: string[][];
+  nest: string[];
+  parentName: string;
+}) {
   names.forEach((name) => {
     if (results.indexOf(name) !== -1) {
       return; // de-dup results
     }
     const node = tasks[name];
     if (!node) {
-      missing.push(name);
+      missing.push([parentName, name].filter((d => !!d)).join('.'));
     } else if (nest.indexOf(name) > -1) {
       nest.push(name);
       recursive.push(nest.slice(0));
-      nest.pop(name);
+      nest.pop();
     } else if (node.dep.length) {
       nest.push(name);
-      sequence(tasks, node.dep, results, missing, recursive, nest); // recurse
+      sequence({
-      nest.pop(name);
+        tasks,
+        parentName: name,
+        names: node.dep,
+        results,
+        missing,
+        recursive,
+        nest,
+      }); // recurse
+      nest.pop();
     }
     results.push(name);
   });
@@ -21,12 +52,19 @@ function sequence(tasks, names, results, missing, recursive, nest) {
 
 // tasks: object with keys as task names
 // names: array of task names
-export default function (tasks, names) {
+export default function (tasks: ITaks, names: string[]) {
-  let results = []; // the final sequence
+  let results: string[] = []; // the final sequence
-  const missing = []; // missing tasks
+  const missing: string[] = []; // missing tasks
-  const recursive = []; // recursive task dependencies
+  const recursive: string[][] = []; // recursive task dependencies
 
-  sequence(tasks, names, results, missing, recursive, []);
+  sequence({
+    tasks,
+    names,
+    results,
+    missing,
+    recursive,
+    nest: [],
+  });
 
   if (missing.length || recursive.length) {
     results = []; // results are incomplete at best, completely wrong at worst, remove them to avoid confusion

packages/designer/tests/plugin/sequencify.test.ts

@@ -0,0 +1,128 @@
+import sequencify, { sequence } from '../../src/plugin/sequencify';
+
+describe('sequence', () => {
+  it('handles tasks with no dependencies', () => {
+    const tasks = {
+      task1: { name: 'Task 1', dep: [] },
+      task2: { name: 'Task 2', dep: [] }
+    };
+    const results = [];
+    const missing = [];
+    const recursive = [];
+    sequence({ tasks, names: ['task1', 'task2'], results, missing, recursive, nest: [] });
+
+    expect(results).toEqual(['task1', 'task2']);
+    expect(missing).toEqual([]);
+    expect(recursive).toEqual([]);
+  });
+
+  it('correctly orders tasks based on dependencies', () => {
+    const tasks = {
+      task1: { name: 'Task 1', dep: [] },
+      task2: { name: 'Task 2', dep: ['task1'] }
+    };
+    const results = [];
+    const missing = [];
+    const recursive = [];
+    sequence({ tasks, names: ['task2', 'task1'], results, missing, recursive, nest: [] });
+
+    expect(results).toEqual(['task1', 'task2']);
+    expect(missing).toEqual([]);
+    expect(recursive).toEqual([]);
+  });
+
+  it('identifies missing tasks', () => {
+    const tasks = {
+      task1: { name: 'Task 1', dep: [] }
+    };
+    const results = [];
+    const missing = [];
+    const recursive = [];
+    const nest = []
+    sequence({ tasks, names: ['task2'], results, missing, recursive, nest });
+
+    expect(results).toEqual(['task2']);
+    expect(missing).toEqual(['task2']);
+    expect(recursive).toEqual([]);
+    expect(nest).toEqual([]);
+  });
+
+  it('detects recursive dependencies', () => {
+    const tasks = {
+      task1: { name: 'Task 1', dep: ['task2'] },
+      task2: { name: 'Task 2', dep: ['task1'] }
+    };
+    const results = [];
+    const missing = [];
+    const recursive = [];
+    const nest = []
+    sequence({ tasks, names: ['task1', 'task2'], results, missing, recursive, nest });
+
+    expect(results).toEqual(['task1', 'task2', 'task1']);
+    expect(missing).toEqual([]);
+    expect(recursive).toEqual([['task1', 'task2', 'task1']]);
+    expect(nest).toEqual([]);
+  });
+});
+
+describe('sequence', () => {
+
+  it('should return tasks in sequence without dependencies', () => {
+    const tasks = {
+      task1: { name: 'Task 1', dep: [] },
+      task2: { name: 'Task 2', dep: [] },
+      task3: { name: 'Task 3', dep: [] }
+    };
+    const names = ['task1', 'task2', 'task3'];
+    const expected = {
+      sequence: ['task1', 'task2', 'task3'],
+      missingTasks: [],
+      recursiveDependencies: []
+    };
+    expect(sequencify(tasks, names)).toEqual(expected);
+  });
+
+  it('should handle tasks with dependencies', () => {
+    const tasks = {
+      task1: { name: 'Task 1', dep: [] },
+      task2: { name: 'Task 2', dep: ['task1'] },
+      task3: { name: 'Task 3', dep: ['task2'] }
+    };
+    const names = ['task3', 'task2', 'task1'];
+    const expected = {
+      sequence: ['task1', 'task2', 'task3'],
+      missingTasks: [],
+      recursiveDependencies: []
+    };
+    expect(sequencify(tasks, names)).toEqual(expected);
+  });
+
+  it('should identify missing tasks', () => {
+    const tasks = {
+      task1: { name: 'Task 1', dep: [] },
+      task2: { name: 'Task 2', dep: ['task3'] } // task3 is missing
+    };
+    const names = ['task1', 'task2'];
+    const expected = {
+      sequence: [],
+      missingTasks: ['task2.task3'],
+      recursiveDependencies: []
+    };
+    expect(sequencify(tasks, names)).toEqual(expected);
+  });
+
+  it('should detect recursive dependencies', () => {
+    const tasks = {
+      task1: { name: 'Task 1', dep: ['task2'] },
+      task2: { name: 'Task 2', dep: ['task1'] } // Recursive dependency
+    };
+    const names = ['task1', 'task2'];
+    const expected = {
+      sequence: [],
+      missingTasks: [],
+      recursiveDependencies: [['task1', 'task2', 'task1']]
+    };
+    expect(sequencify(tasks, names)).toEqual(expected);
+  });
+
+});