Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

11.8 KB
Raw Blame
import { Folder, Organisation, User, Video } from "@cap/web-domain";
import { Effect, Option } from "effect";
import { beforeEach, describe, expect, it, vi } from "vitest";
import {
	type CreateVideoInput,
	VideosRepo,
} from "../../../../packages/web-backend/src/Videos/VideosRepo";

type Row = Record<string, unknown>;
type Predicate = (row: Row) => boolean;
type Store = {
	videos: Map<string, Row>;
	uploads: Map<string, Row>;
	folders: Map<string, Row>;
};

const mocks = vi.hoisted(() => ({
	store: {
		videos: new Map<string, Row>(),
		uploads: new Map<string, Row>(),
		folders: new Map<string, Row>(),
	} as Store,
	rejectUpload: false,
	transactionCalls: 0,
	currentUser: vi.fn(),
	organizationAccess: vi.fn(),
	createUploadTargetForUser: vi.fn(),
	createUploadTargetForVideo: vi.fn(),
	revalidatePath: vi.fn(),
}));

vi.mock("@cap/database", () => {
	type Table = { name: "video" | "upload" | "folder" };
	type Client = {
		insert: (table: Table) => { values: (row: Row | Row[]) => Promise<void> };
		select: () => {
			from: (table: Table) => {
				where: (predicate: Predicate) => Promise<Row[]>;
			};
		};
		transaction: (run: (tx: Client) => Promise<unknown>) => Promise<unknown>;
	};

	function makeClient(store: Store): Client {
		return {
			insert: (table) => ({
				values: async (value) => {
					if (table.name === "upload" && mocks.rejectUpload)
						throw new Error("Injected upload insert failure");
					const rows = table.name === "video" ? store.videos : store.uploads;
					for (const row of Array.isArray(value) ? value : [value]) {
						const key = String(table.name === "video" ? row.id : row.videoId);
						rows.set(key, { ...row });
					}
				},
			}),
			select: () => ({
				from: (table) => ({
					where: async (predicate) => {
						const rows = table.name === "folder" ? store.folders : store.videos;
						return [...rows.values()].filter(predicate);
					},
				}),
			}),
			transaction: async (run) => {
				mocks.transactionCalls += 1;
				const candidate = {
					videos: new Map(store.videos),
					uploads: new Map(store.uploads),
					folders: new Map(store.folders),
				};
				const result = await run(makeClient(candidate));
				mocks.store = candidate;
				return result;
			},
		};
	}

	return { db: () => makeClient(mocks.store) };
});

vi.mock("@cap/database/auth/session", () => ({
	getCurrentUser: mocks.currentUser,
}));
vi.mock("@cap/database/helpers", () => ({ nanoId: () => "fixture-video" }));
vi.mock("@cap/database/schema", () => ({
	videos: { name: "video", id: "id" },
	folders: {
		name: "folder",
		id: "id",
		organizationId: "organizationId",
		createdById: "createdById",
		spaceId: "spaceId",
	},
	videoUploads: { name: "upload", videoId: "videoId" },
}));
// The real lookup reads `organizations`, which this transaction mock does not
// model; visibility is not what these tests are about.
vi.mock("@cap/database/video-sharing-default", () => ({
	getNewVideoPublic: async () => true,
}));
vi.mock("@cap/env", () => ({
	serverEnv: () => ({ CAP_VIDEOS_DEFAULT_PUBLIC: true }),
}));
vi.mock("@cap/utils", () => ({ userIsPro: () => true }));
vi.mock("@cap/web-backend", () => ({
	Storage: {
		createUploadTargetForUser: mocks.createUploadTargetForUser,
		createUploadTargetForVideo: mocks.createUploadTargetForVideo,
	},
}));
vi.mock("@/actions/organization/authorization", () => ({
	requireOrganizationAccess: mocks.organizationAccess,
}));
vi.mock("@/lib/server", async () => ({
	runPromise: (await import("effect")).Effect.runPromise,
}));
vi.mock("next/cache", () => ({ revalidatePath: mocks.revalidatePath }));
vi.mock("drizzle-orm", () => ({
	eq:
		(field: string, value: unknown): Predicate =>
		(row) =>
			row[field] === value,
	and:
		(...predicates: Predicate[]): Predicate =>
		(row) =>
			predicates.every((predicate) => predicate(row)),
	isNull:
		(field: string): Predicate =>
		(row) =>
			row[field] === null,
}));

import { createVideoForServerProcessing } from "@/actions/video/create-for-processing";
import { createVideoAndGetUploadUrl } from "@/actions/video/upload";

