freelang-editor 11.7.4

package/src/test-p0-error-handling.ts

@@ -0,0 +1,231 @@
+// Test suite for P0-1: Task error handling
+// Tests: on_error, fallback, combined error handling
+
+import { createWorkflowModule } from "./stdlib-workflow";
+import { createTimeModule } from "./stdlib-time";
+
+const WF = createWorkflowModule();
+const T = createTimeModule();
+
+interface TestResult {
+  passed: number;
+  failed: number;
+  tests: Array<{ name: string; ok: boolean; reason?: string }>;
+}
+
+const results: TestResult = { passed: 0, failed: 0, tests: [] };
+
+function test(name: string, fn: () => boolean) {
+  try {
+    const ok = fn();
+    if (ok) {
+      results.passed++;
+      results.tests.push({ name, ok: true });
+      console.log(`✓ ${name}`);
+    } else {
+      results.failed++;
+      results.tests.push({ name, ok: false, reason: "assertion failed" });
+      console.log(`✗ ${name} — assertion failed`);
+    }
+  } catch (err: any) {
+    results.failed++;
+    results.tests.push({ name, ok: false, reason: err.message });
+    console.log(`✗ ${name} — ${err.message}`);
+  }
+}
+
+// ── Test 1: on_error handler
+test("P0-1-01: on_error handler catches error", () => {
+  const step = WF["workflow_step"]("test", (ctx) => {
+    throw new Error("Step failed!");
+  }, {
+    on_error: (err) => ({ error_caught: err.error }),
+  });
+
+  const workflow = WF["workflow_create"]("error-test", [step]);
+  const result = WF["workflow_run"](workflow, {});
+
+  // Step should succeed due to on_error handling
+  return result.status === "success" && result.context.error_caught === "Step failed!";
+});
+
+// ── Test 2: fallback used
+test("P0-1-02: fallback value replaces failed step", () => {
+  const step = WF["workflow_step"]("test", (ctx) => {
+    throw new Error("Network error");
+  }, {
+    fallback: { data: [], status: "cached" },
+  });
+
+  const workflow = WF["workflow_create"]("fallback-test", [step]);
+  const result = WF["workflow_run"](workflow, {});
+
+  return result.status === "success" &&
+    result.context.data !== undefined &&
+    result.context.status === "cached";
+});
+
+// ── Test 3: on_error takes precedence over fallback
+test("P0-1-03: on_error handler runs before fallback", () => {
+  let handlerCalled = false;
+
+  const step = WF["workflow_step"]("test", (ctx) => {
+    throw new Error("Failed");
+  }, {
+    on_error: (err) => {
+      handlerCalled = true;
+      return { handled: true };
+    },
+    fallback: { fallback: true },
+  });
+
+  const workflow = WF["workflow_create"]("precedence-test", [step]);
+  const result = WF["workflow_run"](workflow, {});
+
+  // on_error handler should have run (handled=true, not fallback=true)
+  return result.context.handled === true && result.context.fallback === undefined;
+});
+
+// ── Test 4: fallback with function
+test("P0-1-04: fallback function is called", () => {
+  const step = WF["workflow_step"]("test", (ctx) => {
+    throw new Error("Error");
+  }, {
+    fallback: () => ({ computed: 42 }),
+  });
+
+  const workflow = WF["workflow_create"]("fallback-fn-test", [step]);
+  const result = WF["workflow_run"](workflow, {});
+
+  return result.context.computed === 42;
+});
+
+// ── Test 5: required=false still applies with error handling
+test("P0-1-05: optional step with fallback continues workflow", () => {
+  let step2Executed = false;
+
+  const steps = [
+    WF["workflow_step"]("step1", (ctx) => {
+      throw new Error("Step 1 failed");
+    }, {
+      required: false,
+      fallback: { step1_result: "fallback" },
+    }),
+    WF["workflow_step"]("step2", (ctx) => {
+      step2Executed = true;
+      return { step2_result: "ok" };
+    }),
+  ];
+
+  const workflow = WF["workflow_create"]("optional-test", steps);
+  const result = WF["workflow_run"](workflow, {});
+
+  return result.status === "success" &&
+    step2Executed &&
+    result.context.step1_result === "fallback" &&
+    result.context.step2_result === "ok";
+});
+
+// ── Test 6: error handler that also throws
+test("P0-1-06: error handler throwing falls back to fallback", () => {
+  const step = WF["workflow_step"]("test", (ctx) => {
+    throw new Error("Primary error");
+  }, {
+    on_error: (err) => {
+      throw new Error("Handler also failed");
+    },
+    fallback: { error: "all_failed" },
+  });
+
+  const workflow = WF["workflow_create"]("handler-error-test", [step]);
+  const result = WF["workflow_run"](workflow, {});
+
+  return result.status === "success" && result.context.error === "all_failed";
+});
+
+// ── Test 7: error handler receives error details
+test("P0-1-07: on_error receives error object with metadata", () => {
+  let receivedErr: any = null;
+
+  const step = WF["workflow_step"]("test", (ctx) => {
+    throw new Error("Test error message");
+  }, {
+    on_error: (err) => {
+      receivedErr = err;
+      return { ok: true };
+    },
+  });
+
+  const workflow = WF["workflow_create"]("error-details-test", [step]);
+  WF["workflow_run"](workflow, {});
+
+  return receivedErr !== null &&
+    receivedErr.error === "Test error message" &&
+    receivedErr.step_name === "test";
+});
+
+// ── Test 8: workflow continues after successful error recovery
+test("P0-1-08: workflow context updated with error handler result", () => {
+  const steps = [
+    WF["workflow_step"]("fetch", (ctx) => {
+      throw new Error("API timeout");
+    }, {
+      on_error: (err) => ({ cached_users: ["user1", "user2"] }),
+    }),
+    WF["workflow_step"]("process", (ctx) => {
+      // Should be able to access cached_users from previous step
+      return { processed_count: ctx.cached_users.length };
+    }),
+  ];
+
+  const workflow = WF["workflow_create"]("context-test", steps);
+  const result = WF["workflow_run"](workflow, {});
+
+  return result.status === "success" &&
+    result.context.cached_users.length === 2 &&
+    result.context.processed_count === 2;
+});
+
+// ── Test 9: helper function step-with-error
+test("P0-1-09: step-with-error helper adds error handler", () => {
+  const step = WF["workflow_step"]("test", (ctx) => {
+    throw new Error("Error");
+  });
+
+  const enhanced = WF["step-with-error"](step, (err) => ({ recovered: true }));
+
+  const workflow = WF["workflow_create"]("helper-test", [enhanced]);
+  const result = WF["workflow_run"](workflow, {});
+
+  return result.context.recovered === true;
+});
+
+// ── Test 10: helper function step-with-fallback
+test("P0-1-10: step-with-fallback helper adds fallback", () => {
+  const step = WF["workflow_step"]("test", (ctx) => {
+    throw new Error("Error");
+  });
+
+  const enhanced = WF["step-with-fallback"](step, { default: "value" });
+
+  const workflow = WF["workflow_create"]("fallback-helper-test", [enhanced]);
+  const result = WF["workflow_run"](workflow, {});
+
+  return result.context.default === "value";
+});
+
+// ── Print summary
+console.log("\n" + "=".repeat(50));
+console.log(`Test Results: ${results.passed} passed, ${results.failed} failed`);
+console.log("=".repeat(50) + "\n");
+
+if (results.failed > 0) {
+  console.log("Failed tests:");
+  results.tests
+    .filter(t => !t.ok)
+    .forEach(t => console.log(`  - ${t.name}: ${t.reason}`));
+  process.exit(1);
+} else {
+  console.log("✓ All tests passed!");
+  process.exit(0);
+}

