Skip to content

Record your screen, ship a demo. Free and open-source, GPU-accelerated, no watermarks, no subscriptions. Windows, macOS, Linux. Actively maintained.

7.4 KB
Raw Blame
import fs from "node:fs/promises";
import os from "node:os";
import path from "node:path";
import { afterEach, beforeEach, describe, expect, it } from "vitest";
import {
	normalizeProjectEditor,
	PROJECT_VERSION,
} from "../../src/components/video-editor/projectPersistence";
import { migrateProjectDataToAxcutDocument } from "../../src/lib/ai-edition/document/migrate";
import { type PackedProjectData, runInfoCommand, runPackCommand } from "./projectCommands";

let root = "";

/** Absolute path inside the throwaway root, parents created. */
async function make(relative: string, contents = "video-bytes"): Promise<string> {
	const target = path.join(root, relative);
	await fs.mkdir(path.dirname(target), { recursive: true });
	await fs.writeFile(target, contents, "utf8");
	return target;
}

async function writeProject(relative: string, data: PackedProjectData): Promise<string> {
	return make(relative, JSON.stringify(data));
}

/**
 * A project file as the editor saves it: the AxcutDocument itself, one zoom on the timeline, an
 * export format a migrated v2 project left in `legacyEditor`, a speed region where the editor
 * keeps them (`legacyEditor.speedRegions`), and one shader effect.
 */
async function writeDocument(relative: string, screenVideoPath: string): Promise<string> {
	const doc = migrateProjectDataToAxcutDocument({
		version: PROJECT_VERSION,
		media: { screenVideoPath },
		editor: normalizeProjectEditor({
			exportFormat: "gif",
			zoomRegions: [{ id: "z1", startMs: 0, endMs: 1000, depth: 3, focus: { cx: 0.5, cy: 0.5 } }],
		}),
	});
	const speedRegions = [{ id: "s1", startMs: 0, endMs: 500, speed: 2 }];
	return make(
		relative,
		JSON.stringify({
			...doc,
			legacyEditor: { ...doc.legacyEditor, speedRegions },
			shaderEffects: [
				{
					id: "fx1",
					name: "Pass-through",
					contract: 1,
					code: "fn effect(uv: vec2<f32>) -> vec4<f32> { return frame(uv); }",
				},
			],
			shaderEffectRanges: [{ id: "fxr1", startMs: 0, endMs: 500, effectId: "fx1" }],
		}),
	);
}

const readProject = async (file: string): Promise<PackedProjectData> =>
	JSON.parse(await fs.readFile(file, "utf8"));

/** Collects CLI output instead of writing to stdout. */
function recorder() {
	const chunks: string[] = [];
	const write = (text: string) => {
		chunks.push(text);
	};
	return { write, text: () => chunks.join("") };
}

beforeEach(async () => {
	root = await fs.mkdtemp(path.join(os.tmpdir(), "os-cli-pack-"));
});

afterEach(async () => {
	await fs.rm(root, { recursive: true, force: true });
});

