Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
import type { SQL } from "drizzle-orm";
import { MySqlDialect } from "drizzle-orm/mysql-core";
import { Effect } from "effect";
import { NextRequest } from "next/server";
import { beforeEach, describe, expect, it, vi } from "vitest";
import type { DesktopRecordingJob } from "@/lib/desktop-recording-jobs";
const mocks = vi.hoisted(() => ({
secret: "media-secret" as string | undefined,
db: vi.fn(),
getState: vi.fn(),
retry: vi.fn(),
blocked: vi.fn(),
head: vi.fn(),
storage: vi.fn(),
queue: vi.fn(),
transcribe: vi.fn(),
invalidateQuota: vi.fn(),
audio: vi.fn(),
signal: vi.fn(),
tables: {
videos: {
id: "videos.id",
ownerId: "videos.ownerId",
metadata: "videos.metadata",
},
jobs: { videoId: "jobs.videoId" },
uploads: { videoId: "uploads.videoId", rawFileKey: "uploads.rawFileKey" },
},
}));
vi.mock("@cap/database", () => ({ db: mocks.db }));
vi.mock("@/lib/audio-level-publication", () => ({
handleAudioLevelPublication: mocks.audio,
}));
vi.mock("@cap/database/schema", () => ({
videos: mocks.tables.videos,
videoProcessingJobs: mocks.tables.jobs,
videoUploads: mocks.tables.uploads,
}));
vi.mock("@cap/env", () => ({
serverEnv: () => ({ MEDIA_SERVER_WEBHOOK_SECRET: mocks.secret }),
}));
vi.mock("@cap/web-backend", () => ({
Storage: { getAccessForVideo: mocks.storage },
}));
vi.mock("@cap/web-backend/src/Storage/index", () => ({
Storage: { getAccessForVideo: mocks.storage },
}));
vi.mock("@/lib/desktop-recording-jobs", async (importOriginal) => ({
...(await importOriginal<typeof import("@/lib/desktop-recording-jobs")>()),
getProcessingState: mocks.getState,
scheduleRetry: mocks.retry,
markSourceBlocked: mocks.blocked,
}));
vi.mock("@/lib/server", async () => ({
runPromise: (await import("effect")).Effect.runPromise,
}));
vi.mock("@/lib/workflow-runtime", async () => ({
runWorkflowPromise: (await import("effect")).Effect.runPromise,
}));
vi.mock("@/lib/video-storage", () => ({
decodeStorageVideo: (video: unknown) => video,
}));
vi.mock("@/lib/desktop-segments-finalization", () => ({
queueDesktopSegmentsFinalization: mocks.queue,
}));
vi.mock("@/lib/google-drive-storage-quota", () => ({
invalidateGoogleDriveStorageQuotaCache: mocks.invalidateQuota,
}));
vi.mock("@/lib/google-drive-storage-quota-cache", () => ({
invalidateGoogleDriveStorageQuotaCache: mocks.invalidateQuota,
}));
vi.mock("@/lib/queue-video-transcription", () => ({
queueVideoTranscription: mocks.transcribe,
shouldQueueTranscriptionAfterMediaComplete: () => true,
}));
vi.mock("@/lib/loom-import-signal", () => ({
signalLoomImportFinished: mocks.signal,
}));
import { POST } from "@/app/api/webhooks/media-server/progress/route";
import {
parseDesktopRecordingJob,
SourceCommitPendingError,
} from "@/lib/desktop-recording-jobs";
import { getDesktopRecordingOutputKey } from "@/lib/desktop-recording-source";
const ownerId = "owned-user" as DesktopRecordingJob["ownerId"];
const videoId = "owned-video" as DesktopRecordingJob["videoId"];
const generation = "c9699f1a-fe24-44f9-ac89-63d5744a058c";
const attemptId = "cf9f55f8-4d6d-44b4-a670-30c2f7e51d9b";
const manifestSha256 = "a".repeat(64);
const inventorySha256 = "b".repeat(64);
const outputKey = getDesktopRecordingOutputKey(
ownerId,
videoId,
generation,
attemptId,
);
const metadata = {
fileSize: 4096,
duration: 5,
width: 320,
height: 180,
fps: 30,
videoCodec: "h264",
audioCodec: "aac",
};
const verification = {
version: 1 as const,
artifact: { kind: "segments" as const, manifestSha256 },
requiredAudio: true,
};
function fixture() {
const now = new Date();
const job: DesktopRecordingJob = {
videoId,
ownerId,
generation,
attemptId,
manifestSha256,
state: "processing",
attemptCount: 1,
leaseExpiresAt: new Date(now.getTime() + 60_000),
nextRetryAt: now,
workflowRunId: "workflow-1",
remoteJobId: "remote-1",
source: {
version: 1,
kind: "segments",
manifestSha256,
inventorySha256,
inventoryKey: `${ownerId}/${videoId}/.recording/sources/${generation}/snapshot/inventory.json`,
requiredAudio: true,
},
verification,
output: null,
errorCode: null,
errorMessage: null,
createdAt: now,
updatedAt: now,
};
const payload = {
jobId: "remote-1",
videoId,
generation,
attemptId,
phase: "complete",
progress: 100,
metadata: { ...metadata },
recordingVerification: {
request: verification,
fullDecode: true,
objectIdentity: '"output-etag"',
outputKey,
outputSha256: "c".repeat(64),
sourceProof: {
version: 1,
manifestSha256,
inventorySha256,
sourcePreserved: true,
videoDuration: metadata.duration,
hasAudio: true,
audioVerified: true,
},
},
};
return { job, payload };
}
type Mutation = {
operation: "update" | "delete";
table: unknown;
values?: Record<string, unknown>;
};
function databaseFixture(initial: DesktopRecordingJob | null = fixture().job) {
let current = initial;
let rawFileKey: string | null = null;
const video: Record<string, unknown> = {
id: videoId,
ownerId,
source: { type: "desktopSegments" },
metadata: {},
storageIntegrationId: null,
bucket: null,
};
const mutations: Mutation[] = [];
const rows = (table: unknown) => {
if (table === mocks.tables.videos) return [{ ...video }];
if (table === mocks.tables.jobs)
return current ? [structuredClone(current)] : [];
if (table === mocks.tables.uploads) return [{ rawFileKey }];
throw new Error("Unexpected table");
};
const writes = (pending: Mutation[]) => ({
update: (table: unknown) => ({
set: (values: Record<string, unknown>) => ({
where: async () => {
pending.push({ operation: "update", table, values });
return [{ affectedRows: 1 }];
},
}),
}),
delete: (table: unknown) => ({
where: async () => {
pending.push({ operation: "delete", table });
return [{ affectedRows: 1 }];
},
}),
});
function transactionHandle(pending: Mutation[]) {
return {
select: () => ({
from: (table: unknown) => ({
where: () => ({ for: async () => rows(table) }),
}),
}),
...writes(pending),
};
}
const transaction = vi.fn(
async (
operation: (tx: ReturnType<typeof transactionHandle>) => Promise<unknown>,
) => {
const pending: Mutation[] = [];
const result = await operation(transactionHandle(pending));
for (const mutation of pending) {
mutations.push(mutation);
if (mutation.operation !== "update") continue;
if (mutation.table === mocks.tables.jobs && current) {
current = { ...current, ...mutation.values };
} else if (mutation.table === mocks.tables.videos) {
Object.assign(video, mutation.values);
}
}
return result;
},
);
mocks.db.mockReturnValue({
select: () => ({
from: (table: unknown) => ({ where: async () => rows(table) }),
}),
...writes(mutations),
transaction,
});
mocks.getState.mockImplementation(async () =>
current ? parseDesktopRecordingJob(structuredClone(current)) : null,
);
return {
mutations,
video,
transaction,
setRawFileKey: (key: string) => {
rawFileKey = key;
},
};
}
function request(
body: unknown = fixture().payload,
secret: string | null = "media-secret",
search = "",
) {
const headers = new Headers({ "Content-Type": "application/json" });
if (secret !== null) headers.set("x-media-server-secret", secret);
return POST(
new NextRequest(
`https://cap.so/api/webhooks/media-server/progress${search}`,
{
method: "POST",
headers,
body: JSON.stringify(body),
},
),
);
}
describe("media-server recording progress webhook", () => {
beforeEach(() => {
mocks.secret = "media-secret";
mocks.audio.mockReset().mockResolvedValue({ status: "prepared" });
mocks.storage.mockReturnValue(Effect.succeed([{ headObject: mocks.head }]));
mocks.head.mockImplementation((key: string) =>
key.endsWith(".mp4")
? Effect.succeed({
ContentLength: metadata.fileSize,
ETag: '"output-etag"',
})
: Effect.fail(new Error("Asset absent")),
);
mocks.queue.mockReset().mockResolvedValue("queued");
mocks.transcribe.mockReset().mockResolvedValue({ success: true });
mocks.invalidateQuota.mockResolvedValue(undefined);
mocks.retry.mockResolvedValue(true);
mocks.blocked.mockResolvedValue(true);
vi.spyOn(console, "log").mockImplementation(() => undefined);
vi.spyOn(console, "warn").mockImplementation(() => undefined);
vi.spyOn(console, "error").mockImplementation(() => undefined);
});
it("authenticates audio publication before dispatching it without ordinary progress updates", async () => {
const body = { kind: "audio-levels", action: "prepare" };
expect((await request(body, "wrong-secret")).status).toBe(401);
expect(mocks.audio).not.toHaveBeenCalled();
expect(await (await request(body)).json()).toEqual({ status: "prepared" });
expect(mocks.audio).toHaveBeenCalledExactlyOnceWith(body);
});
it("keeps stale edit callbacks out of recording and audio publication", async () => {
const database = databaseFixture();
const response = await POST(
new NextRequest(
"https://cap.so/api/webhooks/media-server/progress?editOperation=old-edit&editStartedAt=2026-09-08T12%3A00%3A00.000Z",
{
method: "POST",
headers: {
"Content-Type": "application/json",
"x-media-server-secret": "media-secret",
},
body: JSON.stringify(fixture().payload),
},
),
);
expect(response.status).toBe(200);
expect(await response.json()).toEqual({ success: true });
expect(database.mutations).toEqual([]);
expect(mocks.audio).not.toHaveBeenCalled();
expect(mocks.transcribe).not.toHaveBeenCalled();
});
it.each([null, "wrong-secret", "éééééééééééé"])(
"rejects unauthenticated callbacks before publication %s",
async (secret) => {
const database = databaseFixture();
expect((await request(fixture().payload, secret)).status).toBe(401);
expect(mocks.getState).not.toHaveBeenCalled();
expect(database.mutations).toEqual([]);
expect(mocks.transcribe).not.toHaveBeenCalled();
},
);
it("refuses callbacks when the webhook secret is not configured", async () => {
databaseFixture();
mocks.secret = undefined;
expect((await request()).status).toBe(401);
expect(mocks.getState).not.toHaveBeenCalled();
});
it("returns a fenced lease acknowledgement only after an authenticated worker claim", async () => {
const { job, payload } = fixture();
const database = databaseFixture({ ...job, remoteJobId: null });
const claim = {
jobId: payload.jobId,
videoId,
generation,
attemptId,
inventorySha256,
manifestSha256,
phase: "queued",
progress: 0,
recordingWorker: { version: 1, action: "claim", sequence: 0 },
};
expect((await request(claim, "wrong-secret")).status).toBe(401);
expect(database.mutations).toEqual([]);
const accepted = await request(claim);
expect(accepted.status).toBe(200);
expect(await accepted.json()).toEqual({
success: true,
recordingWorker: {
version: 1,
status: "accepted",
generation,
attemptId,
jobId: payload.jobId,
sequence: 0,
leaseDurationMs: 300_000,
},
});
const before = database.mutations.length;
const rejected = await request({ ...claim, jobId: "another-replica" });
expect(await rejected.json()).toMatchObject({
recordingWorker: { status: "owned", ownerJobId: payload.jobId },
});
expect(database.mutations).toHaveLength(before);
expect(mocks.head).not.toHaveBeenCalled();
expect(mocks.transcribe).not.toHaveBeenCalled();
});
it("publishes the fenced immutable output before queueing transcription", async () => {
const database = databaseFixture();
mocks.transcribe.mockImplementation(async () => {
expect(database.mutations).toContainEqual(
expect.objectContaining({
table: mocks.tables.jobs,
values: expect.objectContaining({ state: "verified" }),
}),
);
return { success: true };
});
const response = await request();
expect(response.status).toBe(200);
expect(await response.json()).toEqual({ success: true });
expect(database.mutations).toContainEqual(
expect.objectContaining({
table: mocks.tables.videos,
values: expect.objectContaining({
source: { type: "desktopMP4", outputKey },
}),
}),
);
expect(mocks.head).toHaveBeenCalledWith(outputKey);
expect(mocks.transcribe).toHaveBeenCalledExactlyOnceWith(videoId);
expect(mocks.queue).not.toHaveBeenCalled();
});
it("does not repeat publication or transcription for a duplicate callback", async () => {
const database = databaseFixture();
expect((await request()).status).toBe(200);
const count = database.mutations.length;
expect((await request()).status).toBe(200);
expect(database.mutations).toHaveLength(count);
expect(mocks.transcribe).toHaveBeenCalledOnce();
});
it("keeps the completed recording published if transcription is unavailable", async () => {
const database = databaseFixture();
mocks.transcribe.mockRejectedValueOnce(
new Error("Transcription unavailable"),
);
expect((await request()).status).toBe(200);
expect(database.video.source).toEqual({ type: "desktopMP4", outputKey });
});
it.each(["generation", "attempt", "remote", "expired"])(
"acknowledges but does not publish a stale %s callback",
async (reason) => {
const { job, payload } = fixture();
if (reason === "generation") job.generation = "new-generation";
if (reason === "attempt") job.attemptId = "new-attempt";
if (reason === "remote") job.remoteJobId = "new-remote-job";
if (reason === "expired") job.leaseExpiresAt = new Date(Date.now() - 1);
const database = databaseFixture(job);
expect((await request(payload)).status).toBe(200);
expect(database.mutations).toEqual([]);
expect(mocks.head).not.toHaveBeenCalled();
expect(mocks.queue).not.toHaveBeenCalled();
expect(mocks.transcribe).not.toHaveBeenCalled();
},
);
it("rejects fenced callbacks without a current job or from a different owner", async () => {
let database = databaseFixture(null);
expect((await request()).status).toBe(409);
expect(database.mutations).toEqual([]);
database = databaseFixture();
database.video.ownerId = "different-owner";
expect((await request()).status).toBe(409);
expect(database.mutations).toEqual([]);
expect(mocks.head).not.toHaveBeenCalled();
});
it.each([
{ generation: 123 },
{ generation: "" },
{ generation: undefined },
{ attemptId: undefined },
{ attemptId: {} },
{ videoId: undefined },
{ videoId: 123 },
{ jobId: undefined },
{ phase: "unexpected" },
{ progress: 101 },
{ recordingVerification: { request: verification, fullDecode: false } },
])(
"rejects malformed callbacks without falling through to legacy writes %#",
async (change) => {
const database = databaseFixture();
const response = await request({ ...fixture().payload, ...change });
expect(response.status).toBe(400);
expect(database.mutations).toEqual([]);
expect(mocks.head).not.toHaveBeenCalled();
expect(mocks.queue).not.toHaveBeenCalled();
expect(mocks.transcribe).not.toHaveBeenCalled();
},
);
it("leaves the upload pending when the remotely verified object was replaced", async () => {
const database = databaseFixture();
mocks.head.mockReturnValue(
Effect.succeed({
ContentLength: metadata.fileSize,
ETag: '"other-output"',
}),
);
const response = await request();
expect(response.status).toBeGreaterThanOrEqual(400);
expect(database.mutations).toEqual([]);
expect(mocks.transcribe).not.toHaveBeenCalled();
});
it.each(["processing-unavailable", "source-missing"])(
"routes a current %s failure to durable recovery without publishing",
async (errorCode) => {
const database = databaseFixture();
const response = await request({
...fixture().payload,
phase: "error",
errorCode,
error: "Worker failed",
});
expect(response.status).toBe(200);
expect(database.mutations).toContainEqual({
operation: "update",
table: mocks.tables.jobs,
values: expect.objectContaining({
state: errorCode === "source-missing" ? "source-blocked" : "retry",
leaseExpiresAt: null,
errorCode,
errorMessage: "Worker failed",
}),
});
expect(await mocks.getState()).toMatchObject({
source: fixture().job.source,
});
expect(
database.mutations.some(
(mutation) => mutation.table === mocks.tables.videos,
),
).toBe(false);
expect(mocks.transcribe).not.toHaveBeenCalled();
},
);
it.each([
{ sourceType: "desktopSegments", hasProof: false },
{ sourceType: "desktopMP4", hasProof: false },
{ sourceType: "desktopMP4", hasProof: true },
])(
"adopts $sourceType completion (proof: $hasProof) without publishing canonical media",
async ({ sourceType, hasProof }) => {
const database = databaseFixture(null);
database.video.source = { type: sourceType };
const proof = hasProof
? {
request: {
version: 1,
artifact: {
kind: "mp4",
fileSize: 4096,
duration: 5,
objectIdentity: '"legacy-upload"',
},
requiredAudio: true,
},
fullDecode: true,
objectIdentity: '"legacy-upload"',
}
: undefined;
const response = await request({
jobId: "legacy-worker",
videoId,
phase: "complete",
progress: 100,
metadata,
recordingVerification: proof,
});
expect(response.status).toBe(200);
expect(await response.json()).toEqual({
success: true,
status: "queued-for-verification",
});
expect(mocks.queue).toHaveBeenCalledWith({
videoId,
userId: ownerId,
verification: proof?.request,
});
expect(database.mutations).toEqual([]);
expect(mocks.head).not.toHaveBeenCalled();
expect(mocks.transcribe).not.toHaveBeenCalled();
},
);
it("accepts a legacy worker callback while durable source commitment remains pending", async () => {
const database = databaseFixture(null);
mocks.queue.mockRejectedValueOnce(new SourceCommitPendingError());
const response = await request({
jobId: "legacy-worker",
videoId,
phase: "complete",
progress: 100,
});
expect(response.status).toBe(200);
expect(await response.json()).toEqual({
success: true,
status: "queued-for-verification",
});
expect(database.mutations).toEqual([]);
expect(mocks.transcribe).not.toHaveBeenCalled();
});
it("keeps the explicit edit path for this recording's owned original source", async () => {
const database = databaseFixture(null);
database.video.source = { type: "desktopMP4" };
database.setRawFileKey(`${ownerId}/${videoId}/source/original.mp4`);
const response = await request({
jobId: "edit-worker",
videoId,
phase: "complete",
progress: 100,
metadata,
});
expect(response.status).toBe(200);
expect(mocks.queue).not.toHaveBeenCalled();
expect(database.mutations).toContainEqual(
expect.objectContaining({
operation: "update",
table: mocks.tables.uploads,
values: expect.objectContaining({ phase: "complete" }),
}),
);
expect(
database.mutations.some(({ operation }) => operation === "delete"),
).toBe(false);
expect(mocks.head).not.toHaveBeenCalled();
});
it.each([
`other-user/${videoId}/source/original.mp4`,
`${ownerId}/other-video/source/original.mp4`,
])("does not treat the foreign key %s as an edit exception", async (key) => {
const database = databaseFixture(null);
database.video.source = { type: "desktopMP4" };
database.setRawFileKey(key);
const response = await request({
jobId: "legacy-worker",
videoId,
phase: "complete",
progress: 100,
metadata,
});
expect(response.status).toBe(200);
expect(mocks.queue).toHaveBeenCalledWith({
videoId,
userId: ownerId,
verification: undefined,
});
expect(database.mutations).toEqual([]);
});
it.each(["verified", "output-replaced"])(
"preserves intentional generic replacement processing after %s",
async (state) => {
const { job } = fixture();
if (state === "verified") job.state = "verified";
else {
job.state = "source-blocked";
job.errorCode = "output-replaced";
}
const database = databaseFixture(job);
database.video.source = { type: "desktopMP4", outputKey };
database.setRawFileKey(`${ownerId}/${videoId}/replacement.mp4`);
const response = await request({
jobId: "replacement-worker",
videoId,
phase: "complete",
progress: 100,
metadata,
});
expect(response.status).toBe(200);
expect(mocks.queue).not.toHaveBeenCalled();
expect(mocks.head).not.toHaveBeenCalled();
expect(database.mutations).toContainEqual({
operation: "delete",
table: mocks.tables.uploads,
});
expect(
database.mutations.some(
({ table, values }) =>
table === mocks.tables.jobs || values?.source !== undefined,
),
).toBe(false);
},
);
it("does not discard an invalid proof while adopting an old completion", async () => {
const database = databaseFixture(null);
const response = await request({
jobId: "legacy-worker",
videoId,
phase: "complete",
progress: 100,
recordingVerification: {
request: { ...verification, version: 2 },
fullDecode: true,
},
});
expect(response.status).toBeGreaterThanOrEqual(400);
expect(mocks.queue).not.toHaveBeenCalled();
expect(database.mutations).toEqual([]);
});
it("updates only the current attempt's progress without treating it as completed", async () => {
const database = databaseFixture();
const response = await request({
...fixture().payload,
phase: "processing",
progress: 42,
message: "Verifying source media",
});
expect(response.status).toBe(200);
expect(database.mutations).toContainEqual(
expect.objectContaining({
table: mocks.tables.uploads,
values: expect.objectContaining({
phase: "processing",
processingProgress: 42,
}),
}),
);
expect(
database.mutations.some(({ table }) => table === mocks.tables.videos),
).toBe(false);
expect(mocks.head).not.toHaveBeenCalled();
expect(mocks.transcribe).not.toHaveBeenCalled();
});
it("does not let an unfenced old worker replace a managed recording", async () => {
const database = databaseFixture();
const response = await request({
jobId: "legacy-worker",
videoId,
phase: "complete",
progress: 100,
metadata,
});
expect(response.status).toBe(200);
expect(database.mutations).toEqual([]);
expect(mocks.queue).not.toHaveBeenCalled();
expect(mocks.head).not.toHaveBeenCalled();
expect(mocks.transcribe).not.toHaveBeenCalled();
});
it("never falls back to canonical publication if legacy source adoption fails", async () => {
const database = databaseFixture(null);
mocks.queue.mockRejectedValueOnce(new Error("Durable queue unavailable"));
expect(
(
await request({
jobId: "legacy-worker",
videoId,
phase: "complete",
progress: 100,
})
).status,
).toBe(500);
expect(database.mutations).toEqual([]);
expect(mocks.transcribe).not.toHaveBeenCalled();
});
it.each([
["a retryable error", "error", "Worker failed", "?retryable=true"],
[
"a media server shutdown",
"cancelled",
"Server shutting down",
"?retryable=true",
],
])(
"keeps a workflow upload processing for retry after %s",
async (_, phase, message, search) => {
const database = databaseFixture(null);
const response = await request(
{ jobId: "web-job", videoId, phase, progress: 37, message },
"media-secret",
search,
);
expect(response.status).toBe(200);
expect(database.mutations).toEqual([
{
operation: "update",
table: mocks.tables.uploads,
values: expect.objectContaining({
phase: "processing",
processingProgress: 37,
processingError: message,
processingMessage: "Retrying video processing...",
}),
},
]);
},
);
it.each([
["a deliberate cancel", "Cancelled by user", "?retryable=true"],
["a shutdown cancel without retry support", "Server shutting down", ""],
])("marks a workflow upload failed after %s", async (_, message, search) => {
const database = databaseFixture(null);
const response = await request(
{ jobId: "web-job", videoId, phase: "cancelled", progress: 37, message },
"media-secret",
search,
);
expect(response.status).toBe(200);
expect(database.mutations).toEqual([
{
operation: "update",
table: mocks.tables.uploads,
values: expect.objectContaining({
phase: "error",
processingError: message,
processingMessage: message,
}),
},
]);
});
});
describe("Loom importer completions", () => {
const complete = (extra: Record<string, unknown> = {}) => ({
jobId: "importer-1",
videoId,
phase: "complete",
progress: 100,
metadata,
...extra,
});
const metadataWrites = (mutations: Mutation[]) =>
mutations
.filter(
({ table, values }) =>
table === mocks.tables.videos && values?.metadata !== undefined,
)
.map(({ values }) =>
new MySqlDialect().sqlToQuery(values?.metadata as SQL),
);
beforeEach(() => {
mocks.transcribe.mockReset().mockResolvedValue({ success: true });
mocks.queue.mockReset();
vi.spyOn(console, "log").mockImplementation(() => undefined);
});
function loomVideo() {
const database = databaseFixture(null);
database.video.source = { type: "webMP4" };
return database;
}
it("leaves transcription for the first view of importer completions", async () => {
const database = loomVideo();
const response = await request(
complete(),
"media-secret",
"?retryable=true&transcription=on-view",
);
expect(response.status).toBe(200);
expect(mocks.transcribe).not.toHaveBeenCalled();
const [write] = metadataWrites(database.mutations);
expect(write?.sql).toContain(
"'$.transcribeOnView', JSON_EXTRACT('true', '$')",
);
expect(write?.sql).not.toContain("loomDeferredProcessing");
expect(database.mutations).toContainEqual({
operation: "delete",
table: mocks.tables.uploads,
});
});
it("records an imported original that still needs processing", async () => {
const database = loomVideo();
const key = `${ownerId}/${videoId}/raw-upload.webm`;
await request(
complete({ deferredSourceKey: key }),
"media-secret",
"?retryable=true&transcription=on-view",
);
const [write] = metadataWrites(database.mutations);
expect(write?.sql).toContain(
"JSON_OBJECT('rawFileKey', ?, 'status', 'pending')",
);
expect(write?.params).toContain(key);
});
it.each([
`other-user/${videoId}/raw-upload.webm`,
`${ownerId}/other-video/raw-upload.webm`,
`${ownerId}/${videoId}/result.mp4`,
])("ignores the deferred original %s", async (key) => {
const database = loomVideo();
await request(
complete({ deferredSourceKey: key }),
"media-secret",
"?retryable=true&transcription=on-view",
);
for (const write of metadataWrites(database.mutations))
expect(write.sql).not.toContain("loomDeferredProcessing");
});
it("keeps an existing deferred claim when a completion is repeated", async () => {
const database = loomVideo();
await request(
complete({ deferredSourceKey: `${ownerId}/${videoId}/raw-upload.webm` }),
"media-secret",
"?retryable=true&transcription=on-view",
);
const [write] = metadataWrites(database.mutations);
expect(write?.sql).toContain(
"IF(JSON_EXTRACT(?, '$.loomDeferredProcessing') IS NULL",
);
});
it("marks a deferred original complete once it has been processed", async () => {
const database = loomVideo();
const key = `${ownerId}/${videoId}/raw-upload.webm`;
database.video.metadata = {
loomDeferredProcessing: { rawFileKey: key, status: "started" },
};
database.setRawFileKey(key);
await request(complete(), "media-secret", "?retryable=true");
const [write] = metadataWrites(database.mutations);
expect(write?.sql).toContain(
"'$.loomDeferredProcessing.status', 'complete'",
);
expect(mocks.transcribe).toHaveBeenCalledWith(videoId);
});
it("leaves the preview GIF for the first view of importer completions", async () => {
const database = loomVideo();
await request(
complete(),
"media-secret",
"?retryable=true&transcription=on-view&preview=on-view",
);
const [write] = metadataWrites(database.mutations);
expect(write?.sql).toContain(
"'$.loomPreviewGif', COALESCE(JSON_EXTRACT(?, '$.loomPreviewGif'), JSON_OBJECT('status', 'pending'))",
);
});
it("does not wait for a preview view when the original still needs processing", async () => {
const database = loomVideo();
await request(
complete({ deferredSourceKey: `${ownerId}/${videoId}/raw-upload.webm` }),
"media-secret",
"?retryable=true&transcription=on-view&preview=on-view",
);
for (const write of metadataWrites(database.mutations))
expect(write.sql).not.toContain("loomPreviewGif");
});
it("wakes the waiting import once the finished state is saved", async () => {
const database = loomVideo();
mocks.signal.mockReset().mockImplementation(async () => {
expect(database.mutations).toContainEqual({
operation: "delete",
table: mocks.tables.uploads,
});
});
const token = `loom-import:${videoId}:run-1:0`;
const response = await request(
complete(),
"media-secret",
`?retryable=true&signal=${encodeURIComponent(token)}`,
);
expect(response.status).toBe(200);
expect(mocks.signal).toHaveBeenCalledWith(token, videoId, "complete");
});
it("wakes the waiting import when the worker fails", async () => {
loomVideo();
mocks.signal.mockReset().mockResolvedValue(undefined);
await request(
{
jobId: "importer-1",
videoId,
phase: "error",
progress: 40,
error: "Loom 404",
},
"media-secret",
"?retryable=true&signal=loom-import%3Aowned-video%3Arun-1%3A0",
);
expect(mocks.signal).toHaveBeenCalledWith(
"loom-import:owned-video:run-1:0",
videoId,
"error",
);
});
it("does not wake the import for progress updates", async () => {
loomVideo();
mocks.signal.mockReset().mockResolvedValue(undefined);
await request(
{ jobId: "importer-1", videoId, phase: "downloading", progress: 40 },
"media-secret",
"?retryable=true&signal=loom-import%3Aowned-video%3Arun-1%3A0",
);
expect(mocks.signal).not.toHaveBeenCalled();
});
it("keeps queueing transcription for media server completions", async () => {
const database = loomVideo();
await request(
complete({ deferredSourceKey: `${ownerId}/${videoId}/raw-upload.webm` }),
"media-secret",
"?retryable=true",
);
expect(mocks.transcribe).toHaveBeenCalledWith(videoId);
expect(
metadataWrites(database.mutations).some(({ sql }) =>
sql.includes("transcribeOnView"),
),
).toBe(false);
});
});