Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/apps/web/app/routes/customer-portal/project-upload.test.ts
T

130 lines
5.2 KiB
TypeScript

// @vitest-environment jsdom
import { beforeEach, describe, expect, it, vi } from "vitest";
const mocks = vi.hoisted(() => {
class PortalUploadError extends Error {
constructor(readonly code: string) {
super(code);
}
}
class RequestBodyLimitError extends Error {
constructor(readonly limitBytes: number) {
super("request body too large");
}
}
return {
PortalUploadError,
RequestBodyLimitError,
requireSession: vi.fn(),
validateCsrf: vi.fn(),
uploadFiles: vi.fn(),
readLimitedFormData: vi.fn(),
};
});
vi.mock("~/services/customer-portal/portal-data.server", () => ({
requirePortalSessionContext: mocks.requireSession,
portalNotFound: () => new Response(null, { status: 404 }),
}));
vi.mock("~/services/customer-portal/portal-csrf.server", () => ({ validatePortalCsrfToken: mocks.validateCsrf }));
vi.mock("~/utils/http/readLimitedRequestBody.server", () => ({
RequestBodyLimitError: mocks.RequestBodyLimitError,
readLimitedRequestFormData: mocks.readLimitedFormData,
}));
vi.mock("~/services/customer-portal/portal-upload.server", () => ({
PORTAL_UPLOAD_ABSOLUTE_MAX_FILE_BYTES: 100 * 1024 * 1024,
PORTAL_UPLOAD_ABSOLUTE_REQUEST_BYTES: 101 * 1024 * 1024,
PORTAL_UPLOAD_DEFAULT_MAX_FILES: 10,
PortalUploadError: mocks.PortalUploadError,
uploadPortalFiles: mocks.uploadFiles,
}));
import { action } from "./project-upload";
const session = {
identity: { tenantId: "tenant-a", portalUserId: "portal-user-a", tenantFrozen: false },
responseHeaders: new Headers({ "Set-Cookie": "portal=renewed" }),
};
function args(request: Request) {
return { request, params: { tenant: "acme", projectId: "project-a" }, context: {} } as never;
}
function uploadRequest(files: readonly File[]): Request {
const form = new FormData();
form.set("csrf", "csrf-token");
form.set("idempotencyKey", "upload-key-a");
for (const file of files) form.append("files", file);
mocks.readLimitedFormData.mockResolvedValueOnce(form);
const request = new Request("https://portal.example.test/acme/projects/project-a/upload", { method: "POST" });
return request;
}
function testFile(contents: string, name: string, type: string): File {
const file = new File([contents], name, { type });
Object.defineProperty(file, "arrayBuffer", {
value: async () => new TextEncoder().encode(contents).buffer,
});
return file;
}
describe("customer portal project upload route", () => {
beforeEach(() => {
vi.clearAllMocks();
mocks.requireSession.mockResolvedValue(session);
mocks.validateCsrf.mockResolvedValue(undefined);
mocks.uploadFiles.mockResolvedValue([{ uploadId: "upload-a", fileId: "file-a" }]);
});
it("forwards every selected file through the portal session after CSRF validation", async () => {
const request = uploadRequest([testFile("photo", "baustelle.jpg", "image/jpeg"), testFile("voice", "memo.mp3", "audio/mpeg")]);
const response = await action(args(request));
expect(response.status).toBe(201);
expect(mocks.validateCsrf).toHaveBeenCalledWith(request, expect.any(FormData));
expect(mocks.readLimitedFormData).toHaveBeenCalledWith(request, 101 * 1024 * 1024);
expect(mocks.uploadFiles).toHaveBeenCalledWith({
identity: session.identity,
projectId: "project-a",
idempotencyKey: "upload-key-a",
files: [
{ name: "baustelle.jpg", mimeType: "image/jpeg", bytes: expect.any(Uint8Array) },
{ name: "memo.mp3", mimeType: "audio/mpeg", bytes: expect.any(Uint8Array) },
],
});
await expect(response.json()).resolves.toMatchObject({ ok: true, messageKey: "customerPortal.upload.success" });
});
it("returns a stable M002 key before the service when more than ten files are posted", async () => {
const files = Array.from({ length: 11 }, (_, index) => testFile(String(index), `file-${index}.jpg`, "image/jpeg"));
const response = await action(args(uploadRequest(files)));
expect(response.status).toBe(413);
await expect(response.json()).resolves.toEqual({ ok: false, errorKey: "customerPortal.upload.errors.tooManyFiles" });
expect(mocks.uploadFiles).not.toHaveBeenCalled();
});
it("rejects a streamed body that exceeds the absolute request limit before parsing files", async () => {
mocks.readLimitedFormData.mockRejectedValueOnce(new mocks.RequestBodyLimitError(101 * 1024 * 1024));
const request = new Request("https://portal.example.test/acme/projects/project-a/upload", {
method: "POST",
headers: { "content-type": "multipart/form-data; boundary=pilot" },
body: "--pilot--",
});
const response = await action(args(request));
expect(response.status).toBe(413);
expect(response.headers.get("set-cookie")).toBe("portal=renewed");
await expect(response.json()).resolves.toEqual({ ok: false, errorKey: "customerPortal.upload.errors.requestTooLarge" });
expect(mocks.validateCsrf).not.toHaveBeenCalled();
expect(mocks.uploadFiles).not.toHaveBeenCalled();
});
it("maps frozen and revoked project access to a non-enumerating 404", async () => {
mocks.uploadFiles.mockRejectedValueOnce(new mocks.PortalUploadError("PORTAL_FROZEN"));
await expect(action(args(uploadRequest([testFile("photo", "photo.jpg", "image/jpeg")])))).rejects.toMatchObject({ status: 404 });
});
});