repositories / pi-ext
pi-ext
bugabingas pi extensions
owned by admin
extensions/bak/__tests__/s3.test.ts
Rawimport { 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");
});
});