@fedify/fedify 2.1.29 → 2.1.31

package/dist/sig/http.test.mjs

@@ -7,13 +7,15 @@ import { i as assertExists, t as assertStringIncludes } from "../std__assert-Dfl
 import { r as assertFalse, t as assertThrows } from "../assert_throws-D4DNWrux.mjs";
 import { t as assert } from "../assert-BhQd8QHP.mjs";
 import { t as assertRejects } from "../assert_rejects-WyYSTDDX.mjs";
-import { t as exportJwk } from "../key-O-ATwIGS.mjs";
-import { a as parseRfc9421Signature, c as timingSafeEqual, i as formatRfc9421SignatureParameters, l as verifyRequest, n as doubleKnock, o as parseRfc9421SignatureInput, r as formatRfc9421Signature, s as signRequest, t as createRfc9421SignatureBase, u as verifyRequestDetailed } from "../http-C1ga9WQu.mjs";
+import { t as exportJwk } from "../key-Dg6-DV_O.mjs";
+import { a as formatRfc9421SignatureParameters, c as signRequest, d as verifyRequestDetailed, i as formatRfc9421Signature, l as timingSafeEqual, n as doubleKnock, o as parseRfc9421Signature, r as doubleKnockScoped, s as parseRfc9421SignatureInput, t as createRfc9421SignatureBase, u as verifyRequest } from "../http-A9mP2uM7.mjs";
 import { i as rsaPrivateKey2, l as rsaPublicKey5, o as rsaPublicKey1, s as rsaPublicKey2 } from "../keys-CtZLJq76.mjs";
-import { t as KvKeyCache } from "../keycache-RFlZObU3.mjs";
+import { t as KvKeyCache } from "../keycache-DahCaG_m.mjs";
 import { t as MemoryKvStore } from "../kv-HvthQAHr.mjs";
 import { createTestTracerProvider, mockDocumentLoader, test } from "@fedify/fixture";
 import { FetchError, UrlError, exportSpki } from "@fedify/vocab-runtime";
