Files
hyperframes/packages/producer/src/server.keepalive.test.ts
Miguel Ángel 575f68cf5b fix(producer): a render whose capture stops advancing fails within minutes (#6413)
* fix(producer): a render whose capture stops advancing fails within minutes

* fix(producer): keep the bounded probe read the stall change dropped

* chore(producer): shorten a test comment

* fix(producer): every retry batch gets its own first-frame window; the stall test waits for the render to settle

A retry that runs as several batches opened one stall window for the whole attempt, so a later batch whose browsers take longer than the no-progress window to land a frame was killed where main would have finished. The window now opens per batch. The stall tests also waited a fixed number of turns for real file IO after the last frame, which failed about 3 runs in 10 on a loaded machine; they now wait for the render to settle.

* fix(producer): a test reads the stall error fields instead of suppressions; size budget follows

* test(producer): split the scripted capture attempt into small helpers

* test(producer): the stall test advances fake time only while the scripted capture waits
2026-10-26 12:20:19 +00:00

104 lines
3.7 KiB
TypeScript

import { Hono } from "hono";
import { afterEach, beforeEach, expect, it, vi } from "vitest";
// Entry: createRenderHandlers().renderStream, with a render that hangs until the test ends it.
const renders = vi.hoisted(() => ({
jobs: [] as Array<{ framesRendered: number; currentStage: string }>,
finish: [] as Array<() => void>,
sinks: [] as Array<(job: unknown, message: string) => Promise<void>>,
}));
vi.mock("./services/renderOrchestrator.js", () => ({
RenderCancelledError: class extends Error {},
createRenderJob: (config: Record<string, unknown>) => {
const job = { config, progress: 0, currentStage: "Queued", framesRendered: 0, warnings: [] };
renders.jobs.push(job);
return job;
},
executeRenderJob: (
_job: unknown,
_dir: string,
_out: string,
sink: (job: unknown, message: string) => Promise<void>,
) => {
renders.sinks.push(sink);
return new Promise<void>((resolve) => renders.finish.push(resolve));
},
}));
import { createRenderHandlers } from "./server.js";
beforeEach(() => {
renders.jobs.length = 0;
renders.finish.length = 0;
renders.sinks.length = 0;
vi.useFakeTimers({ toFake: ["setTimeout", "clearTimeout", "setInterval", "clearInterval"] });
});
afterEach(() => vi.useRealTimers());
async function settle(until: () => boolean): Promise<void> {
for (let turn = 0; turn < 500 && !until(); turn++) {
await new Promise((resolve) => setImmediate(resolve));
}
expect(until()).toBe(true);
}
function post(app: Hono): Promise<Response> {
return Promise.resolve(
app.request("/v1/render-stream", {
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify({ html: "<html><body></body></html>" }),
}),
);
}
function openStream(app: Hono): { events: Array<Record<string, unknown>> } {
const events: Array<Record<string, unknown>> = [];
void post(app).then(async (response) => {
const decoder = new TextDecoder();
for await (const chunk of response.body as unknown as AsyncIterable<Uint8Array>) {
for (const line of decoder.decode(chunk).split("\n")) {
if (line.startsWith("data:")) events.push(JSON.parse(line.slice(5)));
}
}
});
return { events };
}
it("keeps a queued and a running render-stream alive with live progress, and stops at the terminal event", async () => {
const app = new Hono();
app.post("/v1/render-stream", createRenderHandlers({ maxConcurrentRenders: 1 }).renderStream);
openStream(app);
await settle(() => renders.finish.length === 1);
const queued = openStream(app);
await settle(() => queued.events.some((event) => event.type === "queued"));
renders.jobs[1]!.framesRendered = 7;
await vi.advanceTimersByTimeAsync(95_000);
await settle(() => queued.events.length >= 4);
const pings = queued.events.filter((event) => event.type === "progress");
expect(pings).toHaveLength(3);
expect(pings[0]).toMatchObject({ stage: "Queued", framesRendered: 7 });
expect(renders.finish).toHaveLength(1);
renders.finish[0]!();
await settle(() => renders.finish.length === 2);
renders.finish[1]!();
await settle(() => queued.events.some((event) => event.type === "complete"));
await vi.advanceTimersByTimeAsync(95_000);
await settle(() => true);
expect(queued.events.at(-1)).toMatchObject({ type: "complete" });
});
it("frees the render slot when a render ends, even if its client stops reading", async () => {
const app = new Hono();
app.post("/v1/render-stream", createRenderHandlers({ maxConcurrentRenders: 1 }).renderStream);
void post(app);
await settle(() => renders.finish.length === 1);
void renders.sinks[0]!(renders.jobs[0], "Rendering");
renders.finish[0]!();
openStream(app);
await settle(() => renders.finish.length === 2);
});