const orgId = Organisation.OrganisationId.make("fixture-org");
const uploadTarget = {
	type: "s3Post" as const,
	url: "https://uploads.example.com/fixture",
	fields: {},
};
const repoCreateData: CreateVideoInput = {
	ownerId: User.UserId.make("fixture-user"),
	orgId,
	name: "Fixture recording",
	public: true,
	source: { type: "webMP4" },
	bucketId: Option.none(),
	storageIntegrationId: Option.none(),
	folderId: Option.none(),
	metadata: Option.none(),
	transcriptionStatus: Option.none(),
	width: Option.none(),
	height: Option.none(),
	duration: Option.none(),
};

function createRepoVideo(initialUpload?: {
	mode: "singlepart";
	total?: number;
}) {
	return Effect.runPromise(
		Effect.flatMap(VideosRepo, (repo) =>
			repo.create(repoCreateData, {
				id: Video.VideoId.make("fixture-video"),
				initialUpload,
			}),
		).pipe(Effect.provide(VideosRepo.Default)),
	);
}

beforeEach(() => {
	mocks.store = { videos: new Map(), uploads: new Map(), folders: new Map() };
	mocks.rejectUpload = false;
	mocks.transactionCalls = 0;
	mocks.currentUser.mockResolvedValue({ id: "fixture-user" });
	mocks.organizationAccess.mockResolvedValue(undefined);
	mocks.createUploadTargetForUser.mockReturnValue(
		Effect.succeed({
			bucketId: Option.none(),
			storageIntegrationId: Option.none(),
			upload: uploadTarget,
		}),
	);
	mocks.createUploadTargetForVideo.mockReturnValue(
		Effect.succeed(uploadTarget),
	);
	vi.spyOn(console, "error").mockImplementation(() => undefined);
});

function expectCommittedPair() {
	expect(mocks.transactionCalls).toBe(1);
	expect(mocks.store.videos.size).toBe(1);
	expect(mocks.store.uploads.size).toBe(1);
	const video = [...mocks.store.videos.values()][0];
	const upload = [...mocks.store.uploads.values()][0];
	expect(upload?.videoId).toBe(video?.id);
	expect(mocks.revalidatePath.mock.calls.map(([path]) => path)).toEqual([
		"/dashboard/caps",
		"/dashboard/folder",
		"/dashboard/spaces",
	]);
}

describe("video creation with upload progress", () => {
	it("does not sign or change a recording owned by another user", async () => {
		const videoId = Video.VideoId.make("fixture-video");
		const existingVideo = { id: videoId, ownerId: "other-fixture-user" };
		mocks.store.videos.set(videoId, existingVideo);
		await expect(
			createVideoAndGetUploadUrl({
				orgId,
				videoId,
				supportsUploadProgress: true,
			}),
		).rejects.toThrow("Forbidden");
		expect(mocks.store.videos.get(videoId)).toEqual(existingVideo);
		expect(mocks.store.uploads.size).toBe(0);
		expect(mocks.transactionCalls).toBe(0);
		expect(mocks.createUploadTargetForVideo).not.toHaveBeenCalled();
		expect(mocks.revalidatePath).not.toHaveBeenCalled();
	});

	it("rolls back a recording when the progress insert fails", async () => {
		mocks.rejectUpload = true;
		await expect(
			createVideoAndGetUploadUrl({ orgId, supportsUploadProgress: true }),
		).rejects.toThrow("Injected upload insert failure");
		expect(mocks.transactionCalls).toBe(1);
		expect(mocks.store.videos.size).toBe(0);
		expect(mocks.store.uploads.size).toBe(0);
		expect(mocks.revalidatePath).not.toHaveBeenCalled();
	});

	it("commits a recording and its progress row together", async () => {
		const result = await createVideoAndGetUploadUrl({
			orgId,
			supportsUploadProgress: true,
		});
		expect(result.id).toBe("fixture-video");
		expectCommittedPair();
	});

	it("creates only a recording when progress is disabled", async () => {
		const result = await createVideoAndGetUploadUrl({ orgId });
		expect(result.id).toBe("fixture-video");
		expect(mocks.transactionCalls).toBe(1);
		expect(mocks.store.videos.size).toBe(1);
		expect(mocks.store.uploads.size).toBe(0);
		expect(mocks.revalidatePath).toHaveBeenCalledTimes(3);
	});
});