+import { openDirectFetch } from "@fedify/vocab-runtime/internal";
+import { configure, reset } from "@logtape/logtape";
 import { encodeBase64 } from "byte-encodings/base64";
 //#region src/sig/http.test.ts
 test("signRequest() [draft-cavage]", async () => {
@@ -1239,6 +1241,425 @@ test("doubleKnock() async specDeterminer test", async () => {
 	assertEquals(specUsed, "draft-cavage-http-signatures-12", "Should use spec from async determiner");
 	esm_default.hardReset();
 });
+const lifecycleIdentity = {
+	keyId: rsaPublicKey2.id,
+	privateKey: rsaPrivateKey2
+};
+test("doubleKnockScoped() keeps challenge retries and fallback in the validated hop", async () => {
+	const url = "https://example.com/lifecycle/challenge-fallback";
+	const hops = recordHops((_, index) => index === 1 ? {
+		status: 401,
+		headers: { "Accept-Signature": "challenge=(\"@method\");nonce=\"challenge-nonce\"" },
+		body: "Challenge"
+	} : index === 2 ? {
+		status: 401,
+		body: "Unauthorized"
+	} : {
+		status: 202,
+		body: "Accepted"
+	});
+	assertEquals(await doubleKnockScoped(new Request(url, {
+		method: "POST",
+		body: "activity"
+	}), lifecycleIdentity, {}, hops.openHop, (response) => response.text()), "Accepted");
+	assertEquals(hops.events, [
+		`open ${url}`,
+		`fetch #1 ${url}`,
+		"cancel #1",
+		`fetch #2 ${url}`,
+		"cancel #2",
+		`fetch #3 ${url}`,
+		"consumed #3",
+		`close ${url}`
+	]);
+	assertStringIncludes(hops.requests[1].headers.get("Signature-Input"), "nonce=\"challenge-nonce\"");
+	assertFalse(hops.requests[2].headers.has("Signature-Input"));
+	hops.assertInvariants();
+});
+test("doubleKnockScoped() reopens the session after challenge redirects", async () => {
+	const url = "https://example.com/lifecycle/challenge-redirect";
+	const next = "https://other.example/lifecycle/final";
+	const validated = [];
+	const hops = recordHops((_, index) => index === 1 ? {
+		status: 401,
+		headers: { "Accept-Signature": "challenge=(\"@method\");created" },
+		body: "Challenge"
+	} : index === 2 ? {
+		status: 307,
+		headers: { Location: next },
+		body: "Redirect"
+	} : {
+		status: 200,
+		body: "Done"
+	});
+	assertEquals(await doubleKnockScoped(new Request(url, {
+		method: "POST",
+		body: "activity"
+	}), lifecycleIdentity, { validateRedirect: (target) => {
+		validated.push(target);
+	} }, hops.openHop, (response) => response.text()), "Done");
+	assertEquals(validated, [next]);
+	assertEquals(hops.events, [
+		`open ${url}`,
+		`fetch #1 ${url}`,
+		"cancel #1",
+		`fetch #2 ${url}`,
+		"cancel #2",
+		`close ${url}`,
+		`open ${next}`,
+		`fetch #3 ${next}`,
+		"consumed #3",
+		`close ${next}`
+	]);
+	assertEquals(await hops.requests[2].text(), "activity");
+	hops.assertInvariants();
+});
+test("doubleKnockScoped() detects loops after challenge redirects", async () => {
+	const url = "https://example.com/lifecycle/challenge-loop";
+	const hops = recordHops((_, index) => index === 1 ? {
+		status: 401,
+		headers: { "Accept-Signature": "challenge=(\"@method\");created" },
+		body: "Challenge"
+	} : {
+		status: 307,
+		headers: { Location: url },
+		body: "Redirect"
+	});
+	await assertRejects(() => doubleKnockScoped(new Request(url, {
+		method: "POST",
+		body: "activity"
+	}), lifecycleIdentity, {}, hops.openHop, (response) => response.text()), FetchError, "Redirect loop detected");
+	assertEquals(hops.requests.length, 2);
+	assertEquals(hops.events, [
+		`open ${url}`,
+		`fetch #1 ${url}`,
+		"cancel #1",
+		`fetch #2 ${url}`,
+		"cancel #2",
+		`close ${url}`
+	]);
+	hops.assertInvariants();
+});
+test("doubleKnockScoped() retries another spec on the same hop", async () => {
+	const url = "https://example.com/lifecycle/retry";
+	const hops = recordHops((_, index) => index === 1 ? {
+		status: 401,
+		body: "Unauthorized"
+	} : {
+		status: 202,
+		body: "Accepted"
+	});
+	assertEquals(await doubleKnockScoped(new Request(url, {
+		method: "POST",
+		body: "activity"
+	}), lifecycleIdentity, {}, hops.openHop, (response) => response.text()), "Accepted");
+	assertEquals(hops.events, [
+		`open ${url}`,
+		`fetch #1 ${url}`,
+		"cancel #1",
+		`fetch #2 ${url}`,
+		"consumed #2",
+		`close ${url}`
+	]);
+	assertEquals(hops.requests.map((r) => r.headers.has("Signature-Input")), [true, false]);
+	hops.assertInvariants();
+});
+test("doubleKnockScoped() closes the retried hop before a redirect", async () => {
+	const url = "https://example.com/lifecycle/retry-redirect";
+	const next = "https://example.com/lifecycle/final";
+	const hops = recordHops((_, index) => index === 1 ? {
+		status: 401,
+		body: "Unauthorized"
+	} : index === 2 ? {
+		status: 302,
+		headers: { Location: next },
+		body: "Found"
+	} : {
+		status: 200,
+		body: "Done"
+	});
+	assertEquals(await doubleKnockScoped(new Request(url, {
+		method: "POST",
+		body: "activity"
+	}), lifecycleIdentity, {}, hops.openHop, (response) => response.text()), "Done");
+	assertEquals(hops.events, [
+		`open ${url}`,
+		`fetch #1 ${url}`,
+		"cancel #1",
+		`fetch #2 ${url}`,
+		"cancel #2",
+		`close ${url}`,
+		`open ${next}`,
+		`fetch #3 ${next}`,
+		"consumed #3",
+		`close ${next}`
+	]);
+	assertEquals(await hops.requests[2].text(), "activity");
+	hops.assertInvariants();
+});
+test("doubleKnockScoped() retries transport errors on the same hop", async (t) => {
+	await t.step("GET", async () => {
+		const url = "https://example.com/lifecycle/flaky";
+		const hops = recordHops((_, index) => {
+			if (index === 1) throw new TypeError("connection reset");
+			return { body: "Success" };
+		});
+		assertEquals(await doubleKnockScoped(new Request(url), lifecycleIdentity, {}, hops.openHop, (response) => response.text()), "Success");
+		assertEquals(hops.events, [
+			`open ${url}`,
+			`fetch #1 ${url}`,
+			`fetch #2 ${url}`,
+			"consumed #2",
+			`close ${url}`
+		]);
+		hops.assertInvariants();
+	});
+	await t.step("POST", async () => {
+		const url = "https://example.com/lifecycle/flaky-inbox";
+		const hops = recordHops(() => {
+			throw new TypeError("connection reset");
+		});
+		await assertRejects(() => doubleKnockScoped(new Request(url, {
+			method: "POST",
+			body: "activity"
+		}), lifecycleIdentity, {}, hops.openHop, (response) => response.text()), FetchError);
+		assertEquals(hops.events, [
+			`open ${url}`,
+			`fetch #1 ${url}`,
+			`close ${url}`
+		]);
+		hops.assertInvariants();
+	});
+});
+async function captureLogs(fn) {
+	const records = [];
+	await configure({
+		sinks: { buffer: (record) => records.push(record) },
+		loggers: [{
+			category: "fedify",
+			sinks: ["buffer"],
+			lowestLevel: "debug"
+		}, {
+			category: ["logtape", "meta"],
+			sinks: []
+		}],
+		reset: true
+	});
+	try {
+		await fn();
+		await new Promise((resolve) => setTimeout(resolve, 0));
+	} finally {
+		await reset();
+	}
+	return records;
+}
+test("doubleKnockScoped() logs a redirect body failing to cancel and follows the redirect", async () => {
+	const url = "https://example.com/lifecycle/cancel-failure";
+	const next = "https://example.com/lifecycle/cancel-failure-final";
+	const hops = recordHops((_, index) => index === 1 ? {
+		status: 302,
+		headers: { Location: next },
+		body: "Found",
+		failCancel: true
+	} : {
+		status: 200,
+		body: "Done"
+	});
+	let result;
+	const records = await captureLogs(async () => {
+		result = await doubleKnockScoped(new Request(url), lifecycleIdentity, {}, hops.openHop, (response) => response.text());
+	});
+	assertEquals(result, "Done");
+	assertEquals(hops.events, [
+		`open ${url}`,
+		`fetch #1 ${url}`,
+		"cancel #1",
+		`close ${url}`,
+		`open ${next}`,
+		`fetch #2 ${next}`,
+		"consumed #2",
+		`close ${next}`
+	]);
+	const failures = records.filter((r) => r.rawMessage === "Failed to cancel the response body from {url}: {error}");
+	assertEquals(failures.map((r) => [r.level, r.properties.url]), [["debug", url]]);
+	assertEquals(failures[0].properties.error.message, "cancel #1 failed");
+	hops.assertInvariants();
+});
+test("doubleKnockScoped() is not blocked by a body cancellation that never settles", async () => {
+	const url = "https://example.com/lifecycle/hanging-cancel";
+	const next = "https://example.com/lifecycle/hanging-cancel-final";
+	const hops = recordHops((_, index) => index === 1 ? {
+		status: 401,
+		body: "Unauthorized",
+		hangCancel: true
+	} : index === 2 ? {
+		status: 302,
+		headers: { Location: next },
+		body: "Found",
+		hangCancel: true
+	} : {
+		status: 200,
+		body: "Done",
+		hangCancel: true
+	});
+	assertEquals(await doubleKnockScoped(new Request(url, {
+		method: "POST",
+		body: "activity"
+	}), lifecycleIdentity, {}, hops.openHop, (response) => Promise.resolve(response.status)), 200);
+	assertEquals(hops.events, [
+		`open ${url}`,
+		`fetch #1 ${url}`,
+		"cancel #1",
+		`fetch #2 ${url}`,
+		"cancel #2",
+		`close ${url}`,
+		`open ${next}`,
+		`fetch #3 ${next}`,
+		"cancel #3 by close",
+		`close ${next}`
+	]);
+	hops.assertInvariants();
+});
+test("doubleKnockScoped() completes with responses cloned by fetch-mock", async () => {
+	esm_default.spyGlobal();
+	try {
+		let attempts = 0;
+		esm_default.post("https://example.com/tee/redirect", () => {
+			attempts++;
+			return attempts === 1 ? new Response("Unauthorized", { status: 401 }) : new Response("Found", {
+				status: 302,
+				headers: { Location: "https://example.com/tee/final" }
+			});
+		});
+		esm_default.post("https://example.com/tee/final", () => new Response("Accepted", { status: 202 }));
+		const request = () => new Request("https://example.com/tee/redirect", {
+			method: "POST",
+			body: "activity"
+		});
+		assertEquals(await doubleKnockScoped(request(), lifecycleIdentity, {}, openDirectFetch, (response) => Promise.resolve(response.status)), 202);
+		assertEquals(attempts, 2);
+		attempts = 0;
+		const response = await doubleKnock(request(), lifecycleIdentity);
+		assertEquals(response.status, 202);
+		assertEquals(await response.text(), "Accepted");
+		assertEquals(attempts, 2);
+	} finally {
+		esm_default.hardReset();
+	}
+});
+test("doubleKnockScoped() closes the session when consuming fails", async (t) => {
+	const url = "https://example.com/lifecycle/consume";
+	await t.step("exception", async () => {
+		const hops = recordHops(() => ({ body: "x".repeat(1024) }));
+		const error = /* @__PURE__ */ new Error("consume failed");
+		await assertRejects(() => doubleKnockScoped(new Request(url), lifecycleIdentity, {}, hops.openHop, async (response) => {
+			const reader = response.body.getReader();
+			await reader.read();
+			reader.releaseLock();
+			throw error;
+		}), Error, "consume failed");
+		assertEquals(hops.events, [
+			`open ${url}`,
+			`fetch #1 ${url}`,
+			"cancel #1 by close",
+			`close ${url}`
+		]);
+		hops.assertInvariants();
+	});
+	await t.step("abort", async () => {
+		const hops = recordHops(() => ({ body: "Success" }));
+		const controller = new AbortController();
+		const reason = /* @__PURE__ */ new Error("aborted while consuming");
+		assert(await assertRejects(() => doubleKnockScoped(new Request(url), lifecycleIdentity, { signal: controller.signal }, hops.openHop, () => {
+			controller.abort(reason);
+			controller.signal.throwIfAborted();
+			return Promise.resolve();
+		})) === reason);
+		assertEquals(hops.events, [
+			`open ${url}`,
+			`fetch #1 ${url}`,
+			"cancel #1 by close",
+			`close ${url}`
+		]);
+		hops.assertInvariants();
+	});
+});
+test("doubleKnock() returns the final response without cancelling its body", async () => {
+	const url = "https://example.com/lifecycle/public";
+	const next = "https://example.com/lifecycle/public-final";
+	const events = [];
+	const responses = [];
+	const originalFetch = globalThis.fetch;
+	globalThis.fetch = ((input) => {
+		const requestUrl = input instanceof Request ? input.url : String(input);
+		const index = responses.length + 1;
+		events.push(`fetch #${index} ${requestUrl}`);
+		const recorded = createRecordedResponse(events, index, requestUrl === url ? {
+			status: 302,
+			headers: { Location: next },
+			body: "Found"
+		} : {
+			status: 200,
+			body: "Done"
+		});
+		responses.push(recorded);
+		return Promise.resolve(recorded.response);
+	});
+	try {
+		const response = await doubleKnock(new Request(url), lifecycleIdentity);
+		assertEquals(events, [
+			`fetch #1 ${url}`,
+			"cancel #1",
+			`fetch #2 ${next}`
+		]);
+		assertFalse(responses[1].settled());
+		assertEquals(await response.text(), "Done");
+		assertEquals(events.at(-1), "consumed #2");
+	} finally {
+		globalThis.fetch = originalFetch;
+	}
+});
+test("doubleKnock() is not blocked by a body cancellation that never settles", async () => {
+	const url = "https://example.com/lifecycle/public-hanging";
+	const next = "https://example.com/lifecycle/public-hanging-final";
+	const events = [];
+	const originalFetch = globalThis.fetch;
+	let index = 0;
+	globalThis.fetch = ((input) => {
+		const requestUrl = input instanceof Request ? input.url : String(input);
+		index++;
+		events.push(`fetch #${index} ${requestUrl}`);
+		return Promise.resolve(createRecordedResponse(events, index, index === 1 ? {
+			status: 401,
+			body: "Unauthorized",
+			hangCancel: true
+		} : index === 2 ? {
+			status: 302,
+			headers: { Location: next },
+			body: "Found",
+			hangCancel: true
+		} : {
+			status: 200,
+			body: "Done"
+		}).response);
+	});
+	try {
+		const response = await doubleKnock(new Request(url, {
+			method: "POST",
+			body: "activity"
+		}), lifecycleIdentity);
+		assertEquals(events, [
+			`fetch #1 ${url}`,
+			"cancel #1",
+			`fetch #2 ${url}`,
+			"cancel #2",
+			`fetch #3 ${next}`
+		]);
+		assertEquals(await response.text(), "Done");
+	} finally {
+		globalThis.fetch = originalFetch;
+	}
+});
 test("timingSafeEqual()", async (t) => {
 	await t.step("should return true for equal empty arrays", () => {
 		assert(timingSafeEqual(new Uint8Array([]), new Uint8Array([])));
@@ -1945,5 +2366,88 @@ test("doubleKnock(): Accept-Signature with multiple compatible entries fulfills
 	assertEquals(requestCount, 2);
 	esm_default.hardReset();
 });
+function createRecordedResponse(events, index, init, cancelSuffix = () => "") {
+	const bytes = new TextEncoder().encode(init.body ?? "");
+	const chunkSize = init.chunkSize ?? 256;
+	let offset = 0;
+	let settled = false;
+	const body = new ReadableStream({
+		pull(controller) {
+			if (offset >= bytes.length) {
+				settled = true;
+				events.push(`consumed #${index}`);
+				controller.close();
+				return;
+			}
+			controller.enqueue(bytes.slice(offset, offset + chunkSize));
+			offset += chunkSize;
+		},
+		cancel() {
+			settled = true;
+			events.push(`cancel #${index}${cancelSuffix()}`);
+			if (init.failCancel) throw new Error(`cancel #${index} failed`);
+			if (init.hangCancel) return new Promise(() => {});
+		}
+	}, { highWaterMark: 0 });
+	return {
+		response: new Response(body, {
+			status: init.status ?? 200,
+			headers: init.headers
+		}),
+		settled: () => settled
+	};
+}
+function recordHops(respond) {
+	const events = [];
+	const requests = [];
+	const unsettledAtClose = [];
+	let opens = 0;
+	let closes = 0;
+	let fetches = 0;
+	return {
+		events,
+		requests,
+		openHop(url) {
+			opens++;
+			events.push(`open ${url}`);
+			const tracked = [];
+			let closed = false;
+			let closing = false;
+			return Promise.resolve({
+				url: new URL(url),
+				async fetch(input, init) {
+					if (closed) throw new TypeError("The session is closed.");
+					const request = new Request(input instanceof Request ? input.clone() : input, init);
+					const index = ++fetches;
+					requests.push(request);
+					events.push(`fetch #${index} ${request.url}`);
+					const recorded = createRecordedResponse(events, index, await respond(request, index), () => closing ? " by close" : "");
+					tracked.push({
+						...recorded,
+						index
+					});
+					return recorded.response;
+				},
+				close() {
+					if (closed) return Promise.resolve();
+					closed = true;
+					closes++;
+					closing = true;
+					for (const { response, settled, index } of tracked) {
+						if (settled()) continue;
+						if (response.body?.locked) unsettledAtClose.push(index);
+						else response.body?.cancel().catch(() => {});
+					}
+					events.push(`close ${url}`);
+					return Promise.resolve();
+				}
+			});
+		},
+		assertInvariants() {
+			assertEquals(opens, closes);
+			assertEquals(unsettledAtClose, []);
+		}
+	};
+}
 //#endregion
 export {};