// Parallels Update Job Timeout tests cover parallels update job timeout script behavior.

import { spawnSync } from "node:child_process";

import path from "node:path";

import { pathToFileURL } from "node:url";

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

import { runTimedUpdateJob } from "../../scripts/e2e/parallels/update-job-timeout.ts";

const writeLog = vi.fn(async () => undefined);

const result = runTimedUpdateJob({

abortSettleMs: 1,

append: (chunk) => chunks.push(chunk),

label: "Windows",

run: () => new Promise(() => {}),

writeLog,

});

await vi.advanceTimersByTimeAsync(1000);

await vi.advanceTimersByTimeAsync(1001);

await expect(result).resolves.toBe(1);

expect(chunks).toEqual(["Windows update timed out after 1s\n"]);

expect(writeLog).toHaveBeenCalledTimes(1);

expect(chunks).toEqual(["Linux update timed out after 1s plus cleanup backstop\n"]);

expect(writeLog).toHaveBeenCalledTimes(1);

});

it("waits for abort-aware cleanup before writing the job log", async () => {

vi.useFakeTimers();

const events: string[] = [];

const result = runTimedUpdateJob({

abortSettleMs: 250,

append: (chunk) => events.push(chunk.trim()),

label: "macOS",

run: ({ signal }) =>

new Promise<void>((resolve) => {

signal.addEventListener(

"abort",

() => {

events.push("abort");

setTimeout(() => {

events.push("cleanup");

resolve();

}, 25);

},

{ once: true },

);

}),

timeoutDescription: "1s plus cleanup backstop",

timeoutMs: 1000,

writeLog: async () => {

events.push("writeLog");

},

});

await vi.advanceTimersByTimeAsync(1025);

await expect(result).resolves.toBe(1);

expect(events).toEqual([

"macOS update timed out after 1s plus cleanup backstop",

"abort",

"cleanup",

"writeLog",

]);

});

it("keeps the process alive long enough to write logs for hung runners", () => {

const moduleUrl = pathToFileURL(

path.resolve("scripts/e2e/parallels/update-job-timeout.ts"),

).href;

const probe = `

import { runTimedUpdateJob } from ${JSON.stringify(moduleUrl)};

const events = [];

const result = await runTimedUpdateJob({

abortSettleMs: 25,

append: (chunk) => events.push(chunk.trim()),

label: "Linux",

run: () => new Promise(() => {}),

timeoutDescription: "10ms",

timeoutMs: 10,

writeLog: async () => events.push("writeLog"),

});

console.log(JSON.stringify({ events, result }));

`;

const child = spawnSync(

process.execPath,

["--import", "tsx", "--input-type=module", "--eval", probe],

{

cwd: process.cwd(),

encoding: "utf8",

timeout: 5_000,

},

);

expect(child.stderr).toBe("");

expect(child.status).toBe(0);

expect(JSON.parse(child.stdout)).toEqual({

events: ["Linux update timed out after 10ms", "writeLog"],

result: 1,

});

});

});