73 lines
3.3 KiB
TypeScript
73 lines
3.3 KiB
TypeScript
import { expect, test } from "@playwright/test";
|
|
import crypto from "node:crypto";
|
|
import fs from "node:fs";
|
|
import path from "node:path";
|
|
|
|
const root = path.resolve(import.meta.dirname, "../../..");
|
|
const manifest = JSON.parse(fs.readFileSync(path.join(root, "tests/golden/M11-14/render-compositor-media-recovery.json"), "utf8")) as {
|
|
domains: Array<{
|
|
domain: "RENDER" | "COMPOSITOR" | "MEDIA";
|
|
fixture: string;
|
|
sha256: string;
|
|
cancellationCode: string;
|
|
budgetCode: string;
|
|
}>;
|
|
textureFixture: { path: string; sha256: string };
|
|
};
|
|
const fixtures = Object.fromEntries(manifest.domains.map((item) => [item.domain, fs.readFileSync(path.join(root, item.fixture))]));
|
|
const texture = fs.readFileSync(path.join(root, manifest.textureFixture.path));
|
|
const sha256 = (value: Buffer) => crypto.createHash("sha256").update(value).digest("hex");
|
|
|
|
test("M11-14 recovers real render, compositor and media production paths after lifecycle faults", async ({ page }) => {
|
|
test.setTimeout(120_000);
|
|
for (const item of manifest.domains) expect(sha256(fixtures[item.domain])).toBe(item.sha256);
|
|
expect(sha256(texture)).toBe(manifest.textureFixture.sha256);
|
|
await page.goto("/");
|
|
const reports = await page.evaluate(async ({ renderBlend, compositorBlend, movie, texturePng }) => {
|
|
const { runRenderCompositorMediaRecoverySuite } = await import("/src/testing/render-compositor-media-recovery.ts");
|
|
return runRenderCompositorMediaRecoverySuite({
|
|
renderBlend: Uint8Array.from(renderBlend).buffer,
|
|
compositorBlend: Uint8Array.from(compositorBlend).buffer,
|
|
movie: { mimeType: "video/mp4", data: Uint8Array.from(movie).buffer },
|
|
texturePng: Uint8Array.from(texturePng).buffer,
|
|
});
|
|
}, {
|
|
renderBlend: Array.from(fixtures.RENDER),
|
|
compositorBlend: Array.from(fixtures.COMPOSITOR),
|
|
movie: Array.from(fixtures.MEDIA),
|
|
texturePng: Array.from(texture),
|
|
});
|
|
|
|
expect(reports.map((report) => report.domain)).toEqual(["RENDER", "COMPOSITOR", "MEDIA"]);
|
|
for (const [index, report] of reports.entries()) {
|
|
const expected = manifest.domains[index];
|
|
expect(report.source.sha256).toBe(expected.sha256);
|
|
expect(report.cancellation).toEqual({
|
|
status: "CANCELLED",
|
|
code: expected.cancellationCode,
|
|
publishedResults: 0,
|
|
temporaryResourcesAfter: 0,
|
|
});
|
|
expect(report.restart).toMatchObject({ status: "RECOVERED", generationBefore: 1, generationAfter: 2 });
|
|
expect(report.restart.identityAfter).toBe(report.restart.identityBefore);
|
|
expect(report.restart.outputSha256After).toBe(report.restart.outputSha256Before);
|
|
expect(report.budget).toEqual({
|
|
status: "BLOCKED",
|
|
code: expected.budgetCode,
|
|
retainedIdentityHash: report.restart.identityAfter,
|
|
temporaryResourcesAfter: 0,
|
|
});
|
|
expect(report.release.status).toBe("RELEASED");
|
|
expect(report.release.releasedBytes).toBeGreaterThan(0);
|
|
expect(report.release.releasedResources).toBeGreaterThan(0);
|
|
expect(report.release.resourcesAfter).toBe(0);
|
|
expect(report.recovery).toMatchObject({
|
|
status: "RECOVERED",
|
|
identityHash: report.restart.identityAfter,
|
|
outputSha256: report.restart.outputSha256After,
|
|
});
|
|
expect(report.recovery.outputBytes).toBeGreaterThan(0);
|
|
expect(report.recovery.visibleUnits).toBeGreaterThan(0);
|
|
}
|
|
});
|