Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

24.6 KB
Raw Blame
import { getCurrentUser } from "@cap/database/auth/session";
import {
	CurrentUser,
	Policy,
	Storage as StorageDomain,
	Video,
} from "@cap/web-domain";
import { Effect, Option } from "effect";
import { beforeEach, describe, expect, it, vi } from "vitest";

const deletion = vi.hoisted(() => ({
	deleteVideo: vi.fn(),
	principal: vi.fn(),
}));
const defaultSharing = vi.hoisted(() => ({
	getNewVideoPublic: vi.fn(),
}));

const schema = {
	organizations: { table: "organizations" },
	organizationMembers: { table: "organizationMembers" },
	users: { table: "users" },
	videos: { table: "videos" },
	videoUploads: { table: "videoUploads" },
	importedVideos: { table: "importedVideos" },
	authApiKeys: { table: "authApiKeys" },
};

const mockDb = {
	select: vi.fn(),
	from: vi.fn(),
	innerJoin: vi.fn(),
	leftJoin: vi.fn(),
	insert: vi.fn(),
	values: vi.fn(),
	update: vi.fn(),
	set: vi.fn(),
	where: vi.fn(),
	delete: vi.fn(),
	for: vi.fn(),
	limit: vi.fn(),
	transaction: vi.fn(),
};

vi.mock("@cap/database", () => ({
	db: () => mockDb,
}));
vi.mock("@cap/database/video-sharing-default", () => defaultSharing);

vi.mock("@cap/database/auth/session", () => ({
	getCurrentUser: vi.fn(),
}));

vi.mock("@cap/database/auth/auth-options", () => ({
	getServerSession: vi.fn(),
}));

vi.mock("@cap/database/schema", () => schema);

vi.mock("@cap/database/emails/config", () => ({
	sendEmail: vi.fn(),
}));

vi.mock("@cap/database/emails/first-shareable-link", () => ({
	FirstShareableLink: () => null,
}));

vi.mock("@cap/env", () => ({
	serverEnv: () => ({
		CAP_VIDEOS_DEFAULT_PUBLIC: true,
		WEB_URL: "https://cap.test",
	}),
	buildEnv: {
		NEXT_PUBLIC_IS_CAP: true,
		NEXT_PUBLIC_WEB_URL: "https://cap.test",
	},
}));

vi.mock("@cap/utils", () => ({
	userIsPro: vi.fn(() => true),
}));

vi.mock("@cap/web-backend", async () => {
	const { Effect } = await import("effect");
	const { makeCurrentUserLayer } = await import("@cap/web-backend/src/Auth");
	class Videos extends Effect.Service<Videos>()("Videos", {
		sync: () => ({ delete: deletion.deleteVideo }),
	}) {}
	return {
		makeCurrentUserLayer,
		Videos,
		Storage: {
			getOrganizationWritableAccess: vi.fn(),
			getS3WritableAccessForUser: vi.fn(),
		},
	};
});

vi.mock("@/lib/server", async () => {
	const { Effect } = await import("effect");
	const { Videos } = await import("@cap/web-backend");
	return {
		runPromise: vi.fn(async (value: unknown) =>
			Effect.isEffect(value)
				? Effect.runPromise(
						(
							value as Effect.Effect<
								unknown,
								unknown,
								InstanceType<typeof Videos>
							>
						).pipe(Effect.provide(Videos.Default)),
					)
				: value,
		),
	};
});

vi.mock("@/lib/video-storage", () => ({
	decodeStorageVideo: vi.fn(() => null),
}));

vi.mock("@/lib/google-drive-storage-quota", () => ({
	invalidateGoogleDriveStorageQuotaCache: vi.fn(),
}));

vi.mock("@/lib/server-analytics", () => ({
	trackServerEvent: vi.fn(),
}));

// The live-transcription stack drags in the whole workflow graph
// (server-only modules included); these tests only care that create works.
vi.mock("@/lib/live-transcribe", () => ({
	maybeStartLiveTranscription: vi.fn(async () => "skipped"),
}));

