Files

417 lines
13 KiB
TypeScript

import { Hour, Minute, Week } from "@shared/utils/time";
import BaseStorage from "./BaseStorage";
import env from "@server/env";
/**
* Mock implementation of BaseStorage for testing purposes.
*/
class MockStorage extends BaseStorage {
public storedFiles: Array<{
key: string;
body: Buffer;
contentType?: string;
acl?: string;
}> = [];
async getPresignedPost() {
return {};
}
async getFileStream() {
return null;
}
getUploadUrl() {
return "https://storage.example.com";
}
getUrlForKey(key: string) {
return `https://storage.example.com/${key}`;
}
async getSignedUrl() {
return "https://storage.example.com/signed";
}
async store({
body,
contentType,
key,
acl,
}: {
body: Buffer;
contentType?: string;
key: string;
acl?: string;
}) {
this.storedFiles.push({
key,
body: body as Buffer,
contentType,
acl,
});
return this.getUrlForKey(key);
}
async getFileHandle() {
return { path: "/tmp/test", cleanup: async () => {} };
}
async getFileExists() {
return false;
}
async moveFile() {}
async deleteFile() {}
static signingDateFor(expiresIn: number) {
return MockStorage.getSigningDate(expiresIn);
}
}
describe("BaseStorage", () => {
describe("getSigningDate", () => {
// A time deliberately offset from a window boundary, so that rounding is
// exercised and two calls cannot straddle a boundary.
const now = new Date("2026-04-16T12:07:31.500Z");
beforeEach(() => {
vi.useFakeTimers();
vi.setSystemTime(now);
});
afterEach(() => {
vi.useRealTimers();
});
it("should return the same date for calls within a window", () => {
const first = MockStorage.signingDateFor(Hour.seconds);
vi.setSystemTime(new Date("2026-04-16T12:08:01.500Z"));
const second = MockStorage.signingDateFor(Hour.seconds);
expect(second.getTime()).toBe(first.getTime());
});
it("should round down to the start of the window", () => {
// The window is capped at 15 minutes, so 12:07:31.500 rounds to 12:00.
const signingDate = MockStorage.signingDateFor(Hour.seconds);
expect(signingDate.toISOString()).toBe("2026-04-16T12:00:00.000Z");
});
it("should move to the next window once the boundary passes", () => {
const first = MockStorage.signingDateFor(Hour.seconds);
vi.setSystemTime(new Date("2026-04-16T12:22:31.500Z"));
const second = MockStorage.signingDateFor(Hour.seconds);
expect(second.getTime()).toBeGreaterThan(first.getTime());
});
it("should align to a window no longer than half the lifetime", () => {
// The lifetime is shorter than the cap, so the window halves to 5
// minutes and 12:07:31.500 rounds to 12:05.
const expiresIn = 10 * Minute.seconds;
const signingDate = MockStorage.signingDateFor(expiresIn);
const elapsed = now.getTime() - signingDate.getTime();
expect(signingDate.toISOString()).toBe("2026-04-16T12:05:00.000Z");
expect(elapsed).toBeGreaterThanOrEqual(0);
expect(elapsed).toBeLessThanOrEqual((expiresIn / 2) * 1000);
});
it("should cap the window so long lifetimes stay predictable", () => {
const signingDate = MockStorage.signingDateFor(Week.seconds);
const elapsed = now.getTime() - signingDate.getTime();
expect(elapsed).toBeLessThanOrEqual(BaseStorage.maxSigningWindow * 1000);
});
it("should not align a lifetime too short to divide", () => {
const signingDate = MockStorage.signingDateFor(1);
expect(signingDate.getTime()).toBe(now.getTime());
});
});
describe("getSignedUrlMinimumLifetime", () => {
afterEach(() => {
vi.useRealTimers();
});
it("should return half of the default lifetime", () => {
expect(BaseStorage.getSignedUrlMinimumLifetime()).toBe(
BaseStorage.defaultSignedUrlExpires / 2
);
});
it("should subtract the capped window from long lifetimes", () => {
expect(BaseStorage.getSignedUrlMinimumLifetime(Hour.seconds)).toBe(
Hour.seconds - BaseStorage.maxSigningWindow
);
});
it("should return the full lifetime when it is too short to align", () => {
expect(BaseStorage.getSignedUrlMinimumLifetime(1)).toBe(1);
});
it("should not exceed the remaining lifetime at the end of a window", () => {
const expiresIn = BaseStorage.defaultSignedUrlExpires;
const now = new Date("2026-04-16T12:07:29.999Z");
vi.useFakeTimers();
vi.setSystemTime(now);
const expiresAt =
MockStorage.signingDateFor(expiresIn).getTime() + expiresIn * 1000;
const remaining = (expiresAt - now.getTime()) / 1000;
expect(
BaseStorage.getSignedUrlMinimumLifetime(expiresIn)
).toBeLessThanOrEqual(remaining);
});
});
describe("getPresignedPut", () => {
it("should return undefined from default implementation", async () => {
const storage = new MockStorage();
const result = await storage.getPresignedPut(
"uploads/test/key",
"private",
1000000,
"image/png"
);
expect(result).toBeUndefined();
});
});
describe("storeFromUrl", () => {
let storage: MockStorage;
const originalMaxSize = env.FILE_STORAGE_UPLOAD_MAX_SIZE;
beforeEach(() => {
storage = new MockStorage();
storage.storedFiles = [];
env.FILE_STORAGE_UPLOAD_MAX_SIZE = 500;
});
afterEach(() => {
env.FILE_STORAGE_UPLOAD_MAX_SIZE = originalMaxSize;
});
describe("base64 URL size validation", () => {
it("should enforce maxUploadSize option for base64 URLs", async () => {
const largeDataSize = 1000;
const maxUploadSize = 500;
const largeBuffer = Buffer.alloc(largeDataSize, "a");
const base64Data = largeBuffer.toString("base64");
const base64Url = `data:image/png;base64,${base64Data}`;
const result = await storage.storeFromUrl(
base64Url,
"test-key",
"public-read",
undefined,
{ maxUploadSize }
);
expect(result).toBeUndefined();
expect(storage.storedFiles).toHaveLength(0);
});
it("should enforce FILE_STORAGE_UPLOAD_MAX_SIZE for base64 URLs", async () => {
const largeDataSize = 1000; // Exceeds our test limit of 500
const largeBuffer = Buffer.alloc(largeDataSize, "a");
const base64Data = largeBuffer.toString("base64");
const base64Url = `data:image/png;base64,${base64Data}`;
const result = await storage.storeFromUrl(
base64Url,
"test-key",
"public-read"
);
expect(result).toBeUndefined();
expect(storage.storedFiles).toHaveLength(0);
});
it("should allow base64 URLs within size limits", async () => {
const dataSize = 100;
const maxUploadSize = 500;
const buffer = Buffer.alloc(dataSize, "a");
const base64Data = buffer.toString("base64");
const base64Url = `data:image/png;base64,${base64Data}`;
const result = await storage.storeFromUrl(
base64Url,
"test-key",
"public-read",
undefined,
{ maxUploadSize }
);
expect(result).toBeDefined();
expect(result?.contentLength).toBe(dataSize);
expect(result?.contentType).toBe("image/png");
expect(storage.storedFiles).toHaveLength(1);
expect(storage.storedFiles[0].body.byteLength).toBe(dataSize);
});
it("should use the minimum of maxUploadSize and FILE_STORAGE_UPLOAD_MAX_SIZE", async () => {
// Create data that's larger than maxUploadSize but smaller than FILE_STORAGE_UPLOAD_MAX_SIZE
const maxUploadSize = 200;
const dataSize = 300;
const buffer = Buffer.alloc(dataSize, "a");
const base64Data = buffer.toString("base64");
const base64Url = `data:image/png;base64,${base64Data}`;
const result = await storage.storeFromUrl(
base64Url,
"test-key",
"public-read",
undefined,
{ maxUploadSize }
);
// Should be rejected because it exceeds maxUploadSize even though it's under FILE_STORAGE_UPLOAD_MAX_SIZE
expect(result).toBeUndefined();
expect(storage.storedFiles).toHaveLength(0);
});
it("should return undefined for empty base64 data", async () => {
const base64Url = "data:image/png;base64,";
const result = await storage.storeFromUrl(
base64Url,
"test-key",
"public-read"
);
expect(result).toBeUndefined();
expect(storage.storedFiles).toHaveLength(0);
});
});
describe("imagesOnly", () => {
it("should store a supported image with the detected content type", async () => {
const gif = Buffer.from("GIF89a...").toString("base64");
const result = await storage.storeFromUrl(
`data:image/png;base64,${gif}`,
"test-key",
"public-read",
undefined,
{ imagesOnly: true }
);
expect(result?.contentType).toBe("image/gif");
expect(storage.storedFiles).toHaveLength(1);
expect(storage.storedFiles[0].contentType).toBe("image/gif");
});
it("should not store an SVG", async () => {
const svg = Buffer.from(
'<svg xmlns="http://www.w3.org/2000/svg"></svg>'
).toString("base64");
const result = await storage.storeFromUrl(
`data:image/png;base64,${svg}`,
"test-key",
"public-read",
undefined,
{ imagesOnly: true }
);
expect(result).toBeUndefined();
expect(storage.storedFiles).toHaveLength(0);
});
});
describe("internal URL handling", () => {
it("should return undefined for URLs already on the storage provider", async () => {
const result = await storage.storeFromUrl(
"https://storage.example.com/existing-file.png",
"test-key",
"public-read"
);
expect(result).toBeUndefined();
expect(storage.storedFiles).toHaveLength(0);
});
});
});
describe("getContentDisposition", () => {
const storage = new MockStorage();
it("should include the file name so browsers keep the extension", () => {
expect(storage.getContentDisposition("text/plain", "config.yaml")).toBe(
'attachment; filename="config.yaml"'
);
});
it("should return inline for safe content types", () => {
expect(storage.getContentDisposition("image/png", "photo.png")).toBe(
'inline; filename="photo.png"'
);
});
it("should omit the file name when not provided", () => {
expect(storage.getContentDisposition("text/plain")).toBe("attachment");
expect(storage.getContentDisposition("image/png")).toBe("inline");
});
it("should encode a latin-1 file name rather than send it raw", () => {
expect(
storage.getContentDisposition("application/zip", "Café-export.zip")
).toBe(
"attachment; filename=\"Caf?-export.zip\"; filename*=UTF-8''Caf%C3%A9-export.zip"
);
});
it("should encode a file name outside latin-1", () => {
expect(storage.getContentDisposition("image/png", "日本語.png")).toBe(
"inline; filename=\"???.png\"; filename*=UTF-8''%E6%97%A5%E6%9C%AC%E8%AA%9E.png"
);
});
it("should only produce US-ASCII, whatever the file name", () => {
const names = [
"Zürich Team-export.markdown.zip",
"naïve.pdf",
"Ünicode ✨ 日本語.png",
"plain.txt",
];
for (const name of names) {
const value = storage.getContentDisposition("application/zip", name);
expect(value).toMatch(/^[\x20-\x7e]*$/);
}
});
});
describe("getContentDispositionType", () => {
const storage = new MockStorage();
it("should return attachment when content type is missing", () => {
expect(storage.getContentDispositionType()).toBe("attachment");
});
it("should return inline for audio, video, and safe types", () => {
expect(storage.getContentDispositionType("audio/mpeg")).toBe("inline");
expect(storage.getContentDispositionType("video/mp4")).toBe("inline");
expect(storage.getContentDispositionType("application/pdf")).toBe(
"inline"
);
});
it("should return attachment for other content types", () => {
expect(storage.getContentDispositionType("image/svg+xml")).toBe(
"attachment"
);
expect(storage.getContentDispositionType("text/plain")).toBe(
"attachment"
);
});
});
});