test(browser): consolidate CDP and source map coverage

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.
This commit is contained in:
morluto committed 2026-11-18 03:51:31 -05:00
1 parent 1592b7f2c0
commit caedefa00d
19 files changed
+1729 -2195

No files matched your search

@@ -1,4 +1,3 @@
import { createHash } from "node:crypto";
import { once } from "node:events";
import { createServer } from "node:http";
@@ -9,169 +8,101 @@ import { fetchWebSourceMapsOk } from "../../fixtures/fetchWebSourceMapsOk.js";
import { analyzeWebBundleInputSchema } from "../../../src/domain/webBundleAnalysis.js";
import { WEB_SOURCE_MAP_LIMITS } from "../../../src/domain/sourceMapLimits.js";
it.each([
{ status: 300, followsRedirect: false },
{ status: 304, followsRedirect: false },
{ status: 305, followsRedirect: false },
{ status: 306, followsRedirect: false },
{ status: 301, followsRedirect: true },
{ status: 302, followsRedirect: true },
{ status: 303, followsRedirect: true },
{ status: 307, followsRedirect: true },
{ status: 308, followsRedirect: true },
])(
"follows HTTP $status with Location only when it is a redirect status",
async ({ status, followsRedirect }) => {
const calls: string[] = [];
const server = createServer((request, response) => {
const path = request.url ?? "";
calls.push(path);
if (path === "/delivered.map") {
response.writeHead(200, { "content-type": "application/json" }).end(
JSON.stringify({
version: 3,
names: [],
sources: ["original.js"],
mappings: "AAAA",
}),
);
return;
}
response.writeHead(status, { location: "/delivered.map" }).end();
});
try {
const listening = once(server, "listening");
server.listen(0, "127.0.0.1");
await listening;
const address = server.address();
if (address === null || typeof address === "string")
throw new TypeError("Expected TCP listener");
const origin = `http://127.0.0.1:${String(address.port)}`;
const input = analyzeWebBundleInputSchema.parse({
cdp_endpoint: "http://127.0.0.1:9222",
target_id: "selected-page",
allowed_origins: [origin],
fetch_source_maps: true,
});
const url = `${origin}/${String(status)}`;
const result = await fetchWebSourceMapsOk(
[
{
scriptKey: `scr_${"1".repeat(64)}`,
declaredUrl: url,
fetchUrl: url,
},
],
input,
it("follows only redirect statuses and releases discarded HTTP response bodies", async () => {
const redirects = [301, 302, 303, 307, 308];
const otherStatuses = [300, 304, 305, 306, 400];
const statuses = [...otherStatuses, ...redirects];
const calls: string[] = [];
const closedBodies: string[] = [];
const server = createServer((request, response) => {
const path = request.url ?? "";
calls.push(path);
if (path.startsWith("/delivered/")) {
response.writeHead(200, { "content-type": "application/json" }).end(
JSON.stringify({
version: 3,
names: [],
sources: ["original.js"],
mappings: "AAAA",
}),
);
expect(calls).toEqual(
followsRedirect
? [`/${String(status)}`, "/delivered.map"]
: [`/${String(status)}`],
);
expect(result.items[0]?.status).toBe(
followsRedirect ? "included" : "fetch_failed",
);
expect(result.items[0]).toMatchObject({
declared_url: url,
effective_url: followsRedirect ? `${origin}/delivered.map` : url,
});
if (!followsRedirect)
expect(result.items[0]?.limitation).toBe(
`Source-map server returned HTTP ${String(status)}.`,
);
} finally {
server.closeAllConnections();
if (server.listening)
await new Promise<void>((resolve, reject) =>
server.close((error) =>
error === undefined ? resolve() : reject(error),
),
);
return;
}
},
);
it("keeps the declared URL and reports malformed redirect Location evidence", async () => {
const declaredUrl = "https://app.example.test/declared.map";
const input = analyzeWebBundleInputSchema.parse({
cdp_endpoint: "http://127.0.0.1:9222",
target_id: "selected-page",
allowed_origins: ["https://app.example.test"],
fetch_source_maps: true,
const status = Number(path.slice(1));
if (!statuses.includes(status)) {
response.writeHead(404).end();
return;
}
response.writeHead(status, { location: `/delivered/${status}.map` });
if (status === 302 || status === 400) {
response.once("close", () => closedBodies.push(path));
response.write("unfinished response body");
} else response.end();
});
const result = await fetchWebSourceMapsOk(
[
{
scriptKey: `scr_${"1".repeat(64)}`,
declaredUrl,
fetchUrl: declaredUrl,
},
],
input,
undefined,
{
fetch: () =>
Promise.resolve(
new Response(null, {
status: 302,
headers: { location: "http://[invalid" },
}),
try {
const listening = once(server, "listening");
server.listen(0, "127.0.0.1");
await listening;
const address = server.address();
if (address === null || typeof address === "string")
throw new TypeError("Expected TCP listener");
const origin = `http://127.0.0.1:${address.port}`;
const input = analyzeWebBundleInputSchema.parse({
cdp_endpoint: "http://127.0.0.1:9222",
target_id: "selected-page",
allowed_origins: [origin],
fetch_source_maps: true,
});
const requests = statuses.map((status) => {
const url = `${origin}/${status}`;
return { scriptKey: `script-${status}`, declaredUrl: url, fetchUrl: url };
});
const result = await fetchWebSourceMapsOk(requests, input);
expect(result).toMatchObject({
status: "partial",
requested: statuses.length,
processed: statuses.length,
});
expect(calls.sort()).toEqual(
[
...statuses.map((status) => `/${status}`),
...redirects.map((status) => `/delivered/${status}.map`),
].sort(),
);
const byScript = new Map(
result.items.map((item) => [item.script_key, item]),
);
for (const status of redirects)
expect(byScript.get(`script-${status}`), `HTTP ${status}`).toMatchObject({
status: "included",
declared_url: `${origin}/${status}`,
effective_url: `${origin}/delivered/${status}.map`,
});
for (const status of otherStatuses)
expect(byScript.get(`script-${status}`), `HTTP ${status}`).toMatchObject({
status: "fetch_failed",
declared_url: `${origin}/${status}`,
effective_url: `${origin}/${status}`,
limitation: `Source-map server returned HTTP ${status}.`,
});
await expect.poll(() => closedBodies.toSorted()).toEqual(["/302", "/400"]);
} finally {
server.closeAllConnections();
if (server.listening)
await new Promise<void>((resolve, reject) =>
server.close((error) =>
error === undefined ? resolve() : reject(error),
),
},
);
expect(result.items[0]).toMatchObject({
status: "fetch_failed",
declared_url: declaredUrl,
effective_url: declaredUrl,
limitation: expect.stringContaining("invalid Location URL"),
});
expect(result.items[0]?.limitation).toContain(declaredUrl);
expect(result.items[0]?.limitation).toContain("http://[invalid");
);
}
});
const mapStart = Buffer.from('{"version":3,"names":[],"sources":["source');
const mapEnd = Buffer.from('.ts"],"mappings":"AAAA"}');
const mapWithSourceBytes = (bytes: Uint8Array) =>
Buffer.concat([mapStart, bytes, mapEnd]);
it.each([
{
name: "invalid JSON",
body: Buffer.from("not-json"),
status: "invalid",
diagnostic: "Source-map JSON is not a version 3 map",
},
{
name: "invalid UTF-8",
body: mapWithSourceBytes(Uint8Array.of(0xff)),
status: "invalid",
diagnostic: "Source-map response is not valid UTF-8",
},
{
name: "a valid UTF-8 replacement character",
body: mapWithSourceBytes(Buffer.from("�")),
status: "included",
},
{
name: "HTTP failure",
body: Buffer.from("service unavailable"),
status: "fetch_failed",
responseStatus: 503,
diagnostic: "Source-map server returned HTTP 503",
},
{
name: "response limit",
body: mapWithSourceBytes(Buffer.from("name")),
status: "fetch_failed",
fetchBytes: 1,
},
])("retains a redirected response URL for $name", async (scenario) => {
it("keeps the redirected URL when the body exceeds the fetch limit", async () => {
const origin = "https://app.example.test";
const declaredUrl = `${origin}/declared.map`;
const fetchedUrl = `${origin}/maps/current.map?token=source-value#fragment`;
const calls: string[] = [];
const result = await fetchWebSourceMapsOk(
[{ scriptKey: "script", declaredUrl, fetchUrl: declaredUrl }],
analyzeWebBundleInputSchema.parse({
@@ -179,126 +110,100 @@ it.each([
target_id: "page",
allowed_origins: [origin],
fetch_source_maps: true,
...(scenario.fetchBytes === undefined
? {}
: { source_map_limits: { fetch_bytes: scenario.fetchBytes } }),
source_map_limits: { fetch_bytes: 1 },
}),
undefined,
{
fetch: async (url) =>
String(url) === declaredUrl
fetch: async (url) => {
calls.push(String(url));
return String(url) === declaredUrl
? new Response(null, {
status: 302,
headers: { location: fetchedUrl },
})
: new Response(scenario.body, {
status: scenario.responseStatus ?? 200,
}),
: new Response('{"version":3,"sources":[],"names":[],"mappings":""}');
},
},
);
const item = result.items[0];
if (item === undefined) throw new Error("Expected a fetched map result");
expect(item).toMatchObject({
declared_url: declaredUrl,
effective_url: fetchedUrl,
status: scenario.status,
artifact:
scenario.status === "included"
? expect.objectContaining({ text: scenario.body.toString("utf8") })
: null,
});
if (scenario.status === "invalid") {
expect(item).toMatchObject({
response_identity: {
bytes: scenario.body.byteLength,
sha256: createHash("sha256").update(scenario.body).digest("hex"),
representation: "fetch-response-body-bytes",
expect(calls).toEqual([declaredUrl, fetchedUrl]);
expect(result).toMatchObject({
requested: 1,
processed: 1,
items: [
{
declared_url: declaredUrl,
effective_url: fetchedUrl,
status: "fetch_failed",
artifact: null,
limitation: expect.stringContaining(
"source_map_limits.fetch_bytes is 1",
),
},
});
expect(item.limitation).toContain("Response text was not retained");
}
if (scenario.diagnostic !== undefined)
expect(item.limitation).toContain(scenario.diagnostic);
],
});
expect(result.items[0]).not.toHaveProperty("response_identity");
});
it.each([
{ cancellationFails: false, reason: null, abortDuringCleanup: false },
{
cancellationFails: true,
reason: new Error("fixture cancel failure"),
abortDuringCleanup: false,
},
{ cancellationFails: true, reason: undefined, abortDuringCleanup: false },
{
cancellationFails: true,
reason: new Error("cleanup failed before caller abort"),
abortDuringCleanup: true,
},
])(
"reserves a fetched URL before reading an over-cap response; cancellation failure=$cancellationFails, caller abort=$abortDuringCleanup",
async ({ cancellationFails, reason, abortDuringCleanup }) => {
const origin = "https://app.example.test";
const fetchedUrl = `${origin}/${"u".repeat(WEB_SOURCE_MAP_LIMITS.outputBytes)}`;
let cancelled = false;
let read = false;
it("reserves output for the fetched URL before reading and preserves failed cleanup", async () => {
const origin = "https://app.example.test";
const fetchedUrl = `${origin}/${"u".repeat(WEB_SOURCE_MAP_LIMITS.outputBytes)}`;
const requests = [
{
scriptKey: "script",
declaredUrl: `${origin}/declared.map`,
fetchUrl: fetchedUrl,
},
];
const input = analyzeWebBundleInputSchema.parse({
cdp_endpoint: "http://127.0.0.1:9222",
target_id: "page",
allowed_origins: [origin],
fetch_source_maps: true,
});
const callerReason = { requested: "stop during response cleanup" };
const scenarios = [
{ label: "closed" },
{ label: "close rejection", failure: new Error("fixture cancel failure") },
{ label: "undefined close rejection", failure: undefined },
{
label: "caller abort during failed close",
failure: new Error("cleanup failed during caller abort"),
abortDuringCleanup: true,
},
] as const;
for (const scenario of scenarios) {
let cancelled = 0;
let pulls = 0;
const controller = new AbortController();
const body = new ReadableStream<Uint8Array>(
{
pull(controller) {
read = true;
controller.enqueue(
new TextEncoder().encode(
'{"version":3,"sources":[],"names":[],"mappings":""}',
),
);
controller.close();
pull(stream) {
pulls += 1;
stream.enqueue(new Uint8Array([123, 125]));
stream.close();
},
cancel() {
cancelled = true;
if (abortDuringCleanup)
controller.abort({ requested: "stop during response cleanup" });
if (cancellationFails) throw reason;
cancelled += 1;
if ("abortDuringCleanup" in scenario) controller.abort(callerReason);
if ("failure" in scenario) throw scenario.failure;
},
},
{ highWaterMark: 0 },
);
const pending = fetchWebSourceMaps(
[
{
scriptKey: "script",
declaredUrl: `${origin}/declared.map`,
fetchUrl: fetchedUrl,
},
],
analyzeWebBundleInputSchema.parse({
cdp_endpoint: "http://127.0.0.1:9222",
target_id: "page",
allowed_origins: [origin],
fetch_source_maps: true,
}),
const result = await fetchWebSourceMaps(
requests,
input,
controller.signal,
{ fetch: () => Promise.resolve(new Response(body)) },
{
fetch: async () => new Response(body),
},
);
if (cancellationFails) {
const result = await pending;
expect(result.ok).toBe(false);
if (result.ok) throw new Error("Expected output admission failure");
expect(result.error._tag).toBe("AnalysisResourceConstraintError");
expect(result.error.message).toContain("Expanded source-map evidence");
expect(result.error.cleanupIncomplete).toBe(true);
expect(result.error.cleanupResources.length).toBe(1);
expect(result.error.cleanupResources[0] === fetchedUrl).toBe(true);
await expect
.poll(() =>
result.error.secondaryFailures.some((failure) =>
failure.secondaryFailures.some(
(secondary) => secondary.cause === reason,
),
),
)
.toBe(true);
} else {
await expect(pending).resolves.toMatchObject({
expect(cancelled, scenario.label).toBe(1);
expect(pulls, scenario.label).toBe(0);
if (!("failure" in scenario)) {
expect(result, scenario.label).toMatchObject({
ok: true,
value: {
status: "unavailable",
@@ -308,11 +213,39 @@ it.each([
limitation: expect.stringContaining("1 requested map"),
},
});
continue;
}
expect(cancelled).toBe(true);
expect(read).toBe(false);
},
);
if (result.ok)
throw new Error(`Expected output admission failure: ${scenario.label}`);
const { error } = result;
expect(error, scenario.label).toMatchObject({
_tag: "AnalysisResourceConstraintError",
message: expect.stringContaining("Expanded source-map evidence"),
cleanupIncomplete: true,
});
expect(error.cleanupResources, scenario.label).toHaveLength(1);
expect(error.cleanupResources[0] === fetchedUrl, scenario.label).toBe(true);
const secondaryFailures = () =>
error.secondaryFailures.flatMap((failure) => failure.secondaryFailures);
await expect
.poll(() =>
secondaryFailures().some(
(failure) =>
failure._tag === "ProviderAdapterError" &&
failure.cause === scenario.failure,
),
)
.toBe(true);
if ("abortDuringCleanup" in scenario)
expect(secondaryFailures()).toContainEqual(
expect.objectContaining({
_tag: "AnalysisCancelledError",
cause: callerReason,
}),
);
}
});
it("fits complete malformed redirect diagnostics within the output budget", async () => {
const origin = "https://app.example.test";
@@ -350,11 +283,16 @@ it("fits complete malformed redirect diagnostics within the output budget", asyn
items: requests.slice(0, 2).map(({ scriptKey, declaredUrl }) => ({
script_key: scriptKey,
declared_url: declaredUrl,
effective_url: declaredUrl,
status: "fetch_failed",
limitation: expect.stringContaining(JSON.stringify(location)),
})),
limitation: expect.stringContaining("2 requested maps"),
});
for (const item of result.items) {
expect(item.limitation).toContain("invalid Location URL");
expect(item.limitation).toContain(item.declared_url);
}
expect(Buffer.byteLength(JSON.stringify(result))).toBeLessThanOrEqual(budget);
expect(cancelled).toEqual(
requests.slice(0, 3).map(({ fetchUrl }) => fetchUrl),