Files

122 lines
4.5 KiB
TypeScript

import { beforeEach, describe, expect, it, vi } from "vitest";
const mocks = vi.hoisted(() => ({
loadConfig: vi.fn(),
createReader: vi.fn(),
readObject: vi.fn(),
}));
vi.mock("@hivegrid/config", async (importOriginal) => ({
...(await importOriginal<typeof import("@hivegrid/config")>()),
loadRequiredWebConfig: () => mocks.loadConfig(),
}));
vi.mock("@hivegrid/storage", () => ({ createS3SseCObjectReader: (...args: unknown[]) => mocks.createReader(...args) }));
import { createGdprExportDownloadResponse, readGdprExportObject } from "./gdprExportDownload.server";
describe("GDPR export server-side download", () => {
beforeEach(() => {
vi.clearAllMocks();
mocks.loadConfig.mockReturnValue({
storage: {
endpoint: "https://storage.example.test",
region: "eu-central-1",
bucket: "private-exports",
accessKeyId: "access-key",
secretAccessKey: "secret-key",
gdprExportSseCKey: "BwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwc=",
forcePathStyle: "false",
},
});
mocks.createReader.mockReturnValue({ readObject: mocks.readObject });
mocks.readObject.mockResolvedValue({
body: new ReadableStream({
start(controller) {
controller.enqueue(new TextEncoder().encode("payload"));
controller.close();
},
}),
contentLength: 7,
});
});
it("builds a server-only SSE-C reader and enforces the configured bucket", async () => {
await expect(
readGdprExportObject({ bucket: "private-exports", key: "tenants/t1/gdpr/job.zip", maxBytes: 32, expectedSizeBytes: 7 })
).resolves.toMatchObject({ contentLength: 7 });
expect(mocks.createReader).toHaveBeenCalledWith(
expect.objectContaining({
endpoint: "https://storage.example.test",
customerKeyBase64: "BwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwc=",
})
);
expect(mocks.readObject).toHaveBeenCalledWith({
bucket: "private-exports",
key: "tenants/t1/gdpr/job.zip",
maxBytes: 32,
expectedSizeBytes: 7,
signal: expect.any(AbortSignal),
});
await expect(readGdprExportObject({ bucket: "foreign", key: "tenants/t1/gdpr/job.zip", maxBytes: 32 })).rejects.toThrow(/configured private bucket/u);
expect(mocks.readObject).toHaveBeenCalledTimes(1);
});
it("propagates a provider stream failure without buffering the object in the web heap", async () => {
mocks.readObject.mockResolvedValueOnce({
body: new ReadableStream({
start(controller) {
controller.enqueue(new TextEncoder().encode("partial"));
controller.error(new Error("provider stream failed"));
},
}),
contentLength: 7,
});
const object = await readGdprExportObject({ bucket: "private-exports", key: "gdpr-exports/privacy/tenants/t1/job/attempt.zip", maxBytes: 32 });
await expect(new Response(object.body).arrayBuffer()).rejects.toThrow(/provider stream failed/u);
});
it("propagates a request that was already aborted before listener registration", async () => {
const requestAbort = new AbortController();
const reason = new Error("client disconnected before storage read");
requestAbort.abort(reason);
await expect(
readGdprExportObject({
bucket: "private-exports",
key: "tenants/t1/gdpr/job.zip",
maxBytes: 32,
signal: requestAbort.signal,
}),
).rejects.toBe(reason);
const storageSignal = mocks.readObject.mock.calls[0]?.[0]?.signal as AbortSignal | undefined;
expect(storageSignal?.aborted).toBe(true);
expect(storageSignal?.reason).toBe(reason);
});
it("returns private attachment headers without a redirect", async () => {
const response = createGdprExportDownloadResponse({
object: {
body: new ReadableStream({
start(controller) {
controller.enqueue(new TextEncoder().encode("payload"));
controller.close();
},
}),
contentLength: 7,
},
filename: 'export"\r\n.zip',
contentType: "application/zip",
});
expect(response.status).toBe(200);
expect(response.headers.get("Location")).toBeNull();
expect(response.headers.get("Content-Disposition")).toBe('attachment; filename="export.zip"');
expect(response.headers.get("Content-Length")).toBe("7");
expect(response.headers.get("Cache-Control")).toBe("private, no-store");
expect(response.headers.get("X-Content-Type-Options")).toBe("nosniff");
await expect(response.text()).resolves.toBe("payload");
});
});