Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

5.6 KB
Raw Blame
import { describe, expect, test } from "bun:test";
import {
	checkManifestBounds,
	sourceLimitsFromEnv,
	validateJobRequest,
} from "./validate";

describe("validateJobRequest", () => {
	test("accepts a typical export", () => {
		const request = {
			recording: "recordings/abc123",
			fps: 30,
			resolution: [1920, 1080] as [number, number],
			compression: "Maximum" as const,
		};
		expect(validateJobRequest(request)).toEqual(request);
	});

	test.each([
		[null, "body must be a JSON object"],
		[{}, "recording must be a bucket prefix"],
		[{ recording: "../secrets" }, "recording must be a bucket prefix"],
		[{ recording: "a/../../b" }, "recording must be a bucket prefix"],
		[{ recording: "rec", fps: 0 }, "fps must be an integer from 1 to 120"],
		[{ recording: "rec", fps: 29.97 }, "fps must be an integer from 1 to 120"],
		[{ recording: "rec", resolution: [99999, 1080] }, "resolution"],
		[{ recording: "rec", resolution: [1920] }, "resolution"],
		[
			{ recording: "rec", compression: "Lossless" },
			"compression must be one of",
		],
		[
			{ recording: "rec", compression: "toString" },
			"compression must be one of",
		],
		[{ recording: "rec", maxChunks: -1 }, "maxChunks"],
		[{ recording: "rec", chunks: 5000 }, "chunks"],
		[{ recording: "rec", chunkWorkSeconds: Number.NaN }, "chunkWorkSeconds"],
		[{ recording: "rec", label: "x".repeat(201) }, "label"],
	])("rejects %j", (body, message) => {
		const result = validateJobRequest(body);
		expect(typeof result).toBe("string");
		expect(result as string).toContain(message);
	});
});

describe("checkManifestBounds", () => {
	const limits = {
		...sourceLimitsFromEnv({}),
		files: 4,
		sourceBytes: 1000,
		sidecarBytes: 100,
	};
	const file = (path: string, size: number) => ({ path, size });

	test("accepts a manifest within its limits", () => {
		expect(
			checkManifestBounds(
				{
					files: [
						file("recording-meta.json", 50),
						file("content/segments/segment-0/display.mp4", 800),
						file("content/segments/segment-0/audio-input.ogg", 120),
					],
				},
				limits,
			),
		).toBeNull();
	});

	test.each([
		[{}, "no files list"],
		[
			{ files: Array.from({ length: 5 }, (_, i) => file(`${i}.json`, 1)) },
			"5 files",
		],
		[
			{ files: [file("display.mp4", 999), file("camera.mp4", 2)] },
			"recording is 1001 bytes",
		],
		[{ files: [file("cursors/0.png", 101)] }, "cursors/0.png is 101 bytes"],
		[{ files: [file("display.mp4", -1)] }, "non-negative integer"],
		[{ files: [file("display.mp4", Number.NaN)] }, "non-negative integer"],
		[{ files: [{ path: "", size: 1 }] }, "manifest paths"],
		[{ files: [{ path: "a.json", size: 1, key: 5 }] }, "manifest key"],
		[{ files: [null] }, "not an object"],
	])("rejects %j", (manifest, message) => {
		expect(checkManifestBounds(manifest, limits)).toContain(message);
	});

	test("large video and audio files are bounded only by the total", () => {
		expect(
			checkManifestBounds(
				{ files: [file("display.mp4", 600), file("audio-input.ogg", 300)] },
				limits,
			),
		).toBeNull();
	});

	test("environment overrides apply only to valid positive numbers", () => {
		const parsed = sourceLimitsFromEnv({
			RF_MAX_SOURCE_FILES: "10",
			RF_MAX_SOURCE_BYTES: "-5",
			RF_MAX_EXPORT_SECONDS: "abc",
		});
		expect(parsed.files).toBe(10);
		expect(parsed.sourceBytes).toBe(256 * 2 ** 30);
		expect(parsed.exportSeconds).toBe(4 * 3600);
	});
});

describe("product job fields", () => {
	const base = {
		recording: "owner/video/.recording/render/abc/project",
		sourceRoot: "owner/video/",
	};

	test("accepts outputs and callbacks inside the source folder", () => {
		expect(
			typeof validateJobRequest({
				...base,
				output: {
					key: "owner/video/.recording/render/abc/result.mp4",
					hlsPrefix: "owner/video/.recording/render/abc/hls",
				},
				callbackUrl: "https://preview.cap.test/api/render-farm/callback",
				reference: "video-1",
			}),
		).toBe("object");
	});

	test.each([
		[{ ...base, sourceRoot: "owner/other/" }, "sourceRoot"],
		[{ ...base, sourceRoot: "owner/video" }, "sourceRoot"],
		[{ ...base, output: { key: "owner/other/result.mp4" } }, "output"],
		[{ ...base, output: { key: "owner/video/result.webm" } }, "output"],
		[
			{ ...base, output: { key: "owner/video/result.mp4", hlsPrefix: "hls" } },
			"output",
		],
		[{ ...base, output: { key: "owner/video/../x/result.mp4" } }, "output"],
		[{ ...base, callbackUrl: "http://preview.cap.test/hook" }, "callbackUrl"],
		[{ ...base, callbackUrl: "not a url" }, "callbackUrl"],
		[{ ...base, reference: 7 }, "reference"],
	])("rejects %j", (body, message) => {
		expect(validateJobRequest(body)).toContain(message);
	});

	test("outputs default to the recording's own folder without a sourceRoot", () => {
		expect(
			validateJobRequest({
				recording: "rec",
				output: { key: "rec/out.mp4" },
			}),
		).not.toBeString();
		expect(
			validateJobRequest({
				recording: "rec",
				output: { key: "other/out.mp4" },
			}),
		).toContain("output");
	});
});

describe("manifest transcodes", () => {
	const limits = sourceLimitsFromEnv({});

	test("a source to transcode may omit its size until it exists", () => {
		expect(
			checkManifestBounds(
				{
					files: [
						{
							path: "content/segments/segment-0/display.mp4",
							key: "owner/video/.recording/render/sources/display.mp4",
							transcodeFrom: "owner/video/raw-upload.webm",
						},
					],
				},
				limits,
			),
		).toBeNull();
	});

	test("a transcode must produce an mp4", () => {
		expect(
			checkManifestBounds(
				{
					files: [
						{
							path: "content/segments/segment-0/display.webm",
							transcodeFrom: "owner/video/raw-upload.webm",
						},
					],
				},
				limits,
			),
		).toContain("transcodeFrom");
	});
});