callman-core 1.0.2 → 1.0.4

package/dist/scenario-runner/waitNodeExecutor.js

@@ -0,0 +1,65 @@
+export const MIN_SCENARIO_WAIT_DURATION_MS = 1;
+export const MAX_SCENARIO_WAIT_DURATION_MS = 2_147_483_647;
+const normalizeWaitDurationMs = (value) => Number.isFinite(value) ? Math.round(value) : Number.NaN;
+const createWaitSummary = ({ configuredDurationMs, actualDurationMs, status, }) => ({
+    type: "wait",
+    configuredDurationMs,
+    actualDurationMs: Math.max(0, Math.round(actualDurationMs)),
+    status,
+});
+export class ScenarioWaitNodeValidationError extends Error {
+    summary;
+    constructor(durationMs) {
+        super(`Wait node duration must be a finite number between ${MIN_SCENARIO_WAIT_DURATION_MS} ms and ${MAX_SCENARIO_WAIT_DURATION_MS} ms.`);
+        this.name = "ScenarioWaitNodeValidationError";
+        this.summary = createWaitSummary({
+            configuredDurationMs: normalizeWaitDurationMs(durationMs),
+            actualDurationMs: 0,
+            status: "failed",
+        });
+    }
+}
+export class ScenarioWaitNodeCancelledError extends Error {
+    summary;
+    constructor(durationMs, actualDurationMs) {
+        super("Wait node execution was cancelled.");
+        this.name = "ScenarioWaitNodeCancelledError";
+        this.summary = createWaitSummary({
+            configuredDurationMs: durationMs,
+            actualDurationMs,
+            status: "cancelled",
+        });
+    }
+}
+const waitWithSignal = (durationMs, signal, startedAtMs) => new Promise((resolve, reject) => {
+    const timeoutId = globalThis.setTimeout(() => {
+        signal?.removeEventListener?.("abort", onAbort);
+        resolve();
+    }, durationMs);
+    const onAbort = () => {
+        globalThis.clearTimeout(timeoutId);
+        signal?.removeEventListener?.("abort", onAbort);
+        reject(new ScenarioWaitNodeCancelledError(durationMs, Date.now() - startedAtMs));
+    };
+    if (signal?.aborted) {
+        onAbort();
+        return;
+    }
+    signal?.addEventListener?.("abort", onAbort, { once: true });
+});
+export const executeWaitNode = async ({ durationMs, signal, }) => {
+    const normalizedDurationMs = normalizeWaitDurationMs(durationMs);
+    if (!Number.isFinite(normalizedDurationMs) ||
+        normalizedDurationMs < MIN_SCENARIO_WAIT_DURATION_MS ||
+        normalizedDurationMs > MAX_SCENARIO_WAIT_DURATION_MS) {
+        throw new ScenarioWaitNodeValidationError(durationMs);
+    }
+    const startedAtMs = Date.now();
+    await waitWithSignal(normalizedDurationMs, signal, startedAtMs);
+    return createWaitSummary({
+        configuredDurationMs: normalizedDurationMs,
+        actualDurationMs: Date.now() - startedAtMs,
+        status: "success",
+    });
+};
+//# sourceMappingURL=waitNodeExecutor.js.map

