mirror of
https://github.com/morluto/rea.git
synced 2026-11-18 20:53:00 +00:00
Use shared captures to verify discovery, document identity, screenshot recovery, and source map evidence and cleanup across varied responses. Remove redundant tests and unused fixture controls.
248 lines
7.7 KiB
TypeScript
248 lines
7.7 KiB
TypeScript
import { createHash } from "node:crypto";
|
|
import { expect, it, vi } from "vitest";
|
|
|
|
import { fetchWebSourceMaps } from "../../../src/browser/WebSourceMapFetcher.js";
|
|
import { fetchWebSourceMapsOk } from "../../fixtures/fetchWebSourceMapsOk.js";
|
|
import { analyzeWebBundleInputSchema } from "../../../src/domain/webBundleAnalysis.js";
|
|
|
|
const origin = "https://maps.example.test";
|
|
const request = (index: number) => ({
|
|
scriptKey: `scr_${String(index).padStart(64, "0")}`,
|
|
declaredUrl: `${origin}/${String(index)}.js.map`,
|
|
fetchUrl: `${origin}/${String(index)}.js.map`,
|
|
});
|
|
const input = analyzeWebBundleInputSchema.parse({
|
|
cdp_endpoint: "http://127.0.0.1:9222",
|
|
allowed_origins: [origin],
|
|
target_id: "page-1",
|
|
fetch_source_maps: true,
|
|
});
|
|
const digest = (bytes: Uint8Array | string): string =>
|
|
createHash("sha256").update(bytes).digest("hex");
|
|
|
|
it("preserves redirected response identity across decoding failures and valid UTF-8", async () => {
|
|
const mapWithSourceBytes = (source: Uint8Array) =>
|
|
Buffer.concat([
|
|
Buffer.from('{"version":3,"names":[],"sources":["source'),
|
|
source,
|
|
Buffer.from('.ts"],"mappings":"AAAA"}'),
|
|
]);
|
|
const invalid = [
|
|
{ name: "absent", body: null },
|
|
{
|
|
name: "mapping-index",
|
|
body: JSON.stringify({
|
|
version: 3,
|
|
sources: ["a.js"],
|
|
names: [],
|
|
mappings: "ACAA",
|
|
}),
|
|
},
|
|
{
|
|
name: "invalid-json",
|
|
body: Buffer.from("not-json"),
|
|
diagnostic: "Source-map JSON is not a version 3 map",
|
|
},
|
|
{
|
|
name: "invalid-utf8",
|
|
body: mapWithSourceBytes(Uint8Array.of(0xff)),
|
|
diagnostic: "Source-map response is not valid UTF-8",
|
|
},
|
|
] as const;
|
|
const valid = {
|
|
name: "replacement-character",
|
|
body: mapWithSourceBytes(Buffer.from("�")),
|
|
};
|
|
const unavailable = { name: "http-failure", body: "service unavailable" };
|
|
const fixtures = [...invalid, valid, unavailable].map((scenario, index) => ({
|
|
...scenario,
|
|
...request(index + 1),
|
|
effectiveUrl: `${origin}/maps/${scenario.name}.map?token=source-value#fragment`,
|
|
}));
|
|
const redirects = new Map(
|
|
fixtures.map((scenario) => [scenario.fetchUrl, scenario.effectiveUrl]),
|
|
);
|
|
const replies = new Map(
|
|
fixtures.map((scenario) => [scenario.effectiveUrl, scenario]),
|
|
);
|
|
const calls: string[] = [];
|
|
const result = await fetchWebSourceMapsOk(fixtures, input, undefined, {
|
|
fetch: async (url) => {
|
|
const received = String(url);
|
|
calls.push(received);
|
|
const location = redirects.get(received);
|
|
if (location !== undefined)
|
|
return new Response(null, { status: 302, headers: { location } });
|
|
const scenario = replies.get(received);
|
|
if (scenario === undefined)
|
|
throw new Error(`Unexpected request: ${received}`);
|
|
return new Response(scenario.body, {
|
|
status: scenario.name === unavailable.name ? 503 : 200,
|
|
});
|
|
},
|
|
});
|
|
|
|
expect(result).toMatchObject({
|
|
status: "partial",
|
|
requested: fixtures.length,
|
|
processed: fixtures.length,
|
|
});
|
|
expect(calls.sort()).toEqual(
|
|
fixtures
|
|
.flatMap(({ fetchUrl, effectiveUrl }) => [fetchUrl, effectiveUrl])
|
|
.sort(),
|
|
);
|
|
const byScript = new Map(result.items.map((item) => [item.script_key, item]));
|
|
for (const fixture of fixtures) {
|
|
const item = byScript.get(fixture.scriptKey);
|
|
if (item === undefined)
|
|
throw new Error(`Missing result for ${fixture.name}`);
|
|
expect(item, fixture.name).toMatchObject({
|
|
declared_url: fixture.declaredUrl,
|
|
effective_url: fixture.effectiveUrl,
|
|
});
|
|
if (fixture.name === valid.name) {
|
|
expect(item).toMatchObject({
|
|
status: "included",
|
|
artifact: { text: valid.body.toString("utf8") },
|
|
});
|
|
} else if (fixture.name === unavailable.name) {
|
|
expect(item).toMatchObject({
|
|
status: "fetch_failed",
|
|
artifact: null,
|
|
limitation: expect.stringContaining(
|
|
"Source-map server returned HTTP 503",
|
|
),
|
|
});
|
|
expect(item).not.toHaveProperty("response_identity");
|
|
} else {
|
|
expect(item, fixture.name).toMatchObject({
|
|
status: "invalid",
|
|
artifact: null,
|
|
response_identity: {
|
|
sha256: digest(fixture.body ?? ""),
|
|
bytes: Buffer.byteLength(fixture.body ?? ""),
|
|
representation: "fetch-response-body-bytes",
|
|
},
|
|
original_sources: [],
|
|
original_module_edges: [],
|
|
mappings: [],
|
|
limitation: expect.stringContaining("Response text was not retained"),
|
|
});
|
|
if ("diagnostic" in fixture)
|
|
expect(item.limitation, fixture.name).toContain(fixture.diagnostic);
|
|
}
|
|
}
|
|
});
|
|
|
|
it("retains completed body identity when the deadline lands as the response stream ends", async () => {
|
|
const body = JSON.stringify({
|
|
version: 3,
|
|
sources: ["a.js"],
|
|
names: [],
|
|
mappings: "AAAA",
|
|
});
|
|
let clock = 0;
|
|
const clockSpy = vi.spyOn(performance, "now").mockImplementation(() => clock);
|
|
let sentBody = false;
|
|
const stream = new ReadableStream<Uint8Array>(
|
|
{
|
|
pull(controller) {
|
|
if (sentBody) {
|
|
clock = 1_001;
|
|
controller.close();
|
|
return;
|
|
}
|
|
sentBody = true;
|
|
controller.enqueue(Buffer.from(body));
|
|
},
|
|
},
|
|
{ highWaterMark: 0 },
|
|
);
|
|
|
|
try {
|
|
const result = await fetchWebSourceMaps(
|
|
[request(1)],
|
|
{ ...input, source_map_fetch_timeout_ms: 1_000 },
|
|
undefined,
|
|
{ fetch: async () => new Response(stream) },
|
|
);
|
|
if (!result.ok) throw result.error;
|
|
expect(result.value).toMatchObject({
|
|
status: "unavailable",
|
|
requested: 1,
|
|
processed: 1,
|
|
items: [
|
|
{
|
|
status: "fetch_failed",
|
|
artifact: null,
|
|
response_identity: {
|
|
sha256: digest(body),
|
|
bytes: Buffer.byteLength(body),
|
|
representation: "fetch-response-body-bytes",
|
|
},
|
|
original_sources: [],
|
|
original_module_edges: [],
|
|
mappings: [],
|
|
limitation: expect.stringContaining(
|
|
"source_map_fetch_timeout_ms deadline",
|
|
),
|
|
},
|
|
],
|
|
});
|
|
} finally {
|
|
clockSpy.mockRestore();
|
|
}
|
|
});
|
|
|
|
it("retains body identity and later maps when escaping exceeds the output budget", async () => {
|
|
const budget = 8_000;
|
|
const oversized = Buffer.alloc(2_000, 1);
|
|
expect(oversized.byteLength).toBeLessThan(budget);
|
|
expect(
|
|
Buffer.byteLength(JSON.stringify(oversized.toString("utf8"))),
|
|
).toBeGreaterThan(budget);
|
|
const valid = JSON.stringify({
|
|
version: 3,
|
|
sources: ["a.js"],
|
|
names: [],
|
|
mappings: "AAAA",
|
|
});
|
|
const result = await fetchWebSourceMaps(
|
|
[request(1), request(2)],
|
|
{ ...input, source_map_limits: { output_bytes: budget } },
|
|
undefined,
|
|
{
|
|
fetch: async (url) =>
|
|
new Response(String(url) === request(1).fetchUrl ? oversized : valid),
|
|
},
|
|
);
|
|
if (!result.ok) throw result.error;
|
|
expect(result.value).toMatchObject({
|
|
status: "partial",
|
|
requested: 2,
|
|
processed: 2,
|
|
items: [
|
|
{
|
|
status: "fetch_failed",
|
|
artifact: null,
|
|
response_identity: {
|
|
sha256: digest(oversized),
|
|
bytes: oversized.byteLength,
|
|
representation: "fetch-response-body-bytes",
|
|
},
|
|
mappings: [],
|
|
limitation: expect.stringContaining("Response text was not retained"),
|
|
},
|
|
{ status: "included", artifact: { text: valid }, mappings: [{}] },
|
|
],
|
|
});
|
|
const limitation = result.value.items[0]?.limitation;
|
|
expect(limitation).toMatch(/JSON[- ]escap/i);
|
|
expect(limitation).toContain("source_map_limits.output_bytes is 8000 bytes");
|
|
expect(limitation).toContain("Increase that per-call field");
|
|
expect(Buffer.byteLength(JSON.stringify(result.value))).toBeLessThanOrEqual(
|
|
budget,
|
|
);
|
|
});
|