@fedify/fedify 2.5.0-dev.2597 → 2.5.0-dev.2614

package/dist/federation/outbound-body.test.mjs

@@ -0,0 +1,149 @@
+import "temporal-polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+import { t as ResponseBodyPump } from "../outbound-body-CckPA5gc.mjs";
+import { test } from "@fedify/fixture";
+import { deepStrictEqual, ok, rejects, strictEqual } from "node:assert/strict";
+//#region src/federation/outbound-body.test.ts
+test("response body pump pulls once on demand and releases at EOF", async () => {
+	let pulls = 0;
+	let cancels = 0;
+	let controller;
+	let pulled;
+	const pulling = new Promise((resolve) => {
+		pulled = resolve;
+	});
+	const body = new ReadableStream({
+		start(value) {
+			controller = value;
+		},
+		pull() {
+			pulls++;
+			pulled();
+		},
+		cancel() {
+			cancels++;
+		}
+	}, { highWaterMark: 0 });
+	const pump = new ResponseBodyPump(body, 1e3);
+	try {
+		strictEqual(pulls, 0);
+		ok(body.locked);
+		const first = pump.read();
+		const concurrent = pump.read();
+		strictEqual(first, concurrent);
+		await pulling;
+		strictEqual(pulls, 1);
+		controller.enqueue(new Uint8Array([1, 2]));
+		const result = await first;
+		deepStrictEqual(result, {
+			done: false,
+			value: new Uint8Array([1, 2])
+		});
+		strictEqual(await concurrent, result);
+		strictEqual(pulls, 1);
+		controller.close();
+		deepStrictEqual(await pump.read(), {
+			done: true,
+			value: void 0
+		});
+		strictEqual(body.locked, false);
+		strictEqual(cancels, 0);
+		deepStrictEqual(await pump.read(), {
+			done: true,
+			value: void 0
+		});
+	} finally {
+		pump.close();
+	}
+});
+test("response body pump deadline bounds stalled reads and cancellation cleanup", async (t) => {
+	for (const mode of [
+		"no-pull",
+		"stalled",
+		"late-rejection"
+	]) await t.step(mode, async () => {
+		let pulls = 0;
+		let cancels = 0;
+		let cancelled;
+		const cancelling = new Promise((resolve) => {
+			cancelled = resolve;
+		});
+		let rejectCancel;
+		const cleanup = new Promise((_resolve, reject) => {
+			rejectCancel = reject;
+		});
+		const body = new ReadableStream({
+			pull() {
+				pulls++;
+			},
+			cancel() {
+				cancels++;
+				cancelled();
+				return cleanup;
+			}
+		}, { highWaterMark: 0 });
+		const pump = new ResponseBodyPump(body, 25);
+		try {
+			if (mode === "no-pull") await cancelling;
+			else strictEqual(await pump.read(), void 0);
+			strictEqual(cancels, 1);
+			strictEqual(body.locked, false);
+			strictEqual(pulls, mode === "no-pull" ? 0 : 1);
+			strictEqual(await pump.read(), void 0);
+			pump.close();
+			strictEqual(cancels, 1);
+			if (mode === "late-rejection") {
+				rejectCancel(/* @__PURE__ */ new Error("late cleanup failure"));
+				await Promise.resolve();
+				await Promise.resolve();
+			}
+		} finally {
+			pump.close();
+		}
+	});
+});
+test("response body pump deadline also stops continuously ready empty chunks", async () => {
+	let pulls = 0;
+	let cancels = 0;
+	const body = new ReadableStream({
+		pull(controller) {
+			pulls++;
+			controller.enqueue(/* @__PURE__ */ new Uint8Array());
+		},
+		cancel() {
+			cancels++;
+		}
+	}, { highWaterMark: 0 });
+	const pump = new ResponseBodyPump(body, 25);
+	try {
+		while (await pump.read() != null);
+		ok(pulls > 0);
+		strictEqual(cancels, 1);
+		strictEqual(body.locked, false);
+		const stoppedAt = pulls;
+		strictEqual(await pump.read(), void 0);
+		strictEqual(pulls, stoppedAt);
+	} finally {
+		pump.close();
+	}
+});
+test("response body pump preserves read failure and releases ownership", async () => {
+	const failure = /* @__PURE__ */ new Error("broken body");
+	const body = new ReadableStream({ pull(controller) {
+		controller.error(failure);
+	} }, { highWaterMark: 0 });
+	const pump = new ResponseBodyPump(body, 1e3);
+	try {
+		await rejects(pump.read(), (error) => error === failure);
+		strictEqual(body.locked, false);
+		deepStrictEqual(await pump.read(), {
+			done: true,
+			value: void 0
+		});
+	} finally {
+		pump.close();
+	}
+});
+//#endregion
+export {};

