Luigit
repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by admin

extensions/bak/__tests__/s3.test.ts

Raw
import { describe, expect, it } from "vitest";
import { resolveE2eStorageConfig } from "../__e2e__/support.js";
import { S3SizeLimitError, S3Store } from "../s3.js";

const config = {
	endpoint: "https://example.invalid",
	bucket: "bucket",
	region: "auto",
	accessKeyId: "id",
	secretAccessKey: "secret",
};

function recorder(response: () => Response) {
	const calls: { url: string; init: RequestInit }[] = [];
	const client = {
		fetch: (input: RequestInfo | URL, init?: RequestInit) => {
			calls.push({ url: String(input), init: init ?? {} });
			return Promise.resolve(response());
		},
	} as unknown as Pick<import("aws4fetch").AwsClient, "fetch">;
	return { calls, client };
}

function header(init: RequestInit, name: string): string | null {
	return new Headers(init.headers).get(name);
}

describe("real S3 E2E opt-in", () => {
	it("does not use credentials without explicit opt-in", () => {
		const env = {
			PI_BAK_S3_ENDPOINT: "https://example.invalid",
			PI_BAK_S3_ACCESS_KEY_ID: "id",
			PI_BAK_S3_SECRET_ACCESS_KEY: "secret",
		};
		expect(resolveE2eStorageConfig(env)).toBeUndefined();
		expect(
			resolveE2eStorageConfig({ ...env, PI_BAK_E2E_S3: "1" }),
		).toMatchObject({
			endpoint: env.PI_BAK_S3_ENDPOINT,
		});
		expect(() => resolveE2eStorageConfig({ PI_BAK_E2E_S3: "1" })).toThrow(
			/Real S3 E2E requires/,
		);
	});
});

describe("bounded S3 inspection ranges", () => {
	it("requests exact identity-encoded ranges with a pinned strong validator", async () => {
		const { client, calls } = recorder(
			() =>
				new Response("body", {
					status: 206,
					headers: { etag: '"version"', "content-range": "bytes 10-13/100" },
				}),
		);
		const result = await new S3Store(config, client).getRange("session", {
			start: 10,
			endInclusive: 13,
			etag: '"version"',
		});
		expect(result).toMatchObject({
			start: 10,
			totalBytes: 100,
			etag: '"version"',
		});
		expect(new TextDecoder().decode(result.body)).toBe("body");
		expect(header(calls[0]!.init, "range")).toBe("bytes=10-13");
		expect(header(calls[0]!.init, "if-match")).toBe('"version"');
		expect(header(calls[0]!.init, "accept-encoding")).toBe("identity");
	});

	it.each([
		{
			status: 200,
			headers: { etag: '"version"' },
			message: /requested byte range/,
		},
		{ status: 412, headers: {}, message: /changed/ },
		{ status: 416, headers: {}, message: /outside/ },
		{
			status: 206,
			headers: { etag: 'W/"version"', "content-range": "bytes 0-3/100" },
			message: /validator/,
		},
		{
			status: 206,
			headers: { "content-range": "bytes 0-3/100" },
			message: /validator/,
		},
		{
			status: 206,
			headers: { etag: '"version"', "content-range": "bytes 1-4/100" },
			message: /range response/,
		},
		{
			status: 206,
			headers: {
				etag: '"version"',
				"content-range": "bytes 0-3/9007199254740992",
			},
			message: /range response/,
		},
		{
			status: 206,
			headers: { etag: '"changed"', "content-range": "bytes 0-3/100" },
			message: /validator/,
		},
		{
			status: 206,
			headers: {
				etag: '"version"',
				"content-range": "bytes 0-3/100",
				"content-encoding": "gzip",
			},
			message: /range response/,
		},
	])(
		"rejects and cancels unsupported or inconsistent ranges: $status $headers",
		async ({ status, headers, message }) => {
			let cancelled = false;
			const stream = new ReadableStream<Uint8Array>({
				cancel() {
					cancelled = true;
				},
			});
			const { client } = recorder(
				() => new Response(stream, { status, headers: headers as HeadersInit }),
			);
			await expect(
				new S3Store(config, client).getRange("session", {
					start: 0,
					endInclusive: 3,
					etag: '"version"',
				}),
			).rejects.toThrow(message);
			expect(cancelled).toBe(true);
		},
	);

	it.each(["abc", "abcde"])(
		"rejects truncated or excessive ranged bodies: %s",
		async (body) => {
			const { client } = recorder(
				() =>
					new Response(body, {
						status: 206,
						headers: { etag: '"version"', "content-range": "bytes 0-3/100" },
					}),
			);
			await expect(
				new S3Store(config, client).getRange("session", {
					start: 0,
					endInclusive: 3,
				}),
			).rejects.toThrow(/Incomplete|size limit/);
		},
	);

	it("cancels an in-flight raw range without returning partial bytes", async () => {
		const reading = Promise.withResolvers<void>();
		let pulls = 0,
			cancelled = false;
		const stream = new ReadableStream<Uint8Array>({
			pull(controller) {
				if (++pulls === 1) controller.enqueue(new Uint8Array([1]));
				else reading.resolve();
			},
			cancel() {
				cancelled = true;
			},
		});
		const { client } = recorder(
			() =>
				new Response(stream, {
					status: 206,
					headers: { etag: '"version"', "content-range": "bytes 0-9/100" },
				}),
		);
		const controller = new AbortController();
		const pending = new S3Store(config, client).getRange("session", {
			start: 0,
			endInclusive: 9,
			signal: controller.signal,
		});
		await reading.promise;
		controller.abort(new Error("stop"));
		await expect(pending).rejects.toThrow("stop");
		expect(cancelled).toBe(true);
	});

	it("rejects unsafe range sizes and validators before fetching", async () => {
		const { client, calls } = recorder(() => new Response("unused"));
		const store = new S3Store(config, client);
		for (const options of [
			{ start: -1, endInclusive: 3 },
			{ start: 0, endInclusive: 128 * 1024 },
			{ start: 0, endInclusive: 3, etag: 'W/"version"' },
		])
			await expect(store.getRange("session", options)).rejects.toThrow(
				/range|validator/,
			);
		expect(calls).toEqual([]);
	});
});

