ai-chatbot/tests/routes/image-archive-lanes.test.ts

68 lines
3.6 KiB
TypeScript

import { test, expect } from "@playwright/test";
import { serverLoader } from "../helpers/canvas-download-server-loader";
test("a slow original and slow reference updates do not block later files or new downloads", async () => {
let finishSlow!: () => void;
let finishReplacement!: () => void;
const slow = new Promise<void>(resolve => { finishSlow = resolve; });
const replacement = new Promise<void>(resolve => { finishReplacement = resolve; });
const pending = Array.from({ length: 25 }, (_, i) => `image-${i}`);
const completed: string[] = [];
const callbacks: Array<() => Promise<void>> = [];
let active = 0;
let peak = 0;
let replacing = false;
const module = serverLoader({
"next/server": { after: (callback: () => Promise<void>) => callbacks.push(callback) },
"./image-archive-db": { recoverStaleImageArchiveTasks: async () => {}, hasPendingImageArchives: async () => false, hasPendingImageDownloads: async () => false },
"./image-download-preparation": { scheduleImageDownloadPreparation() {} },
"@/lib/jobs/image-archive-job": {
storeNextImageArchive: async (preferred?: string) => {
const index = preferred ? pending.indexOf(preferred) : -1;
const id = pending.splice(index < 0 ? 0 : index, 1)[0];
if (!id) return false;
active++; peak = Math.max(peak, active);
if (id === "image-0") await slow;
else await new Promise(resolve => setTimeout(resolve, 1));
completed.push(id); active--;
return true;
},
replacePendingImageArchives: async () => { replacing = true; await replacement; return 0; },
},
})("lib/storage/image-archive-worker.ts");
module.scheduleImageArchiveWorker();
await callbacks.shift()!();
await expect.poll(() => completed.length).toBe(24);
expect(completed).not.toContain("image-0");
expect(replacing).toBe(true);
pending.push("new-download");
module.scheduleImageArchiveWorker(false, "new-download");
await callbacks.shift()!();
await expect.poll(() => completed.includes("new-download")).toBe(true);
expect(peak).toBeLessThanOrEqual(4);
finishSlow(); finishReplacement();
await expect.poll(() => completed.length).toBe(26);
expect(new Set(completed).size).toBe(26);
});
test("conversion requests wait for the original archive and never invoke the relay preparation queue", async () => {
const pending = { id: "queued", sourceUrl: "https://model.example/image", status: "pending" };
const route = serverLoader({
"next/server": { NextResponse: Response },
"@/app/(auth)/auth": { auth: async () => ({ user: { id: "test" } }) },
"@/lib/storage/image-download-preparation": { scheduleImageDownloadPreparation() {} },
"@/lib/storage/canvas-cdn-download": { resolveCanvasCdnDownload: async () => ({ task: pending, direct: null, canPrepareDirect: false }) },
"@/lib/storage/original-image-download": {
prepareOriginalImageArchive: async () => pending,
originalImagePreparing: () => ({ delivery: "preparing", phase: "preparing", requestId: pending.id }),
},
"@/lib/canvas/download-preparation": { getDownloadPreparationQueue() { throw new Error("Must not relay image bytes"); } },
})("app/api/canvas/download-image/route.ts");
const response = await route.POST(new Request("https://app.example/api/canvas/download-image", {
method: "POST", headers: { "content-type": "application/json" },
body: JSON.stringify({ url: pending.sourceUrl, preferDirect: true, preparation: "async" }),
}));
expect(response.status).toBe(202);
expect(await response.json()).toMatchObject({ delivery: "preparing", phase: "preparing" });
});