describe("video creation for server processing", () => {
	it("rolls back a video when the progress insert fails", async () => {
		mocks.rejectUpload = true;
		await expect(createVideoForServerProcessing({ orgId })).rejects.toThrow(
			"Injected upload insert failure",
		);
		expect(mocks.transactionCalls).toBe(1);
		expect(mocks.store.videos.size).toBe(0);
		expect(mocks.store.uploads.size).toBe(0);
		expect(mocks.revalidatePath).not.toHaveBeenCalled();
	});

	it("commits the video and its raw upload metadata together", async () => {
		const result = await createVideoForServerProcessing({ orgId });
		expect(result.id).toBe("fixture-video");
		expectCommittedPair();
		const upload = [...mocks.store.uploads.values()][0];
		expect(upload).toMatchObject({
			mode: "singlepart",
			phase: "uploading",
			processingProgress: 0,
			rawFileKey: "fixture-user/fixture-video/raw-upload.mp4",
		});
	});
});

describe("VideosRepo.create", () => {
	it("commits a video and optional upload row together", async () => {
		const id = await createRepoVideo({ mode: "singlepart", total: 123 });
		expect(id).toBe("fixture-video");
		expect(mocks.transactionCalls).toBe(1);
		expect(mocks.store.videos.get(id)).toMatchObject({
			id,
			ownerId: "fixture-user",
			orgId,
		});
		expect(mocks.store.uploads.get(id)).toMatchObject({
			videoId: id,
			mode: "singlepart",
			total: 123,
		});
		expect(mocks.revalidatePath).not.toHaveBeenCalled();
	});

	it("rolls back a video if its optional upload insert fails", async () => {
		mocks.rejectUpload = true;
		await expect(createRepoVideo({ mode: "singlepart" })).rejects.toThrow(
			"Injected upload insert failure",
		);
		expect(mocks.transactionCalls).toBe(1);
		expect(mocks.store.videos.size).toBe(0);
		expect(mocks.store.uploads.size).toBe(0);
	});

	it("commits a video without an upload row when progress is disabled", async () => {
		const id = await createRepoVideo();
		expect(id).toBe("fixture-video");
		expect(mocks.transactionCalls).toBe(1);
		expect(mocks.store.videos.get(id)?.id).toBe(id);
		expect(mocks.store.uploads.size).toBe(0);
	});
});

describe.each([
	{
		name: "video file import",
		create: (folderId?: Folder.FolderId) =>
			createVideoForServerProcessing({ orgId, folderId }),
	},
	{
		name: "image file import",
		create: (folderId?: Folder.FolderId) =>
			createVideoAndGetUploadUrl({
				orgId,
				folderId,
				isUpload: true,
				isScreenshot: true,
			}),
	},
])("$name destination", ({ create }) => {
	const folderId = Folder.FolderId.make("fixture-folder");
	const personalFolder = {
		id: folderId,
		organizationId: orgId,
		createdById: "fixture-user",
		spaceId: null,
	};

	it.each([
		{ name: "missing folder", folder: undefined },
		{
			name: "a different folder",
			folder: { ...personalFolder, id: "different-folder" },
		},
		{
			name: "another user's personal folder",
			folder: { ...personalFolder, createdById: "other-user" },
		},
		{
			name: "own folder in another organization",
			folder: { ...personalFolder, organizationId: "other-org" },
		},
		{
			name: "space folder",
			folder: { ...personalFolder, spaceId: "fixture-space" },
		},
		{
			name: "organization folder",
			folder: { ...personalFolder, spaceId: orgId },
		},
	])(
		"rejects $name before signing or creating an upload",
		async ({ folder }) => {
			if (folder) mocks.store.folders.set(folderId, folder);

			await expect(create(folderId)).rejects.toThrow("Folder not found");

			expect(mocks.createUploadTargetForUser).not.toHaveBeenCalled();
			expect(mocks.store.videos.size).toBe(0);
			expect(mocks.store.uploads.size).toBe(0);
			expect(mocks.transactionCalls).toBe(0);
			expect(mocks.revalidatePath).not.toHaveBeenCalled();
		},
	);

	it("accepts an owned personal folder in the selected organization", async () => {
		mocks.store.folders.set(folderId, personalFolder);

		const result = await create(folderId);

		expect(mocks.store.videos.get(result.id)?.folderId).toBe(folderId);
		expect(mocks.createUploadTargetForUser).toHaveBeenCalledOnce();
	});

	it("accepts an import without a folder", async () => {
		const result = await create();

		expect(mocks.store.videos.get(result.id)?.folderId).toBeUndefined();
		expect(mocks.createUploadTargetForUser).toHaveBeenCalledOnce();
	});
});