Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
import { beforeEach, describe, expect, it, vi } from "vitest";
const mockDb = vi.fn();
const mockStart = vi.fn();
const serverEnvMock = vi.hoisted(() =>
vi.fn<() => Record<string, string | undefined>>(() => ({
GROQ_API_KEY: "test-key",
})),
);
vi.mock("@cap/database", () => ({
db: mockDb,
}));
vi.mock("@cap/database/schema", () => ({
videos: {
id: "videos.id",
metadata: "videos.metadata",
transcriptionStatus: "videos.transcriptionStatus",
updatedAt: "videos.updatedAt",
},
}));
vi.mock("@cap/env", () => ({
serverEnv: serverEnvMock,
}));
vi.mock("drizzle-orm", () => ({
and: vi.fn((...conditions: unknown[]) => conditions),
eq: vi.fn((left: unknown, right: unknown) => ({ left, right })),
sql: vi.fn((strings: TemplateStringsArray, ...values: unknown[]) => ({
strings,
values,
})),
}));
vi.mock("workflow/api", () => ({
start: mockStart,
}));
vi.mock("@/workflows/generate-ai", () => ({
generateAiWorkflow: vi.fn(),
}));
function makeSelectChain(video: unknown) {
const chain = {
select: vi.fn(),
from: vi.fn(),
where: vi.fn(),
};
chain.select.mockReturnValue(chain);
chain.from.mockReturnValue(chain);
chain.where.mockResolvedValue([{ video }]);
return chain;
}
function makeUpdateChain(affectedRows: number) {
const chain = {
update: vi.fn(),
set: vi.fn(),
where: vi.fn(),
};
chain.update.mockReturnValue(chain);
chain.set.mockReturnValue(chain);
chain.where.mockResolvedValue([{ affectedRows }]);
return chain;
}
const video = {
id: "video-1",
transcriptionStatus: "COMPLETE",
metadata: {},
updatedAt: new Date("2026-07-20T15:00:00.000Z"),
};
beforeEach(() => {
vi.clearAllMocks();
serverEnvMock.mockReturnValue({ GROQ_API_KEY: "test-key" });
mockStart.mockResolvedValue({ runId: "run-1" });
});
describe("startAiGeneration", () => {
it("queues without replacing concurrently edited metadata", async () => {
const update = makeUpdateChain(1);
mockDb
.mockReturnValueOnce(makeSelectChain(video))
.mockReturnValueOnce(update);
const { startAiGeneration } = await import("@/lib/generate-ai");
await startAiGeneration("video-1" as never, "user-1");
const value = update.set.mock.calls[0]?.[0];
expect(value.metadata.strings.join("")).toContain("JSON_SET(COALESCE(");
expect(value.metadata.strings.join("")).toContain(
"'$.aiGenerationStatus', 'QUEUED'",
);
expect(value.metadata.values).toEqual(["videos.metadata"]);
});
it("fails fast when no AI provider is configured", async () => {
serverEnvMock.mockReturnValue({});
const { startAiGeneration } = await import("@/lib/generate-ai");
const result = await startAiGeneration("video-1" as never, "user-1");
expect(result).toEqual({
success: false,
message: "No AI provider configured",
});
expect(mockDb).not.toHaveBeenCalled();
expect(mockStart).not.toHaveBeenCalled();
});
it("starts after atomically claiming the current video version", async () => {
mockDb
.mockReturnValueOnce(makeSelectChain(video))
.mockReturnValueOnce(makeUpdateChain(1));
const { startAiGeneration } = await import("@/lib/generate-ai");
const result = await startAiGeneration("video-1" as never, "user-1");
expect(result).toEqual({
success: true,
message: "AI generation workflow started",
});
expect(mockStart).toHaveBeenCalledTimes(1);
});
it("does not start a duplicate after losing the optimistic claim", async () => {
mockDb
.mockReturnValueOnce(makeSelectChain(video))
.mockReturnValueOnce(makeUpdateChain(0));
const { startAiGeneration } = await import("@/lib/generate-ai");
const result = await startAiGeneration("video-1" as never, "user-1");
expect(result).toEqual({
success: true,
message: "AI generation already in progress",
});
expect(mockStart).not.toHaveBeenCalled();
});
it("marks only the queued generation as errored when start fails", async () => {
mockDb
.mockReturnValueOnce(makeSelectChain(video))
.mockReturnValueOnce(makeUpdateChain(1))
.mockReturnValueOnce(makeUpdateChain(1));
mockStart.mockRejectedValueOnce(new Error("workflow unavailable"));
const { startAiGeneration } = await import("@/lib/generate-ai");
const result = await startAiGeneration("video-1" as never, "user-1");
expect(result).toEqual({
success: false,
message: "Failed to start AI generation workflow",
});
expect(mockDb).toHaveBeenCalledTimes(3);
});
});