package/dist/federation/outbound-capture.test.d.mts

@@ -0,0 +1,2 @@
+import { Temporal } from "temporal-polyfill";
+import { URLPattern } from "urlpattern-polyfill";

package/dist/federation/outbound-capture.test.mjs

@@ -0,0 +1,394 @@
+import "temporal-polyfill";
+import "urlpattern-polyfill";
+globalThis.addEventListener = () => {};
+import { n as snapshotBodyCapture, r as takeCapturedDiagnostic, t as captureResponseBody } from "../outbound-capture-DVgnRzlf.mjs";
+import { n as FederationBuilderImpl, r as createFederationBuilder } from "../builder-B2H8GsyI.mjs";
+import { test } from "@fedify/fixture";
+import { deepStrictEqual, ok, rejects, strictEqual, throws } from "node:assert/strict";
+//#region src/federation/outbound-capture.test.ts
+const limits = {
+	maxBytes: 32,
+	timeoutMs: 1e3
+};
+async function drain(body) {
+	const reader = body.getReader();
+	const bytes = [];
+	try {
+		while (true) {
+			const value = await reader.read();
+			if (value.done) return bytes;
+			bytes.push(...value.value);
+		}
+	} catch {
+		return bytes;
+	} finally {
+		reader.releaseLock();
+	}
+}
+test("response body capture validates explicit limits before replacing registration", () => {
+	const config = {
+		maxBytes: 32,
+		timeoutMs: .5,
+		onBody() {}
+	};
+	const builder = createFederationBuilder();
+	ok(builder instanceof FederationBuilderImpl);
+	builder.setOutboundObservers({ responseBodyCapture: config });
+	const original = builder.outboundObservers;
+	deepStrictEqual(original.responseBodyCapture, {
+		...config,
+		timeoutMs: 1,
+		responses: "all"
+	});
+	ok(Object.isFrozen(original.responseBodyCapture));
+	config.maxBytes = 1;
+	strictEqual(original.responseBodyCapture?.maxBytes, 32);
+	for (const [value, error] of [
+		[null, TypeError],
+		[{ ...limits }, TypeError],
+		[{
+			onBody() {},
+			timeoutMs: 1
+		}, TypeError],
+		[{
+			onBody() {},
+			maxBytes: 1
+		}, TypeError],
+		[{
+			...limits,
+			onBody() {},
+			maxBytes: "1"
+		}, TypeError],
+		[{
+			...limits,
+			onBody() {},
+			maxBytes: 0
+		}, RangeError],
+		[{
+			...limits,
+			onBody() {},
+			maxBytes: 1.5
+		}, RangeError],
+		[{
+			...limits,
+			onBody() {},
+			maxBytes: Number.MAX_SAFE_INTEGER + 1
+		}, RangeError],
+		[{
+			...limits,
+			onBody() {},
+			timeoutMs: Infinity
+		}, RangeError],
+		[{
+			...limits,
+			onBody() {},
+			timeoutMs: NaN
+		}, RangeError],
+		[{
+			...limits,
+			onBody() {},
+			timeoutMs: 0
+		}, RangeError],
+		[{
+			...limits,
+			onBody() {},
+			timeoutMs: 2147483647.1
+		}, RangeError],
+		[{
+			...limits,
+			onBody() {},
+			responses: "failures"
+		}, TypeError]
+	]) {
+		throws(() => builder.setOutboundObservers({ responseBodyCapture: value }), error);
+		strictEqual(builder.outboundObservers, original);
+	}
+	strictEqual(snapshotBodyCapture(void 0), void 0);
+});
+test("response body capture distinguishes selection EOF and exact byte limits", async (t) => {
+	for (const mode of [
+		"filtered",
+		"no-body",
+		"empty",
+		"short",
+		"exact",
+		"over"
+	]) await t.step(mode, async () => {
+		const response = new Response(mode === "no-body" ? null : mode === "empty" ? "" : mode === "over" ? "abcd" : "abc");
+		let calls = 0;
+		let exposed = [];
+		let signal;
+		const result = await captureResponseBody(response, {
+			maxBytes: mode === "exact" || mode === "over" ? 3 : 32,
+			timeoutMs: 1e3,
+			...mode === "filtered" ? { responses: "non-success-http-responses" } : {}
+		}, async (body, current) => {
+			calls++;
+			signal = current;
+			exposed = await drain(body);
+		});
+		strictEqual(result.type, mode === "filtered" || mode === "no-body" ? mode : mode === "exact" || mode === "over" ? "limit-reached" : "complete");
+		strictEqual(result.bytesExposed, mode === "filtered" || mode === "no-body" || mode === "empty" ? 0 : 3);
+		strictEqual(calls, mode === "filtered" || mode === "no-body" ? 0 : 1);
+		if (calls) {
+			ok(signal?.aborted);
+			strictEqual(response.body?.locked, false);
+		}
+		if (result.bytesExposed) deepStrictEqual(exposed, [
+			97,
+			98,
+			99
+		]);
+		ok(Object.isFrozen(result));
+	});
+});
+test("response body capture revokes locked readers and bounds callback cleanup", async (t) => {
+	for (const mode of [
+		"returned",
+		"cancelled",
+		"throws",
+		"hangs",
+		"pending-read",
+		"body-error"
+	]) await t.step(mode, async () => {
+		const failure = new Error(mode);
+		let signal;
+		let retained;
+		let pending;
+		let rejectLate;
+		const late = new Promise((_resolve, reject) => {
+			rejectLate = reject;
+		});
+		const body = new ReadableStream({
+			pull(controller) {
+				if (mode === "body-error") controller.error(failure);
+			},
+			cancel() {
+				return new Promise(() => {});
+			}
+		}, { highWaterMark: 0 });
+		const result = await captureResponseBody(new Response(body), {
+			...limits,
+			timeoutMs: 25
+		}, async (stream, current) => {
+			signal = current;
+			retained = stream.getReader();
+			if (mode === "throws") throw failure;
+			if (mode === "cancelled") await retained.cancel(failure);
+			if (mode === "hangs") await late;
+			if (mode === "pending-read") pending = retained.read().catch((error) => error);
+			if (mode === "body-error") await retained.read();
+		});
+		const expected = mode === "returned" || mode === "pending-read" ? "callback-returned" : mode === "cancelled" ? "consumer-stopped" : mode === "hangs" ? "deadline" : "failed";
+		strictEqual(result.type, expected);
+		strictEqual(result.bytesExposed, 0);
+		ok(signal.aborted);
+		strictEqual(body.locked, false);
+		if (result.type === "failed") {
+			strictEqual(result.phase, mode === "throws" ? "observer" : "body");
+			strictEqual(result.error, failure);
+		}
+		if (result.type === "consumer-stopped") strictEqual(result.reason, failure);
+		if (mode !== "cancelled") await rejects(retained.read());
+		if (pending) ok(await pending instanceof Error);
+		retained.releaseLock();
+		if (mode === "hangs") {
+			rejectLate(failure);
+			await Promise.resolve();
+			await Promise.resolve();
+		}
+	});
+});
+test("response body capture shares one reader with bounded diagnostics", async () => {
+	const response = new Response("diagnostic failure", { status: 503 });
+	ok(response.body);
+	const getReader = response.body.getReader.bind(response.body);
+	let acquisitions = 0;
+	Object.defineProperty(response.body, "getReader", { value: () => {
+		acquisitions++;
+		return getReader();
+	} });
+	const summary = await captureResponseBody(response, {
+		...limits,
+		maxBytes: 4
+	}, async (body) => {
+		await drain(body);
+	});
+	strictEqual(summary.type, "limit-reached");
+	strictEqual(summary.bytesExposed, 4);
+	strictEqual(acquisitions, 1);
+	strictEqual(takeCapturedDiagnostic(response), "diagnostic failure");
+	strictEqual(takeCapturedDiagnostic(response), void 0);
+});
+test("response body capture isolates unavailable readers and diagnostic deadlines", async (t) => {
+	await t.step("already locked source", async () => {
+		const response = new Response("locked");
+		const reader = response.body.getReader();
+		try {
+			const result = await captureResponseBody(response, limits, () => {
+				throw new Error("must not invoke callback");
+			});
+			ok(result.type === "failed");
+			strictEqual(result.phase, "body");
+			strictEqual(result.bytesExposed, 0);
+		} finally {
+			await reader.cancel();
+			reader.releaseLock();
+		}
+	});
+	await t.step("diagnostics retain their own deadline", async () => {
+		let cancels = 0;
+		const body = new ReadableStream({
+			pull() {},
+			cancel() {
+				cancels++;
+				return new Promise(() => {});
+			}
+		}, { highWaterMark: 0 });
+		const response = new Response(body, { status: 503 });
+		deepStrictEqual(await captureResponseBody(response, {
+			...limits,
+			timeoutMs: 1e4
+		}, () => {}), {
+			type: "callback-returned",
+			bytesExposed: 0
+		});
+		strictEqual(takeCapturedDiagnostic(response), "… (timed out)");
+		strictEqual(cancels, 1);
+		strictEqual(body.locked, false);
+	});
+});
+test("response body capture bounds oversized and nonterminating sources", async (t) => {
+	for (const mode of [
+		"oversized",
+		"infinite",
+		"empty-infinite"
+	]) await t.step(mode, async () => {
+		let pulls = 0;
+		let cancels = 0;
+		const source = new Uint8Array(mode === "oversized" ? 1024 * 1024 : mode === "infinite" ? 1 : 0).fill(255);
+		const original = new ReadableStream({
+			pull(controller) {
+				pulls++;
+				controller.enqueue(source);
+			},
+			cancel() {
+				cancels++;
+			}
+		}, { highWaterMark: 0 });
+		let exposed = 0;
+		const result = await captureResponseBody(new Response(original), {
+			maxBytes: 17,
+			timeoutMs: 50
+		}, async (body) => {
+			const reader = body.getReader();
+			try {
+				while (true) {
+					const chunk = await reader.read();
+					if (chunk.done) break;
+					exposed += chunk.value.length;
+					ok(chunk.value.buffer.byteLength <= 17);
+					strictEqual(chunk.value[0], 255);
+					chunk.value.fill(0);
+				}
+			} catch {} finally {
+				reader.releaseLock();
+			}
+		});
+		strictEqual(result.type, mode === "empty-infinite" ? "deadline" : "limit-reached");
+		strictEqual(result.bytesExposed, mode === "empty-infinite" ? 0 : 17);
+		strictEqual(exposed, result.bytesExposed);
+		strictEqual(cancels, 1);
+		strictEqual(original.locked, false);
+		if (mode !== "empty-infinite") {
+			strictEqual(pulls, mode === "oversized" ? 1 : 17);
+			strictEqual(source[0], 255);
+		}
+	});
+});
+test("response body capture applies backpressure and revokes a paused consumer", async () => {
+	let pulls = 0;
+	let cancels = 0;
+	let retained;
+	let exposed = 0;
+	const source = new ReadableStream({
+		pull(controller) {
+			pulls++;
+			controller.enqueue(new Uint8Array([1]));
+		},
+		cancel() {
+			cancels++;
+			return new Promise(() => {});
+		}
+	}, { highWaterMark: 0 });
+	deepStrictEqual(await captureResponseBody(new Response(source), {
+		maxBytes: 32,
+		timeoutMs: 50
+	}, async (body, signal) => {
+		retained = body.getReader();
+		const first = await retained.read();
+		ok(!first.done);
+		exposed += first.value.length;
+		await new Promise((resolve) => {
+			if (signal.aborted) resolve();
+			else signal.addEventListener("abort", () => resolve(), { once: true });
+		});
+		strictEqual(pulls, 1);
+		await rejects(retained.read());
+	}), {
+		type: "deadline",
+		bytesExposed: 1
+	});
+	strictEqual(exposed, 1);
+	strictEqual(pulls, 1);
+	strictEqual(cancels, 1);
+	strictEqual(source.locked, false);
+	await rejects(retained.read());
+	retained.releaseLock();
+});
+test("response body capture rejects late source data and observes late pull failure", async () => {
+	let controller;
+	let rejectPull;
+	const pulling = new Promise((_resolve, reject) => {
+		rejectPull = reject;
+	});
+	let cancels = 0;
+	const source = new ReadableStream({
+		start(value) {
+			controller = value;
+		},
+		pull() {
+			return pulling;
+		},
+		cancel() {
+			cancels++;
+			return new Promise(() => {});
+		}
+	}, { highWaterMark: 0 });
+	let retained;
+	let exposed = 0;
+	deepStrictEqual(await captureResponseBody(new Response(source), {
+		maxBytes: 32,
+		timeoutMs: 25
+	}, async (body) => {
+		retained = body.getReader();
+		try {
+			const chunk = await retained.read();
+			if (!chunk.done) exposed += chunk.value.length;
+		} catch {}
+	}), {
+		type: "deadline",
+		bytesExposed: 0
+	});
+	strictEqual(exposed, 0);
+	strictEqual(cancels, 1);
+	throws(() => controller.enqueue(new Uint8Array([1])), TypeError);
+	rejectPull(/* @__PURE__ */ new Error("late upstream failure"));
+	await Promise.resolve();
+	await Promise.resolve();
+	await rejects(retained.read());
+	retained.releaseLock();
+	strictEqual(source.locked, false);
+});
+//#endregion
+export {};

package/dist/federation/outbound-dispatch.test.d.mts

@@ -0,0 +1,2 @@
+import { Temporal } from "temporal-polyfill";
+import { URLPattern } from "urlpattern-polyfill";