package/src/test-p0-error-messages.ts

@@ -0,0 +1,220 @@
+// Test suite for P0-4: Clear error messages with metadata
+// Tests: error categorization, metadata inclusion
+
+import { createWorkflowModule } from "./stdlib-workflow";
+import { createTimeModule } from "./stdlib-time";
+
+const WF = createWorkflowModule();
+const T = createTimeModule();
+
+interface TestResult {
+  passed: number;
+  failed: number;
+  tests: Array<{ name: string; ok: boolean; reason?: string }>;
+}
+
+const results: TestResult = { passed: 0, failed: 0, tests: [] };
+
+function test(name: string, fn: () => boolean) {
+  try {
+    const ok = fn();
+    if (ok) {
+      results.passed++;
+      results.tests.push({ name, ok: true });
+      console.log(`✓ ${name}`);
+    } else {
+      results.failed++;
+      results.tests.push({ name, ok: false, reason: "assertion failed" });
+      console.log(`✗ ${name} — assertion failed`);
+    }
+  } catch (err: any) {
+    results.failed++;
+    results.tests.push({ name, ok: false, reason: err.message });
+    console.log(`✗ ${name} — ${err.message}`);
+  }
+}
+
+// ── Test 1: Timeout error categorized
+test("P0-4-01: TIMEOUT category detected", () => {
+  const step = WF["workflow_step"]("api_call", (ctx) => {
+    throw new Error("Request timeout after 5000ms");
+  }, {
+    fallback: { default: true },
+  });
+
+  const workflow = WF["workflow_create"]("test", [step]);
+  const result = WF["workflow_run"](workflow, {});
+
+  const logEntry = result.log.find(l => l.step === "api_call");
+  return logEntry?.category === "TIMEOUT";
+});
+
+// ── Test 2: Connection error categorized
+test("P0-4-02: CONNECTION category detected", () => {
+  const step = WF["workflow_step"]("network_call", (ctx) => {
+    throw new Error("Error: connect ECONNREFUSED 127.0.0.1:3000");
+  }, {
+    fallback: {},
+  });
+
+  const workflow = WF["workflow_create"]("test", [step]);
+  const result = WF["workflow_run"](workflow, {});
+
+  const logEntry = result.log.find(l => l.step === "network_call");
+  return logEntry?.category === "CONNECTION";
+});
+
+// ── Test 3: Parse error categorized
+test("P0-4-03: PARSE_ERROR category detected", () => {
+  const step = WF["workflow_step"]("json_parse", (ctx) => {
+    throw new Error("JSON parse error: unexpected token");
+  }, {
+    fallback: { data: [] },
+  });
+
+  const workflow = WF["workflow_create"]("test", [step]);
+  const result = WF["workflow_run"](workflow, {});
+
+  const logEntry = result.log.find(l => l.step === "json_parse");
+  return logEntry?.category === "PARSE_ERROR";
+});
+
+// ── Test 4: Type error categorized
+test("P0-4-04: TYPE_ERROR category detected", () => {
+  const step = WF["workflow_step"]("type_check", (ctx) => {
+    throw new Error("Cannot read property 'length' of undefined");
+  }, {
+    fallback: { length: 0 },
+  });
+
+  const workflow = WF["workflow_create"]("test", [step]);
+  const result = WF["workflow_run"](workflow, {});
+
+  const logEntry = result.log.find(l => l.step === "type_check");
+  return logEntry?.category === "TYPE_ERROR" || logEntry?.category === "UNKNOWN";
+});
+
+// ── Test 5: Not found error categorized
+test("P0-4-05: NOT_FOUND category detected", () => {
+  const step = WF["workflow_step"]("file_read", (ctx) => {
+    throw new Error("ENOENT: no such file or directory");
+  }, {
+    fallback: { content: "" },
+  });
+
+  const workflow = WF["workflow_create"]("test", [step]);
+  const result = WF["workflow_run"](workflow, {});
+
+  const logEntry = result.log.find(l => l.step === "file_read");
+  return logEntry?.category === "NOT_FOUND";
+});
+
+// ── Test 6: Retry count in log
+test("P0-4-06: attempted count in log", () => {
+  const step = WF["workflow_step"]("retry_test", (ctx) => {
+    throw new Error("Transient error");
+  }, {
+    retry: 2,
+    fallback: { ok: true },
+  });
+
+  const workflow = WF["workflow_create"]("test", [step]);
+  const result = WF["workflow_run"](workflow, {});
+
+  const logEntry = result.log.find(l => l.step === "retry_test");
+  // retry: 2 means maxAttempts = 3 (1 initial + 2 retries)
+  return logEntry?.attempted === 3;
+});
+
+// ── Test 7: Error message preserved
+test("P0-4-07: error message in log", () => {
+  const errorMsg = "Database connection pool exhausted";
+
+  const step = WF["workflow_step"]("db_query", (ctx) => {
+    throw new Error(errorMsg);
+  }, {
+    fallback: { cached: true },
+  });
+
+  const workflow = WF["workflow_create"]("test", [step]);
+  const result = WF["workflow_run"](workflow, {});
+
+  const logEntry = result.log.find(l => l.step === "db_query");
+  return logEntry?.error?.includes("Database connection");
+});
+
+// ── Test 8: Step timing in log
+test("P0-4-08: step timing recorded", () => {
+  const step = WF["workflow_step"]("timed_step", (ctx) => {
+    // Simulate some work
+    const start = Date.now();
+    while (Date.now() - start < 50) {}
+    throw new Error("Failed");
+  }, {
+    fallback: {},
+  });
+
+  const workflow = WF["workflow_create"]("test", [step]);
+  const result = WF["workflow_run"](workflow, {});
+
+  const logEntry = result.log.find(l => l.step === "timed_step");
+  return logEntry && logEntry.ms >= 40;  // At least ~40ms
+});
+
+// ── Test 9: Status field in log
+test("P0-4-09: status field indicates how error was handled", () => {
+  const step1 = WF["workflow_step"]("with_on_error", (ctx) => {
+    throw new Error("Error");
+  }, {
+    on_error: (err) => ({ handled: true }),
+  });
+
+  const step2 = WF["workflow_step"]("with_fallback", (ctx) => {
+    throw new Error("Error");
+  }, {
+    fallback: { ok: true },
+  });
+
+  const workflow = WF["workflow_create"]("test", [step1, step2]);
+  const result = WF["workflow_run"](workflow, {});
+
+  const log1 = result.log.find(l => l.step === "with_on_error");
+  const log2 = result.log.find(l => l.step === "with_fallback");
+
+  return log1?.status === "error_handled" && log2?.status === "fallback_used";
+});
+
+// ── Test 10: Detailed error in result.errors
+test("P0-4-10: detailed error message in errors array", () => {
+  const step = WF["workflow_step"]("failing_step", (ctx) => {
+    throw new Error("API returned 500 Internal Server Error");
+  }, {
+    required: true,
+    fallback: {},  // Won't be used (required=true)
+  });
+
+  const workflow = WF["workflow_create"]("test", [step]);
+  const result = WF["workflow_run"](workflow, {});
+
+  const hasError = result.errors.some(e =>
+    e.includes("failing_step") && e.includes("API returned")
+  );
+
+  return result.status === "failed" && hasError;
+});
+
+// ── Print summary
+console.log("\n" + "=".repeat(50));
+console.log(`Test Results: ${results.passed} passed, ${results.failed} failed`);
+console.log("=".repeat(50) + "\n");
+
+if (results.failed > 0) {
+  console.log("Failed tests:");
+  results.tests
+    .filter(t => !t.ok)
+    .forEach(t => console.log(`  - ${t.name}: ${t.reason}`));
+  process.exit(1);
+} else {
+  console.log("✓ All tests passed!");
+  process.exit(0);
+}

