Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
import type { Organisation } from "@cap/web-domain";
import { Effect, Option } from "effect";
import { beforeEach, describe, expect, it, vi } from "vitest";
const whereMock = vi.fn();
const valuesMock = vi.fn();
const startMock = vi.fn();
const getRunMock = vi.hoisted(() => vi.fn());
const revalidatePathMock = vi.fn();
const storageGetWritableAccessForUserMock = vi.hoisted(() => vi.fn());
const storageGetAccessForVideoMock = vi.hoisted(() => vi.fn());
const startVideoProcessingWorkflowMock = vi.hoisted(() => vi.fn());
const startLoomFileProcessingWorkflowMock = vi.hoisted(() => vi.fn());
const uploadedFileHeadMock = vi.hoisted(() => vi.fn());
const checkRateLimitMock = vi.hoisted(() => vi.fn());
const headersMock = vi.hoisted(() => vi.fn());
const getOrganizationAccessMock = vi.hoisted(() => vi.fn());
const requireSpaceManagerMock = vi.hoisted(() => vi.fn());
const requireOrganizationSettingsManagerMock = vi.hoisted(() => vi.fn());
const getLoomImportRunStateMock = vi.hoisted(() => vi.fn());
const restoreLoomImportStartErrorMock = vi.hoisted(() => vi.fn());
const defaultSharing = vi.hoisted(() => ({
getNewVideoPublic: vi.fn(),
}));
const conciergeMocks = vi.hoisted(() => ({
requireMigrationOperator: vi.fn(),
reserveConciergeImport: vi.fn(),
renewConciergeImport: vi.fn(),
releaseConciergeImport: vi.fn(),
}));
const mockDb = {
select: vi.fn(() => mockDb),
insert: vi.fn(() => mockDb),
update: vi.fn(() => mockDb),
delete: vi.fn(() => mockDb),
from: vi.fn(() => mockDb),
innerJoin: vi.fn(() => mockDb),
leftJoin: vi.fn(() => mockDb),
where: whereMock,
set: vi.fn((_value: { updatedAt?: Date }) => mockDb),
values: valuesMock,
transaction: vi.fn((callback) => callback(mockDb)),
};
vi.mock("@cap/database", () => ({
db: vi.fn(() => mockDb),
}));
vi.mock("@cap/database/video-sharing-default", () => defaultSharing);
vi.mock("server-only", () => ({}));
vi.mock("@cap/database/auth/session", () => ({
getCurrentUser: vi.fn(),
}));
vi.mock("@cap/database/helpers", () => ({
nanoId: vi.fn(() => "video-123"),
}));
vi.mock("@cap/database/schema", () => ({
folders: {
id: "folderId",
name: "folderName",
parentId: "folderParentId",
organizationId: "folderOrganizationId",
createdById: "folderCreatedById",
spaceId: "folderSpaceId",
},
sharedVideos: { id: "sharedVideoId" },
importedVideos: {
id: "id",
orgId: "orgId",
source: "source",
sourceId: "sourceId",
},
loomMigrationImports: {
videoId: "loomMigrationImportVideoId",
requestId: "loomMigrationImportRequestId",
},
loomMigrationRequests: {
id: "loomMigrationRequestId",
organizationId: "loomMigrationRequestOrganizationId",
activeOrganizationId: "loomMigrationRequestActiveOrganizationId",
status: "loomMigrationRequestStatus",
activeImportLeaseToken: "loomMigrationRequestLeaseToken",
activeImportLeaseUntil: "loomMigrationRequestLeaseUntil",
queuedVideoCount: "loomMigrationRequestQueuedVideoCount",
},
organizationMembers: {
id: "memberId",
userId: "memberUserId",
organizationId: "memberOrganizationId",
role: "memberRole",
hasProSeat: "memberHasProSeat",
},
organizationInvites: {
id: "inviteId",
organizationId: "inviteOrganizationId",
invitedEmail: "invitedEmail",
invitedByUserId: "invitedByUserId",
role: "inviteRole",
},
organizations: {
id: "organizationId",
ownerId: "organizationOwnerId",
tombstoneAt: "organizationTombstoneAt",
},
s3Buckets: {
id: "id",
ownerId: "ownerId",
},
spaceMembers: {
id: "spaceMemberId",
spaceId: "spaceMemberSpaceId",
userId: "spaceMemberUserId",
role: "spaceMemberRole",
},
spaces: {
id: "spaceId",
name: "spaceName",
organizationId: "spaceOrganizationId",
createdById: "spaceCreatedById",
},
spaceVideos: {
id: "spaceVideoId",
spaceId: "spaceVideoSpaceId",
videoId: "spaceVideoVideoId",
},
users: {
id: "userId",
email: "email",
activeOrganizationId: "activeOrganizationId",
defaultOrgId: "defaultOrgId",
inviteQuota: "inviteQuota",
stripeSubscriptionId: "stripeSubscriptionId",
thirdPartyStripeSubscriptionId: "thirdPartyStripeSubscriptionId",
},
videos: {
id: "id",
orgId: "orgId",
},
videoUploads: {
videoId: "videoId",
phase: "phase",
rawFileKey: "rawFileKey",
updatedAt: "updatedAt",
},
}));
vi.mock("@cap/env", () => ({
buildEnv: { NEXT_PUBLIC_IS_CAP: false },
NODE_ENV: "production",
serverEnv: vi.fn(() => ({
CAP_VIDEOS_DEFAULT_PUBLIC: true,
WEB_URL: "https://cap.test",
})),
}));
vi.mock("@cap/utils", () => ({
dub: vi.fn(() => ({
links: {
create: vi.fn(),
},
})),
userIsPro: vi.fn(() => true),
}));
vi.mock("@cap/web-backend", () => ({
Storage: {
getWritableAccessForUser: storageGetWritableAccessForUserMock,
getAccessForVideo: storageGetAccessForVideoMock,
},
}));
vi.mock("@/lib/video-processing", () => ({
startVideoProcessingWorkflow: startVideoProcessingWorkflowMock,
}));
vi.mock("@/lib/loom-file-processing", () => ({
LOOM_FILE_SINGLE_UPLOAD_MAX_BYTES: 5 * 1024 ** 3,
startLoomFileProcessingWorkflow: startLoomFileProcessingWorkflowMock,
}));
vi.mock("@/lib/video-storage", () => ({
decodeStorageVideo: (video: unknown) => video,
}));
vi.mock("@cap/web-domain", () => ({
Space: {
SpaceId: {
make: vi.fn((value: string) => value),
},
},
SpaceMemberId: {
make: vi.fn((value: string) => value),
},
User: {
UserId: {
make: vi.fn((value: string) => value),
},
},
Video: {
VideoId: {
make: vi.fn((value: string) => value),
},
},
}));
vi.mock("drizzle-orm", () => ({
asc: vi.fn((field: unknown) => ({ field })),
and: vi.fn((...args: unknown[]) => args),
eq: vi.fn((field: unknown, value: unknown) => ({ field, value })),
isNull: vi.fn((field: unknown) => ({ field })),
isNotNull: vi.fn((field: unknown) => ({ field })),
sql: vi.fn((strings: TemplateStringsArray, ...values: unknown[]) => ({
strings,
values,
})),
}));
vi.mock("next/cache", () => ({
revalidatePath: revalidatePathMock,
}));
vi.mock("next/headers", () => ({
headers: headersMock,
}));
vi.mock("@vercel/firewall", () => ({
checkRateLimit: checkRateLimitMock,
}));
vi.mock("@/lib/server", async () => {
const { Effect } = await import("effect");
return { runPromise: Effect.runPromise };
});
vi.mock("@/actions/organization/authorization", () => ({
getOrganizationAccess: getOrganizationAccessMock,
requireOrganizationAccess: vi.fn(),
requireOrganizationSettingsManager: requireOrganizationSettingsManagerMock,
}));
vi.mock("@/actions/organization/space-authorization", () => ({
requireSpaceManager: requireSpaceManagerMock,
}));
vi.mock("workflow/api", () => ({
start: startMock,
getRun: getRunMock,
}));
vi.mock("@/workflows/import-loom-video", () => ({
importLoomVideoWorkflow: Symbol("importLoomVideoWorkflow"),
}));
vi.mock("@/lib/loom-concierge", () => ({
...conciergeMocks,
toLoomMigrationResult: async (run: () => Promise<unknown>) => {
const { LoomMigrationError } = await import("@/lib/loom-migration-state");
try {
return { ok: true, value: await run() };
} catch (error) {
if (error instanceof LoomMigrationError) {
return { ok: false, error: error.message };
}
throw error;
}
},
}));
vi.mock("@/lib/org-pro", () => ({
isOrganizationOwnerPro: vi.fn(async () => true),
}));
vi.mock("@/lib/loom-import-start", () => ({
getLoomImportRunState: getLoomImportRunStateMock,
LOOM_IMPORT_CONFIRMATION_MESSAGE: "Confirmation required",
restoreLoomImportStartError: restoreLoomImportStartErrorMock,
startLoomImportWorkflow: (payload: unknown) =>
startMock(Symbol("workflow"), [payload]),
LoomImportStartError: class extends Error {
constructor(readonly canRetry: boolean) {
super("Loom import startup failed");
}
},
}));
import { getCurrentUser } from "@cap/database/auth/session";
const mockGetCurrentUser = getCurrentUser as ReturnType<typeof vi.fn>;
function withLimit(value: unknown) {
return {
limit: vi.fn().mockResolvedValue(value),
};
}
describe("importFromLoom", () => {
beforeEach(() => {
vi.clearAllMocks();
defaultSharing.getNewVideoPublic.mockResolvedValue(true);
whereMock.mockReset();
requireSpaceManagerMock.mockReset();
requireOrganizationSettingsManagerMock.mockReset();
requireSpaceManagerMock.mockResolvedValue({ organizationId: "org-1" });
valuesMock.mockReset();
mockDb.select.mockReturnValue(mockDb);
mockDb.insert.mockReturnValue(mockDb);
mockDb.update.mockReturnValue(mockDb);
mockDb.delete.mockReturnValue(mockDb);
mockDb.from.mockReturnValue(mockDb);
mockDb.innerJoin.mockReturnValue(mockDb);
mockDb.leftJoin.mockReturnValue(mockDb);
mockDb.transaction.mockImplementation((callback) => callback(mockDb));
mockDb.set.mockReturnValue(mockDb);
valuesMock.mockResolvedValue(undefined);
whereMock.mockResolvedValue([]);
startMock.mockResolvedValue(undefined);
getLoomImportRunStateMock.mockResolvedValue("inactive");
checkRateLimitMock.mockResolvedValue({ rateLimited: false });
getOrganizationAccessMock.mockResolvedValue({
id: "org-1",
ownerId: "user-123",
memberId: null,
role: "owner",
});
headersMock.mockResolvedValue(
new Headers({
host: "cap.test",
"x-real-ip": "127.0.0.1",
}),
);
storageGetWritableAccessForUserMock.mockReturnValue(
Effect.succeed({
bucketId: Option.some("bucket-1"),
storageIntegrationId: Option.none(),
}),
);
mockGetCurrentUser.mockResolvedValue({
id: "user-123",
});
vi.stubGlobal("fetch", vi.fn());
});
it("restarts a failed import without creating another video", async () => {
whereMock
.mockResolvedValueOnce([
{
videoId: "existing-video",
ownerId: "user-123",
bucketId: "bucket-1",
phase: "error",
rawFileKey: null,
uploadUpdatedAt: new Date("2026-09-01T00:00:00Z"),
},
])
.mockResolvedValueOnce([{ affectedRows: 1 }]);
const { importFromLoom } = await import("@/actions/loom");
await expect(
importFromLoom({
loomUrl: "https://www.loom.com/share/loom-abc1234567",
orgId: "org-1" as Organisation.OrganisationId,
}),
).resolves.toEqual({ success: true, videoId: "existing-video" });
expect(mockDb.insert).not.toHaveBeenCalled();
expect(startMock).toHaveBeenCalledWith(expect.anything(), [
{
videoId: "existing-video",
userId: "user-123",
bucketId: "bucket-1",
loomVideoId: "loom-abc1234567",
rawFileKey: "user-123/existing-video/raw-upload.mp4",
reuseExistingRawUpload: true,
},
]);
});
it.each([true, false])(
"restores a rejected startup without reopening an uncertain dispatch: %s",
async (canRetry) => {
whereMock
.mockResolvedValueOnce([
{
videoId: "existing-video",
ownerId: "user-123",
phase: "error",
bucketId: null,
rawFileKey: null,
uploadUpdatedAt: new Date(),
},
])
.mockResolvedValueOnce([{ affectedRows: 1 }]);
const { LoomImportStartError } = await import("@/lib/loom-import-start");
startMock.mockRejectedValueOnce(
new LoomImportStartError(canRetry, new Error()),
);
const { importFromLoom } = await import("@/actions/loom");
expect(
await importFromLoom({
loomUrl: "https://www.loom.com/share/loom-abc1234567",
orgId: "org-1" as never,
}),
).toMatchObject({ success: false, error: "Loom import startup failed" });
if (canRetry) {
expect(restoreLoomImportStartErrorMock).toHaveBeenCalledWith(
"existing-video",
"processing",
mockDb.set.mock.calls[0]?.[0].updatedAt,
"Loom import startup failed",
);
} else expect(restoreLoomImportStartErrorMock).not.toHaveBeenCalled();
},
);
it("holds a failed row while its recorded workflow is still active", async () => {
const receipt = { runId: "run-active", dispatch: "accepted" };
whereMock.mockResolvedValueOnce([
{
videoId: "existing-video",
ownerId: "user-123",
phase: "error",
uploadUpdatedAt: new Date(),
metadata: { loomImportRun: receipt },
},
]);
getLoomImportRunStateMock.mockResolvedValueOnce("active");
const { importFromLoom } = await import("@/actions/loom");
expect(
await importFromLoom({
loomUrl: "https://www.loom.com/share/loom-abc1234567",
orgId: "org-1" as never,
}),
).toMatchObject({ success: false });
expect(getLoomImportRunStateMock).toHaveBeenCalledWith(receipt);
expect(mockDb.update).not.toHaveBeenCalled();
expect(startMock).not.toHaveBeenCalled();
});
it("reports an unconfirmed dispatch without claiming it again", async () => {
whereMock.mockResolvedValueOnce([
{
videoId: "existing-video",
ownerId: "user-123",
phase: "error",
uploadUpdatedAt: new Date(),
metadata: {
loomImportRun: { runId: "missing-run", dispatch: "uncertain" },
},
},
]);
getLoomImportRunStateMock.mockResolvedValueOnce("unconfirmed");
const { importFromLoom } = await import("@/actions/loom");
expect(
await importFromLoom({
loomUrl: "https://www.loom.com/share/loom-abc1234567",
orgId: "org-1" as never,
}),
).toMatchObject({ success: false, error: "Confirmation required" });
expect(mockDb.update).not.toHaveBeenCalled();
expect(startMock).not.toHaveBeenCalled();
});
it.each([
{ ownerId: "user-123", phase: "processing", affectedRows: 1 },
{ ownerId: "other-user", phase: "error", affectedRows: 1 },
{ ownerId: "user-123", phase: "error", affectedRows: 0 },
])("does not restart an unclaimed or foreign import: %j", async (row) => {
whereMock
.mockResolvedValueOnce([
{
videoId: "existing-video",
bucketId: "bucket-1",
rawFileKey: null,
uploadUpdatedAt: new Date("2026-09-01T00:00:00Z"),
...row,
},
])
.mockResolvedValueOnce([{ affectedRows: row.affectedRows }]);
const { importFromLoom } = await import("@/actions/loom");
await expect(
importFromLoom({
loomUrl: "https://www.loom.com/share/loom-abc1234567",
orgId: "org-1" as Organisation.OrganisationId,
}),
).resolves.toMatchObject({ success: false });
expect(startMock).not.toHaveBeenCalled();
expect(mockDb.insert).not.toHaveBeenCalled();
});
it("returns direct MP4 URLs for public Loom downloads", async () => {
const fetchMock = vi.mocked(fetch);
fetchMock.mockImplementation(async (input) => {
const url = typeof input === "string" ? input : input.toString();
if (url.includes("/transcoded-url")) {
return {
ok: true,
status: 200,
text: async () =>
JSON.stringify({ url: "https://cdn.loom.com/video.mp4" }),
} as Response;
}
if (url === "https://www.loom.com/graphql") {
return {
ok: true,
json: async () => ({
data: { getVideo: { name: "Public download" } },
}),
} as Response;
}
if (url.includes("/v1/oembed")) {
return {
ok: true,
json: async () => ({ duration: 42, width: 1920, height: 1080 }),
} as Response;
}
throw new Error(`Unexpected fetch: ${url}`);
});
const { downloadLoomVideo } = await import("@/actions/loom");
const result = await downloadLoomVideo(
"https://www.loom.com/share/loom-abc1234567",
);
expect(result).toEqual({
success: true,
videoId: "loom-abc1234567",
videoName: "Public download",
downloadUrl: "https://cdn.loom.com/video.mp4",
downloadMode: "direct-download",
durationSeconds: 42,
width: 1920,
height: 1080,
requiresProxy: false,
});
});
it("returns streaming Loom URLs for browser conversion instead of proxying", async () => {
const fetchMock = vi.mocked(fetch);
fetchMock.mockImplementation(async (input) => {
const url = typeof input === "string" ? input : input.toString();
if (url.includes("/transcoded-url")) {
return {
ok: true,
status: 200,
text: async () =>
JSON.stringify({ url: "https://cdn.loom.com/video.m3u8" }),
} as Response;
}
if (url.includes("/raw-url")) {
return {
ok: false,
status: 404,
text: async () => "",
} as Response;
}
if (url === "https://www.loom.com/graphql") {
return {
ok: true,
json: async () => ({
data: { getVideo: { name: "Streaming download" } },
}),
} as Response;
}
if (url.includes("/v1/oembed")) {
return {
ok: true,
json: async () => ({ duration: 90, width: 1280, height: 720 }),
} as Response;
}
throw new Error(`Unexpected fetch: ${url}`);
});
const { downloadLoomVideo } = await import("@/actions/loom");
const result = await downloadLoomVideo(
"https://www.loom.com/share/loom-abc1234567",
);
expect(result).toEqual({
success: true,
videoId: "loom-abc1234567",
videoName: "Streaming download",
downloadUrl: "https://cdn.loom.com/video.m3u8",
downloadMode: "browser-conversion",
durationSeconds: 90,
width: 1280,
height: 720,
requiresProxy: false,
});
});
it("rejects a Loom import when the linked Cap still exists", async () => {
whereMock.mockResolvedValueOnce([
{ importedVideoId: "video-123", videoId: "video-123" },
]);
const fetchMock = vi.mocked(fetch);
const { importFromLoom } = await import("@/actions/loom");
const result = await importFromLoom({
loomUrl: "https://www.loom.com/share/loom-abc1234567",
orgId: "org-1" as never,
});
expect(result).toEqual({
success: false,
error: "This Loom video has already been imported.",
});
expect(fetchMock).not.toHaveBeenCalled();
expect(valuesMock).not.toHaveBeenCalled();
});
it.each([
["long titles", "a".repeat(383), "a".repeat(255)],
["Unicode titles", "🎥".repeat(260), "🎥".repeat(255)],
["short titles", "Imported 🎥 video", "Imported 🎥 video"],
])(
"fits %s into the destination without changing the import",
async (_, title, expected) => {
valuesMock.mockImplementation(async (value: { name?: string }) => {
if (value.name && Array.from(value.name).length > 255) {
throw new Error("Data too long for column name");
}
});
vi.mocked(fetch).mockImplementation(async (input) => {
const url = input.toString();
if (url.includes("/transcoded-url")) {
return Response.json({ url: "https://cdn.loom.com/video.mp4" });
}
if (url === "https://www.loom.com/graphql") {
return Response.json({ data: { getVideo: { name: title } } });
}
if (url.includes("/v1/oembed")) {
return Response.json({ duration: 42, width: 1920, height: 1080 });
}
throw new Error(`Unexpected fetch: ${url}`);
});
const { importFromLoom } = await import("@/actions/loom");
expect(
await importFromLoom({
loomUrl: "https://www.loom.com/share/loom-abc1234567",
orgId: "org-1" as Organisation.OrganisationId,
}),
).toEqual({ success: true, videoId: "video-123" });
expect(valuesMock).toHaveBeenCalledWith(
expect.objectContaining({
name: expected,
ownerId: "user-123",
orgId: "org-1",
}),
);
expect(startMock).toHaveBeenCalledTimes(1);
},
);
it("does not call the Vercel firewall from the Loom import server action", async () => {
checkRateLimitMock.mockResolvedValueOnce({ rateLimited: true });
const fetchMock = vi.mocked(fetch);
fetchMock.mockImplementation(async (input) => {
const url = typeof input === "string" ? input : input.toString();
if (url.includes("/transcoded-url")) {
return {
ok: true,
status: 200,
text: async () =>
JSON.stringify({ url: "https://cdn.loom.com/video.mp4" }),
} as Response;
}
if (url === "https://www.loom.com/graphql") {
return {
ok: true,
json: async () => ({
data: { getVideo: { name: "Imported video" } },
}),
} as Response;
}
if (url.includes("/v1/oembed")) {
return {
ok: true,
json: async () => ({ duration: 42, width: 1920, height: 1080 }),
} as Response;
}
throw new Error(`Unexpected fetch: ${url}`);
});
const { importFromLoom } = await import("@/actions/loom");
const result = await importFromLoom({
loomUrl: "https://www.loom.com/share/loom-abc1234567",
orgId: "org-1" as never,
});
expect(result).toEqual({
success: true,
videoId: "video-123",
});
expect(checkRateLimitMock).not.toHaveBeenCalled();
expect(startMock).toHaveBeenCalledTimes(1);
});
it("removes a stale Loom row and recreates it with the Cap video id", async () => {
whereMock
.mockResolvedValueOnce([{ importedVideoId: "stale-row", videoId: null }])
.mockResolvedValueOnce(undefined);
const fetchMock = vi.mocked(fetch);
fetchMock.mockImplementation(async (input) => {
const url = typeof input === "string" ? input : input.toString();
if (url.includes("/transcoded-url")) {
return {
ok: true,
status: 200,
text: async () =>
JSON.stringify({ url: "https://cdn.loom.com/video.mp4" }),
} as Response;
}
if (url === "https://www.loom.com/graphql") {
return {
ok: true,
json: async () => ({
data: { getVideo: { name: "Imported video" } },
}),
} as Response;
}
if (url.includes("/v1/oembed")) {
return {
ok: true,
json: async () => ({ duration: 42, width: 1920, height: 1080 }),
} as Response;
}
throw new Error(`Unexpected fetch: ${url}`);
});
const { importFromLoom } = await import("@/actions/loom");
const result = await importFromLoom({
loomUrl: "https://www.loom.com/share/loom-abc1234567",
orgId: "org-1" as never,
});
expect(result).toEqual({
success: true,
videoId: "video-123",
});
expect(mockDb.delete).toHaveBeenCalledTimes(1);
expect(valuesMock).toHaveBeenCalledTimes(3);
expect(valuesMock).toHaveBeenNthCalledWith(
3,
expect.objectContaining({
id: "video-123",
orgId: "org-1" as Organisation.OrganisationId,
source: "loom",
sourceId: "loom-abc1234567",
}),
);
expect(startMock).toHaveBeenCalledTimes(1);
expect(revalidatePathMock).toHaveBeenCalledWith("/dashboard/caps");
});
function mockSuccessfulDownload() {
vi.mocked(fetch).mockImplementation(async (input) => {
const url = String(input);
if (url.includes("/transcoded-url"))
return {
ok: true,
status: 200,
text: async () =>
JSON.stringify({ url: "https://cdn.loom.com/video.mp4" }),
} as Response;
if (url === "https://www.loom.com/graphql")
return {
ok: true,
json: async () => ({
data: { getVideo: { name: "Imported video" } },
}),
} as Response;
if (url.includes("/v1/oembed"))
return { ok: true, json: async () => ({ duration: 42 }) } as Response;
throw new Error(`Unexpected fetch: ${url}`);
});
}
it.each([
{
spaceId: undefined,
expectedPersonalFolder: "nested-folder",
sharing: null,
},
{
spaceId: "space-1",
expectedPersonalFolder: undefined,
sharing: {
spaceId: "space-1",
folderId: "nested-folder",
addedById: "user-123",
},
},
{
spaceId: "org-1",
expectedPersonalFolder: undefined,
sharing: {
organizationId: "org-1",
folderId: "nested-folder",
sharedByUserId: "user-123",
},
},
])(
"persists a nested folder before processing in $spaceId",
async ({ spaceId, expectedPersonalFolder, sharing }) => {
whereMock.mockReturnValueOnce(withLimit([{ id: "nested-folder" }]));
mockSuccessfulDownload();
const { importFromLoom } = await import("@/actions/loom");
const result = await importFromLoom({
loomUrl: "https://www.loom.com/share/loom-abc1234567",
orgId: "org-1" as never,
folderId: "nested-folder" as never,
spaceId: spaceId as never,
});
expect(result.success).toBe(true);
expect(mockDb.transaction).toHaveBeenCalledTimes(1);
expect(valuesMock).toHaveBeenNthCalledWith(
1,
expect.objectContaining({
id: "video-123",
ownerId: "user-123",
folderId: expectedPersonalFolder,
}),
);
if (sharing)
expect(valuesMock).toHaveBeenLastCalledWith(
expect.objectContaining({ videoId: "video-123", ...sharing }),
);
expect(startMock.mock.invocationCallOrder[0]).toBeGreaterThan(
valuesMock.mock.invocationCallOrder.at(-1) ?? Infinity,
);
if (spaceId === "org-1")
expect(requireOrganizationSettingsManagerMock).toHaveBeenCalledWith(
"user-123",
"org-1",
);
else if (spaceId)
expect(requireSpaceManagerMock).toHaveBeenCalledWith(
"user-123",
spaceId,
);
else expect(requireSpaceManagerMock).not.toHaveBeenCalled();
expect(revalidatePathMock).toHaveBeenCalledWith(
"/dashboard/folder/[id]",
"page",
);
if (spaceId)
expect(revalidatePathMock).toHaveBeenCalledWith(
"/dashboard/spaces/[spaceId]/folder/[folderId]",
"page",
);
},
);
it("rejects a missing or foreign personal folder before fetching or writing", async () => {
whereMock.mockReturnValueOnce(withLimit([]));
const { importFromLoom } = await import("@/actions/loom");
const result = await importFromLoom({
loomUrl: "https://www.loom.com/share/loom-abc1234567",
orgId: "org-1" as never,
folderId: "foreign-folder" as never,
});
expect(result.success).toBe(false);
expect(result.error).toContain("Destination folder not found");
const conditions = JSON.stringify(whereMock.mock.calls[0]);
for (const required of [
"foreign-folder",
"folderOrganizationId",
"org-1",
"folderCreatedById",
"user-123",
"folderSpaceId",
])
expect(conditions).toContain(required);
expect(fetch).not.toHaveBeenCalled();
expect(valuesMock).not.toHaveBeenCalled();
});
it.each(["space-1", "org-1"])(
"rejects unauthorized shared destination %s",
async (spaceId) => {
requireSpaceManagerMock.mockRejectedValue(new Error("Forbidden"));
requireOrganizationSettingsManagerMock.mockRejectedValue(
new Error("Forbidden"),
);
const { importFromLoom } = await import("@/actions/loom");
await expect(
importFromLoom({
loomUrl: "https://www.loom.com/share/loom-abc1234567",
orgId: "org-1" as never,
folderId: "folder-1" as never,
spaceId: spaceId as never,
}),
).rejects.toThrow("Forbidden");
expect(fetch).not.toHaveBeenCalled();
expect(valuesMock).not.toHaveBeenCalled();
},
);
it("rejects a space from a different organization even for its manager", async () => {
requireSpaceManagerMock.mockResolvedValueOnce({
organizationId: "foreign-org",
});
const { importFromLoom } = await import("@/actions/loom");
await expect(
importFromLoom({
loomUrl: "https://www.loom.com/share/loom-abc1234567",
orgId: "org-1" as never,
spaceId: "foreign-space" as never,
}),
).rejects.toThrow("Space not found");
expect(fetch).not.toHaveBeenCalled();
expect(valuesMock).not.toHaveBeenCalled();
});
it("does not start processing when persisting a shared destination fails", async () => {
mockSuccessfulDownload();
valuesMock
.mockResolvedValueOnce(undefined)
.mockResolvedValueOnce(undefined)
.mockResolvedValueOnce(undefined)
.mockRejectedValueOnce(new Error("Could not save destination"));
const { importFromLoom } = await import("@/actions/loom");
await expect(
importFromLoom({
loomUrl: "https://www.loom.com/share/loom-abc1234567",
orgId: "org-1" as never,
spaceId: "space-1" as never,
}),
).rejects.toThrow("Could not save destination");
expect(mockDb.transaction).toHaveBeenCalledTimes(1);
expect(startMock).not.toHaveBeenCalled();
});
it("lists only the current user's personal folders in the requested organization", async () => {
const rows = [
{ id: "parent", name: "Course", parentId: null },
{ id: "child", name: "Live Calls", parentId: "parent" },
];
whereMock.mockReturnValueOnce({ orderBy: vi.fn().mockResolvedValue(rows) });
const { getLoomImportFolders } = await import("@/actions/loom");
expect(await getLoomImportFolders({ orgId: "org-1" as never })).toEqual(
rows,
);
const conditions = JSON.stringify(whereMock.mock.calls[0]);
for (const required of [
"folderOrganizationId",
"org-1",
"folderCreatedById",
"user-123",
"folderSpaceId",
])
expect(conditions).toContain(required);
});
it("rejects a CSV import when the current user is not an organization admin or owner", async () => {
getOrganizationAccessMock.mockResolvedValueOnce({
id: "org-1",
ownerId: "owner-456",
memberId: "member-row",
role: "member",
});
const fetchMock = vi.mocked(fetch);
const { importFromLoomCsv } = await import("@/actions/loom");
const result = await importFromLoomCsv({
orgId: "org-1" as never,
rows: [
{
rowNumber: 2,
loomUrl: "https://www.loom.com/share/loom-abc1234567",
userEmail: "[email protected]",
},
],
});
expect(result).toEqual({
success: false,
importedCount: 0,
failedCount: 0,
results: [],
error:
"Only organization admins and owners can import Loom videos from a CSV.",
});
expect(getOrganizationAccessMock).toHaveBeenCalledWith("user-123", "org-1");
expect(fetchMock).not.toHaveBeenCalled();
expect(valuesMock).not.toHaveBeenCalled();
});
it("provisions missing CSV users and starts imports for them", async () => {
whereMock
.mockReturnValueOnce(withLimit([]))
.mockReturnValueOnce(withLimit([]))
.mockReturnValueOnce(withLimit([]))
.mockReturnValueOnce(withLimit([]))
.mockReturnValueOnce(withLimit([{ ownerId: "owner-456" }]))
.mockReturnValueOnce(
withLimit([{ inviteQuota: 1, stripeSubscriptionId: null }]),
)
.mockResolvedValueOnce([]);
const fetchMock = vi.mocked(fetch);
fetchMock.mockImplementation(async (input) => {
const url = typeof input === "string" ? input : input.toString();
if (url.includes("/transcoded-url")) {
return {
ok: true,
status: 200,
text: async () =>
JSON.stringify({ url: "https://cdn.loom.com/video.mp4" }),
} as Response;
}
if (url === "https://www.loom.com/graphql") {
return {
ok: true,
json: async () => ({
data: { getVideo: { name: "Imported video" } },
}),
} as Response;
}
if (url.includes("/v1/oembed")) {
return {
ok: true,
json: async () => ({ duration: 42, width: 1920, height: 1080 }),
} as Response;
}
throw new Error(`Unexpected fetch: ${url}`);
});
const { importFromLoomCsv } = await import("@/actions/loom");
const result = await importFromLoomCsv({
orgId: "org-1" as never,
rows: [
{
rowNumber: 2,
loomUrl: "https://www.loom.com/share/loom-abc1234567",
userEmail: "[email protected]",
},
],
});
expect(result).toEqual({
success: true,
importedCount: 1,
failedCount: 0,
results: [
{
rowNumber: 2,
userEmail: "[email protected]",
spaceName: undefined,
success: true,
videoId: "video-123",
error: undefined,
},
],
error: undefined,
});
expect(fetchMock).toHaveBeenCalled();
expect(valuesMock).toHaveBeenCalledWith(
expect.objectContaining({
email: "[email protected]",
activeOrganizationId: "org-1",
defaultOrgId: "org-1",
}),
);
expect(valuesMock).toHaveBeenCalledWith(
expect.objectContaining({
organizationId: "org-1",
invitedEmail: "[email protected]",
invitedByUserId: "user-123",
role: "member",
}),
);
expect(valuesMock).toHaveBeenCalledWith(
expect.objectContaining({
organizationId: "org-1",
userId: "video-123",
role: "member",
}),
);
expect(storageGetWritableAccessForUserMock).toHaveBeenCalledWith(
"video-123",
"org-1",
);
});
it("imports a CSV row without calling the Vercel firewall", async () => {
whereMock.mockImplementation((conditions: unknown) => {
const serializedConditions = JSON.stringify(conditions);
if (serializedConditions.includes("sourceId")) {
return Promise.resolve(
serializedConditions.includes("loom-existing123")
? [{ videoId: "existing-video" }]
: [],
);
}
return withLimit([{ userId: "member-123", email: "[email protected]" }]);
});
const fetchMock = vi.mocked(fetch);
fetchMock.mockImplementation(async (input) => {
const url = typeof input === "string" ? input : input.toString();
if (url.includes("/transcoded-url")) {
return {
ok: true,
status: 200,
text: async () =>
JSON.stringify({ url: "https://cdn.loom.com/video.mp4" }),
} as Response;
}
if (url === "https://www.loom.com/graphql") {
return {
ok: true,
json: async () => ({
data: { getVideo: { name: "Imported video" } },
}),
} as Response;
}
if (url.includes("/v1/oembed")) {
return {
ok: true,
json: async () => ({ duration: 42, width: 1920, height: 1080 }),
} as Response;
}
throw new Error(`Unexpected fetch: ${url}`);
});
const { importFromLoomCsv } = await import("@/actions/loom");
const result = await importFromLoomCsv({
orgId: "org-1" as never,
rows: [
{
rowNumber: 2,
loomUrl: "https://www.loom.com/share/loom-existing123",
userEmail: "[email protected]",
},
{
rowNumber: 3,
loomUrl: "https://www.loom.com/share/loom-newvideo123",
userEmail: "[email protected]",
},
],
});
expect(result).toEqual({
success: true,
importedCount: 1,
failedCount: 1,
results: [
{
rowNumber: 2,
userEmail: "[email protected]",
spaceName: undefined,
success: false,
error: "This Loom video has already been imported.",
},
{
rowNumber: 3,
userEmail: "[email protected]",
spaceName: undefined,
success: true,
videoId: "video-123",
error: undefined,
},
],
error: undefined,
});
expect(checkRateLimitMock).not.toHaveBeenCalled();
expect(fetchMock).toHaveBeenCalled();
expect(startMock).toHaveBeenCalledTimes(1);
});
it("marks CSV rows that hit a temporary Loom failure as retryable", async () => {
whereMock.mockImplementation((conditions: unknown) => {
if (JSON.stringify(conditions).includes("sourceId")) {
return Promise.resolve([]);
}
return withLimit([{ userId: "member-123", email: "[email protected]" }]);
});
const fetchMock = vi.mocked(fetch);
fetchMock.mockImplementation(async (input) => {
const url = typeof input === "string" ? input : input.toString();
if (url.includes("/transcoded-url")) {
return {
ok: false,
status: 429,
headers: new Headers({ "retry-after": "30" }),
body: null,
} as Response;
}
throw new Error(`Unexpected fetch: ${url}`);
});
const { importFromLoomCsv } = await import("@/actions/loom");
const result = await importFromLoomCsv({
orgId: "org-1" as never,
rows: [
{
rowNumber: 2,
loomUrl: "https://www.loom.com/share/loom-ratelimited1",
userEmail: "[email protected]",
},
],
});
expect(result.results).toStrictEqual([
{
rowNumber: 2,
userEmail: "[email protected]",
spaceName: undefined,
success: false,
videoId: undefined,
error:
"Loom is temporarily unavailable. Please retry the import later.",
errorCode: "loom_temporarily_unavailable",
},
]);
expect(startMock).not.toHaveBeenCalled();
});
it("limits CSV imports to 500 rows", async () => {
const fetchMock = vi.mocked(fetch);
const { importFromLoomCsv } = await import("@/actions/loom");
const result = await importFromLoomCsv({
orgId: "org-1" as never,
rows: Array.from({ length: 501 }, (_, index) => ({
rowNumber: index + 2,
loomUrl: `https://www.loom.com/share/loom-${String(index).padStart(10, "0")}`,
userEmail: "[email protected]",
})),
});
expect(result).toEqual({
success: false,
importedCount: 0,
failedCount: 501,
results: [],
error:
"CSV imports are limited to 500 rows at a time. Contact support to raise this limit.",
});
expect(checkRateLimitMock).not.toHaveBeenCalled();
expect(fetchMock).not.toHaveBeenCalled();
expect(valuesMock).not.toHaveBeenCalled();
});
it("starts CSV Loom imports for matched organization members when the current user is an organization admin", async () => {
getOrganizationAccessMock.mockResolvedValueOnce({
id: "org-1",
ownerId: "owner-456",
memberId: "member-row",
role: "admin",
});
whereMock
.mockReturnValueOnce(
withLimit([{ userId: "member-123", email: "[email protected]" }]),
)
.mockResolvedValueOnce([]);
const fetchMock = vi.mocked(fetch);
fetchMock.mockImplementation(async (input) => {
const url = typeof input === "string" ? input : input.toString();
if (url.includes("/transcoded-url")) {
return {
ok: true,
status: 200,
text: async () =>
JSON.stringify({ url: "https://cdn.loom.com/video.mp4" }),
} as Response;
}
if (url === "https://www.loom.com/graphql") {
return {
ok: true,
json: async () => ({
data: { getVideo: { name: "Imported video" } },
}),
} as Response;
}
if (url.includes("/v1/oembed")) {
return {
ok: true,
json: async () => ({ duration: 42, width: 1920, height: 1080 }),
} as Response;
}
throw new Error(`Unexpected fetch: ${url}`);
});
const { importFromLoomCsv } = await import("@/actions/loom");
const result = await importFromLoomCsv({
orgId: "org-1" as never,
rows: [
{
rowNumber: 2,
loomUrl: "https://www.loom.com/share/loom-abc1234567",
userEmail: "[email protected]",
},
],
});
expect(result).toEqual({
success: true,
importedCount: 1,
failedCount: 0,
results: [
{
rowNumber: 2,
userEmail: "[email protected]",
spaceName: undefined,
success: true,
videoId: "video-123",
error: undefined,
},
],
error: undefined,
});
expect(storageGetWritableAccessForUserMock).toHaveBeenCalledWith(
"member-123",
"org-1",
);
expect(valuesMock).toHaveBeenNthCalledWith(
1,
expect.objectContaining({
ownerId: "member-123",
}),
);
expect(startMock).toHaveBeenCalledWith(
expect.anything(),
expect.arrayContaining([
expect.objectContaining({
userId: "member-123",
rawFileKey: "member-123/video-123/raw-upload.mp4",
}),
]),
);
});
it("creates missing spaces and adds CSV Loom imports to them", async () => {
whereMock
.mockReturnValueOnce(
withLimit([{ userId: "member-123", email: "[email protected]" }]),
)
.mockResolvedValueOnce([])
.mockReturnValueOnce(withLimit([]))
.mockReturnValueOnce(withLimit([]))
.mockReturnValueOnce(withLimit([]));
const fetchMock = vi.mocked(fetch);
fetchMock.mockImplementation(async (input) => {
const url = typeof input === "string" ? input : input.toString();
if (url.includes("/transcoded-url")) {
return {
ok: true,
status: 200,
text: async () =>
JSON.stringify({ url: "https://cdn.loom.com/video.mp4" }),
} as Response;
}
if (url === "https://www.loom.com/graphql") {
return {
ok: true,
json: async () => ({
data: { getVideo: { name: "Imported video" } },
}),
} as Response;
}
if (url.includes("/v1/oembed")) {
return {
ok: true,
json: async () => ({ duration: 42, width: 1920, height: 1080 }),
} as Response;
}
throw new Error(`Unexpected fetch: ${url}`);
});
const { importFromLoomCsv } = await import("@/actions/loom");
const result = await importFromLoomCsv({
orgId: "org-1" as never,
rows: [
{
rowNumber: 2,
loomUrl: "https://www.loom.com/share/loom-abc1234567",
userEmail: "[email protected]",
spaceName: " Sales Team ",
},
],
});
expect(result).toEqual({
success: true,
importedCount: 1,
failedCount: 0,
results: [
{
rowNumber: 2,
userEmail: "[email protected]",
spaceName: "Sales Team",
success: true,
videoId: "video-123",
error: undefined,
},
],
error: undefined,
});
expect(mockDb.transaction).toHaveBeenCalledTimes(2);
expect(valuesMock).toHaveBeenCalledWith(
expect.objectContaining({
name: "Sales Team",
organizationId: "org-1",
createdById: "user-123",
}),
);
expect(valuesMock).toHaveBeenCalledWith(
expect.objectContaining({
spaceId: "video-123",
userId: "user-123",
role: "admin",
}),
);
expect(valuesMock).toHaveBeenCalledWith(
expect.objectContaining({
spaceId: "video-123",
videoId: "video-123",
addedById: "user-123",
}),
);
expect(revalidatePathMock).toHaveBeenCalledWith(
"/dashboard/spaces/video-123",
);
expect(revalidatePathMock).toHaveBeenCalledWith("/dashboard");
});
});
describe("importFromLoomCsvForConcierge", () => {
const requestId = "request12345678";
const leaseToken = "lease-1";
const failedImport = {
videoId: "existing-video",
ownerId: "user-123",
bucketId: "bucket-1",
phase: "error",
rawFileKey: null,
uploadUpdatedAt: new Date("2026-09-01T00:00:00Z"),
};
const forUpdateMock = vi.fn();
function withReservation(reservation: unknown) {
forUpdateMock.mockResolvedValueOnce([reservation]);
return { limit: vi.fn(() => ({ for: forUpdateMock })) };
}
function queueConciergeRowLookups() {
whereMock
.mockReturnValueOnce(
withLimit([
{
organizationId: "org-1",
status: "in_progress",
ownerId: "owner-1",
},
]),
)
.mockReturnValueOnce(
withLimit([{ userId: "user-123", email: "[email protected]" }]),
)
.mockResolvedValueOnce([failedImport]);
}
async function importConciergeRow() {
const { importFromLoomCsvForConcierge } = await import("@/actions/loom");
return importFromLoomCsvForConcierge({
requestId,
rows: [
{
rowNumber: 2,
loomUrl: "https://www.loom.com/share/loom-abc1234567",
userEmail: "[email protected]",
},
],
});
}
beforeEach(() => {
vi.clearAllMocks();
whereMock.mockReset();
valuesMock.mockReset();
forUpdateMock.mockReset();
mockDb.select.mockReturnValue(mockDb);
mockDb.insert.mockReturnValue(mockDb);
mockDb.update.mockReturnValue(mockDb);
mockDb.from.mockReturnValue(mockDb);
mockDb.innerJoin.mockReturnValue(mockDb);
mockDb.leftJoin.mockReturnValue(mockDb);
mockDb.set.mockReturnValue(mockDb);
mockDb.transaction.mockImplementation((callback) => callback(mockDb));
valuesMock.mockResolvedValue(undefined);
whereMock.mockResolvedValue([]);
startMock.mockResolvedValue(undefined);
getLoomImportRunStateMock.mockResolvedValue("inactive");
conciergeMocks.requireMigrationOperator.mockResolvedValue({
id: "operator-1",
});
conciergeMocks.reserveConciergeImport.mockResolvedValue(leaseToken);
conciergeMocks.renewConciergeImport.mockResolvedValue(undefined);
conciergeMocks.releaseConciergeImport.mockResolvedValue(undefined);
});
it("records a restarted failed import against the migration request under the lease", async () => {
queueConciergeRowLookups();
whereMock
.mockReturnValueOnce(
withReservation({
activeOrganizationId: "org-1",
leaseToken,
leaseUntil: new Date(Date.now() + 60_000),
}),
)
.mockReturnValueOnce(withLimit([]))
.mockResolvedValueOnce([{ affectedRows: 1 }]);
const result = await importConciergeRow();
expect(result).toMatchObject({
ok: true,
value: {
success: true,
importedCount: 1,
results: [{ success: true, videoId: "existing-video" }],
},
});
expect(forUpdateMock).toHaveBeenCalledWith("update");
expect(mockDb.set).toHaveBeenCalledWith(
expect.objectContaining({ phase: "processing" }),
);
expect(valuesMock).toHaveBeenCalledWith({
videoId: "existing-video",
requestId,
});
expect(mockDb.set).toHaveBeenCalledWith(
expect.objectContaining({ queuedVideoCount: expect.anything() }),
);
expect(startMock).toHaveBeenCalledWith(expect.anything(), [
expect.objectContaining({
videoId: "existing-video",
reuseExistingRawUpload: true,
}),
]);
expect(conciergeMocks.releaseConciergeImport).toHaveBeenCalledWith(
requestId,
leaseToken,
);
});
it("does not count a failed import twice when it already belongs to the request", async () => {
queueConciergeRowLookups();
whereMock
.mockReturnValueOnce(
withReservation({
activeOrganizationId: "org-1",
leaseToken,
leaseUntil: new Date(Date.now() + 60_000),
}),
)
.mockReturnValueOnce(withLimit([{ requestId }]))
.mockResolvedValueOnce([{ affectedRows: 1 }]);
const result = await importConciergeRow();
expect(result).toMatchObject({ ok: true, value: { importedCount: 1 } });
expect(valuesMock).not.toHaveBeenCalled();
expect(mockDb.set).not.toHaveBeenCalledWith(
expect.objectContaining({ queuedVideoCount: expect.anything() }),
);
expect(startMock).toHaveBeenCalledTimes(1);
});
it("does not restart a failed import once the concierge lease has expired", async () => {
queueConciergeRowLookups();
whereMock.mockReturnValueOnce(
withReservation({
activeOrganizationId: "org-1",
leaseToken: "newer-lease",
leaseUntil: new Date(Date.now() + 60_000),
}),
);
const result = await importConciergeRow();
expect(result).toMatchObject({
ok: true,
value: { success: false, importedCount: 0, failedCount: 1 },
});
expect(mockDb.update).not.toHaveBeenCalled();
expect(valuesMock).not.toHaveBeenCalled();
expect(startMock).not.toHaveBeenCalled();
});
it("refuses to restart a failed import that belongs to another migration request", async () => {
queueConciergeRowLookups();
whereMock
.mockReturnValueOnce(
withReservation({
activeOrganizationId: "org-1",
leaseToken,
leaseUntil: new Date(Date.now() + 60_000),
}),
)
.mockReturnValueOnce(withLimit([{ requestId: "otherrequest123" }]));
const result = await importConciergeRow();
expect(result).toMatchObject({
ok: true,
value: {
success: false,
results: [
{
success: false,
error: "This Loom import belongs to another migration request.",
},
],
},
});
expect(mockDb.update).not.toHaveBeenCalled();
expect(valuesMock).not.toHaveBeenCalled();
expect(startMock).not.toHaveBeenCalled();
});
});
describe("resuming an uploaded concierge Loom file", () => {
const input = {
requestId: "req000000000001",
loomUrl: "https://www.loom.com/share/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
userEmail: "[email protected]",
confirmedPreviousProcessingStopped: true,
};
const recording = {
videoId: "existing-video",
ownerId: "owner-id",
ownerEmail: "[email protected]",
organizationId: "org-1",
metadata: { loomImportRun: { runId: "old-run", dispatch: "accepted" } },
};
const uploaded = {
loomVideoId: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
video: {
id: "existing-video",
ownerId: "owner-id",
orgId: "org-1",
bucket: null,
},
rawFileKey: "owner-id/existing-video/raw-upload.mp4",
phase: "error",
processingMessage: null,
};
beforeEach(() => {
vi.clearAllMocks();
whereMock.mockReset();
mockDb.select.mockReturnValue(mockDb);
mockDb.from.mockReturnValue(mockDb);
mockDb.innerJoin.mockReturnValue(mockDb);
mockDb.leftJoin.mockReturnValue(mockDb);
conciergeMocks.requireMigrationOperator.mockResolvedValue({
id: "operator",
});
conciergeMocks.reserveConciergeImport.mockResolvedValue("lease");
conciergeMocks.releaseConciergeImport.mockResolvedValue(undefined);
storageGetAccessForVideoMock.mockReturnValue(
Effect.succeed([{ provider: "s3", headObject: uploadedFileHeadMock }]),
);
uploadedFileHeadMock.mockReturnValue(
Effect.succeed({ ContentLength: 6 * 1024 ** 3 }),
);
startVideoProcessingWorkflowMock.mockResolvedValue("started");
startLoomFileProcessingWorkflowMock.mockResolvedValue("started");
getRunMock.mockReturnValue({ status: Promise.resolve("failed") });
});
it("requires explicit confirmation before inspecting a recording", async () => {
const { resumeConciergeLoomFileUpload } = await import("@/actions/loom");
await expect(
resumeConciergeLoomFileUpload({
...input,
confirmedPreviousProcessingStopped: false,
}),
).resolves.toMatchObject({ ok: false });
expect(mockDb.select).not.toHaveBeenCalled();
expect(startVideoProcessingWorkflowMock).not.toHaveBeenCalled();
});
it.each(["running", "pending"])(
"refuses a previous workflow that is still %s",
async (status) => {
whereMock.mockReturnValueOnce(withLimit([recording]));
getRunMock.mockReturnValueOnce({ status: Promise.resolve(status) });
const { resumeConciergeLoomFileUpload } = await import("@/actions/loom");
await expect(resumeConciergeLoomFileUpload(input)).resolves.toMatchObject(
{
ok: false,
error: expect.stringContaining("active or could not be confirmed"),
},
);
expect(startVideoProcessingWorkflowMock).not.toHaveBeenCalled();
},
);
it("refuses an unconfirmed previous workflow", async () => {
whereMock.mockReturnValueOnce(withLimit([recording]));
getRunMock.mockImplementationOnce(() => ({
status: Promise.reject(new Error("Unavailable")),
}));
const { resumeConciergeLoomFileUpload } = await import("@/actions/loom");
await expect(resumeConciergeLoomFileUpload(input)).resolves.toMatchObject({
ok: false,
error: expect.stringContaining("active or could not be confirmed"),
});
expect(startVideoProcessingWorkflowMock).not.toHaveBeenCalled();
});
it("can resume after a confirmed queue rejection without querying its unqueued run", async () => {
whereMock
.mockReturnValueOnce(
withLimit([
{
...recording,
metadata: {
loomImportRun: {
runId: "rejected-run",
dispatch: "rejected",
},
},
},
]),
)
.mockReturnValueOnce(withLimit([uploaded]));
getRunMock.mockImplementation(() => {
throw new Error("Unqueued run is unavailable");
});
const { resumeConciergeLoomFileUpload } = await import("@/actions/loom");
await expect(resumeConciergeLoomFileUpload(input)).resolves.toEqual({
ok: true,
value: { status: "started" },
});
expect(getRunMock).not.toHaveBeenCalled();
expect(startLoomFileProcessingWorkflowMock).toHaveBeenCalledOnce();
});
it("processes a large uploaded file in its existing recording", async () => {
whereMock
.mockReturnValueOnce(withLimit([recording]))
.mockReturnValueOnce(withLimit([uploaded]));
const { resumeConciergeLoomFileUpload } = await import("@/actions/loom");
await expect(resumeConciergeLoomFileUpload(input)).resolves.toEqual({
ok: true,
value: { status: "started" },
});
expect(startLoomFileProcessingWorkflowMock).toHaveBeenCalledExactlyOnceWith(
{
videoId: "existing-video",
userId: "owner-id",
rawFileKey: uploaded.rawFileKey,
bucketId: null,
processingMessage: "Processing Loom video...",
startFailureMessage: "Loom file processing could not start.",
loomVideoId: uploaded.loomVideoId,
},
);
expect(startVideoProcessingWorkflowMock).not.toHaveBeenCalled();
expect(mockDb.insert).not.toHaveBeenCalled();
expect(mockDb.update).not.toHaveBeenCalled();
expect(storageGetWritableAccessForUserMock).not.toHaveBeenCalled();
});
it.each([1024, 5 * 1024 ** 3])(
"keeps the existing file workflow for a %i-byte upload",
async (bytes) => {
whereMock
.mockReturnValueOnce(withLimit([recording]))
.mockReturnValueOnce(withLimit([uploaded]));
uploadedFileHeadMock.mockReturnValue(
Effect.succeed({ ContentLength: bytes }),
);
const { resumeConciergeLoomFileUpload } = await import("@/actions/loom");
await expect(resumeConciergeLoomFileUpload(input)).resolves.toMatchObject(
{
ok: true,
},
);
expect(startVideoProcessingWorkflowMock).toHaveBeenCalledOnce();
expect(startLoomFileProcessingWorkflowMock).not.toHaveBeenCalled();
},
);
it("keeps non-S3 storage on its existing processing path", async () => {
whereMock
.mockReturnValueOnce(withLimit([recording]))
.mockReturnValueOnce(withLimit([uploaded]));
storageGetAccessForVideoMock.mockReturnValue(
Effect.succeed([
{ provider: "google-drive", headObject: uploadedFileHeadMock },
]),
);
const { resumeConciergeLoomFileUpload } = await import("@/actions/loom");
await expect(resumeConciergeLoomFileUpload(input)).resolves.toMatchObject({
ok: true,
});
expect(startVideoProcessingWorkflowMock).toHaveBeenCalledOnce();
expect(startLoomFileProcessingWorkflowMock).not.toHaveBeenCalled();
});
it.each([
{ records: [] },
{ records: [{ ...recording, ownerEmail: "[email protected]" }] },
])(
"refuses missing or differently owned recordings without creating one",
async ({ records }) => {
whereMock.mockReturnValueOnce(withLimit(records));
const { resumeConciergeLoomFileUpload } = await import("@/actions/loom");
await expect(resumeConciergeLoomFileUpload(input)).resolves.toMatchObject(
{
ok: false,
error: expect.stringContaining("matches this request and owner"),
},
);
expect(mockDb.insert).not.toHaveBeenCalled();
expect(mockDb.update).not.toHaveBeenCalled();
expect(storageGetAccessForVideoMock).not.toHaveBeenCalled();
expect(startVideoProcessingWorkflowMock).not.toHaveBeenCalled();
},
);
it.each(["processing", "complete"])(
"does not start another job for a recording in phase %s",
async (phase) => {
whereMock
.mockReturnValueOnce(withLimit([recording]))
.mockReturnValueOnce(withLimit([{ ...uploaded, phase }]));
const { resumeConciergeLoomFileUpload } = await import("@/actions/loom");
await expect(resumeConciergeLoomFileUpload(input)).resolves.toMatchObject(
{
ok: false,
error: expect.stringContaining("no longer available"),
},
);
expect(startVideoProcessingWorkflowMock).not.toHaveBeenCalled();
},
);
it("rejects an empty uploaded file", async () => {
whereMock
.mockReturnValueOnce(withLimit([recording]))
.mockReturnValueOnce(withLimit([uploaded]));
uploadedFileHeadMock.mockReturnValue(Effect.succeed({ ContentLength: 0 }));
const { resumeConciergeLoomFileUpload } = await import("@/actions/loom");
await expect(resumeConciergeLoomFileUpload(input)).resolves.toMatchObject({
ok: false,
error: "The uploaded file is empty.",
});
expect(startVideoProcessingWorkflowMock).not.toHaveBeenCalled();
});
it("rejects an oversized upload before starting any processing", async () => {
whereMock
.mockReturnValueOnce(withLimit([recording]))
.mockReturnValueOnce(withLimit([uploaded]));
uploadedFileHeadMock.mockReturnValue(
Effect.succeed({ ContentLength: 11 * 1024 ** 3 }),
);
const { resumeConciergeLoomFileUpload } = await import("@/actions/loom");
await expect(resumeConciergeLoomFileUpload(input)).resolves.toMatchObject({
ok: false,
error: expect.stringContaining("exceeds 10 GB"),
});
expect(startVideoProcessingWorkflowMock).not.toHaveBeenCalled();
});
it("stops if ownership changes during resume preparation", async () => {
whereMock
.mockReturnValueOnce(withLimit([recording]))
.mockReturnValueOnce(
withLimit([
{ ...uploaded, video: { ...uploaded.video, ownerId: "new-owner" } },
]),
);
const { resumeConciergeLoomFileUpload } = await import("@/actions/loom");
await expect(resumeConciergeLoomFileUpload(input)).resolves.toMatchObject({
ok: false,
error: expect.stringContaining("no longer available"),
});
expect(startVideoProcessingWorkflowMock).not.toHaveBeenCalled();
});
it("does not start when the stored upload cannot be found", async () => {
whereMock
.mockReturnValueOnce(withLimit([recording]))
.mockReturnValueOnce(withLimit([uploaded]));
uploadedFileHeadMock.mockReturnValue(Effect.fail(new Error("Not found")));
const { resumeConciergeLoomFileUpload } = await import("@/actions/loom");
await expect(resumeConciergeLoomFileUpload(input)).resolves.toMatchObject({
ok: false,
error: expect.stringContaining("not found in storage"),
});
expect(startVideoProcessingWorkflowMock).not.toHaveBeenCalled();
});
it("requires an operator before reading any recording", async () => {
conciergeMocks.requireMigrationOperator.mockRejectedValueOnce(
new Error("Unauthorized"),
);
const { resumeConciergeLoomFileUpload } = await import("@/actions/loom");
await expect(resumeConciergeLoomFileUpload(input)).rejects.toThrow(
"Unauthorized",
);
expect(mockDb.select).not.toHaveBeenCalled();
expect(startVideoProcessingWorkflowMock).not.toHaveBeenCalled();
});
});