test(recorder): add unit tests for recording pipeline, uploader, spool, and backup

Author: richiemcilroy

apps/web/__tests__/unit/instant-recording-uploader.test.ts

@@ -0,0 +1,80 @@
+import { describe, expect, it } from "vitest";
+import {
+	appendLocalRecordingChunk,
+	finalizeLocalRecording,
+	initialLocalRecordingState,
+} from "@/app/(org)/dashboard/caps/components/web-recorder-dialog/local-recording-backup";
+
+const makeBlob = (size: number, type = "video/webm;codecs=vp9,opus") =>
+	new Blob([new Uint8Array(size)], { type });
+
+describe("local recording backup", () => {
+	it("retains a full local copy when configured for capped streaming backup", () => {
+		const firstChunk = makeBlob(3);
+		const secondChunk = makeBlob(4);
+
+		const afterFirstChunk = appendLocalRecordingChunk(
+			initialLocalRecordingState(),
+			firstChunk,
+			{ mode: "capped", maxBytes: 10 },
+		);
+		const afterSecondChunk = appendLocalRecordingChunk(
+			afterFirstChunk,
+			secondChunk,
+			{ mode: "capped", maxBytes: 10 },
+		);
+
+		const blob = finalizeLocalRecording(afterSecondChunk);
+
+		expect(afterSecondChunk.overflowed).toBe(false);
+		expect(afterSecondChunk.retainedBytes).toBe(7);
+		expect(blob?.size).toBe(7);
+		expect(blob?.type).toBe("video/webm;codecs=vp9,opus");
+	});
+
+	it("drops the backup copy after the capped limit is exceeded", () => {
+		const firstChunk = makeBlob(6);
+		const secondChunk = makeBlob(5);
+		const thirdChunk = makeBlob(3);
+
+		const afterFirstChunk = appendLocalRecordingChunk(
+			initialLocalRecordingState(),
+			firstChunk,
+			{ mode: "capped", maxBytes: 10 },
+		);
+		const afterSecondChunk = appendLocalRecordingChunk(
+			afterFirstChunk,
+			secondChunk,
+			{ mode: "capped", maxBytes: 10 },
+		);
+		const afterThirdChunk = appendLocalRecordingChunk(
+			afterSecondChunk,
+			thirdChunk,
+			{ mode: "capped", maxBytes: 10 },
+		);
+
+		const blob = finalizeLocalRecording(afterThirdChunk);
+
+		expect(afterSecondChunk.overflowed).toBe(true);
+		expect(afterSecondChunk.retainedBytes).toBe(0);
+		expect(afterSecondChunk.chunks).toHaveLength(0);
+		expect(afterThirdChunk.overflowed).toBe(true);
+		expect(afterThirdChunk.retainedBytes).toBe(0);
+		expect(afterThirdChunk.chunks).toHaveLength(0);
+		expect(blob).toBeNull();
+	});
+
+	it("keeps the uncapped buffered fallback intact", () => {
+		const state = appendLocalRecordingChunk(
+			initialLocalRecordingState(),
+			makeBlob(12, "video/mp4"),
+			{ mode: "full" },
+		);
+
+		const blob = finalizeLocalRecording(state);
+
+		expect(state.overflowed).toBe(false);
+		expect(blob?.size).toBe(12);
+		expect(blob?.type).toBe("video/mp4");
+	});
+});

apps/web/__tests__/unit/local-recording-backup.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, it } from "vitest";
+import {
+	getMultipartFileKey,
+	getSubpath,
+	isRawRecorderUpload,
+} from "@/app/api/upload/[...route]/multipart-utils";
+
+describe("multipart upload utils", () => {
+	it("builds a multipart file key from video id and subpath", () => {
+		expect(
+			getMultipartFileKey("user-123", {
+				videoId: "video-456",
+				subpath: "raw-upload.webm",
+			}),
+		).toBe("user-123/video-456/raw-upload.webm");
+	});
+
+	it("defaults the multipart subpath to result.mp4", () => {
+		const input: { subpath?: string } = {};
+
+		expect(
+			getMultipartFileKey("user-123", {
+				videoId: "video-456",
+			}),
+		).toBe("user-123/video-456/result.mp4");
+		expect(getSubpath(input)).toBe("result.mp4");
+	});
+
+	it("parses deprecated fileKey input into the current user-scoped key", () => {
+		expect(
+			getMultipartFileKey("user-123", {
+				fileKey: "legacy-owner/video-456/raw-upload.webm",
+			}),
+		).toBe("user-123/video-456/raw-upload.webm");
+		expect(
+			getSubpath({
+				fileKey: "legacy-owner/video-456/raw-upload.webm",
+			}),
+		).toBeUndefined();
+	});
+
+	it("detects raw recorder uploads", () => {
+		expect(isRawRecorderUpload("raw-upload.webm")).toBe(true);
+		expect(isRawRecorderUpload("raw-upload.mp4")).toBe(true);
+		expect(isRawRecorderUpload("result.mp4")).toBe(false);
+	});
+
+	it("rejects missing video ids", () => {
+		expect(() =>
+			getMultipartFileKey("user-123", {
+				subpath: "raw-upload.webm",
+			}),
+		).toThrow("Video id not found");
+	});
+});

apps/web/__tests__/unit/multipart-upload-utils.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it, vi } from "vitest";
+import { moveRecordingSpoolToInMemoryBackup } from "@/app/(org)/dashboard/caps/components/web-recorder-dialog/recording-spool-fallback";
+
+const blobToText = async (blob: Blob) =>
+	new TextDecoder().decode(await blob.arrayBuffer());
+
+describe("moveRecordingSpoolToInMemoryBackup", () => {
+	it("merges recovered chunks with later in-memory chunks without duplicating them", async () => {
+		let retainedChunks = [new Blob(["older"], { type: "video/webm" })];
+		let releaseRecovery: (() => void) | null = null;
+
+		const replaceLocalRecording = vi.fn((chunks: Blob[]) => {
+			retainedChunks = chunks;
+		});
+
+		const transitionPromise = moveRecordingSpoolToInMemoryBackup({
+			spool: {
+				recoverBlob: () =>
+					new Promise<Blob>((resolve) => {
+						releaseRecovery = () =>
+							resolve(new Blob(["persisted"], { type: "video/webm" }));
+					}),
+			},
+			setLocalRecordingStrategy: () => {
+				retainedChunks = [];
+			},
+			getRetainedChunks: () => [...retainedChunks],
+			replaceLocalRecording,
+		});
+
+		retainedChunks = [
+			...retainedChunks,
+			new Blob(["later"], { type: "video/webm" }),
+		];
+
+		releaseRecovery?.();
+		await transitionPromise;
+
+		expect(replaceLocalRecording).toHaveBeenCalledTimes(1);
+		expect(retainedChunks).toHaveLength(2);
+		expect(await blobToText(new Blob(retainedChunks))).toBe("persistedlater");
+	});
+});