Files
rea/tests/boundary/cli/browserCompareJsonFiles.test.ts
T
Rudy Celekliandmorluto 4e4b15b825 fix(browser): validate PNG chunks and preserve unsupported encodings
Validate chunk checksums, type bytes, ordering and end boundaries before pixel comparison. Distinguish malformed PNGs and corrupt DEFLATE streams from recognized unsupported encodings through CLI and MCP error projection.

Adapted from #1375 with additional decoder and public boundary regressions. Eighteen decoder tests and six compiled CLI/MCP cases passed.

Signed-off-by: Rudy Celekli <47457359+rudycelekli@users.noreply.github.com>

Co-authored-by: morluto <76467478+morluto@users.noreply.github.com>
2026-10-11 11:07:15 +08:00

201 lines
6.2 KiB
TypeScript

import { randomBytes } from "node:crypto";
import { writeFile } from "node:fs/promises";
import { join } from "node:path";
import { crc32, deflateSync } from "node:zlib";
import { describe, expect, it } from "vitest";
import { createWebScreenshotArtifact } from "../../../src/domain/webScreenshot.js";
import { runCliJson as runCli } from "../../fixtures/cliJsonProcess.js";
import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";
const INTEGRATION_TEST_TIMEOUT_MS = 60_000;
// Linux limits one argument to 128 KiB and macOS all arguments to 1 MiB.
const COMMAND_LINE_LIMIT_BYTES = 1024 * 1024;
const pngChunk = (type: string, data: Buffer): Buffer => {
const typed = Buffer.concat([Buffer.from(type, "latin1"), data]);
const length = Buffer.alloc(4);
length.writeUInt32BE(data.length);
const checksum = Buffer.alloc(4);
checksum.writeUInt32BE(crc32(typed));
return Buffer.concat([length, typed, checksum]);
};
/** An incompressible RGB PNG whose artifact JSON exceeds command-line limits. */
const noisePng = (width: number, height: number): Buffer => {
const header = Buffer.alloc(13);
header.writeUInt32BE(width, 0);
header.writeUInt32BE(height, 4);
header.set([8, 2, 0, 0, 0], 8);
const rows = Array.from({ length: height }, () =>
Buffer.concat([Buffer.of(0), randomBytes(width * 3)]),
);
return Buffer.concat([
Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]),
pngChunk("IHDR", header),
pngChunk("IDAT", deflateSync(Buffer.concat(rows))),
pngChunk("IEND", Buffer.alloc(0)),
]);
};
describe("browser comparison JSON file inputs", () => {
it(
"compares screenshot artifacts too large for a command-line argument",
async () => {
const root = await createTestTempDirectory("rea-screenshot-files-");
const artifact = JSON.stringify(
createWebScreenshotArtifact(noisePng(640, 640)),
);
expect(Buffer.byteLength(artifact)).toBeGreaterThan(
COMMAND_LINE_LIMIT_BYTES,
);
const before = join(root, "before.json");
const after = join(root, "after.json");
await writeFile(before, artifact);
await writeFile(after, artifact);
expect(
await runCli(["compare-web-screenshots", before, after, "--json"]),
).toMatchObject({
operation: "compare_web_screenshots",
normalized_result: { status: "identical", changed_pixels: 0 },
});
},
INTEGRATION_TEST_TIMEOUT_MS,
);
it(
"reports which screenshot artifact failed validation",
async () => {
const root = await createTestTempDirectory("rea-screenshot-invalid-");
const valid = createWebScreenshotArtifact(noisePng(2, 2));
const before = join(root, "before.json");
await writeFile(before, JSON.stringify({ ...valid, bytes: 1 }));
expect(
await runCli([
"compare-web-screenshots",
before,
JSON.stringify(valid),
"--json",
]),
).toMatchObject({
error: "Browser observation failed",
code: "invalid_request",
details: {
operation: "compare_web_screenshots",
issues: [
{
path: ["before"],
message: "Screenshot artifact digest or size mismatch",
},
],
},
});
},
INTEGRATION_TEST_TIMEOUT_MS,
);
it(
"reports malformed PNG chunks as invalid input and valid unsupported PNGs as unsupported targets",
async () => {
await assertPngInputErrorProjections();
},
INTEGRATION_TEST_TIMEOUT_MS,
);
it(
"identifies a missing capture file instead of reporting malformed JSON",
async () => {
const root = await createTestTempDirectory("rea-capture-missing-");
const missing = join(root, "before.json");
expect(
await runCli(["compare-web-captures", missing, "{}", "--json"]),
).toMatchObject({
code: "invalid_request",
details: {
operation: "compare_web_captures",
issues: [
{
reason: "invalid_value",
message: expect.stringContaining(`(ENOENT): ${missing}`),
},
],
},
input_path: missing,
input_reason: "read-failed",
});
},
INTEGRATION_TEST_TIMEOUT_MS,
);
});
const assertPngInputErrorProjections = async (): Promise<void> => {
const damagedBytes = noisePng(1, 1);
damagedBytes[29] = (damagedBytes[29] ?? 0) ^ 1;
const damaged = JSON.stringify(createWebScreenshotArtifact(damagedBytes));
expect(
await runCli(["compare-web-screenshots", damaged, damaged, "--json"]),
).toMatchObject({
code: "invalid_request",
details: {
operation: "compare_web_screenshots",
issues: [
{ path: [], reason: "invalid_format", message: expect.any(String) },
],
},
});
const header = Buffer.alloc(13);
header.writeUInt32BE(1, 0);
header.writeUInt32BE(1, 4);
header.set([8, 2, 0, 0, 0], 8);
const malformedDeflate = JSON.stringify(
createWebScreenshotArtifact(
Buffer.concat([
Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]),
pngChunk("IHDR", header),
pngChunk("IDAT", Buffer.from("bad")),
pngChunk("IEND", Buffer.alloc(0)),
]),
),
);
expect(
await runCli([
"compare-web-screenshots",
malformedDeflate,
malformedDeflate,
"--json",
]),
).toMatchObject({
code: "invalid_request",
details: {
operation: "compare_web_screenshots",
issues: [{ path: [], reason: "invalid_format" }],
},
});
const grayscaleHeader = Buffer.alloc(13);
grayscaleHeader.writeUInt32BE(1, 0);
grayscaleHeader.writeUInt32BE(1, 4);
grayscaleHeader.set([8, 0, 0, 0, 0], 8);
const grayscale = JSON.stringify(
createWebScreenshotArtifact(
Buffer.concat([
Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]),
pngChunk("IHDR", grayscaleHeader),
pngChunk("IDAT", deflateSync(Buffer.from([0, 30]))),
pngChunk("IEND", Buffer.alloc(0)),
]),
),
);
expect(
await runCli(["compare-web-screenshots", grayscale, grayscale, "--json"]),
).toMatchObject({
code: "unsupported_target",
details: { operation: "compare_web_screenshots" },
});
};