ai-chatbot/tests/routes/canvas-zip-worker.test.ts

168 lines
8.6 KiB
TypeScript

import { test, expect } from "@playwright/test";
import JSZip from "jszip";
import { NextRequest, NextResponse } from "next/server";
import sharp from "sharp";
import { once } from "node:events";
import { Readable } from "node:stream";
import { mkdtemp, rm } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { randomUUID } from "node:crypto";
import { serverLoader } from "../helpers/canvas-download-server-loader";
test("the worker prepares 13 images and uploads the ZIP through Qiniu multipart", async () => {
const directory = await mkdtemp(join(tmpdir(), "zip-worker-test-"));
const token = "local-test-secret".repeat(3);
const id = randomUUID();
const key = "canvas-downloads/" + id + ".zip";
const rgb = { r: 25, g: 100, b: 170 };
const png = await sharp({ create: { width: 800, height: 800, channels: 3, background: rgb } }).png().toBuffer();
const jpeg = await sharp({ create: { width: 800, height: 800, channels: 3, background: rgb } }).jpeg().toBuffer();
const parts: Buffer[] = [];
let complete = 0, downloads = 0;
const loader = serverLoader({
"../../lib/video-canvas/download-media": {
openPublicMedia: async (url: string, options: { allowUrl: (url: URL) => boolean }) => {
const parsed = new URL(url);
expect(options.allowUrl(parsed)).toBe(true);
expect(options.allowUrl(new URL("https://ai.yydd.ai/api/image-proxy"))).toBe(false);
downloads++;
const original = parsed.pathname.endsWith("original.jpeg") ? jpeg : png;
return Object.assign(Readable.from([original]), {
statusCode: 200, headers: { "content-type": original === png ? "image/png" : "image/jpeg" },
});
},
},
fetch: async (uri: URL | string, init: RequestInit) => {
const url = new URL(uri);
if (init.method === "HEAD") return new Response(null, { status: 404 });
expect(url.hostname).toBe("upload.qiniup.com");
expect(new Headers(init.headers).get("Authorization")).toBe("UpToken scoped-test-token");
if (url.pathname.endsWith("/uploads")) return Response.json({ uploadId: "one-upload" });
if (init.method === "PUT") {
parts.push(Buffer.from(init.body as Uint8Array));
return Response.json({ etag: "one-part" });
}
expect(init.method).toBe("POST");
expect(JSON.parse(init.body as string).mimeType).toBe("application/zip");
complete++;
return Response.json({ key, fsize: Buffer.concat(parts).length });
},
}, { CANVAS_DOWNLOAD_ZIP_DIR: directory, CANVAS_ZIP_WORKER_TOKEN: token });
const { router } = loader("services/canvas-zip/server.ts");
router.listen(0, "127.0.0.1");
await once(router, "listening");
const endpoint = "http://127.0.0.1:" + router.address().port + "/v1/jobs/" + id;
const files = Array.from({ length: 13 }, (_, i) => ({
name: "详情图-" + i,
sources: ["https://cdn.example/" + i + (i === 12 ? "/original.jpeg" : "/original.png")],
}));
const job = {
attempt: 0, folderName: "详情图", expiresAt: Date.now() + 60_000, appOrigin: "https://ai.yydd.ai", files,
storage: { bucket: "qa-bucket", token: "scoped-test-token", publicUrl: "https://cdn.example/" + key },
};
const post = async () => fetch(endpoint, {
method: "PUT", headers: { Authorization: "Bearer " + token, "content-type": "application/json" }, body: JSON.stringify(job),
});
try {
expect((await fetch(endpoint, { method: "PUT" })).status).toBe(401);
expect((await post()).status).toBe(200);
await expect.poll(async () => {
const response = await post();
const state = await response.json();
return state.status;
}, { timeout: 10_000 }).toBe("completed");
await expect((await post()).json()).resolves.toMatchObject({ successCount: 13, failedCount: 0 });
expect(downloads).toBe(13);
expect(complete).toBe(1);
const archive = await JSZip.loadAsync(Buffer.concat(parts), { checkCRC32: true });
const images = Object.values(archive.files).filter(file => !file.dir);
expect(images).toHaveLength(13);
for (const [i, entry] of images.entries()) {
const data = await entry.async("nodebuffer");
expect(entry.name).toMatch(/\.png$/);
if (i < 12) expect(data).toEqual(png);
else {
const metadata = await sharp(data).metadata();
expect(metadata).toMatchObject({ width: 800, height: 800, space: "srgb", format: "png" });
const color = (await sharp(data).extract({ left: 20, top: 20, width: 1, height: 1 }).raw().toBuffer());
expect(Math.abs(color[0] - rgb.r)).toBeLessThan(4);
expect(Math.abs(color[1] - rgb.g)).toBeLessThan(4);
expect(Math.abs(color[2] - rgb.b)).toBeLessThan(4);
}
}
} finally {
await new Promise<void>(resolve => router.close(() => resolve()));
await rm(directory, { recursive: true, force: true });
}
});
test("the style-detail route gives the worker addresses and returns a CDN redirect even when local is requested", async () => {
const directory = await mkdtemp(join(tmpdir(), "zip-remote-route-"));
const id = randomUUID();
const callbacks: Array<() => Promise<void>> = [];
let owner = "owner";
const zipUrl = "https://cdn.example/canvas-downloads/" + id + ".zip";
const raw = { id: "storage", isEnabled: true };
const worker = "http://127.0.0.1:18343";
const config = { provider: "qiniu-kodo", region: "cn-east-1", bucket: "qa", publicUrl: "https://cdn.example",
accessKeyId: "fake-public-id", secretAccessKey: "fake-private-key" };
let workerCalls = 0;
const route = serverLoader({
"@/lib/observability/active-work": { trackRuntimeWork: async (fn: () => Promise<void>) => fn() },
"@/app/(auth)/auth": { auth: async () => ({ user: { id: owner } }) },
"next/server": { NextResponse, after: (fn: () => Promise<void>) => callbacks.push(fn) },
"@/lib/canvas/photoshop-safe-download": {
fetchCanvasDownloadAsset: () => { throw new Error("The production server must not fetch the originals"); },
},
"@/lib/storage/image-archive-db": { getArchivedImageUrlMappings: async () => ({
"https://ai.yydd.ai/archive": "https://cdn.example/archive.png",
}) },
"@/lib/db/queries": { getDefaultStorageConfig: async () => raw, getStorageConfigById: async () => raw },
"@/lib/storage/service": { toDbS3UploadConfig: () => config, buildS3PublicUrl: () => zipUrl },
"@/lib/storage/canvas-zip-delivery": {
publishCanvasZip: () => { throw new Error("The production server must not upload the ZIP"); },
},
fetch: async (uri: URL | string, init: RequestInit) => {
const url = new URL(uri);
if (url.origin === worker) {
workerCalls++;
const job = JSON.parse(init.body as string);
expect(job.files[0].sources).toEqual(["https://cdn.example/archive.png"]);
expect(job.files[1].sources).toEqual(["https://provider.example/result.png"]);
expect(job).not.toHaveProperty("cookie");
expect(job.storage).not.toHaveProperty("secretAccessKey");
const policy = JSON.parse(Buffer.from(job.storage.token.split(":")[2], "base64url").toString());
expect(policy.scope).toBe("qa:canvas-downloads/" + id + ".zip");
return Response.json({ status: "completed", stage: "打包完成", processedCount: 2,
successCount: 2, failedCount: 0, compressPercent: 100, bytes: 12345 });
}
expect(url.href).toContain(zipUrl);
expect(init.method).toBe("HEAD");
return new Response(null, { headers: { "content-length": "12345" } });
},
}, { CANVAS_DOWNLOAD_ZIP_DIR: directory, CANVAS_ZIP_WORKER_URL: worker,
CANVAS_ZIP_WORKER_TOKEN: "local-test-secret".repeat(3) })("app/api/canvas/download-zip-task/route.ts");
const endpoint = "https://ai.yydd.ai/api/canvas/download-zip-task";
try {
const started = await route.POST(new NextRequest(endpoint, {
method: "POST",
body: JSON.stringify({ taskId: id, scope: "style-detail", folderName: "详情图", files: [
{ url: "https://ai.yydd.ai/archive" }, { url: "https://provider.example/result.png" },
] }),
headers: { cookie: "auth=private-test-cookie" },
}));
expect(started.status).toBe(202);
while (callbacks.length) await callbacks.shift()!();
expect(workerCalls).toBe(1);
const download = await route.GET(new NextRequest(endpoint + "?taskId=" + id + "&download=1&local=1"));
expect(download.status).toBe(307);
expect(download.headers.get("location")).toContain(zipUrl);
owner = "another-user";
const denied = await route.GET(new NextRequest(endpoint + "?taskId=" + id + "&download=1"));
expect(denied.status).toBe(404);
} finally { await rm(directory, { recursive: true, force: true }); }
});