Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

test: cover Loom concierge migration against MySQL and S3

Richie McIlroyd5e6a5d37b9c
diff --git a/apps/web/__tests__/integration/loom-concierge-database.test.ts b/apps/web/__tests__/integration/loom-concierge-database.test.ts
new file mode 100644
index 000000000..ae8f4fe55
--- /dev/null
+++ b/apps/web/__tests__/integration/loom-concierge-database.test.ts
@@ -0,0 +1,843 @@
+import { randomUUID } from "node:crypto";
+import { db } from "@cap/database";
+import {
+ importedVideos,
+ loomMigrationImports,
+ loomMigrationRequests,
+ organizationMembers,
+ organizations,
+ users,
+ videos,
+ videoUploads,
+} from "@cap/database/schema";
+import { Organisation, User, Video } from "@cap/web-domain";
+import { eq } from "drizzle-orm";
+import {
+ afterAll,
+ beforeAll,
+ beforeEach,
+ describe,
+ expect,
+ it,
+ vi,
+} from "vitest";
+import {
+ type LoomMigrationResult,
+ unwrapLoomMigrationResult,
+} from "@/lib/loom-migration-state";
+
+const databaseUrl = process.env.CAP_LOOM_CONCIERGE_TEST_DATABASE_URL;
+
+const fixture = vi.hoisted(() => {
+ const url = process.env.CAP_LOOM_CONCIERGE_TEST_DATABASE_URL;
+ if (url) process.env.DATABASE_URL = url;
+ return {
+ currentUserId: null as string | null,
+ sendEmail: vi.fn(async (_input: unknown) => ({})),
+ start: vi.fn(async (_workflow: unknown, _args: unknown) => ({
+ runId: "run_fixture",
+ })),
+ };
+});
+
+vi.mock("server-only", () => ({}));
+vi.mock("next/cache", () => ({ revalidatePath: vi.fn() }));
+vi.mock("next/headers", () => ({
+ cookies: async () => ({ get: () => undefined }),
+ headers: async () => new Headers(),
+}));
+vi.mock("workflow/api", () => ({ start: fixture.start }));
+vi.mock("@cap/database/emails/config", () => ({
+ sendEmail: fixture.sendEmail,
+}));
+vi.mock("@cap/database/auth/session", () => ({
+ getCurrentUser: async () => {
+ if (!fixture.currentUserId) return null;
+ const [user] = await db()
+ .select()
+ .from(users)
+ .where(eq(users.id, User.UserId.make(fixture.currentUserId)))
+ .limit(1);
+ return user ?? null;
+ },
+}));
+
+const OPERATOR_EMAIL = "[email protected]";
+const realFetch = globalThis.fetch;
+
+function id() {
+ return randomUUID().replaceAll("-", "").slice(0, 15);
+}
+
+function loomId() {
+ return randomUUID().replaceAll("-", "");
+}
+
+function unwrapped<Args extends unknown[], T>(
+ action: (...args: Args) => Promise<LoomMigrationResult<T>>,
+) {
+ return async (...args: Args) =>
+ unwrapLoomMigrationResult(await action(...args));
+}
+
+function signInAs(userId: string | null) {
+ fixture.currentUserId = userId;
+}
+
+async function makeUser({
+ email = `${id()}@example.com`,
+ pro = false,
+ activeOrganizationId = Organisation.OrganisationId.make(id()),
+}: {
+ email?: string;
+ pro?: boolean;
+ activeOrganizationId?: Organisation.OrganisationId;
+} = {}) {
+ const userId = User.UserId.make(id());
+ await db()
+ .insert(users)
+ .values({
+ id: userId,
+ email,
+ activeOrganizationId,
+ stripeSubscriptionStatus: pro ? "active" : null,
+ stripeSubscriptionId: pro ? `sub_fixture_${id()}` : null,
+ });
+ return userId;
+}
+
+async function makeOrganization({
+ pro = true,
+ privateByDefault = false,
+}: {
+ pro?: boolean;
+ privateByDefault?: boolean;
+} = {}) {
+ const organizationId = Organisation.OrganisationId.make(id());
+ const ownerId = await makeUser({ pro, activeOrganizationId: organizationId });
+ await db()
+ .insert(organizations)
+ .values({
+ id: organizationId,
+ ownerId,
+ name: "Concierge fixture",
+ defaultVideoVisibility: privateByDefault ? "private" : null,
+ });
+ await db().insert(organizationMembers).values({
+ id: id(),
+ userId: ownerId,
+ organizationId,
+ role: "owner",
+ });
+ return { ownerId, organizationId };
+}
+
+async function addMember(
+ organizationId: Organisation.OrganisationId,
+ role: "member" | "admin",
+) {
+ const userId = await makeUser();
+ await db().insert(organizationMembers).values({
+ id: id(),
+ userId,
+ organizationId,
+ role,
+ });
+ return userId;
+}
+
+async function getOperatorId() {
+ const [existing] = await db()
+ .select({ id: users.id })
+ .from(users)
+ .where(eq(users.email, OPERATOR_EMAIL))
+ .limit(1);
+ return existing?.id ?? (await makeUser({ email: OPERATOR_EMAIL }));
+}
+
+async function getRequest(requestId: string) {
+ const [request] = await db()
+ .select()
+ .from(loomMigrationRequests)
+ .where(eq(loomMigrationRequests.id, requestId))
+ .limit(1);
+ if (!request) throw new Error("Missing request fixture");
+ return request;
+}
+
+async function setUploadPhase(
+ videoId: string,
+ phase: "uploading" | "processing" | "complete" | "error",
+) {
+ await db()
+ .update(videoUploads)
+ .set({ phase })
+ .where(eq(videoUploads.videoId, Video.VideoId.make(videoId)));
+}
+
+function stubLoomFetch() {
+ vi.stubGlobal(
+ "fetch",
+ vi.fn(async (input: RequestInfo | URL, init?: RequestInit) => {
+ const url = typeof input === "string" ? input : input.toString();
+ if (url.includes("/transcoded-url") || url.includes("/raw-url")) {
+ return new Response(
+ JSON.stringify({ url: "https://cdn.loom.com/sessions/video.mp4" }),
+ { status: 200 },
+ );
+ }
+ if (url.startsWith("https://www.loom.com/graphql")) {
+ return Response.json({ data: { getVideo: { name: "Loom fixture" } } });
+ }
+ if (url.startsWith("https://www.loom.com/v1/oembed")) {
+ return Response.json({ duration: 12, width: 1280, height: 720 });
+ }
+ return realFetch(input, init);
+ }),
+ );
+}
+
+describe.skipIf(!databaseUrl)("Loom concierge migration database", () => {
+ let rawActions: typeof import("@/actions/loom-concierge");
+ let rawLoom: typeof import("@/actions/loom");
+ let operatorId: User.UserId;
+
+ const actions = {
+ getLoomMigrationDashboard: (
+ ...args: Parameters<typeof rawActions.getLoomMigrationDashboard>
+ ) => rawActions.getLoomMigrationDashboard(...args),
+ getLoomMigrationOperatorQueue: () =>
+ rawActions.getLoomMigrationOperatorQueue(),
+ requestLoomMigration: unwrapped(
+ (...args: Parameters<typeof rawActions.requestLoomMigration>) =>
+ rawActions.requestLoomMigration(...args),
+ ),
+ confirmLoomMigrationInvite: unwrapped((requestId: string) =>
+ rawActions.confirmLoomMigrationInvite(requestId),
+ ),
+ answerLoomMigrationQuestion: unwrapped(
+ (...args: Parameters<typeof rawActions.answerLoomMigrationQuestion>) =>
+ rawActions.answerLoomMigrationQuestion(...args),
+ ),
+ updateLoomMigrationStatus: unwrapped(
+ (...args: Parameters<typeof rawActions.updateLoomMigrationStatus>) =>
+ rawActions.updateLoomMigrationStatus(...args),
+ ),
+ };
+ const loom = {
+ importFromLoomCsvForConcierge: unwrapped(
+ (...args: Parameters<typeof rawLoom.importFromLoomCsvForConcierge>) =>
+ rawLoom.importFromLoomCsvForConcierge(...args),
+ ),
+ createConciergeLoomFileUpload: unwrapped(
+ (...args: Parameters<typeof rawLoom.createConciergeLoomFileUpload>) =>
+ rawLoom.createConciergeLoomFileUpload(...args),
+ ),
+ finishConciergeLoomFileUpload: unwrapped(
+ (...args: Parameters<typeof rawLoom.finishConciergeLoomFileUpload>) =>
+ rawLoom.finishConciergeLoomFileUpload(...args),
+ ),
+ };
+
+ beforeAll(async () => {
+ rawActions = await import("@/actions/loom-concierge");
+ rawLoom = await import("@/actions/loom");
+ operatorId = await getOperatorId();
+ });
+
+ beforeEach(() => {
+ signInAs(null);
+ stubLoomFetch();
+ });
+
+ afterAll(() => {
+ vi.unstubAllGlobals();
+ });
+
+ async function requestMigration(
+ organizationId: Organisation.OrganisationId,
+ ownerId: User.UserId,
+ ) {
+ signInAs(ownerId);
+ const result = await actions.requestLoomMigration({
+ organizationId,
+ workspaceName: " Acme Loom ",
+ note: "Two workspaces",
+ });
+ return result.id;
+ }
+
+ it("lets a Pro organization manager request one active migration", async () => {
+ const { ownerId, organizationId } = await makeOrganization();
+ signInAs(ownerId);
+ const first = await actions.requestLoomMigration({
+ organizationId,
+ workspaceName: " Acme Loom ",
+ note: "",
+ });
+ const second = await actions.requestLoomMigration({
+ organizationId,
+ workspaceName: "Again",
+ note: "",
+ });
+
+ expect(first.alreadyRequested).toBe(false);
+ expect(second).toEqual({ id: first.id, alreadyRequested: true });
+ const request = await getRequest(first.id);
+ expect(request.workspaceName).toBe("Acme Loom");
+ expect(request.status).toBe("pending");
+ expect(request.activeOrganizationId).toBe(organizationId);
+ expect(fixture.sendEmail).toHaveBeenCalledTimes(1);
+ expect(fixture.sendEmail.mock.calls[0]?.[0]).toMatchObject({
+ email: "[email protected]",
+ });
+
+ const dashboard = await actions.getLoomMigrationDashboard(organizationId);
+ expect(dashboard.isPro).toBe(true);
+ expect(dashboard.requests.map((item) => item.id)).toEqual([first.id]);
+ });
+
+ it("rejects free organizations, members, outsiders, and signed-out users", async () => {
+ const free = await makeOrganization({ pro: false });
+ signInAs(free.ownerId);
+ await expect(
+ actions.requestLoomMigration({
+ organizationId: free.organizationId,
+ workspaceName: "",
+ note: "",
+ }),
+ ).rejects.toThrow("requires Cap Pro");
+
+ const { ownerId, organizationId } = await makeOrganization();
+ const requestId = await requestMigration(organizationId, ownerId);
+
+ const member = await addMember(organizationId, "member");
+ signInAs(member);
+ await expect(
+ actions.getLoomMigrationDashboard(organizationId),
+ ).rejects.toThrow();
+ await expect(
+ actions.confirmLoomMigrationInvite(requestId),
+ ).rejects.toThrow();
+
+ const outsider = await makeOrganization();
+ signInAs(outsider.ownerId);
+ await expect(
+ actions.getLoomMigrationDashboard(organizationId),
+ ).rejects.toThrow();
+ await expect(
+ actions.confirmLoomMigrationInvite(requestId),
+ ).rejects.toThrow();
+ await expect(
+ actions.answerLoomMigrationQuestion({ requestId, answer: "hi" }),
+ ).rejects.toThrow();
+
+ signInAs(null);
+ await expect(actions.confirmLoomMigrationInvite(requestId)).rejects.toThrow(
+ "Unauthorized",
+ );
+
+ const admin = await addMember(organizationId, "admin");
+ signInAs(admin);
+ await actions.confirmLoomMigrationInvite(requestId);
+ expect((await getRequest(requestId)).invitedAt).not.toBeNull();
+ });
+
+ it("limits every operator action to the Cap operator account", async () => {
+ const { ownerId, organizationId } = await makeOrganization();
+ const requestId = await requestMigration(organizationId, ownerId);
+
+ signInAs(ownerId);
+ await expect(actions.getLoomMigrationOperatorQueue()).rejects.toThrow(
+ "Unauthorized",
+ );
+ await expect(
+ actions.updateLoomMigrationStatus({
+ requestId,
+ nextStatus: "in_progress",
+ message: "",
+ verified: false,
+ expectedVideoCount: null,
+ importedVideoCount: 0,
+ }),
+ ).rejects.toThrow("Unauthorized");
+ await expect(
+ loom.importFromLoomCsvForConcierge({ requestId, rows: [] }),
+ ).rejects.toThrow("Unauthorized");
+ await expect(
+ loom.createConciergeLoomFileUpload({
+ requestId,
+ loomUrl: `https://www.loom.com/share/${loomId()}`,
+ userEmail: "[email protected]",
+ spaceName: "",
+ videoTitle: "Title",
+ }),
+ ).rejects.toThrow("Unauthorized");
+ await expect(
+ loom.finishConciergeLoomFileUpload({
+ requestId,
+ videoId: Video.VideoId.make(id()),
+ }),
+ ).rejects.toThrow("Unauthorized");
+
+ signInAs(operatorId);
+ const queue = await actions.getLoomMigrationOperatorQueue();
+ expect(queue.find((item) => item.id === requestId)).toMatchObject({
+ organizationName: "Concierge fixture",
+ status: "pending",
+ });
+ });
+
+ it("returns expected failures as data so production clients can show them", async () => {
+ const { ownerId, organizationId } = await makeOrganization();
+ const requestId = await requestMigration(organizationId, ownerId);
+
+ signInAs(operatorId);
+ await expect(
+ rawActions.updateLoomMigrationStatus({
+ requestId,
+ nextStatus: "completed",
+ message: "",
+ verified: false,
+ expectedVideoCount: 1,
+ importedVideoCount: 1,
+ }),
+ ).resolves.toEqual({
+ ok: false,
+ error: "Verify the migrated library before marking it complete.",
+ });
+ await expect(
+ rawLoom.finishConciergeLoomFileUpload({
+ requestId: "not-a-request",
+ videoId: Video.VideoId.make(id()),
+ }),
+ ).resolves.toEqual({ ok: false, error: "Invalid migration request." });
+
+ signInAs(ownerId);
+ await expect(
+ rawLoom.importFromLoomCsvForConcierge({ requestId, rows: [] }),
+ ).resolves.toEqual({ ok: false, error: "Unauthorized" });
+ });
+
+ it("keeps an open customer question while imports run and only emails visible changes", async () => {
+ const { ownerId, organizationId } = await makeOrganization();
+ const requestId = await requestMigration(organizationId, ownerId);
+
+ signInAs(operatorId);
+ await actions.updateLoomMigrationStatus({
+ requestId,
+ nextStatus: "needs_information",
+ message: "Please share the Sales folder",
+ verified: false,
+ expectedVideoCount: null,
+ importedVideoCount: 0,
+ });
+ await loom.importFromLoomCsvForConcierge({
+ requestId,
+ rows: [
+ {
+ rowNumber: 2,
+ loomUrl: `https://www.loom.com/share/${loomId()}`,
+ userEmail: `${id()}@example.com`,
+ spaceName: "",
+ },
+ ],
+ });
+ expect((await getRequest(requestId)).status).toBe("needs_information");
+
+ fixture.sendEmail.mockClear();
+ await actions.updateLoomMigrationStatus({
+ requestId,
+ nextStatus: "needs_information",
+ message: "Please share the Sales folder",
+ verified: false,
+ expectedVideoCount: 5,
+ importedVideoCount: 1,
+ });
+ expect(fixture.sendEmail).not.toHaveBeenCalled();
+ expect((await getRequest(requestId)).expectedVideoCount).toBe(5);
+
+ signInAs(ownerId);
+ await actions.answerLoomMigrationQuestion({
+ requestId,
+ answer: "Shared it",
+ });
+ expect((await getRequest(requestId)).status).toBe("pending");
+ });
+
+ it("round-trips an information request with the customer", async () => {
+ const { ownerId, organizationId } = await makeOrganization();
+ const requestId = await requestMigration(organizationId, ownerId);
+
+ signInAs(operatorId);
+ await expect(
+ actions.updateLoomMigrationStatus({
+ requestId,
+ nextStatus: "needs_information",
+ message: " ",
+ verified: false,
+ expectedVideoCount: null,
+ importedVideoCount: 0,
+ }),
+ ).rejects.toThrow("what information you need");
+ await actions.updateLoomMigrationStatus({
+ requestId,
+ nextStatus: "needs_information",
+ message: "Which Loom workspace?",
+ verified: false,
+ expectedVideoCount: null,
+ importedVideoCount: 0,
+ });
+
+ signInAs(ownerId);
+ await actions.answerLoomMigrationQuestion({
+ requestId,
+ answer: "The Acme one",
+ });
+ const answered = await getRequest(requestId);
+ expect(answered.status).toBe("pending");
+ expect(answered.customerReply).toBe("The Acme one");
+ await expect(
+ actions.answerLoomMigrationQuestion({ requestId, answer: "Again" }),
+ ).rejects.toThrow("changed");
+ });
+
+ it("imports CSV rows into the customer workspace under the request", async () => {
+ const { ownerId, organizationId } = await makeOrganization();
+ const requestId = await requestMigration(organizationId, ownerId);
+ const firstRow = {
+ rowNumber: 2,
+ loomUrl: `https://www.loom.com/share/${loomId()}`,
+ userEmail: `${id()}@example.com`,
+ spaceName: "Sales",
+ };
+ const rows = [
+ firstRow,
+ {
+ rowNumber: 3,
+ loomUrl: `https://www.loom.com/share/${loomId()}`,
+ userEmail: `${id()}@example.com`,
+ spaceName: "",
+ },
+ ];
+
+ signInAs(operatorId);
+ await expect(
+ loom.importFromLoomCsvForConcierge({
+ requestId,
+ rows: Array.from({ length: 11 }, () => firstRow),
+ }),
+ ).rejects.toThrow("batches of 10");
+
+ const result = await loom.importFromLoomCsvForConcierge({
+ requestId,
+ rows,
+ });
+ expect(result.importedCount).toBe(2);
+ expect(fixture.start).toHaveBeenCalledTimes(2);
+
+ const mapped = await db()
+ .select({ videoId: loomMigrationImports.videoId, orgId: videos.orgId })
+ .from(loomMigrationImports)
+ .innerJoin(videos, eq(videos.id, loomMigrationImports.videoId))
+ .where(eq(loomMigrationImports.requestId, requestId));
+ expect(mapped).toHaveLength(2);
+ expect(mapped.every((row) => row.orgId === organizationId)).toBe(true);
+
+ const request = await getRequest(requestId);
+ expect(request.queuedVideoCount).toBe(2);
+ expect(request.status).toBe("in_progress");
+ expect(request.activeImportCount).toBe(0);
+ expect(request.activeImportLeaseToken).toBeNull();
+
+ const repeat = await loom.importFromLoomCsvForConcierge({
+ requestId,
+ rows: [firstRow],
+ });
+ expect(repeat.importedCount).toBe(0);
+ expect((await getRequest(requestId)).queuedVideoCount).toBe(2);
+ });
+
+ it("serializes imports and recovers expired reservations", async () => {
+ const { ownerId, organizationId } = await makeOrganization();
+ const requestId = await requestMigration(organizationId, ownerId);
+ const row = {
+ rowNumber: 2,
+ loomUrl: `https://www.loom.com/share/${loomId()}`,
+ userEmail: `${id()}@example.com`,
+ spaceName: "",
+ };
+
+ await db()
+ .update(loomMigrationRequests)
+ .set({
+ activeImportCount: 1,
+ activeImportLeaseToken: randomUUID(),
+ activeImportLeaseUntil: new Date(Date.now() + 60_000),
+ })
+ .where(eq(loomMigrationRequests.id, requestId));
+
+ signInAs(operatorId);
+ await expect(
+ loom.importFromLoomCsvForConcierge({ requestId, rows: [row] }),
+ ).rejects.toThrow("another import is starting");
+ await expect(
+ actions.updateLoomMigrationStatus({
+ requestId,
+ nextStatus: "completed",
+ message: "",
+ verified: true,
+ expectedVideoCount: 0,
+ importedVideoCount: 0,
+ }),
+ ).rejects.toThrow("imports are starting");
+
+ await db()
+ .update(loomMigrationRequests)
+ .set({ activeImportLeaseUntil: new Date(Date.now() - 1_000) })
+ .where(eq(loomMigrationRequests.id, requestId));
+ const result = await loom.importFromLoomCsvForConcierge({
+ requestId,
+ rows: [row],
+ });
+ expect(result.importedCount).toBe(1);
+ expect((await getRequest(requestId)).activeImportLeaseToken).toBeNull();
+ });
+
+ it("only completes reconciled requests with finished imports", async () => {
+ const { ownerId, organizationId } = await makeOrganization();
+ const requestId = await requestMigration(organizationId, ownerId);
+
+ signInAs(operatorId);
+ await loom.importFromLoomCsvForConcierge({
+ requestId,
+ rows: [
+ {
+ rowNumber: 2,
+ loomUrl: `https://www.loom.com/share/${loomId()}`,
+ userEmail: `${id()}@example.com`,
+ spaceName: "",
+ },
+ ],
+ });
+ const [mapped] = await db()
+ .select({ videoId: loomMigrationImports.videoId })
+ .from(loomMigrationImports)
+ .where(eq(loomMigrationImports.requestId, requestId));
+ if (!mapped) throw new Error("Missing mapped import");
+
+ const complete = {
+ requestId,
+ nextStatus: "completed" as const,
+ message: "All done",
+ verified: true,
+ expectedVideoCount: 1,
+ importedVideoCount: 1,
+ };
+ await expect(
+ actions.updateLoomMigrationStatus({ ...complete, verified: false }),
+ ).rejects.toThrow("Verify");
+ await expect(
+ actions.updateLoomMigrationStatus({
+ ...complete,
+ expectedVideoCount: null,
+ }),
+ ).rejects.toThrow("agreed source video count");
+ await expect(
+ actions.updateLoomMigrationStatus({ ...complete, expectedVideoCount: 2 }),
+ ).rejects.toThrow("Reconcile");
+
+ for (const phase of ["uploading", "processing", "error"] as const) {
+ await setUploadPhase(mapped.videoId, phase);
+ await expect(actions.updateLoomMigrationStatus(complete)).rejects.toThrow(
+ "still processing",
+ );
+ }
+
+ const unrelated = await makeOrganization();
+ signInAs(unrelated.ownerId);
+ const unrelatedRequest = await requestMigration(
+ unrelated.organizationId,
+ unrelated.ownerId,
+ );
+ expect(unrelatedRequest).not.toBe(requestId);
+
+ signInAs(operatorId);
+ await setUploadPhase(mapped.videoId, "complete");
+ fixture.sendEmail.mockClear();
+ await actions.updateLoomMigrationStatus(complete);
+
+ const completed = await getRequest(requestId);
+ expect(completed.status).toBe("completed");
+ expect(completed.activeOrganizationId).toBeNull();
+ expect(completed.completedAt).not.toBeNull();
+ expect(fixture.sendEmail).toHaveBeenCalledTimes(1);
+
+ await expect(
+ actions.updateLoomMigrationStatus({
+ ...complete,
+ nextStatus: "in_progress",
+ }),
+ ).rejects.toThrow("cannot be changed");
+ await expect(
+ loom.importFromLoomCsvForConcierge({ requestId, rows: [] }),
+ ).rejects.toThrow("no longer active");
+
+ const queue = await actions.getLoomMigrationOperatorQueue();
+ expect(queue.some((item) => item.id === requestId)).toBe(false);
+
+ signInAs(ownerId);
+ const reopened = await actions.requestLoomMigration({
+ organizationId,
+ workspaceName: "",
+ note: "One more workspace",
+ });
+ expect(reopened.alreadyRequested).toBe(false);
+ expect(reopened.id).not.toBe(requestId);
+ });
+
+ it("uploads restricted MP4 files to storage and starts processing", async () => {
+ const { ownerId, organizationId } = await makeOrganization({
+ privateByDefault: true,
+ });
+ const requestId = await requestMigration(organizationId, ownerId);
+ const ownerEmail = `${id()}@example.com`;
+ const loomUrl = `https://www.loom.com/share/${loomId()}`;
+
+ signInAs(operatorId);
+ await expect(
+ loom.createConciergeLoomFileUpload({
+ requestId,
+ loomUrl: "http://evil.example.com/share/abcdefghijk",
+ userEmail: ownerEmail,
+ spaceName: "",
+ videoTitle: "Kickoff",
+ }),
+ ).rejects.toThrow("valid Loom video URL");
+
+ const prepared = await loom.createConciergeLoomFileUpload({
+ requestId,
+ loomUrl,
+ userEmail: ownerEmail,
+ spaceName: "Imported",
+ videoTitle: "Kickoff",
+ });
+ const [video] = await db()
+ .select()
+ .from(videos)
+ .where(eq(videos.id, prepared.videoId));
+ if (!video) throw new Error("Missing uploaded video");
+ expect(video).toMatchObject({ orgId: organizationId, public: false });
+ const [owner] = await db()
+ .select({ email: users.email })
+ .from(users)
+ .where(eq(users.id, video.ownerId));
+ expect(owner?.email).toBe(ownerEmail);
+ const [imported] = await db()
+ .select()
+ .from(importedVideos)
+ .where(eq(importedVideos.id, prepared.videoId));
+ expect(imported?.source).toBe("loom");
+
+ await expect(
+ loom.finishConciergeLoomFileUpload({
+ requestId,
+ videoId: prepared.videoId,
+ }),
+ ).rejects.toThrow("not found in storage");
+
+ const retry = await loom.createConciergeLoomFileUpload({
+ requestId,
+ loomUrl,
+ userEmail: ownerEmail,
+ spaceName: "Imported",
+ videoTitle: "Kickoff",
+ });
+ expect(retry.videoId).toBe(prepared.videoId);
+ await expect(
+ loom.createConciergeLoomFileUpload({
+ requestId,
+ loomUrl,
+ userEmail: `${id()}@example.com`,
+ spaceName: "",
+ videoTitle: "Kickoff",
+ }),
+ ).rejects.toThrow("already in the Cap import inventory");
+
+ const target = retry.uploadTarget;
+ const body = new Uint8Array(4096).fill(7);
+ if (target.type === "put") {
+ const response = await realFetch(target.url, {
+ method: "PUT",
+ headers: target.headers,
+ body,
+ });
+ expect(response.ok).toBe(true);
+ } else if (target.type === "s3Post") {
+ const form = new FormData();
+ for (const [key, value] of Object.entries(target.fields)) {
+ form.append(key, value);
+ }
+ form.append("file", new Blob([body], { type: "video/mp4" }));
+ const response = await realFetch(target.url, {
+ method: "POST",
+ body: form,
+ });
+ expect(response.ok).toBe(true);
+ } else {
+ throw new Error(`Unexpected upload target ${target.type}`);
+ }
+
+ fixture.start.mockClear();
+ const finished = await loom.finishConciergeLoomFileUpload({
+ requestId,
+ videoId: prepared.videoId,
+ });
+ expect(finished.status).toBe("started");
+ expect(fixture.start).toHaveBeenCalledTimes(1);
+ const [upload] = await db()
+ .select({ phase: videoUploads.phase })
+ .from(videoUploads)
+ .where(eq(videoUploads.videoId, prepared.videoId));
+ expect(upload?.phase).toBe("processing");
+ expect((await getRequest(requestId)).queuedVideoCount).toBe(1);
+
+ await expect(
+ loom.createConciergeLoomFileUpload({
+ requestId,
+ loomUrl,
+ userEmail: ownerEmail,
+ spaceName: "",
+ videoTitle: "Kickoff",
+ }),
+ ).rejects.toThrow("already in the Cap import inventory");
+ });
+
+ it("refuses to map another request's video", async () => {
+ const first = await makeOrganization();
+ const firstRequest = await requestMigration(
+ first.organizationId,
+ first.ownerId,
+ );
+ const second = await makeOrganization();
+ const secondRequest = await requestMigration(
+ second.organizationId,
+ second.ownerId,
+ );
+
+ signInAs(operatorId);
+ const prepared = await loom.createConciergeLoomFileUpload({
+ requestId: firstRequest,
+ loomUrl: `https://www.loom.com/share/${loomId()}`,
+ userEmail: `${id()}@example.com`,
+ spaceName: "",
+ videoTitle: "First",
+ });
+ await expect(
+ loom.finishConciergeLoomFileUpload({
+ requestId: secondRequest,
+ videoId: prepared.videoId,
+ }),
+ ).rejects.toThrow("no longer available");
+ });
+});