package/dist/scenario-runner/waitNodeExecutor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"waitNodeExecutor.js","sourceRoot":"","sources":["../../src/scenario-runner/waitNodeExecutor.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "callman-core",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
   "scripts": {
     "build": "tsc -p tsconfig.json",
-    "sample": "node samples/runSample.mjs"
+    "sample": "node samples/runSample.mjs",
+    "test": "npm run build && node --test tests/*.test.mjs"
   },
   "dependencies": {
     "axios": "^1.6.0"

package/tests/waitNode.test.mjs

@@ -0,0 +1,311 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { runScenario } from "../dist/index.js";
+
+const STRICT_POLICY = {
+  onFailure: "stop",
+  retry: {
+    enabled: false,
+    maxAttempts: 0,
+    delayMs: 0,
+  },
+};
+
+const createWaitNode = (id, durationMs, label = "Wait") => ({
+  id,
+  type: "wait",
+  position: { x: 0, y: 0 },
+  data: {
+    label,
+    config: {
+      durationMs,
+      executionPolicy: STRICT_POLICY,
+    },
+  },
+});
+
+const createScriptNode = (id, label = "Script") => ({
+  id,
+  type: "script",
+  position: { x: 240, y: 0 },
+  data: {
+    label,
+    config: {
+      script: "return { ok: true };",
+      timeoutMs: 3000,
+      executionPolicy: STRICT_POLICY,
+    },
+  },
+});
+
+const createEndNode = (id, label = "End") => ({
+  id,
+  type: "end",
+  position: { x: 480, y: 0 },
+  data: {
+    label,
+    config: {
+      loop: false,
+      loopTargetNodeId: null,
+      loopIterations: 1,
+      loopDelayMs: 0,
+      executionPolicy: STRICT_POLICY,
+    },
+  },
+});
+
+const createConditionNode = (id, label = "Condition") => ({
+  id,
+  type: "condition",
+  position: { x: 0, y: 0 },
+  data: {
+    label,
+    config: {
+      mode: "builder",
+      expertExpression: 'env.runWait == "yes"',
+      rootGroup: {
+        id: `${id}-group`,
+        type: "group",
+        operator: "AND",
+        children: [
+          {
+            id: `${id}-rule`,
+            type: "rule",
+            left: {
+              mode: "runtime",
+              valueType: "string",
+              value: "env.runWait",
+            },
+            operator: "equals",
+            right: {
+              mode: "literal",
+              valueType: "string",
+              value: "yes",
+            },
+          },
+        ],
+      },
+    },
+  },
+});
+
+const createRuntimeAdapters = ({ onScript } = {}) => ({
+  requestExecutor: async () => {
+    throw new Error("Request executor should not be called in wait node tests.");
+  },
+  dbExecutor: async () => ({
+    rawResult: {
+      success: true,
+      rows: [],
+      rowCount: 0,
+    },
+    dbResult: null,
+    outputData: null,
+  }),
+  redisExecutor: async () => ({
+    commandResults: [],
+    redisResult: null,
+    outputData: null,
+  }),
+  scriptExecutor: async ({ node }) => {
+    onScript?.(node);
+
+    return {
+      variableMutations: [],
+      testResults: [],
+      logs: [],
+      error: null,
+      hasReturnValue: true,
+      returnValue: { ok: true },
+      outputData: { ok: true },
+      scriptSource: node.data.config.script,
+      timeoutMs: node.data.config.timeoutMs ?? 3000,
+    };
+  },
+  kafkaExecutor: async () => ({
+    captureResult: {
+      topic: "test",
+      durationMs: 0,
+      timeoutMs: 0,
+      messages: [],
+      timedOut: false,
+      errorMessage: null,
+    },
+  }),
+});
+
+const findNodeExecution = (report, stepId) => {
+  const execution = report.nodeExecutions.find((entry) => entry.stepId === stepId);
+  assert.ok(execution, `Expected node execution record for ${stepId}.`);
+  return execution;
+};
+
+test("wait node delays execution and reports timing summary", async () => {
+  const durationMs = 50;
+  const scriptStartsAt = [];
+  const scenario = {
+    id: "scenario-wait-success",
+    name: "Wait Success",
+    nodes: [
+      createWaitNode("wait-1", durationMs, "Pause"),
+      createScriptNode("script-1", "AfterWait"),
+    ],
+    edges: [
+      {
+        id: "edge-wait-script",
+        source: "wait-1",
+        target: "script-1",
+        type: "default",
+      },
+    ],
+  };
+
+  const startedAtMs = Date.now();
+  const report = await runScenario({
+    scenario,
+    runtimeAdapters: createRuntimeAdapters({
+      onScript: () => {
+        scriptStartsAt.push(Date.now());
+      },
+    }),
+  });
+
+  assert.equal(report.scenarioStatus, "success");
+  assert.equal(scriptStartsAt.length, 1);
+
+  const waitExecution = findNodeExecution(report, "wait-1");
+  assert.equal(waitExecution.status, "success");
+  assert.equal(waitExecution.outputData?.type, "wait");
+  assert.equal(waitExecution.outputData?.configuredDurationMs, durationMs);
+  assert.equal(waitExecution.outputData?.status, "success");
+  assert.ok(waitExecution.outputData.actualDurationMs >= durationMs - 10);
+  assert.ok(scriptStartsAt[0] - startedAtMs >= durationMs - 10);
+  assert.ok(
+    report.events.some(
+      (event) => event.type === "step:start" && event.stepId === "wait-1",
+    ),
+  );
+  assert.ok(
+    report.events.some(
+      (event) => event.type === "step:success" && event.stepId === "wait-1",
+    ),
+  );
+});
+
+test("wait node rejects zero duration", async () => {
+  const scenario = {
+    id: "scenario-wait-invalid",
+    name: "Wait Invalid",
+    nodes: [createWaitNode("wait-1", 0, "InvalidWait")],
+    edges: [],
+  };
+
+  const report = await runScenario({
+    scenario,
+    runtimeAdapters: createRuntimeAdapters(),
+  });
+
+  const waitExecution = findNodeExecution(report, "wait-1");
+
+  assert.equal(report.scenarioStatus, "failed");
+  assert.equal(waitExecution.status, "failed");
+  assert.match(waitExecution.errorMessage ?? "", /Wait node duration must be a finite number/);
+  assert.equal(waitExecution.outputData?.type, "wait");
+  assert.equal(waitExecution.outputData?.status, "failed");
+  assert.equal(waitExecution.outputData?.actualDurationMs, 0);
+});
+
+test("wait node executes correctly inside a condition branch", async () => {
+  const scriptStartsAt = [];
+  const scenario = {
+    id: "scenario-wait-branch",
+    name: "Wait Branch",
+    nodes: [
+      createConditionNode("condition-1", "CheckFlag"),
+      createWaitNode("wait-1", 25, "BranchWait"),
+      createScriptNode("script-1", "BranchScript"),
+      createEndNode("end-1", "BranchEnd"),
+    ],
+    edges: [
+      {
+        id: "edge-condition-yes",
+        source: "condition-1",
+        target: "wait-1",
+        type: "yes",
+      },
+      {
+        id: "edge-wait-script",
+        source: "wait-1",
+        target: "script-1",
+        type: "default",
+      },
+      {
+        id: "edge-condition-no",
+        source: "condition-1",
+        target: "end-1",
+        type: "no",
+      },
+    ],
+  };
+
+  const report = await runScenario({
+    scenario,
+    environment: {
+      runWait: "yes",
+    },
+    runtimeAdapters: createRuntimeAdapters({
+      onScript: () => {
+        scriptStartsAt.push(Date.now());
+      },
+    }),
+  });
+
+  assert.equal(report.scenarioStatus, "success");
+  assert.equal(scriptStartsAt.length, 1);
+  assert.equal(findNodeExecution(report, "condition-1").status, "success");
+  assert.equal(findNodeExecution(report, "wait-1").status, "success");
+  assert.equal(findNodeExecution(report, "script-1").status, "success");
+  assert.equal(findNodeExecution(report, "end-1").status, "skipped");
+});
+
+test("wait node captures cancellation and stops the scenario", async () => {
+  const controller = new AbortController();
+  const abortTimer = setTimeout(() => controller.abort(), 30);
+  const scenario = {
+    id: "scenario-wait-cancelled",
+    name: "Wait Cancelled",
+    nodes: [
+      createWaitNode("wait-1", 200, "CancelableWait"),
+      createScriptNode("script-1", "ShouldNotRun"),
+    ],
+    edges: [
+      {
+        id: "edge-wait-script",
+        source: "wait-1",
+        target: "script-1",
+        type: "default",
+      },
+    ],
+  };
+
+  try {
+    const report = await runScenario({
+      scenario,
+      runtimeAdapters: createRuntimeAdapters(),
+      signal: controller.signal,
+    });
+
+    const waitExecution = findNodeExecution(report, "wait-1");
+    const scriptExecution = findNodeExecution(report, "script-1");
+
+    assert.equal(report.scenarioStatus, "stopped");
+    assert.equal(waitExecution.status, "skipped");
+    assert.equal(waitExecution.outputData?.type, "wait");
+    assert.equal(waitExecution.outputData?.status, "cancelled");
+    assert.ok(waitExecution.outputData.actualDurationMs < 200);
+    assert.equal(scriptExecution.status, "skipped");
+  } finally {
+    clearTimeout(abortTimer);
+  }
+});