Luigit
repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by admin

extensions/web/__tests__/fetch.test.ts

Raw
import { describe, expect, it, vi } from "vitest";
import { fetchSearchHtml, fetchUrlStream } from "../fetch";

const resolver = async () => ["93.184.216.34"];

describe("bounded web responses", () => {
	it("interrupts DNS validation at deadline and never starts fetch late", async () => {
		let resolveDns!: (addresses: string[]) => void;
		const injectedResolver = vi.fn(
			() => new Promise<string[]>((resolve) => (resolveDns = resolve)),
		);
		const fetchMock = vi.spyOn(globalThis, "fetch");
		try {
			await expect(
				fetchUrlStream("https://example.com", undefined, undefined, {
					timeoutMs: 5,
					resolver: injectedResolver,
				}),
			).rejects.toThrow();
			resolveDns(["93.184.216.34"]);
			await Promise.resolve();
			expect(fetchMock).not.toHaveBeenCalled();
		} finally {
			fetchMock.mockRestore();
		}
	});

	it.each(["fetch", "search"] as const)(
		"cancels a stalled %s response body at deadline",
		async (action) => {
			let cancelled = false;
			const stream = new ReadableStream<Uint8Array>({
				pull() {
					return new Promise<void>(() => {});
				},
				cancel() {
					cancelled = true;
				},
			});
			const fetchMock = vi
				.spyOn(globalThis, "fetch")
				.mockResolvedValue(new Response(stream, { status: 200 }));
			try {
				await expect(
					action === "search"
						? fetchSearchHtml("https://93.184.216.34/search", undefined, 5)
						: fetchUrlStream(
								"https://93.184.216.34/page",
								undefined,
								new AbortController().signal,
								{ timeoutMs: 5 },
							),
				).rejects.toThrow();
				expect(cancelled).toBe(true);
			} finally {
				fetchMock.mockRestore();
			}
		},
	);

	it("keeps timeout active when caller supplies a signal", async () => {
		const fetchMock = vi.spyOn(globalThis, "fetch").mockImplementation(
			async (_url, init) =>
				await new Promise<Response>((_resolve, reject) => {
					init?.signal?.addEventListener(
						"abort",
						() => reject(init.signal?.reason),
						{ once: true },
					);
				}),
		);
		try {
			await expect(
				fetchUrlStream(
					"https://example.com",
					undefined,
					new AbortController().signal,
					{ timeoutMs: 5, resolver },
				),
			).rejects.toThrow();
			expect(fetchMock).toHaveBeenCalled();
		} finally {
			fetchMock.mockRestore();
		}
	});

	it("rejects search bodies exceeding cap from Content-Length", async () => {
		let cancelled = false;
		const stream = new ReadableStream<Uint8Array>({
			cancel() {
				cancelled = true;
			},
		});
		const fetchMock = vi.spyOn(globalThis, "fetch").mockResolvedValue(
			new Response(stream, {
				status: 200,
				headers: { "content-length": String(8 * 1024 * 1024 + 1) },
			}),
		);
		try {
			await expect(fetchSearchHtml("https://93.184.216.34")).rejects.toThrow(
				/search response limit/,
			);
			expect(cancelled).toBe(true);
		} finally {
			fetchMock.mockRestore();
		}
	});

	it("cancels chunked search bodies exceeding cap", async () => {
		let cancelled = false;
		const stream = new ReadableStream<Uint8Array>({
			start(controller) {
				controller.enqueue(new Uint8Array(8 * 1024 * 1024 + 1));
			},
			cancel() {
				cancelled = true;
			},
		});
		const fetchMock = vi
			.spyOn(globalThis, "fetch")
			.mockResolvedValue(new Response(stream, { status: 200 }));
		try {
			await expect(fetchSearchHtml("https://93.184.216.34")).rejects.toThrow(
				/search response limit/,
			);
			expect(cancelled).toBe(true);
		} finally {
			fetchMock.mockRestore();
		}
	});
});