vi.mock("drizzle-orm", () => ({
	and: vi.fn((...args: unknown[]) => args),
	eq: vi.fn((field: unknown, value: unknown) => ({ field, value })),
	count: vi.fn(() => "count()"),
	lte: vi.fn(() => "lte()"),
}));

const mockGetCurrentUser = getCurrentUser as ReturnType<typeof vi.fn>;
const { Storage } = await import("@cap/web-backend");
const { invalidateGoogleDriveStorageQuotaCache } = await import(
	"@/lib/google-drive-storage-quota"
);
const { maybeStartLiveTranscription } = await import("@/lib/live-transcribe");
const { trackServerEvent } = await import("@/lib/server-analytics");

function resetMockDb() {
	for (const key of Object.keys(mockDb)) {
		const fn = mockDb[key as keyof typeof mockDb];
		if (typeof fn?.mockClear === "function") {
			fn.mockClear();
		}
	}
	mockDb.select.mockReturnValue(mockDb);
	mockDb.from.mockReturnValue(mockDb);
	mockDb.innerJoin.mockReturnValue(mockDb);
	mockDb.leftJoin.mockReturnValue(mockDb);
	mockDb.insert.mockReturnValue(mockDb);
	mockDb.values.mockResolvedValue([]);
	mockDb.update.mockReturnValue(mockDb);
	mockDb.set.mockReturnValue(mockDb);
	mockDb.where.mockResolvedValue([]);
	mockDb.for.mockResolvedValue([]);
	mockDb.limit.mockResolvedValue([]);
	mockDb.transaction.mockImplementation(
		async (fn: (tx: typeof mockDb) => unknown) => fn(mockDb),
	);
}

function insertedValues(table: unknown) {
	const index = mockDb.insert.mock.calls.findIndex(([t]) => t === table);
	if (index === -1) return undefined;
	return mockDb.values.mock.calls[index]?.[0] as
		| Record<string, unknown>
		| undefined;
}

function recordingTransactionFixture(rejectUpload: boolean) {
	type Row = Record<string, unknown>;
	type Rows = { videos: Map<string, Row>; uploads: Map<string, Row> };
	const committed: Rows = { videos: new Map(), uploads: new Map() };
	const transactionInserts: unknown[] = [];
	const directInserts: unknown[] = [];
	const insertInto = (rows: Rows, inserts: unknown[]) => (table: unknown) => {
		inserts.push(table);
		return {
			values: async (value: Row) => {
				if (table === schema.videoUploads && rejectUpload)
					throw new Error("Injected upload insert failure");
				const target =
					table === schema.videos
						? rows.videos
						: table === schema.videoUploads
							? rows.uploads
							: null;
				if (!target) throw new Error("Unexpected insert table");
				const id = String(table === schema.videos ? value.id : value.videoId);
				target.set(id, { ...value });
			},
		};
	};
	mockDb.insert.mockImplementation(insertInto(committed, directInserts));
	mockDb.transaction.mockImplementation(
		async (
			run: (tx: { insert: ReturnType<typeof insertInto> }) => Promise<unknown>,
		) => {
			const candidate: Rows = {
				videos: new Map(committed.videos),
				uploads: new Map(committed.uploads),
			};
			const result = await run({
				insert: insertInto(candidate, transactionInserts),
			});
			committed.videos = candidate.videos;
			committed.uploads = candidate.uploads;
			return result;
		},
	);
	return { committed, transactionInserts, directInserts };
}

function stubStorage() {
	const getOrganizationWritableAccess =
		Storage.getOrganizationWritableAccess as ReturnType<typeof vi.fn>;
	const getS3WritableAccessForUser =
		Storage.getS3WritableAccessForUser as ReturnType<typeof vi.fn>;
	getOrganizationWritableAccess.mockReturnValue(Effect.succeed(Option.none()));
	getS3WritableAccessForUser.mockReturnValue(
		Effect.succeed({
			bucketId: Option.some("bucket-1"),
			storageIntegrationId: Option.none(),
		}),
	);
}