describe("runPackCommand", () => {
	it("keeps screen and webcam apart when they share a basename", async () => {
		const screen = await make("rec/a/clip.mp4", "screen");
		const webcam = await make("rec/b/clip.mp4", "webcam");
		const project = await writeProject("demo.openscreen", {
			version: 1,
			media: { screenVideoPath: screen, webcamVideoPath: webcam },
		});
		const outDir = path.join(root, "packed");

		const out = recorder();
		expect(await runPackCommand(project, outDir, false, out.write)).toBe(0);

		const packed = await readProject(path.join(outDir, "demo.openscreen"));
		expect(packed.media?.screenVideoPath).not.toBe(packed.media?.webcamVideoPath);
		await expect(fs.readFile(packed.media?.screenVideoPath ?? "", "utf8")).resolves.toBe("screen");
		await expect(fs.readFile(packed.media?.webcamVideoPath ?? "", "utf8")).resolves.toBe("webcam");
	});

	it("copies the cursor sidecar and drops the legacy videoPath", async () => {
		const screen = await make("rec/clip.mp4", "screen");
		await make("rec/clip.mp4.cursor.json", "[]");
		const project = await writeProject("demo.openscreen", { version: 1, videoPath: screen });
		const outDir = path.join(root, "packed");

		const out = recorder();
		expect(await runPackCommand(project, outDir, true, out.write)).toBe(0);

		const packed = await readProject(path.join(outDir, "demo.openscreen"));
		expect(packed.videoPath).toBeUndefined();
		expect(packed.media?.screenVideoPath).toBe(path.join(outDir, "clip.mp4"));
		await expect(fs.readFile(path.join(outDir, "clip.mp4.cursor.json"), "utf8")).resolves.toBe(
			"[]",
		);
		expect(JSON.parse(out.text())).toMatchObject({ event: "done", cursorData: true });
	});

	it("falls back to media sitting next to the project when the stored path is stale", async () => {
		await make("moved/clip.mp4", "screen");
		const project = await writeProject("moved/demo.openscreen", {
			version: 1,
			media: { screenVideoPath: path.join(root, "gone", "clip.mp4") },
		});
		const outDir = path.join(root, "packed");

		const out = recorder();
		expect(await runPackCommand(project, outDir, false, out.write)).toBe(0);
		await expect(fs.readFile(path.join(outDir, "clip.mp4"), "utf8")).resolves.toBe("screen");
	});

	it("fails when the referenced media is nowhere to be found", async () => {
		const project = await writeProject("demo.openscreen", {
			version: 1,
			media: { screenVideoPath: path.join(root, "gone", "clip.mp4") },
		});

		const out = recorder();
		await expect(
			runPackCommand(project, path.join(root, "packed"), false, out.write),
		).rejects.toThrow(/Referenced media not found/);
	});
});

describe("runInfoCommand", () => {
	it("exits 1 when the project's video is missing, 0 when it is there", async () => {
		const missing = await writeProject("missing.openscreen", {
			version: 1,
			media: { screenVideoPath: path.join(root, "gone", "clip.mp4") },
		});
		const present = await writeProject("present.openscreen", {
			version: 1,
			media: { screenVideoPath: await make("rec/clip.mp4") },
		});

		const out = recorder();
		expect(await runInfoCommand(missing, false, out.write)).toBe(1);
		expect(out.text()).toContain("[MISSING]");
		expect(await runInfoCommand(present, false, out.write)).toBe(0);
	});

	it("counts timeline regions in --json mode", async () => {
		const project = await writeProject("demo.openscreen", {
			version: 1,
			media: { screenVideoPath: await make("rec/clip.mp4") },
			editor: { zoomRegions: [{}, {}], trimRegions: [{}], exportFormat: "mp4" },
		});

		const out = recorder();
		expect(await runInfoCommand(project, true, out.write)).toBe(0);
		expect(JSON.parse(out.text())).toMatchObject({
			zoomRegions: 2,
			trimRegions: 1,
			speedRegions: 0,
			annotationRegions: 0,
			shaderEffectRegions: 0,
			exportFormat: "mp4",
			screenVideoExists: true,
		});
	});
});

describe("a project the editor saved", () => {
	it("is described by info from its primary asset", async () => {
		const screen = await make("rec/clip.mp4");
		const project = await writeDocument("saved.openscreen", screen);

		const out = recorder();
		expect(await runInfoCommand(project, true, out.write)).toBe(0);
		expect(JSON.parse(out.text())).toMatchObject({
			version: 9,
			screenVideoPath: screen,
			screenVideoExists: true,
			exportFormat: "gif",
			zoomRegions: 1,
			trimRegions: 0,
			speedRegions: 1,
			shaderEffectRegions: 1,
		});
	});

	it("is reported MISSING by info when its media is gone", async () => {
		const project = await writeDocument("saved.openscreen", path.join(root, "gone", "clip.mp4"));

		const out = recorder();
		expect(await runInfoCommand(project, false, out.write)).toBe(1);
		expect(out.text()).toContain("[MISSING]");
	});

	it("is refused by pack with a reason, not as a project without video", async () => {
		const project = await writeDocument("saved.openscreen", await make("rec/clip.mp4"));

		await expect(
			runPackCommand(project, path.join(root, "packed"), false, recorder().write),
		).rejects.toThrow("pack does not support projects saved by the editor yet");
	});
});