Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
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");
});
});