callman-core 1.0.3 → 1.0.4

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);
+  }
+});