src/lib/documents/storage.test.ts

Linked repository file from this build.

import { expect, test } from "bun:test";
import { MAX_PDF_BYTES, validatePdf } from "./storage";

test("PDF validation rejects empty and disguised files", async () => {
  await expect(validatePdf(new File([], "empty.pdf", { type: "application/pdf" }))).rejects.toThrow(
    "empty",
  );
  await expect(
    validatePdf(new File(["not PDF"], "fake.pdf", { type: "application/pdf" })),
  ).rejects.toThrow("header");
  await expect(
    validatePdf(new File(["%PDF-1.4"], "fake.txt", { type: "text/plain" })),
  ).rejects.toThrow("Select a PDF");
  await expect(
    validatePdf(new File(["%PDF-1.4"], "evidence.pdf", { type: "application/pdf" })),
  ).resolves.toBeUndefined();
});

test("PDF size limit is inclusive at 10 MiB", async () => {
  const content = new Uint8Array(MAX_PDF_BYTES);
  content.set(new TextEncoder().encode("%PDF-1.4"));
  await expect(
    validatePdf(new File([content], "limit.pdf", { type: "application/pdf" })),
  ).resolves.toBeUndefined();
  await expect(
    validatePdf(new File([content, "x"], "large.pdf", { type: "application/pdf" })),
  ).rejects.toThrow("10 MB");
});

test("browser uploads directly and returns only the completed document key", async () => {
  const { createDocumentStorage } = await import("./storage");
  const { spyOn } = await import("bun:test");
  const uploadId = "11111111-1111-4111-8111-111111111111";
  const key = "22222222-2222-4222-8222-222222222222";
  const requests: { url: unknown; init: RequestInit | undefined }[] = [];
  const responses = [
    Response.json({
      mode: "neon",
      uploadId,
      url: "https://storage.example.com/docs",
      fields: { policy: "signed" },
    }),
    new Response(null, { status: 204 }),
    Response.json({ key }),
  ];
  const fetchMock = spyOn(globalThis, "fetch").mockImplementation(
    Object.assign(
      async (url: RequestInfo | URL, init?: RequestInit) => {
        requests.push({ url, init });
        return responses.shift()!;
      },
      { preconnect: globalThis.fetch.preconnect },
    ),
  );
  try {
    expect(await createDocumentStorage().put(new File(["%PDF-1.4"], "test.pdf"))).toBe(key);
    expect(requests.map((request) => request.url)).toEqual([
      "/api/documents",
      "https://storage.example.com/docs",
      "/api/documents",
    ]);
    expect(requests[1].init?.credentials).toBe("omit");
    const body = requests[1].init?.body as FormData;
    expect(body.get("policy")).toBe("signed");
    expect(body.get("file")).toBeInstanceOf(File);
    expect(JSON.parse(requests[2].init?.body as string)).toEqual({ uploadId });
  } finally {
    fetchMock.mockRestore();
  }
});

test("failed direct uploads do not complete or attach a document", async () => {
  const { createDocumentStorage } = await import("./storage");
  const { spyOn } = await import("bun:test");
  const fetchMock = spyOn(globalThis, "fetch")
    .mockResolvedValueOnce(
      Response.json({
        mode: "neon",
        uploadId: "11111111-1111-4111-8111-111111111111",
        url: "https://storage.example.com/docs",
        fields: {},
      }),
    )
    .mockResolvedValueOnce(new Response(null, { status: 403 }));
  try {
    await expect(createDocumentStorage().put(new File(["%PDF-1.4"], "test.pdf"))).rejects.toThrow(
      "Unable to upload",
    );
    expect(fetchMock).toHaveBeenCalledTimes(2);
  } finally {
    fetchMock.mockRestore();
  }
});