package/src/test-p1-1-parallel-tasks.js

@@ -0,0 +1,214 @@
+"use strict";
+// P1-1: Parallel Task Execution Tests
+// 8 test cases for parallel workflow execution
+Object.defineProperty(exports, "__esModule", { value: true });
+const stdlib_workflow_1 = require("./stdlib-workflow");
+const stdlib_time_1 = require("./stdlib-time");
+const WF = (0, stdlib_workflow_1.createWorkflowModule)();
+const T = (0, stdlib_time_1.createTimeModule)();
+async function runTest(testName, testFn) {
+    try {
+        console.log(`\n✓ Running: ${testName}`);
+        await testFn();
+        console.log(`  ✅ PASSED`);
+    }
+    catch (err) {
+        console.error(`  ❌ FAILED: ${err.message}`);
+        process.exit(1);
+    }
+}
+async function main() {
+    console.log("═══════════════════════════════════════════");
+    console.log("P1-1: Parallel Task Execution Tests");
+    console.log("═══════════════════════════════════════════");
+    // Test 1: Two parallel tasks, both succeed
+    await runTest("1. Two parallel tasks (all-success, both pass)", async () => {
+        const workflow = WF.workflow_create("parallel-success", [
+            WF.workflow_step("fetch-data", (ctx) => {
+                return { data1: "value1" };
+            }),
+            WF.workflow_step("process-data", () => ({}), {
+                parallel_tasks: [
+                    WF.workflow_step("task1", (ctx) => ({ result1: "processed1" })),
+                    WF.workflow_step("task2", (ctx) => ({ result2: "processed2" })),
+                ],
+                merge_strategy: "all-success",
+            }),
+        ]);
+        const result = await WF.workflow_run_async(workflow, {});
+        if (result.status !== "success") {
+            throw new Error(`Expected success, got ${result.status}`);
+        }
+        if (!result.context.process_data || !result.context.process_data.task1 || !result.context.process_data.task2) {
+            throw new Error("Parallel task results not merged properly");
+        }
+    });
+    // Test 2: Two parallel tasks, one fails, all-success strategy
+    await runTest("2. Two parallel tasks (all-success, one fails)", async () => {
+        const workflow = WF.workflow_create("parallel-one-fails", [
+            WF.workflow_step("process", () => ({}), {
+                parallel_tasks: [
+                    WF.workflow_step("task1", (ctx) => ({ result1: "ok" })),
+                    WF.workflow_step("task2", (ctx) => {
+                        throw new Error("Task 2 failed");
+                    }),
+                ],
+                merge_strategy: "all-success",
+            }),
+        ]);
+        const result = await WF.workflow_run_async(workflow, {});
+        if (result.status !== "failed") {
+            throw new Error(`Expected failed, got ${result.status}`);
+        }
+    });
+    // Test 3: Two parallel tasks, one fails, first-success strategy
+    await runTest("3. Two parallel tasks (first-success, one fails)", async () => {
+        const workflow = WF.workflow_create("parallel-first-success", [
+            WF.workflow_step("process", () => ({}), {
+                parallel_tasks: [
+                    WF.workflow_step("task1", (ctx) => ({ result1: "ok" })),
+                    WF.workflow_step("task2", (ctx) => {
+                        throw new Error("Task 2 failed");
+                    }),
+                ],
+                merge_strategy: "first-success",
+            }),
+        ]);
+        const result = await WF.workflow_run_async(workflow, {});
+        if (result.status !== "success") {
+            throw new Error(`Expected success, got ${result.status}`);
+        }
+    });
+    // Test 4: Nested parallel tasks
+    await runTest("4. Nested parallel tasks", async () => {
+        const workflow = WF.workflow_create("nested-parallel", [
+            WF.workflow_step("phase1", () => ({}), {
+                parallel_tasks: [
+                    WF.workflow_step("task1", (ctx) => ({ result1: "ok" })),
+                    WF.workflow_step("task2", (ctx) => ({ result2: "ok" })),
+                ],
+                merge_strategy: "all-success",
+            }),
+            WF.workflow_step("phase2", (ctx) => {
+                return { phase2_done: true };
+            }, {
+                parallel_tasks: [
+                    WF.workflow_step("subtask1", (ctx) => ({ sub1: "ok" })),
+                    WF.workflow_step("subtask2", (ctx) => ({ sub2: "ok" })),
+                ],
+                merge_strategy: "all-success",
+            }),
+        ]);
+        const result = await WF.workflow_run_async(workflow, {});
+        if (result.status !== "success") {
+            throw new Error(`Expected success, got ${result.status}`);
+        }
+        if (result.steps_ok !== 2) {
+            throw new Error(`Expected 2 steps ok, got ${result.steps_ok}`);
+        }
+    });
+    // Test 5: Parallel tasks with conditional execution
+    await runTest("5. Parallel tasks with conditional execution", async () => {
+        const workflow = WF.workflow_create("parallel-conditional", [
+            WF.workflow_step("setup", (ctx) => ({ should_process: true })),
+            WF.workflow_step("process", () => ({}), {
+                if: (ctx) => ctx.should_process === true,
+                parallel_tasks: [
+                    WF.workflow_step("task1", (ctx) => ({ result1: "ok" })),
+                    WF.workflow_step("task2", (ctx) => ({ result2: "ok" })),
+                ],
+                merge_strategy: "all-success",
+            }),
+        ]);
+        const result = await WF.workflow_run_async(workflow, {});
+        if (result.status !== "success") {
+            throw new Error(`Expected success, got ${result.status}`);
+        }
+    });
+    // Test 6: Parallel tasks using context from previous step
+    await runTest("6. Parallel tasks using context from previous step", async () => {
+        const workflow = WF.workflow_create("parallel-with-context", [
+            WF.workflow_step("fetch", (ctx) => ({ user_id: 123, user_name: "Alice" })),
+            WF.workflow_step("process", (ctx) => {
+                return { user_id: ctx.user_id };
+            }, {
+                parallel_tasks: [
+                    WF.workflow_step("validate", (ctx) => {
+                        if (!ctx.user_id)
+                            throw new Error("user_id missing");
+                        return { validated: true };
+                    }),
+                    WF.workflow_step("enrich", (ctx) => {
+                        if (!ctx.user_name)
+                            throw new Error("user_name missing");
+                        return { enriched: true };
+                    }),
+                ],
+                merge_strategy: "all-success",
+            }),
+        ]);
+        const result = await WF.workflow_run_async(workflow, {});
+        if (result.status !== "success") {
+            throw new Error(`Expected success, got ${result.status}`);
+        }
+    });
+    // Test 7: Parallel tasks with fallback on failure
+    await runTest("7. Parallel tasks with fallback on failure", async () => {
+        const workflow = WF.workflow_create("parallel-with-fallback", [
+            WF.workflow_step("process", () => ({}), {
+                parallel_tasks: [
+                    WF.workflow_step("task1", (ctx) => {
+                        throw new Error("Task 1 failed");
+                    }),
+                    WF.workflow_step("task2", (ctx) => {
+                        throw new Error("Task 2 failed");
+                    }),
+                ],
+                merge_strategy: "all-success",
+                fallback: { fallback_result: "recovered" },
+            }),
+        ]);
+        const result = await WF.workflow_run_async(workflow, {});
+        if (result.status !== "success") {
+            throw new Error(`Expected success (with fallback), got ${result.status}`);
+        }
+        if (!result.context.fallback_result) {
+            throw new Error("Fallback value not applied");
+        }
+    });
+    // Test 8: Parallel tasks execution time (should be faster than sequential)
+    await runTest("8. Parallel tasks execution time optimization", async () => {
+        const workflow = WF.workflow_create("parallel-timing", [
+            WF.workflow_step("parallel-phase", () => ({}), {
+                parallel_tasks: [
+                    WF.workflow_step("slow-task1", (ctx) => {
+                        const start = T.now();
+                        while (T.now() - start < 100) { /* simulate work */ }
+                        return { result1: "done" };
+                    }),
+                    WF.workflow_step("slow-task2", (ctx) => {
+                        const start = T.now();
+                        while (T.now() - start < 100) { /* simulate work */ }
+                        return { result2: "done" };
+                    }),
+                ],
+                merge_strategy: "all-success",
+            }),
+        ]);
+        const result = await WF.workflow_run_async(workflow, {});
+        if (result.status !== "success") {
+            throw new Error(`Expected success, got ${result.status}`);
+        }
+        // Should be around 100ms, not 200ms (if they were sequential)
+        if (result.total_ms > 250) {
+            console.warn(`  ⚠️ Parallel execution took ${result.total_ms}ms (expected ~100ms)`);
+        }
+    });
+    console.log("\n═══════════════════════════════════════════");
+    console.log("✅ All P1-1 tests passed!");
+    console.log("═══════════════════════════════════════════");
+}
+main().catch((err) => {
+    console.error("Fatal error:", err);
+    process.exit(1);
+});