Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/apps/web/app/routes/app.$tenant/files.upload.security.test.ts
T

118 lines
4.8 KiB
TypeScript

import { beforeEach, describe, expect, it, vi } from "vitest";
const mocks = vi.hoisted(() => ({
loadFilesContext: vi.fn(),
requireFilesPermission: vi.fn(),
validateCSRFToken: vi.fn(),
createUploadSession: vi.fn(),
storeUploadChunk: vi.fn(),
completeUpload: vi.fn(),
auditFileEvent: vi.fn(),
}));
vi.mock("~/utils/integrations/fileAccess.server", () => ({
fileActionErrorResponse: (error: unknown) => {
throw error;
},
loadFilesContext: mocks.loadFilesContext,
requireFilesPermission: mocks.requireFilesPermission,
}));
vi.mock("~/utils/session.server", () => ({ validateCSRFToken: mocks.validateCSRFToken }));
vi.mock("~/utils/integrations/fileService.server", () => ({
createUploadSession: mocks.createUploadSession,
storeUploadChunk: mocks.storeUploadChunk,
completeUpload: mocks.completeUpload,
}));
vi.mock("~/utils/integrations/fileAudit.server", () => ({ auditFileEvent: mocks.auditFileEvent }));
import { action as initUpload } from "./files.upload.init";
import { action as storeChunk } from "./files.upload.$uploadId.chunk.$index";
import { action as completeUpload } from "./files.upload.$uploadId.complete";
const filesContext = {
tenantId: "tenant_1",
userId: "user_1",
permissions: ["files.write"],
hasModule: true,
};
beforeEach(() => {
vi.clearAllMocks();
mocks.loadFilesContext.mockResolvedValue(filesContext);
mocks.requireFilesPermission.mockImplementation((context) => context);
mocks.validateCSRFToken.mockResolvedValue(undefined);
mocks.createUploadSession.mockResolvedValue({ uploadId: "upload_1", chunkSize: 5, totalChunks: 1 });
mocks.storeUploadChunk.mockResolvedValue({ receivedChunks: 1, totalChunks: 1 });
mocks.completeUpload.mockResolvedValue({
id: "file_1",
displayName: "pilot.pdf",
mimeType: "application/pdf",
sizeBytes: 4,
});
mocks.auditFileEvent.mockResolvedValue(undefined);
});
describe("tenant file upload mutation CSRF boundary", () => {
it("validates header-only CSRF before parsing or creating an upload session", async () => {
const request = new Request("https://app.example.test/demo/files/upload/init", {
method: "POST",
headers: { "content-type": "application/json", "x-csrf-token": "csrf-token" },
body: JSON.stringify({ originalFilename: "pilot.pdf", mimeType: "application/pdf", totalSizeBytes: 4 }),
});
const response = await initUpload({ request, params: { tenant: "demo" }, context: {} } as never);
expect(response.status).toBe(200);
expect(mocks.validateCSRFToken).toHaveBeenCalledWith(request, { headerOnly: true });
expect(mocks.validateCSRFToken.mock.invocationCallOrder[0]).toBeLessThan(mocks.createUploadSession.mock.invocationCallOrder[0]);
});
it("validates header-only CSRF before reading or storing raw chunk bytes", async () => {
const request = new Request("https://app.example.test/demo/files/upload/upload_1/chunk/0", {
method: "PUT",
headers: { "x-csrf-token": "csrf-token" },
body: new Uint8Array([1, 2, 3, 4]),
});
const response = await storeChunk({
request,
params: { tenant: "demo", uploadId: "upload_1", index: "0" },
context: {},
} as never);
expect(response.status).toBe(200);
expect(mocks.validateCSRFToken).toHaveBeenCalledWith(request, { headerOnly: true });
expect(mocks.validateCSRFToken.mock.invocationCallOrder[0]).toBeLessThan(mocks.storeUploadChunk.mock.invocationCallOrder[0]);
});
it("validates header-only CSRF before completing and auditing an upload", async () => {
const request = new Request("https://app.example.test/demo/files/upload/upload_1/complete", {
method: "POST",
headers: { "content-type": "application/json", "x-csrf-token": "csrf-token" },
body: JSON.stringify({ displayName: "Pilot proof" }),
});
const response = await completeUpload({
request,
params: { tenant: "demo", uploadId: "upload_1" },
context: {},
} as never);
expect(response.status).toBe(200);
expect(mocks.validateCSRFToken).toHaveBeenCalledWith(request, { headerOnly: true });
expect(mocks.validateCSRFToken.mock.invocationCallOrder[0]).toBeLessThan(mocks.completeUpload.mock.invocationCallOrder[0]);
});
it("does not mutate upload state when CSRF validation fails", async () => {
mocks.validateCSRFToken.mockRejectedValueOnce(new Error("invalid csrf"));
const request = new Request("https://app.example.test/demo/files/upload/init", {
method: "POST",
headers: { "content-type": "application/json" },
body: JSON.stringify({ originalFilename: "pilot.pdf", mimeType: "application/pdf", totalSizeBytes: 4 }),
});
await expect(initUpload({ request, params: { tenant: "demo" }, context: {} } as never)).rejects.toThrow("invalid csrf");
expect(mocks.createUploadSession).not.toHaveBeenCalled();
});
});