describe("S3Store weak ETag handling", () => {
	it("requests identity encoding and strips weak validators on get", async () => {
		const { calls, client } = recorder(
			() =>
				new Response("body", {
					status: 200,
					headers: { etag: 'W/"abc"' },
				}),
		);
		const store = new S3Store(config, client);

		const object = await store.get("hosts/host.json");

		expect(object?.etag).toBe('"abc"');
		expect(header(calls[0]?.init ?? {}, "accept-encoding")).toBe("identity");
	});

	it("sends a strong validator when given a weak ifMatch", async () => {
		const { calls, client } = recorder(
			() => new Response(null, { status: 200, headers: { etag: 'W/"def"' } }),
		);
		const store = new S3Store(config, client);

		const etag = await store.put("hosts/host.json", "body", {
			contentType: "application/json",
			ifMatch: 'W/"abc"',
		});

		expect(header(calls[0]?.init ?? {}, "if-match")).toBe('"abc"');
		expect(etag).toBe('"def"');
	});

	it("cancels chunked responses exceeding get limit", async () => {
		let cancelled = false;
		const stream = new ReadableStream<Uint8Array>({
			start(controller) {
				controller.enqueue(new Uint8Array([1, 2]));
				controller.enqueue(new Uint8Array([3, 4]));
			},
			cancel() {
				cancelled = true;
			},
		});
		const { client } = recorder(() => new Response(stream));
		const store = new S3Store(config, client);

		await expect(store.get("large", { maxBytes: 3 })).rejects.toBeInstanceOf(
			S3SizeLimitError,
		);
		expect(cancelled).toBe(true);
	});

	it.each([200, 403])(
		"cancels an in-flight %s body read without partial success",
		async (status) => {
			const reading = Promise.withResolvers<void>();
			let pulls = 0;
			let cancelled = false;
			const stream = new ReadableStream<Uint8Array>({
				pull(controller) {
					if (++pulls === 1) controller.enqueue(new Uint8Array([1]));
					else reading.resolve();
				},
				cancel() {
					cancelled = true;
				},
			});
			const { client } = recorder(() => new Response(stream, { status }));
			const controller = new AbortController();
			const pending = new S3Store(config, client).get("stream", {
				signal: controller.signal,
				maxBytes: 10,
			});
			await reading.promise;
			controller.abort(new Error("stop"));
			await expect(pending).rejects.toThrow("stop");
			expect(cancelled).toBe(true);
		},
	);

	it("rejects declared oversized content before consuming it", async () => {
		let cancelled = false;
		const stream = new ReadableStream<Uint8Array>({
			cancel() {
				cancelled = true;
			},
		});
		const { client } = recorder(
			() => new Response(stream, { headers: { "content-length": "1000" } }),
		);
		await expect(
			new S3Store(config, client).get("big", { maxBytes: 10 }),
		).rejects.toBeInstanceOf(S3SizeLimitError);
		expect(cancelled).toBe(true);
	});

	it("bounds error bodies without buffering their remainder", async () => {
		let cancelled = false;
		const stream = new ReadableStream<Uint8Array>({
			start(controller) {
				controller.enqueue(new TextEncoder().encode("x".repeat(10000)));
			},
			cancel() {
				cancelled = true;
			},
		});
		const { client } = recorder(() => new Response(stream, { status: 403 }));
		await expect(
			new S3Store(config, client).get("denied"),
		).rejects.toMatchObject({ status: 403, message: "x".repeat(500) });
		expect(cancelled).toBe(true);
	});

	it("rejects invalid byte limits before network work", async () => {
		const { client, calls } = recorder(() => new Response("body"));
		await expect(
			new S3Store(config, client).get("any", { maxBytes: -1 }),
		).rejects.toThrow("byte limit");
		expect(calls).toEqual([]);
	});

	it("aborts retry delay", async () => {
		const { client } = recorder(() => {
			throw new Error("offline");
		});
		const store = new S3Store(config, client);
		const controller = new AbortController();
		const pending = store.get("retry", { signal: controller.signal });
		controller.abort(new Error("stop"));

		await expect(pending).rejects.toThrow("stop");
	});
});