import { MAX_TIMER_TIMEOUT_MS } from "openclaw/plugin-sdk/number-runtime";

import { describe, expect, it, vi } from "vitest";

import { waitForCronRunCompletion } from "./cron-run-wait.js";

import { resolveCronRunPollIntervalMs, waitForCronRunCompletion } from "./cron-run-wait.js";

describe("waitForCronRunCompletion", () => {

it("ignores older entries and returns the newly finished run", async () => {

}),

).rejects.toThrow(/timed out waiting for cron run completion/);

});

it("clamps oversized poll intervals before sleeping", () => {

expect(resolveCronRunPollIntervalMs(Number.MAX_SAFE_INTEGER)).toBe(MAX_TIMER_TIMEOUT_MS);

});

it("keeps oversized poll intervals within the overall timeout", async () => {

const callGateway = vi

.fn<

(method: string, rpcParams?: unknown, opts?: { timeoutMs?: number }) => Promise<unknown>

>()

.mockResolvedValue({

entries: [{ ts: 100, status: "ok", summary: "older run" }],

});

await expect(

waitForCronRunCompletion({

callGateway,

jobId: "dreaming-job",

afterTs: 150,

timeoutMs: 5,

intervalMs: Number.MAX_SAFE_INTEGER,

}),

).rejects.toThrow(/timed out waiting for cron run completion/);

});

});

import { setTimeout as sleep } from "node:timers/promises";

import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";

import { resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";

type QaCronRunLogEntry = {

ts?: number;

entries?: QaCronRunLogEntry[];

};

export function resolveCronRunPollIntervalMs(intervalMs: number | undefined): number {

return resolveTimerTimeoutMs(intervalMs ?? 1_000, 1_000, 0);

}

export async function waitForCronRunCompletion(params: {

callGateway: (

method: string,

intervalMs?: number;

}) {

const timeoutMs = params.timeoutMs ?? 90_000;

const intervalMs = params.intervalMs ?? 1_000;

const intervalMs = resolveCronRunPollIntervalMs(params.intervalMs);

const startedAt = Date.now();

let lastEntries: QaCronRunLogEntry[] = [];

while (Date.now() - startedAt < timeoutMs) {

if (completed) {

return completed;

}

await sleep(intervalMs);

const remainingMs = timeoutMs - (Date.now() - startedAt);

if (remainingMs <= 0) {

break;

}

await sleep(Math.min(intervalMs, remainingMs));

}

throw new Error(

`timed out waiting for cron run completion for ${params.jobId}: ${formatErrorMessage(lastEntries)}`,