callman-core 1.0.6 → 1.2.0

package/tests/waitNode.test.mjs

@@ -1,311 +0,0 @@
-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);
-  }
-});

package/tsconfig.json

@@ -1,18 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ESNext",
-    "module": "ESNext",
-    "moduleResolution": "Bundler",
-    "outDir": "dist",
-    "rootDir": "src",
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["dist", "node_modules"]
-}