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; 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({ 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(); let pulls = 0, cancelled = false; const stream = new ReadableStream({ 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({ 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(); let pulls = 0; let cancelled = false; const stream = new ReadableStream({ 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({ 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({ 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"); }); });