describe("GET /new-id", () => {
	let app: typeof import("@/app/api/desktop/[...route]/video")["app"];

	beforeEach(async () => {
		vi.clearAllMocks();
		resetMockDb();
		stubStorage();
		mockGetCurrentUser.mockResolvedValue({
			id: "user-1",
			email: "[email protected]",
			defaultOrgId: "org-1",
			activeOrganizationId: "org-1",
		});
		const mod = await import("@/app/api/desktop/[...route]/video");
		app = mod.app;
	});

	it("allocates an ID without creating a video", async () => {
		const response = await app.request("https://cap.test/new-id");

		expect(response.status).toBe(200);
		expect(await response.json()).toEqual({
			id: expect.stringMatching(/^[0-9abcdefghjkmnpqrstvwxyz]{15}$/),
		});
		expect(mockDb.insert).not.toHaveBeenCalled();
	});
});

describe("DELETE /delete", () => {
	let app: typeof import("@/app/api/desktop/[...route]/video")["app"];
	const ownedVideo = {
		id: "video-1",
		ownerId: "user-1",
		storageIntegrationId: "drive-1",
	};

	beforeEach(async () => {
		vi.clearAllMocks();
		resetMockDb();
		mockGetCurrentUser.mockResolvedValue({
			id: "user-1",
			email: "[email protected]",
			activeOrganizationId: "org-1",
			image: null,
		});
		mockDb.where.mockResolvedValue([{ video: ownedVideo }]);
		deletion.deleteVideo
			.mockReset()
			.mockImplementation(() =>
				Effect.flatMap(CurrentUser, (principal) =>
					Effect.sync(() => deletion.principal(principal)),
				),
			);
		app = (await import("@/app/api/desktop/[...route]/video")).app;
	});

	it("delegates deletion under the authenticated principal and then invalidates quota", async () => {
		const response = await app.request(
			"https://cap.test/delete?videoId=video-1",
			{ method: "DELETE" },
		);
		expect(response.status).toBe(200);
		expect(await response.json()).toBe(true);
		expect(deletion.deleteVideo).toHaveBeenCalledExactlyOnceWith("video-1");
		expect(deletion.principal).toHaveBeenCalledWith({
			id: "user-1",
			email: "[email protected]",
			activeOrganizationId: "org-1",
			iconUrlOrKey: Option.none(),
		});
		expect(mockDb.delete).not.toHaveBeenCalled();
		expect(
			invalidateGoogleDriveStorageQuotaCache,
		).toHaveBeenCalledExactlyOnceWith("drive-1");
	});

	it("uses the desktop bearer principal without replacing it with a cookie session", async () => {
		mockGetCurrentUser.mockResolvedValue({ id: "cookie-user" });
		mockDb.where
			.mockResolvedValueOnce([
				{
					users: {
						id: "token-user",
						email: "[email protected]",
						activeOrganizationId: "token-org",
						image: null,
					},
				},
			])
			.mockResolvedValueOnce([
				{ video: { ...ownedVideo, ownerId: "token-user" } },
			]);
		const response = await app.request(
			"https://cap.test/delete?videoId=video-1",
			{
				method: "DELETE",
				headers: {
					Authorization: "Bearer 00000000-0000-4000-8000-000000000000",
				},
			},
		);
		expect(response.status).toBe(200);
		expect(mockGetCurrentUser).not.toHaveBeenCalled();
		expect(deletion.principal).toHaveBeenCalledWith(
			expect.objectContaining({
				id: "token-user",
				activeOrganizationId: "token-org",
			}),
		);
		expect(mockDb.delete).not.toHaveBeenCalled();
	});

	it("does not invalidate quota or return success before central deletion finishes", async () => {
		let release: (() => void) | undefined;
		const gate = new Promise<void>((resolve) => {
			release = resolve;
		});
		deletion.deleteVideo.mockReturnValue(Effect.promise(() => gate));
		const pending = app.request("https://cap.test/delete?videoId=video-1", {
			method: "DELETE",
		});
		await vi.waitFor(() =>
			expect(deletion.deleteVideo).toHaveBeenCalledTimes(1),
		);
		expect(invalidateGoogleDriveStorageQuotaCache).not.toHaveBeenCalled();
		if (!release) throw new Error("Missing central deletion resolver");
		release();
		const response = await pending;
		expect(response.status).toBe(200);
		expect(
			invalidateGoogleDriveStorageQuotaCache,
		).toHaveBeenCalledExactlyOnceWith("drive-1");
	});

	it("keeps the not-found response when no owned recording matches", async () => {
		mockDb.where.mockResolvedValue([]);
		const response = await app.request(
			"https://cap.test/delete?videoId=video-1",
			{ method: "DELETE" },
		);
		expect(response.status).toBe(404);
		expect(await response.json()).toEqual({
			error: true,
			message: "Video not found",
		});
		expect(deletion.deleteVideo).not.toHaveBeenCalled();
		expect(invalidateGoogleDriveStorageQuotaCache).not.toHaveBeenCalled();
	});

	it.each([
		{ reason: "missing", error: new Video.NotFoundError() },
		{ reason: "forbidden", error: new Policy.PolicyDeniedError() },
	])(
		"preserves 404 if the central service reports $reason after the preflight",
		async ({ error }) => {
			deletion.deleteVideo.mockReturnValue(Effect.fail(error));
			const response = await app.request(
				"https://cap.test/delete?videoId=video-1",
				{ method: "DELETE" },
			);
			expect(response.status).toBe(404);
			expect(await response.json()).toEqual({
				error: true,
				message: "Video not found",
			});
			expect(mockDb.delete).not.toHaveBeenCalled();
			expect(invalidateGoogleDriveStorageQuotaCache).not.toHaveBeenCalled();
		},
	);

	it("returns 500 without invalidating quota when central storage cleanup fails", async () => {
		deletion.deleteVideo.mockReturnValue(
			Effect.fail(
				new StorageDomain.StorageError({
					cause: new Error("Provider deletion failed"),
				}),
			),
		);
		const response = await app.request(
			"https://cap.test/delete?videoId=video-1",
			{ method: "DELETE" },
		);
		expect(response.status).toBe(500);
		expect(await response.json()).toEqual({ error: "Internal server error" });
		expect(mockDb.delete).not.toHaveBeenCalled();
		expect(invalidateGoogleDriveStorageQuotaCache).not.toHaveBeenCalled();
	});

	it("does not delegate an unauthenticated request", async () => {
		mockGetCurrentUser.mockResolvedValue(null);
		const response = await app.request(
			"https://cap.test/delete?videoId=video-1",
			{ method: "DELETE" },
		);
		expect(response.status).toBe(401);
		expect(deletion.deleteVideo).not.toHaveBeenCalled();
		expect(mockDb.select).not.toHaveBeenCalled();
	});

	it("rejects a missing recording id before deletion", async () => {
		const response = await app.request("https://cap.test/delete", {
			method: "DELETE",
		});
		expect(response.status).toBe(400);
		expect(deletion.deleteVideo).not.toHaveBeenCalled();
		expect(mockDb.delete).not.toHaveBeenCalled();
	});

	it("reports why the desktop app cleaned up an Instant start after deleting it", async () => {
		mockDb.where.mockResolvedValue([
			{ video: { ...ownedVideo, source: { type: "desktopSegments" } } },
		]);
		const response = await app.request(
			"https://cap.test/delete?videoId=video-1&reason=start-failed&cause=microphone",
			{
				method: "DELETE",
				headers: { "X-Cap-Desktop-Features": "googleDriveUpload,gpui" },
			},
		);
		expect(response.status).toBe(200);
		expect(await response.json()).toBe(true);
		expect(trackServerEvent).toHaveBeenCalledExactlyOnceWith(
			"user-1",
			"desktop_instant_cleanup",
			{
				reason: "start-failed",
				cause: "microphone",
				app: "gpui",
				sourceType: "desktopSegments",
			},
		);
	});

	it.each([
		"https://cap.test/delete?videoId=video-1",
		"https://cap.test/delete?videoId=video-1&reason=unknown&cause=microphone",
	])(
		"deletes without reporting when no known reason is sent: %s",
		async (url) => {
			const response = await app.request(url, { method: "DELETE" });
			expect(response.status).toBe(200);
			expect(await response.json()).toBe(true);
			expect(deletion.deleteVideo).toHaveBeenCalledExactlyOnceWith("video-1");
			expect(trackServerEvent).not.toHaveBeenCalled();
		},
	);

	it("drops an unknown cause and labels other desktop apps", async () => {
		const response = await app.request(
			"https://cap.test/delete?videoId=video-1&reason=interrupted&cause=../../etc",
			{ method: "DELETE" },
		);
		expect(response.status).toBe(200);
		expect(trackServerEvent).toHaveBeenCalledExactlyOnceWith(
			"user-1",
			"desktop_instant_cleanup",
			{ reason: "interrupted", cause: null, app: "desktop", sourceType: null },
		);
	});

	it("reports nothing when the deletion itself fails", async () => {
		deletion.deleteVideo.mockReturnValue(
			Effect.fail(
				new StorageDomain.StorageError({
					cause: new Error("Provider deletion failed"),
				}),
			),
		);
		const response = await app.request(
			"https://cap.test/delete?videoId=video-1&reason=start-failed",
			{ method: "DELETE" },
		);
		expect(response.status).toBe(500);
		expect(trackServerEvent).not.toHaveBeenCalled();
	});
});

