mirror of
https://github.com/morluto/rea.git
synced 2026-11-17 04:04:25 +00:00
934 lines
29 KiB
TypeScript
934 lines
29 KiB
TypeScript
import process from "node:process";
|
|
import { createServer } from "node:http";
|
|
import { once } from "node:events";
|
|
|
|
import { expect, it } from "vitest";
|
|
|
|
import { fetchWebSourceMaps } from "./WebSourceMapFetcher.js";
|
|
import { analyzeWebBundleInputSchema } from "../domain/webBundleAnalysis.js";
|
|
import { fetchWebSourceMapsOk } from "../../tests/fixtures/fetchWebSourceMapsOk.js";
|
|
|
|
const input = analyzeWebBundleInputSchema.parse({
|
|
cdp_endpoint: "http://127.0.0.1:9222",
|
|
allowed_origins: ["http://127.0.0.1:9222"],
|
|
target_id: "page-1",
|
|
fetch_source_maps: true,
|
|
});
|
|
const request = {
|
|
scriptKey: `scr_${"1".repeat(64)}`,
|
|
declaredUrl: "https://app.example.test/app.js.map",
|
|
fetchUrl: "https://app.example.test/app.js.map",
|
|
};
|
|
|
|
it("reports a source map that is not UTF-8 as invalid with its response identity", async () => {
|
|
const result = await fetchWebSourceMapsOk(
|
|
[request],
|
|
{ ...input, allowed_origins: [new URL(request.fetchUrl).origin] },
|
|
undefined,
|
|
{ fetch: async () => new Response(Buffer.from([0x7b, 0xff, 0x7d])) },
|
|
);
|
|
|
|
expect(result.items[0]).toMatchObject({
|
|
status: "invalid",
|
|
limitation: expect.stringMatching(
|
|
/^Source-map response is not valid UTF-8\. Response text was not retained/u,
|
|
),
|
|
response_identity: {
|
|
bytes: 3,
|
|
representation: "fetch-response-body-bytes",
|
|
},
|
|
});
|
|
});
|
|
|
|
it("reports an empty selected request set without starting fetch work", async () => {
|
|
const result = await fetchWebSourceMapsOk([], input, undefined, {
|
|
fetch: async () => {
|
|
throw new Error("No source-map request should be made");
|
|
},
|
|
});
|
|
|
|
expect(result).toEqual({
|
|
status: "not_requested",
|
|
requested: 0,
|
|
processed: 0,
|
|
items: [],
|
|
});
|
|
});
|
|
|
|
it("honors cancellation before returning an empty request set", async () => {
|
|
const controller = new AbortController();
|
|
const reason = new Error("cancelled before fetching");
|
|
controller.abort(reason);
|
|
|
|
const result = await fetchWebSourceMaps([], input, controller.signal);
|
|
expect(result.ok).toBe(false);
|
|
if (!result.ok) expect(result.error.cause).toBe(reason);
|
|
});
|
|
|
|
it("cancels a response body that arrives after its fetch host aborts synchronously", async () => {
|
|
const controller = new AbortController();
|
|
const reason = new Error("fetch host aborted during admission");
|
|
let resolveFetch!: (response: Response) => void;
|
|
const fetchPromise = new Promise<Response>((resolve) => {
|
|
resolveFetch = resolve;
|
|
});
|
|
let markCancelled!: () => void;
|
|
const cancelled = new Promise<void>((resolve) => {
|
|
markCancelled = resolve;
|
|
});
|
|
let cancellationReason: unknown;
|
|
const body = new ReadableStream<Uint8Array>({
|
|
cancel: (cause) => {
|
|
cancellationReason = cause;
|
|
markCancelled();
|
|
},
|
|
});
|
|
const fetchInput = analyzeWebBundleInputSchema.parse({
|
|
cdp_endpoint: "http://127.0.0.1:9222",
|
|
allowed_origins: [new URL(request.fetchUrl).origin],
|
|
target_id: "page-1",
|
|
fetch_source_maps: true,
|
|
});
|
|
const pending = fetchWebSourceMaps([request], fetchInput, controller.signal, {
|
|
fetch: () => {
|
|
controller.abort(reason);
|
|
return fetchPromise;
|
|
},
|
|
});
|
|
|
|
const result = await pending;
|
|
expect(result.ok).toBe(false);
|
|
if (!result.ok) expect(result.error.cause).toBe(reason);
|
|
resolveFetch(new Response(body));
|
|
await cancelled;
|
|
expect(cancellationReason).toBe(reason);
|
|
});
|
|
|
|
it("retains cleanup when a response arrives after fetch cancellation", async () => {
|
|
const controller = new AbortController();
|
|
const reason = new Error("caller cancelled during fetch");
|
|
let resolveFetch!: (response: Response) => void;
|
|
const fetching = new Promise<Response>((resolve) => {
|
|
resolveFetch = resolve;
|
|
});
|
|
const [body, sibling] = new ReadableStream<Uint8Array>({
|
|
start(stream) {
|
|
stream.enqueue(new Uint8Array([1]));
|
|
},
|
|
}).tee();
|
|
const pending = fetchWebSourceMaps(
|
|
[request],
|
|
{ ...input, allowed_origins: [new URL(request.fetchUrl).origin] },
|
|
controller.signal,
|
|
{ fetch: async () => fetching },
|
|
);
|
|
controller.abort(reason);
|
|
const result = await pending;
|
|
if (result.ok) throw new Error("Expected cancellation");
|
|
expect(result.error.cause).toBe(reason);
|
|
try {
|
|
resolveFetch(new Response(body));
|
|
await new Promise<void>((resolve) => setImmediate(resolve));
|
|
expect(result.error.cleanupIncomplete).toBe(true);
|
|
expect(result.error.cleanupResources).toEqual([request.fetchUrl]);
|
|
await sibling.cancel();
|
|
await expect.poll(() => result.error.cleanupIncomplete).toBe(false);
|
|
} finally {
|
|
await sibling.cancel();
|
|
}
|
|
});
|
|
|
|
it("releases a late response already errored with the caller reason", async () => {
|
|
const controller = new AbortController();
|
|
const reason = new Error("caller cancelled during fetch");
|
|
let resolveFetch!: (response: Response) => void;
|
|
const fetching = new Promise<Response>((resolve) => {
|
|
resolveFetch = resolve;
|
|
});
|
|
const pending = fetchWebSourceMaps(
|
|
[request],
|
|
{ ...input, allowed_origins: [new URL(request.fetchUrl).origin] },
|
|
controller.signal,
|
|
{ fetch: async () => fetching },
|
|
);
|
|
controller.abort(reason);
|
|
const result = await pending;
|
|
if (result.ok) throw new Error("Expected cancellation");
|
|
expect(result.error.cleanupIncomplete).toBe(true);
|
|
resolveFetch(
|
|
new Response(
|
|
new ReadableStream<Uint8Array>({
|
|
start(stream) {
|
|
stream.error(reason);
|
|
},
|
|
}),
|
|
),
|
|
);
|
|
await expect.poll(() => result.error.cleanupIncomplete).toBe(false);
|
|
expect(result.error.cleanupResources).toEqual([]);
|
|
expect(result.error.cause).toBe(reason);
|
|
});
|
|
|
|
it("retains the exact failure of a late response cancellation", async () => {
|
|
const controller = new AbortController();
|
|
const reason = new Error("caller cancelled during fetch");
|
|
const physical = new Error("late response cancellation failed");
|
|
let resolveFetch!: (response: Response) => void;
|
|
const fetching = new Promise<Response>((resolve) => {
|
|
resolveFetch = resolve;
|
|
});
|
|
const pending = fetchWebSourceMaps(
|
|
[request],
|
|
{ ...input, allowed_origins: [new URL(request.fetchUrl).origin] },
|
|
controller.signal,
|
|
{ fetch: async () => fetching },
|
|
);
|
|
controller.abort(reason);
|
|
const result = await pending;
|
|
if (result.ok) throw new Error("Expected cancellation");
|
|
resolveFetch(
|
|
new Response(
|
|
new ReadableStream<Uint8Array>({
|
|
cancel() {
|
|
throw physical;
|
|
},
|
|
}),
|
|
),
|
|
);
|
|
await expect.poll(() => result.error.secondaryFailures.length).toBe(1);
|
|
expect(result.error.cause).toBe(reason);
|
|
expect(result.error.cleanupIncomplete).toBe(true);
|
|
expect(result.error.cleanupResources).toEqual([request.fetchUrl]);
|
|
expect(result.error.secondaryFailures[0]?.secondaryFailures[0]?.cause).toBe(
|
|
physical,
|
|
);
|
|
});
|
|
|
|
it("retains a fetch host that ignores an item deadline until it settles", async () => {
|
|
let rejectFetch!: (cause: unknown) => void;
|
|
const fetching = new Promise<Response>((_resolve, reject) => {
|
|
rejectFetch = reject;
|
|
});
|
|
const pending = fetchWebSourceMaps(
|
|
[request],
|
|
{
|
|
...input,
|
|
allowed_origins: [new URL(request.fetchUrl).origin],
|
|
source_map_fetch_timeout_ms: 50,
|
|
},
|
|
undefined,
|
|
{ fetch: async () => fetching },
|
|
);
|
|
const result = await pending;
|
|
if (result.ok) throw new Error("Expected pending-fetch cleanup");
|
|
expect(result.error.cleanupIncomplete).toBe(true);
|
|
expect(result.error.cleanupResources).toEqual([request.fetchUrl]);
|
|
rejectFetch(result.error.cause);
|
|
await expect.poll(() => result.error.cleanupIncomplete).toBe(false);
|
|
expect(result.error.cleanupResources).toEqual([]);
|
|
});
|
|
|
|
it("preserves a physical fetch failure when the caller cancels before delivery", async () => {
|
|
const controller = new AbortController();
|
|
const physical = new Error("physical fetch failure");
|
|
const reason = { kind: "late caller cancellation" };
|
|
const result = await fetchWebSourceMaps(
|
|
[request],
|
|
{ ...input, allowed_origins: [new URL(request.fetchUrl).origin] },
|
|
controller.signal,
|
|
{
|
|
fetch: () => {
|
|
const rejected = Promise.reject(physical);
|
|
void rejected.catch(() => {
|
|
queueMicrotask(() => controller.abort(reason));
|
|
});
|
|
return rejected;
|
|
},
|
|
},
|
|
);
|
|
if (result.ok) throw new Error("Expected physical fetch failure");
|
|
expect(result.error).toMatchObject({
|
|
_tag: "ProviderAdapterError",
|
|
cause: physical,
|
|
});
|
|
expect(
|
|
result.error.secondaryFailures.some((failure) => failure.cause === reason),
|
|
).toBe(true);
|
|
});
|
|
|
|
it("observes a fetch rejection that arrives after its host aborts synchronously", async () => {
|
|
const controller = new AbortController();
|
|
const reason = new Error("fetch host aborted during admission");
|
|
const lateFailure = new Error("late fetch failure");
|
|
let rejectFetch!: (cause: unknown) => void;
|
|
const fetchPromise = new Promise<Response>((_resolve, reject) => {
|
|
rejectFetch = reject;
|
|
});
|
|
const fetchInput = analyzeWebBundleInputSchema.parse({
|
|
cdp_endpoint: "http://127.0.0.1:9222",
|
|
allowed_origins: [new URL(request.fetchUrl).origin],
|
|
target_id: "page-1",
|
|
fetch_source_maps: true,
|
|
});
|
|
const pending = fetchWebSourceMaps([request], fetchInput, controller.signal, {
|
|
fetch: () => {
|
|
controller.abort(reason);
|
|
return fetchPromise;
|
|
},
|
|
});
|
|
let unhandled: unknown;
|
|
const onUnhandled = (cause: unknown): void => {
|
|
unhandled = cause;
|
|
};
|
|
process.on("unhandledRejection", onUnhandled);
|
|
|
|
try {
|
|
const result = await pending;
|
|
expect(result.ok).toBe(false);
|
|
if (!result.ok) expect(result.error.cause).toBe(reason);
|
|
rejectFetch(lateFailure);
|
|
await new Promise<void>((resolve) => setImmediate(resolve));
|
|
expect(unhandled).toBeUndefined();
|
|
} finally {
|
|
process.off("unhandledRejection", onUnhandled);
|
|
}
|
|
});
|
|
|
|
it.each([
|
|
{
|
|
sourceRoot: "https://cdn.example/src/",
|
|
expected: "https://cdn.example/src/a.js",
|
|
},
|
|
{
|
|
sourceRoot: "https://cdn.example/src//",
|
|
expected: "https://cdn.example/src//a.js",
|
|
},
|
|
{ sourceRoot: "webpack://", expected: "webpack://a.js" },
|
|
{ sourceRoot: "webpack:///", expected: "webpack:///a.js" },
|
|
{ sourceRoot: "", expected: "https://app.example.test/maps/a.js" },
|
|
{ sourceRoot: null, expected: "https://app.example.test/maps/a.js" },
|
|
])(
|
|
"retains the admitted ECMA-426 source identity for root $sourceRoot",
|
|
async ({ sourceRoot, expected }) => {
|
|
const text = JSON.stringify({
|
|
version: 3,
|
|
sourceRoot,
|
|
sources: ["a.js", null],
|
|
names: [],
|
|
mappings: "AAAA;ACAA",
|
|
});
|
|
const fetchInput = analyzeWebBundleInputSchema.parse({
|
|
cdp_endpoint: "http://127.0.0.1:9222",
|
|
target_id: "page-1",
|
|
fetch_source_maps: true,
|
|
allowed_origins: [new URL(request.fetchUrl).origin],
|
|
});
|
|
const selectedRequest = {
|
|
...request,
|
|
declaredUrl: "https://app.example.test/maps/app.js.map",
|
|
fetchUrl: "https://app.example.test/maps/app.js.map",
|
|
};
|
|
const result = await fetchWebSourceMapsOk(
|
|
[selectedRequest],
|
|
fetchInput,
|
|
undefined,
|
|
{
|
|
fetch: async () => new Response(text, { status: 200 }),
|
|
},
|
|
);
|
|
expect(result.items[0]).toMatchObject({
|
|
status: "included",
|
|
original_sources: [{ source: expected }, { source: null }],
|
|
mappings: [{ source: expected }, { source: null }],
|
|
});
|
|
},
|
|
);
|
|
|
|
it.each([
|
|
{ trigger: "caller-abort", rejects: false },
|
|
{ trigger: "caller-abort", rejects: true },
|
|
{ trigger: "response-limit", rejects: false },
|
|
{ trigger: "response-limit", rejects: true },
|
|
])(
|
|
"retains original cancellation after $trigger (rejects: $rejects)",
|
|
async ({ trigger, rejects }) => {
|
|
let started!: () => void;
|
|
const reading = new Promise<void>((resolve) => {
|
|
started = resolve;
|
|
});
|
|
let cancelled!: () => void;
|
|
const cancelling = new Promise<void>((resolve) => {
|
|
cancelled = resolve;
|
|
});
|
|
let finish!: () => void;
|
|
const held = new Promise<void>((resolve) => {
|
|
finish = resolve;
|
|
});
|
|
let calls = 0;
|
|
const cleanupFailure = new Error("response cancellation failed");
|
|
const body = new ReadableStream<Uint8Array>(
|
|
{
|
|
pull(controller) {
|
|
started();
|
|
if (trigger === "response-limit")
|
|
controller.enqueue(new Uint8Array(2));
|
|
},
|
|
async cancel() {
|
|
calls += 1;
|
|
cancelled();
|
|
await held;
|
|
if (rejects) throw cleanupFailure;
|
|
},
|
|
},
|
|
{ highWaterMark: 0 },
|
|
);
|
|
const controller = new AbortController();
|
|
const reason = { requested: "stop source-map response" };
|
|
const pending = fetchWebSourceMaps(
|
|
[request],
|
|
{
|
|
...input,
|
|
allowed_origins: [new URL(request.fetchUrl).origin],
|
|
source_map_limits: { fetch_bytes: 1 },
|
|
},
|
|
controller.signal,
|
|
{ fetch: async () => new Response(body) },
|
|
);
|
|
try {
|
|
await reading;
|
|
if (trigger === "caller-abort") controller.abort(reason);
|
|
await cancelling;
|
|
if (trigger === "response-limit") controller.abort(reason);
|
|
const result = await pending;
|
|
if (result.ok) throw new Error("Expected caller cancellation");
|
|
expect(result.error).toMatchObject({
|
|
_tag:
|
|
trigger === "caller-abort"
|
|
? "AnalysisCancelledError"
|
|
: "ProviderAdapterError",
|
|
cleanupIncomplete: true,
|
|
cleanupResources: [request.fetchUrl],
|
|
});
|
|
expect(result.error.hasCleanupOwner).toBe(true);
|
|
expect(result.error.cleanupRetry).toBeUndefined();
|
|
expect(result.error.cleanup?.reason).toContain("pending");
|
|
finish();
|
|
await expect
|
|
.poll(() =>
|
|
rejects
|
|
? result.error.cleanup?.reason.includes(
|
|
"response cancellation failed",
|
|
)
|
|
: !result.error.cleanupIncomplete,
|
|
)
|
|
.toBe(true);
|
|
if (trigger === "caller-abort") expect(result.error.cause).toBe(reason);
|
|
else {
|
|
expect(result.error.cause).toMatchObject({
|
|
name: "ParseFailureError",
|
|
failure: {
|
|
kind: "limit",
|
|
format: "source-map",
|
|
limit: { name: "fetch_bytes", maximum: 1 },
|
|
},
|
|
});
|
|
expect(
|
|
result.error.secondaryFailures.some(
|
|
(failure) => failure.cause === reason,
|
|
),
|
|
).toBe(true);
|
|
}
|
|
expect(result.error.cleanupIncomplete).toBe(rejects);
|
|
if (rejects)
|
|
expect(
|
|
result.error.secondaryFailures.some(
|
|
(failure) => failure.cause === cleanupFailure,
|
|
),
|
|
).toBe(true);
|
|
expect(result.error.cleanupResources).toEqual(
|
|
rejects ? [request.fetchUrl] : [],
|
|
);
|
|
expect(calls).toBe(1);
|
|
} finally {
|
|
finish();
|
|
controller.abort(reason);
|
|
await pending;
|
|
}
|
|
},
|
|
);
|
|
|
|
it("keeps same-URL response cleanup owners independent across mixed outcomes", async () => {
|
|
const cleanupFailure = new Error("second response cancellation failed");
|
|
const operations = [false, true].map((rejects) => {
|
|
let start!: () => void;
|
|
const reading = new Promise<void>((resolve) => {
|
|
start = resolve;
|
|
});
|
|
let finish!: () => void;
|
|
const held = new Promise<void>((resolve) => {
|
|
finish = resolve;
|
|
});
|
|
let calls = 0;
|
|
const body = new ReadableStream<Uint8Array>(
|
|
{
|
|
pull() {
|
|
start();
|
|
},
|
|
async cancel() {
|
|
calls += 1;
|
|
await held;
|
|
if (rejects) throw cleanupFailure;
|
|
},
|
|
},
|
|
{ highWaterMark: 0 },
|
|
);
|
|
const controller = new AbortController();
|
|
const reason = { rejects };
|
|
const pending = fetchWebSourceMaps(
|
|
[request],
|
|
{
|
|
...input,
|
|
allowed_origins: [new URL(request.fetchUrl).origin],
|
|
},
|
|
controller.signal,
|
|
{ fetch: async () => new Response(body) },
|
|
);
|
|
return {
|
|
reading,
|
|
finish,
|
|
controller,
|
|
reason,
|
|
pending,
|
|
calls: () => calls,
|
|
body,
|
|
};
|
|
});
|
|
try {
|
|
await Promise.all(operations.map(({ reading }) => reading));
|
|
for (const operation of operations)
|
|
operation.controller.abort(operation.reason);
|
|
const errors = await Promise.all(
|
|
operations.map(async ({ pending }) => {
|
|
const result = await pending;
|
|
if (result.ok) throw new Error("Expected cancellation");
|
|
return result.error;
|
|
}),
|
|
);
|
|
expect(errors.map((error) => error.cleanupResources)).toEqual([
|
|
[request.fetchUrl],
|
|
[request.fetchUrl],
|
|
]);
|
|
operations[0]!.finish();
|
|
await expect.poll(() => errors[0]!.cleanupIncomplete).toBe(false);
|
|
expect(errors[1]!.cleanupIncomplete).toBe(true);
|
|
expect(errors[1]!.cleanupResources).toEqual([request.fetchUrl]);
|
|
operations[1]!.finish();
|
|
await expect.poll(() => errors[1]!.secondaryFailures.length).toBe(1);
|
|
expect(errors[1]!.secondaryFailures[0]?.cause).toBe(cleanupFailure);
|
|
expect(errors.map((error) => error.cleanupIncomplete)).toEqual([
|
|
false,
|
|
true,
|
|
]);
|
|
expect(errors.map((error) => error.cause)).toEqual(
|
|
operations.map(({ reason }) => reason),
|
|
);
|
|
expect(operations.map(({ calls }) => calls())).toEqual([1, 1]);
|
|
expect(operations.map(({ body }) => body.locked)).toEqual([false, false]);
|
|
} finally {
|
|
for (const operation of operations) {
|
|
operation.finish();
|
|
operation.controller.abort(operation.reason);
|
|
}
|
|
await Promise.all(operations.map(({ pending }) => pending));
|
|
}
|
|
});
|
|
|
|
it.each([null, false])(
|
|
"preserves a falsy caller reason and releases a native HTTP body: %s",
|
|
async (reason) => {
|
|
const server = createServer((_request, response) => {
|
|
response.writeHead(200, { "content-type": "application/json" });
|
|
response.write('{"version":3,');
|
|
});
|
|
server.listen(0, "127.0.0.1");
|
|
await once(server, "listening");
|
|
const address = server.address();
|
|
if (address === null || typeof address === "string")
|
|
throw new Error("Expected TCP address");
|
|
const url = `http://127.0.0.1:${address.port}/map`;
|
|
const controller = new AbortController();
|
|
let delivered!: () => void;
|
|
const responseReceived = new Promise<void>((resolve) => {
|
|
delivered = resolve;
|
|
});
|
|
try {
|
|
const pending = fetchWebSourceMaps(
|
|
[{ ...request, declaredUrl: url, fetchUrl: url }],
|
|
{
|
|
...input,
|
|
allowed_origins: [new URL(url).origin],
|
|
source_map_fetch_timeout_ms: 10_000,
|
|
},
|
|
controller.signal,
|
|
{
|
|
fetch: async (...args) => {
|
|
const response = await fetch(...args);
|
|
delivered();
|
|
return response;
|
|
},
|
|
},
|
|
);
|
|
await responseReceived;
|
|
await new Promise<void>((resolve) => setImmediate(resolve));
|
|
controller.abort(reason);
|
|
const result = await pending;
|
|
if (result.ok) throw new Error("Expected caller cancellation");
|
|
expect(result.error).toMatchObject({
|
|
_tag: "AnalysisCancelledError",
|
|
cause: reason,
|
|
});
|
|
await expect.poll(() => result.error.cleanupIncomplete).toBe(false);
|
|
expect(result.error.cleanupResources).toEqual([]);
|
|
} finally {
|
|
server.closeAllConnections();
|
|
await new Promise<void>((resolve, reject) =>
|
|
server.close((error) => (error ? reject(error) : resolve())),
|
|
);
|
|
}
|
|
},
|
|
);
|
|
|
|
it("does not mistake an independent body AbortError for a falsy caller cancellation", async () => {
|
|
const controller = new AbortController();
|
|
const physical = new DOMException("independent body failure", "AbortError");
|
|
const body = new ReadableStream<Uint8Array>(
|
|
{
|
|
pull(stream) {
|
|
stream.error(physical);
|
|
queueMicrotask(() => controller.abort(false));
|
|
},
|
|
},
|
|
{ highWaterMark: 0 },
|
|
);
|
|
const result = await fetchWebSourceMaps(
|
|
[request],
|
|
{ ...input, allowed_origins: [new URL(request.fetchUrl).origin] },
|
|
controller.signal,
|
|
{ fetch: async () => new Response(body) },
|
|
);
|
|
if (result.ok) throw new Error("Expected the independent body failure");
|
|
expect(result.error).toMatchObject({
|
|
_tag: "ProviderAdapterError",
|
|
cause: physical,
|
|
});
|
|
expect(
|
|
result.error.secondaryFailures.some((failure) => failure.cause === false),
|
|
).toBe(true);
|
|
});
|
|
|
|
it.each(["headers", "body"] as const)(
|
|
"keeps an actual stalled HTTP %s deadline local to its map",
|
|
async (stage) => {
|
|
const server = createServer((_request, response) => {
|
|
if (stage === "body") {
|
|
response.writeHead(200, { "content-type": "application/json" });
|
|
response.write('{"version":3,');
|
|
}
|
|
});
|
|
server.listen(0, "127.0.0.1");
|
|
await once(server, "listening");
|
|
const address = server.address();
|
|
if (address === null || typeof address === "string")
|
|
throw new Error("Expected TCP address");
|
|
const url = `http://127.0.0.1:${address.port}/map`;
|
|
try {
|
|
const result = await fetchWebSourceMaps(
|
|
[{ ...request, declaredUrl: url, fetchUrl: url }],
|
|
{
|
|
...input,
|
|
allowed_origins: [new URL(url).origin],
|
|
source_map_fetch_timeout_ms: 1000,
|
|
},
|
|
undefined,
|
|
{ fetch },
|
|
);
|
|
expect(result).toMatchObject({
|
|
ok: true,
|
|
value: {
|
|
items: [
|
|
{
|
|
status: "fetch_failed",
|
|
limitation: expect.stringContaining("deadline"),
|
|
},
|
|
],
|
|
},
|
|
});
|
|
} finally {
|
|
server.closeAllConnections();
|
|
await new Promise<void>((resolve, reject) =>
|
|
server.close((error) => (error ? reject(error) : resolve())),
|
|
);
|
|
}
|
|
},
|
|
);
|
|
|
|
it.each([302, 503])(
|
|
"retains HTTP %s response cleanup without hanging on an independent tee branch",
|
|
async (status) => {
|
|
const [body, sibling] = new ReadableStream<Uint8Array>({
|
|
start(controller) {
|
|
controller.enqueue(new Uint8Array([1]));
|
|
},
|
|
}).tee();
|
|
const pending = fetchWebSourceMaps(
|
|
[request],
|
|
{
|
|
...input,
|
|
allowed_origins: [new URL(request.fetchUrl).origin],
|
|
source_map_fetch_timeout_ms: 100,
|
|
},
|
|
undefined,
|
|
{
|
|
fetch: async () =>
|
|
new Response(body, {
|
|
status,
|
|
...(status === 302 ? { headers: { location: "/next" } } : {}),
|
|
}),
|
|
},
|
|
);
|
|
let timer: ReturnType<typeof setTimeout> | undefined;
|
|
try {
|
|
const result = await Promise.race([
|
|
pending,
|
|
new Promise<never>((_, reject) => {
|
|
timer = setTimeout(
|
|
() => reject(new Error("response cleanup waited for sibling")),
|
|
1000,
|
|
);
|
|
}),
|
|
]);
|
|
expect(result).toMatchObject({
|
|
ok: false,
|
|
error: {
|
|
cleanupIncomplete: true,
|
|
cleanupResources: [request.fetchUrl],
|
|
},
|
|
});
|
|
} finally {
|
|
if (timer !== undefined) clearTimeout(timer);
|
|
await sibling.cancel();
|
|
await pending;
|
|
}
|
|
},
|
|
);
|
|
|
|
it("retains an admitted response when the deadline expires before body reading", async () => {
|
|
const [body, sibling] = new ReadableStream<Uint8Array>({
|
|
start(controller) {
|
|
controller.enqueue(new Uint8Array([1]));
|
|
},
|
|
}).tee();
|
|
const pending = fetchWebSourceMaps(
|
|
[request],
|
|
{
|
|
...input,
|
|
allowed_origins: [new URL(request.fetchUrl).origin],
|
|
source_map_fetch_timeout_ms: 50,
|
|
},
|
|
undefined,
|
|
{
|
|
fetch: async () => {
|
|
// Keep the timer callback queued while synchronous delivery crosses the deadline.
|
|
Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 150);
|
|
return new Response(body);
|
|
},
|
|
},
|
|
);
|
|
try {
|
|
const result = await pending;
|
|
if (result.ok) throw new Error("Expected owned response cleanup");
|
|
expect(result.error).toMatchObject({
|
|
cleanupIncomplete: true,
|
|
cleanupResources: [request.fetchUrl],
|
|
});
|
|
await sibling.cancel();
|
|
await expect.poll(() => result.error.cleanupIncomplete).toBe(false);
|
|
} finally {
|
|
await Promise.allSettled([body.cancel(), sibling.cancel()]);
|
|
}
|
|
});
|
|
|
|
it("retains an oversized redirect identity's pending response cleanup", async () => {
|
|
const [body, sibling] = new ReadableStream<Uint8Array>({
|
|
start(controller) {
|
|
controller.enqueue(new Uint8Array([1]));
|
|
},
|
|
}).tee();
|
|
const finalUrl = new URL(`/${"a".repeat(6000)}`, request.fetchUrl).href;
|
|
const pending = fetchWebSourceMaps(
|
|
[request],
|
|
{
|
|
...input,
|
|
allowed_origins: [new URL(request.fetchUrl).origin],
|
|
source_map_limits: { output_bytes: 4000 },
|
|
source_map_fetch_timeout_ms: 100,
|
|
},
|
|
undefined,
|
|
{
|
|
fetch: async (url) =>
|
|
String(url) === request.fetchUrl
|
|
? new Response(null, { status: 302, headers: { location: finalUrl } })
|
|
: new Response(body),
|
|
},
|
|
);
|
|
try {
|
|
const result = await pending;
|
|
if (result.ok) throw new Error("Expected output capacity refusal");
|
|
expect(result.error).toMatchObject({
|
|
_tag: "AnalysisResourceConstraintError",
|
|
cleanupIncomplete: true,
|
|
cleanupResources: [finalUrl],
|
|
});
|
|
expect(result.error.hasCleanupOwner).toBe(true);
|
|
await sibling.cancel();
|
|
await expect.poll(() => result.error.cleanupIncomplete).toBe(false);
|
|
expect(result.error.cleanupResources).toEqual([]);
|
|
} finally {
|
|
await sibling.cancel();
|
|
await pending;
|
|
}
|
|
});
|
|
|
|
it("preserves the physical reader failure when stream cancellation also rejects", async () => {
|
|
const failure = new Error("response transport failed");
|
|
const body = new ReadableStream<Uint8Array>(
|
|
{
|
|
pull(controller) {
|
|
controller.error(failure);
|
|
},
|
|
},
|
|
{ highWaterMark: 0 },
|
|
);
|
|
const result = await fetchWebSourceMaps(
|
|
[request],
|
|
{
|
|
...input,
|
|
allowed_origins: [new URL(request.fetchUrl).origin],
|
|
},
|
|
undefined,
|
|
{ fetch: async () => new Response(body) },
|
|
);
|
|
if (result.ok) throw new Error("Expected the physical read failure");
|
|
expect(result.error).toMatchObject({
|
|
_tag: "ProviderAdapterError",
|
|
cause: failure,
|
|
cleanupIncomplete: true,
|
|
cleanupResources: [request.fetchUrl],
|
|
});
|
|
await expect
|
|
.poll(() => result.error.secondaryFailures[0]?.cause)
|
|
.toBe(failure);
|
|
expect(result.error.cleanup?.reason).toContain("response transport failed");
|
|
expect(result.error.cleanupRetry).toBeUndefined();
|
|
expect(body.locked).toBe(false);
|
|
});
|
|
|
|
it("recovers a fetched map by raising its exact structural admission on the next call", async () => {
|
|
const text = JSON.stringify({
|
|
version: 3,
|
|
sources: ["a.ts"],
|
|
sourcesContent: ["export const a = 1;"],
|
|
names: [],
|
|
mappings: "AAAA",
|
|
});
|
|
const selected = {
|
|
...input,
|
|
allowed_origins: [new URL(request.fetchUrl).origin],
|
|
};
|
|
const host = { fetch: async () => new Response(text) };
|
|
const refused = await fetchWebSourceMapsOk(
|
|
[request],
|
|
{ ...selected, source_map_limits: { decoded_records: 4 } },
|
|
undefined,
|
|
host,
|
|
);
|
|
expect(refused.items[0]).toMatchObject({
|
|
status: "fetch_failed",
|
|
limitation: expect.stringContaining(
|
|
"source_map_limits.decoded_records is 4",
|
|
),
|
|
});
|
|
const recovered = await fetchWebSourceMapsOk(
|
|
[request],
|
|
{ ...selected, source_map_limits: { decoded_records: 5 } },
|
|
undefined,
|
|
host,
|
|
);
|
|
expect(recovered.items[0]).toMatchObject({
|
|
status: "included",
|
|
original_sources: [{ source: "https://app.example.test/a.ts" }],
|
|
mappings: [{ generated_line: 1, generated_column: 0 }],
|
|
});
|
|
});
|
|
|
|
it.each([
|
|
{ limits: { decoded_records: 4 }, directory: "maps" },
|
|
{ limits: { fetch_bytes: 1500 }, directory: "m".repeat(1000) },
|
|
])(
|
|
"releases discarded map interpretations before the next map: $limits",
|
|
async ({ limits, directory }) => {
|
|
const selected = {
|
|
...request,
|
|
fetchUrl: `https://app.example.test/${directory}/app.js.map`,
|
|
};
|
|
const responses = ["ACAA", "AAAA"].map((mappings) =>
|
|
JSON.stringify({ version: 3, sources: ["a.js"], names: [], mappings }),
|
|
);
|
|
const result = await fetchWebSourceMapsOk(
|
|
[selected, { ...selected, scriptKey: `scr_${"2".repeat(64)}` }],
|
|
{
|
|
...input,
|
|
allowed_origins: [new URL(selected.fetchUrl).origin],
|
|
source_map_limits: limits,
|
|
},
|
|
undefined,
|
|
{ fetch: async () => new Response(responses.shift()) },
|
|
);
|
|
|
|
expect(result.items.map(({ status }) => status)).toEqual([
|
|
"invalid",
|
|
"included",
|
|
]);
|
|
expect(result.items[0]).toMatchObject({
|
|
response_identity: { representation: "fetch-response-body-bytes" },
|
|
});
|
|
expect(result.items[1]?.mappings).toMatchObject([
|
|
{ source: `https://app.example.test/${directory}/a.js` },
|
|
]);
|
|
const retained = await fetchWebSourceMapsOk(
|
|
[selected, { ...selected, scriptKey: `scr_${"2".repeat(64)}` }],
|
|
{
|
|
...input,
|
|
allowed_origins: [new URL(selected.fetchUrl).origin],
|
|
source_map_limits: limits,
|
|
},
|
|
undefined,
|
|
{
|
|
fetch: async () =>
|
|
new Response(
|
|
JSON.stringify({
|
|
version: 3,
|
|
sources: ["a.js"],
|
|
names: [],
|
|
mappings: "AAAA",
|
|
}),
|
|
),
|
|
},
|
|
);
|
|
expect(retained.items.map(({ status }) => status)).toEqual([
|
|
"included",
|
|
"fetch_failed",
|
|
]);
|
|
},
|
|
);
|