mirror of
https://github.com/morluto/rea.git
synced 2026-11-19 13:12:26 +00:00
303 lines
9.9 KiB
TypeScript
303 lines
9.9 KiB
TypeScript
import { once } from "node:events";
|
|
import { createServer } from "node:http";
|
|
|
|
import { expect, it } from "vitest";
|
|
|
|
import { fetchWebSourceMaps } from "../../../src/browser/WebSourceMapFetcher.js";
|
|
import { fetchWebSourceMapsOk } from "../../fixtures/fetchWebSourceMapsOk.js";
|
|
import { analyzeWebBundleInputSchema } from "../../../src/domain/webBundleAnalysis.js";
|
|
|
|
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",
|
|
}),
|
|
);
|
|
return;
|
|
}
|
|
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();
|
|
});
|
|
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),
|
|
),
|
|
);
|
|
}
|
|
});
|
|
|
|
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({
|
|
cdp_endpoint: "http://127.0.0.1:9222",
|
|
target_id: "page",
|
|
allowed_origins: [origin],
|
|
fetch_source_maps: true,
|
|
source_map_limits: { fetch_bytes: 1 },
|
|
}),
|
|
undefined,
|
|
{
|
|
fetch: async (url) => {
|
|
calls.push(String(url));
|
|
return String(url) === declaredUrl
|
|
? new Response(null, {
|
|
status: 302,
|
|
headers: { location: fetchedUrl },
|
|
})
|
|
: new Response('{"version":3,"sources":[],"names":[],"mappings":""}');
|
|
},
|
|
},
|
|
);
|
|
|
|
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(result.items[0]).not.toHaveProperty("response_identity");
|
|
});
|
|
|
|
it("reserves output for the fetched URL before reading and preserves failed cleanup", async () => {
|
|
const origin = "https://app.example.test";
|
|
const outputBytes = 4_000;
|
|
const fetchedUrl = `${origin}/${"u".repeat(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,
|
|
source_map_limits: { output_bytes: outputBytes },
|
|
});
|
|
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(stream) {
|
|
pulls += 1;
|
|
stream.enqueue(new Uint8Array([123, 125]));
|
|
stream.close();
|
|
},
|
|
cancel() {
|
|
cancelled += 1;
|
|
if ("abortDuringCleanup" in scenario) controller.abort(callerReason);
|
|
if ("failure" in scenario) throw scenario.failure;
|
|
},
|
|
},
|
|
{ highWaterMark: 0 },
|
|
);
|
|
const result = await fetchWebSourceMaps(
|
|
requests,
|
|
input,
|
|
controller.signal,
|
|
{
|
|
fetch: async () => new Response(body),
|
|
},
|
|
);
|
|
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",
|
|
requested: 1,
|
|
processed: 0,
|
|
items: [],
|
|
limitation: expect.stringContaining("1 requested map"),
|
|
},
|
|
});
|
|
continue;
|
|
}
|
|
|
|
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"),
|
|
reportedLimits: { boundary: "output_bytes", maximum: outputBytes },
|
|
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";
|
|
const location = `http://[${'\\"'.repeat(400)}`;
|
|
const requests = ["first", "second", "third", "fourth"].map((name) => ({
|
|
scriptKey: name,
|
|
declaredUrl: `${origin}/${name}.map`,
|
|
fetchUrl: `${origin}/${name}.map`,
|
|
}));
|
|
const budget = 9_000;
|
|
const input = analyzeWebBundleInputSchema.parse({
|
|
cdp_endpoint: "http://127.0.0.1:9222",
|
|
target_id: "page",
|
|
allowed_origins: [origin],
|
|
fetch_source_maps: true,
|
|
source_map_limits: { output_bytes: budget },
|
|
});
|
|
const cancelled: string[] = [];
|
|
const result = await fetchWebSourceMapsOk(requests, input, undefined, {
|
|
fetch: async (url) =>
|
|
new Response(
|
|
new ReadableStream<Uint8Array>({
|
|
cancel() {
|
|
cancelled.push(String(url));
|
|
},
|
|
}),
|
|
{ status: 302, headers: { location } },
|
|
),
|
|
});
|
|
|
|
expect(result).toMatchObject({
|
|
status: "unavailable",
|
|
requested: 4,
|
|
processed: 2,
|
|
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),
|
|
);
|
|
});
|