describe("GET /create", () => {
	let app: typeof import("@/app/api/desktop/[...route]/video")["app"];

	beforeEach(async () => {
		vi.clearAllMocks();
		resetMockDb();
		stubStorage();
		defaultSharing.getNewVideoPublic.mockResolvedValue(true);
		const mod = await import("@/app/api/desktop/[...route]/video");
		app = mod.app;
	});

	it("provisions a personal org and creates the video there when the user has none", async () => {
		mockGetCurrentUser.mockResolvedValue({
			id: "user-1",
			email: "[email protected]",
			defaultOrgId: null,
			activeOrganizationId: "",
		});
		mockDb.where
			.mockResolvedValueOnce([])
			.mockResolvedValueOnce([])
			.mockResolvedValueOnce([])
			.mockResolvedValueOnce([{ count: 5 }]);

		const response = await app.request("https://cap.test/create");

		expect(response.status).toBe(200);
		expect(mockDb.transaction).toHaveBeenCalledTimes(2);

		const orgValues = insertedValues(schema.organizations) as
			| { id: string; ownerId: string; name: string }
			| undefined;
		expect(orgValues).toMatchObject({
			ownerId: "user-1",
			name: "My Organization",
		});

		expect(insertedValues(schema.organizationMembers)).toMatchObject({
			userId: "user-1",
			role: "owner",
			organizationId: orgValues?.id,
		});

		expect(mockDb.set).toHaveBeenCalledWith(
			expect.objectContaining({
				activeOrganizationId: orgValues?.id,
				defaultOrgId: orgValues?.id,
			}),
		);

		expect(insertedValues(schema.videos)).toMatchObject({
			orgId: orgValues?.id,
			ownerId: "user-1",
		});

		const body = await response.json();
		expect(body.id).toBeTruthy();
	});

	it("does not provision when the user already belongs to an org", async () => {
		mockGetCurrentUser.mockResolvedValue({
			id: "user-1",
			email: "[email protected]",
			defaultOrgId: "org-1",
			activeOrganizationId: "org-1",
		});
		mockDb.where
			.mockResolvedValueOnce([
				{ id: "org-1", name: "Acme", createdAt: new Date() },
			])
			.mockResolvedValueOnce([])
			.mockResolvedValueOnce([{ count: 5 }]);

		const response = await app.request("https://cap.test/create");

		expect(response.status).toBe(200);
		expect(mockDb.transaction).toHaveBeenCalledTimes(1);

		expect(insertedValues(schema.videos)).toMatchObject({
			orgId: "org-1",
			ownerId: "user-1",
		});
	});

	it("creates a private recording when the organization default resolves to private", async () => {
		defaultSharing.getNewVideoPublic.mockResolvedValue(false);
		mockGetCurrentUser.mockResolvedValue({
			id: "user-1",
			email: "[email protected]",
			defaultOrgId: "org-1",
			activeOrganizationId: "org-1",
		});
		mockDb.where
			.mockResolvedValueOnce([
				{ id: "org-1", name: "Acme", createdAt: new Date() },
			])
			.mockResolvedValueOnce([])
			.mockResolvedValueOnce([{ count: 5 }]);

		const response = await app.request("https://cap.test/create");

		expect(response.status).toBe(200);
		expect(defaultSharing.getNewVideoPublic).toHaveBeenCalledWith("org-1");
		expect(insertedValues(schema.videos)).toMatchObject({
			orgId: "org-1",
			public: false,
		});
	});

	it("heals a dangling defaultOrgId when the user has no remaining orgs", async () => {
		mockGetCurrentUser.mockResolvedValue({
			id: "user-1",
			email: "[email protected]",
			defaultOrgId: "org-stale",
			activeOrganizationId: "",
		});
		mockDb.where
			.mockResolvedValueOnce([])
			.mockResolvedValueOnce([])
			.mockResolvedValueOnce([])
			.mockResolvedValueOnce([])
			.mockResolvedValueOnce([{ count: 5 }]);

		const response = await app.request("https://cap.test/create");

		expect(response.status).toBe(200);
		expect(mockDb.transaction).toHaveBeenCalledTimes(2);

		const orgValues = insertedValues(schema.organizations) as
			| { id: string }
			| undefined;

		expect(insertedValues(schema.videos)).toMatchObject({
			orgId: orgValues?.id,
		});
	});

	it("routes a stale explicit orgId to the provisioned org when the user has none", async () => {
		mockGetCurrentUser.mockResolvedValue({
			id: "user-1",
			email: "[email protected]",
			defaultOrgId: "org-stale",
			activeOrganizationId: "",
		});
		mockDb.where
			.mockResolvedValueOnce([])
			.mockResolvedValueOnce([])
			.mockResolvedValueOnce([])
			.mockResolvedValueOnce([])
			.mockResolvedValueOnce([{ count: 5 }]);

		const response = await app.request(
			"https://cap.test/create?orgId=org-stale",
		);

		expect(response.status).toBe(200);
		expect(mockDb.transaction).toHaveBeenCalledTimes(2);

		const orgValues = insertedValues(schema.organizations) as
			| { id: string }
			| undefined;

		expect(insertedValues(schema.videos)).toMatchObject({
			orgId: orgValues?.id,
		});

		expect(mockDb.set).toHaveBeenCalledWith(
			expect.objectContaining({ defaultOrgId: orgValues?.id }),
		);
	});

	it("falls back to the default org when a stale explicit orgId is sent and the user still has orgs", async () => {
		mockGetCurrentUser.mockResolvedValue({
			id: "user-1",
			email: "[email protected]",
			defaultOrgId: "org-1",
			activeOrganizationId: "org-1",
		});
		mockDb.where
			.mockResolvedValueOnce([
				{ id: "org-1", name: "Acme", createdAt: new Date() },
			])
			.mockResolvedValueOnce([])
			.mockResolvedValueOnce([{ count: 5 }]);

		const response = await app.request(
			"https://cap.test/create?orgId=org-stale",
		);

		expect(response.status).toBe(200);
		expect(mockDb.transaction).toHaveBeenCalledTimes(1);

		expect(insertedValues(schema.videos)).toMatchObject({
			orgId: "org-1",
			ownerId: "user-1",
		});
	});

	it("honours an explicit orgId the user belongs to", async () => {
		mockGetCurrentUser.mockResolvedValue({
			id: "user-1",
			email: "[email protected]",
			defaultOrgId: "org-1",
			activeOrganizationId: "org-1",
		});
		mockDb.where
			.mockResolvedValueOnce([
				{ id: "org-1", name: "Acme", createdAt: new Date() },
			])
			.mockResolvedValueOnce([
				{ id: "org-2", name: "Team", createdAt: new Date() },
			])
			.mockResolvedValueOnce([{ count: 5 }]);

		const response = await app.request("https://cap.test/create?orgId=org-2");

		expect(response.status).toBe(200);
		expect(mockDb.transaction).toHaveBeenCalledTimes(1);

		expect(insertedValues(schema.videos)).toMatchObject({
			orgId: "org-2",
			ownerId: "user-1",
		});
	});

	it("creates a missing video with an explicitly reserved ID", async () => {
		mockGetCurrentUser.mockResolvedValue({
			id: "user-1",
			email: "[email protected]",
			defaultOrgId: "org-1",
			activeOrganizationId: "org-1",
		});
		mockDb.where
			.mockResolvedValueOnce([])
			.mockResolvedValueOnce([
				{ id: "org-1", name: "Acme", createdAt: new Date() },
			])
			.mockResolvedValueOnce([])
			.mockResolvedValueOnce([{ count: 5 }]);

		const response = await app.request(
			"https://cap.test/create?videoId=0123456789abcde&createWithId=true",
		);

		expect(response.status).toBe(200);
		expect(insertedValues(schema.videos)).toMatchObject({
			id: "0123456789abcde",
			ownerId: "user-1",
		});
		expect(await response.json()).toMatchObject({ id: "0123456789abcde" });
	});

	it("commits a progress-capable recording and its upload row in one transaction", async () => {
		mockGetCurrentUser.mockResolvedValue({
			id: "fixture-user",
			email: "[email protected]",
			defaultOrgId: "fixture-org",
			activeOrganizationId: "fixture-org",
		});
		mockDb.where
			.mockResolvedValueOnce([
				{
					id: "fixture-org",
					name: "Fixture organization",
					createdAt: new Date("2026-01-01T00:00:00.000Z"),
				},
			])
			.mockResolvedValueOnce([]);
		const fixture = recordingTransactionFixture(false);

		const response = await app.request(
			"https://cap.test/create?recordingMode=desktopMP4",
			{ headers: { "X-Cap-Desktop-Version": "0.3.68" } },
		);

		expect(response.status).toBe(200);
		expect(mockDb.transaction).toHaveBeenCalledTimes(1);
		expect(fixture.transactionInserts).toEqual([
			schema.videos,
			schema.videoUploads,
		]);
		expect(fixture.directInserts).toEqual([]);
		const body = await response.json();
		expect(fixture.committed.videos.get(body.id)).toMatchObject({
			id: body.id,
			ownerId: "fixture-user",
			orgId: "fixture-org",
		});
		expect(fixture.committed.uploads.get(body.id)).toMatchObject({
			videoId: body.id,
			mode: "singlepart",
		});
	});

	it("rolls back a recording and skips transcription when its upload insert fails", async () => {
		mockGetCurrentUser.mockResolvedValue({
			id: "fixture-user",
			email: "[email protected]",
			defaultOrgId: "fixture-org",
			activeOrganizationId: "fixture-org",
		});
		mockDb.where
			.mockResolvedValueOnce([
				{
					id: "fixture-org",
					name: "Fixture organization",
					createdAt: new Date("2026-01-01T00:00:00.000Z"),
				},
			])
			.mockResolvedValueOnce([]);
		const fixture = recordingTransactionFixture(true);
		vi.spyOn(console, "error").mockImplementation(() => undefined);

		const response = await app.request(
			"https://cap.test/create?recordingMode=desktopSegments",
			{ headers: { "X-Cap-Desktop-Version": "0.3.68" } },
		);

		expect(response.status).toBe(500);
		expect(mockDb.transaction).toHaveBeenCalledTimes(1);
		expect(fixture.transactionInserts).toEqual([
			schema.videos,
			schema.videoUploads,
		]);
		expect(fixture.directInserts).toEqual([]);
		expect(fixture.committed.videos.size).toBe(0);
		expect(fixture.committed.uploads.size).toBe(0);
		expect(maybeStartLiveTranscription).not.toHaveBeenCalled();
	});

	it("rejects an invalid client-selected video ID", async () => {
		mockGetCurrentUser.mockResolvedValue({
			id: "user-1",
			email: "[email protected]",
			defaultOrgId: "org-1",
			activeOrganizationId: "org-1",
		});

		const response = await app.request(
			"https://cap.test/create?videoId=not-valid&createWithId=true",
		);

		expect(response.status).toBe(400);
		expect(await response.json()).toEqual({ error: "invalid_video_id" });
		expect(mockDb.insert).not.toHaveBeenCalled();
	});
});