reelkit-cli 0.3.1 → 0.5.0

package/src/testing/conformance.ts

@@ -23,8 +23,11 @@ export type Harness = {
   // Optional, for the cutout tests. A file name that makes a cutout job fail (the fake fails any name containing "cutout-fail"); without
   // it the failing-job case is skipped. The cutout tests wait between status asks for `clipPollMs` too.
   cutoutFailFilename?: string;
+  // Optional, for the transcript tests. A file name that makes a transcription fail (the fake fails any name containing "transcribe-fail");
+  // without it the failing-job case is skipped.
+  transcribeFailFilename?: string;
 };
-export type StartOptions = { voiceoverChars?: number; images?: number; clips?: number; cutoutSeconds?: number };
+export type StartOptions = { voiceoverChars?: number; images?: number; clips?: number; cutoutSeconds?: number; transcribeSeconds?: number };
 
 const PNG = new Uint8Array(Buffer.from("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==", "base64"));
 const DATE = /\d{4}-\d{2}-\d{2}/;
@@ -87,6 +90,8 @@ export function runConformance(name: string, start: (opts: StartOptions) => Prom
         expect(me.quota.clips.limit).toBeGreaterThan(0);
         expect(me.quota.cutoutSeconds.used).toBe(0);
         expect(me.quota.cutoutSeconds.limit).toBeGreaterThan(0);
+        expect(me.quota.transcribeSeconds.used).toBe(0);
+        expect(me.quota.transcribeSeconds.limit).toBeGreaterThan(0);
         expect(me.quota.voiceoverChars.limit).toBeGreaterThan(0);
         expect(me.contributions).toBe(0);
         const resets = new Date(me.quota.resetsAt);
@@ -522,6 +527,107 @@ export function runConformance(name: string, start: (opts: StartOptions) => Prom
       });
     });
 
+    describe("transcripts", () => {
+      const AUDIO = new Uint8Array([73, 68, 51, 4, ...new Array(2000).fill(9)]);
+      const meta = (over: Record<string, unknown> = {}) => ({ filename: "talk.mp3", contentType: "audio/mpeg" as const, bytes: AUDIO.length, durationSec: 12.4, ...over });
+      const sent = async (api: Api, over: Record<string, unknown> = {}) => {
+        const started = await api("transcribeStart", meta(over) as never);
+        await put(started.uploadUrl, AUDIO, (over.contentType as string | undefined) ?? "audio/mpeg");
+        return started;
+      };
+
+      it("start, upload, run: text and segments with increasing times inside the audio; charged in whole seconds to this user only", async () => {
+        const api = await as("user-trn0000001"), other = await as("user-trn0000002");
+        const started = await api("transcribeStart", meta());
+        expect(started.id).toBeTruthy();
+        expect(started.uploadUrl).toBeTruthy();
+        expect((await api("me", {})).quota.transcribeSeconds.used).toBe(0);
+        expect((await put(started.uploadUrl, AUDIO, "audio/mpeg")).ok).toBe(true);
+        const t = await api("transcribeRun", { id: started.id });
+        expect(t.id).toBe(started.id);
+        expect(t.text.length).toBeGreaterThan(0);
+        expect(t.durationSec).toBeGreaterThan(0);
+        expect(t.segments.length).toBeGreaterThan(0);
+        let last = 0;
+        for (const s of t.segments) {
+          expect(s.text.length).toBeGreaterThan(0);
+          expect(s.startSec).toBeGreaterThanOrEqual(last);
+          expect(s.endSec).toBeGreaterThanOrEqual(s.startSec);
+          expect(s.endSec).toBeLessThanOrEqual(t.durationSec + 0.5);
+          last = s.endSec;
+        }
+        expect((await api("me", {})).quota.transcribeSeconds.used).toBe(13);
+        expect((await other("me", {})).quota.transcribeSeconds.used).toBe(0);
+      });
+
+      it("a run before the audio arrived is invalid_request and charges nothing", async () => {
+        const api = await as("user-trn0000003");
+        const started = await api("transcribeStart", meta());
+        expect((await failure(api("transcribeRun", { id: started.id }))).code).toBe("invalid_request");
+        expect((await api("me", {})).quota.transcribeSeconds.used).toBe(0);
+        await put(started.uploadUrl, AUDIO, "audio/mpeg");
+        expect((await api("transcribeRun", { id: started.id })).text.length).toBeGreaterThan(0);
+      });
+
+      it("running twice returns the same transcript and charges once", async () => {
+        const api = await as("user-trn0000004");
+        const started = await sent(api);
+        const first = await api("transcribeRun", { id: started.id });
+        const second = await api("transcribeRun", { id: started.id });
+        expect(second).toEqual(first);
+        expect((await api("me", {})).quota.transcribeSeconds.used).toBe(13);
+      });
+
+      it("a transcript id belongs to its caller: another user, or an unknown id, is not_found", async () => {
+        const api = await as("user-trn0000005"), other = await as("user-trn0000006");
+        const started = await sent(api);
+        await api("transcribeRun", { id: started.id });
+        expect((await failure(other("transcribeRun", { id: started.id }))).code).toBe("not_found");
+        expect((await failure(api("transcribeRun", { id: "tr-nosuchjob" }))).code).toBe("not_found");
+        expect((await other("me", {})).quota.transcribeSeconds.used).toBe(0);
+      });
+
+      it("a failing job is a server error and is not charged", async () => {
+        if (!h.transcribeFailFilename) return;
+        const api = await as("user-trn0000007");
+        const started = await sent(api, { filename: h.transcribeFailFilename });
+        expect((await failure(api("transcribeRun", { id: started.id }))).code).toBe("server_error");
+        expect((await api("me", {})).quota.transcribeSeconds.used).toBe(0);
+      });
+
+      it("at the limit a run is quota_exceeded with the reset date, charged nothing; other users are unaffected", async () => {
+        const t = await start({ transcribeSeconds: 5 });
+        try {
+          const api = createClient({ baseUrl: t.baseUrl, token: await t.login("user-trnq000001") });
+          const other = createClient({ baseUrl: t.baseUrl, token: await t.login("user-trnq000002") });
+          const first = await sent(api, { durationSec: 3 });
+          await api("transcribeRun", { id: first.id });
+          const second = await sent(api, { durationSec: 3 });
+          const e = await failure(api("transcribeRun", { id: second.id }));
+          expect(e.code).toBe("quota_exceeded");
+          expect(e.message).toMatch(DATE);
+          const me = await api("me", {});
+          expect(me.quota.transcribeSeconds).toEqual({ used: 3, limit: 5 });
+          expect(e.message).toContain(me.quota.resetsAt.slice(0, 10));
+          const third = await sent(other, { durationSec: 3 });
+          expect((await other("transcribeRun", { id: third.id })).text.length).toBeGreaterThan(0);
+        } finally { await t.close(); }
+      });
+
+      it("refuses audio over 600 seconds, a type that is not audio, a size out of range and a missing login", async () => {
+        const api = await as("user-trn0000008");
+        for (const bad of [{ durationSec: 600.5 }, { durationSec: 0 }, { durationSec: -1 }, { contentType: "video/mp4" }, { bytes: 0 }, { bytes: 26_214_401 }, { filename: "a\u0000b.mp3" }]) {
+          expect((await failure(api("transcribeStart", meta(bad) as never))).code, JSON.stringify(bad)).toBe("invalid_request");
+        }
+        for (const ok of [{ durationSec: 600 }, { contentType: "audio/mp4" as const }, { contentType: "audio/wav" as const }, { bytes: 26_214_400 }]) {
+          expect((await api("transcribeStart", meta(ok))).id).toBeTruthy();
+        }
+        expect((await failure(api("transcribeRun", { id: "../x" }))).code).toBe("invalid_request");
+        expect((await failure(anon("transcribeStart", meta()))).code).toBe("unauthenticated");
+        expect((await failure(anon("transcribeRun", { id: "tr-x" }))).code).toBe("unauthenticated");
+      });
+    });
+
     describe("quota", () => {
       it("passes exactly at the limit; one over is quota_exceeded with the reset date; other users are unaffected", async () => {
         const t = await start({ voiceoverChars: 10, images: 1 });

package/src/testing/fake-api.ts

@@ -81,10 +81,14 @@ function makeCutout(): Blob {
   } finally { rmSync(dir, { recursive: true, force: true }); }
 }
 
+// A transcript job: the audio arrives at the upload URL; `run` reserves the seconds, deletes the audio and keeps the answer, so a second run is free.
+type TranscriptJob = { owner: string; filename: string; durationSec: number; file?: Uint8Array; result?: { id: string; text: string; language: string; segments: { text: string; startSec: number; endSec: number }[]; durationSec: number } };
+const TRANSCRIBE_FAIL = "transcribe-fail";
+
 export type FakeApi = Awaited<ReturnType<typeof startFakeApi>>;
 
 // An in-memory stand-in for the Reelkit API. It implements every route in the contract.
-export async function startFakeApi(opts: { voiceoverCharLimit?: number; imageLimit?: number; clipLimit?: number; noClipProvider?: boolean; cutoutSecondsLimit?: number; noCutoutService?: boolean; autoApprove?: boolean } = {}) {
+export async function startFakeApi(opts: { voiceoverCharLimit?: number; imageLimit?: number; clipLimit?: number; noClipProvider?: boolean; cutoutSecondsLimit?: number; noCutoutService?: boolean; transcribeSecondsLimit?: number; autoApprove?: boolean } = {}) {
   // token -> the user it belongs to
   const tokens = new Map<string, string>();
   const devices = new Map<string, { userCode: string; approved: boolean; userId: string }>();
@@ -96,15 +100,16 @@ export async function startFakeApi(opts: { voiceoverCharLimit?: number; imageLim
   // `sink` is where the accepted bytes go: a library item, or a cutout job.
   const uploads = new Map<string, { contentType: string; bytes: number; used: boolean; sink: { has(): boolean; put(bytes: Uint8Array): void } | undefined }>();
   // Totals over every user (for tests of the CLI), and the same counts per user (what a quota is measured against).
-  const usage = { chars: 0, images: 0, clips: 0, cutoutSeconds: 0, pulls: 0, uploads: 0 };
-  const meters = new Map<string, { chars: number; images: number; clips: number; cutoutSeconds: number; uploads: number }>();
+  const usage = { chars: 0, images: 0, clips: 0, cutoutSeconds: 0, transcribeSeconds: 0, pulls: 0, uploads: 0 };
+  const meters = new Map<string, { chars: number; images: number; clips: number; cutoutSeconds: number; transcribeSeconds: number; uploads: number }>();
   const meter = (userId: string | undefined) => {
     const id = userId ?? "u-test";
-    if (!meters.has(id)) meters.set(id, { chars: 0, images: 0, clips: 0, cutoutSeconds: 0, uploads: 0 });
+    if (!meters.has(id)) meters.set(id, { chars: 0, images: 0, clips: 0, cutoutSeconds: 0, transcribeSeconds: 0, uploads: 0 });
     return meters.get(id)!;
   };
   const resetDate = () => nextMonthStart().toISOString();
-  const limits = { chars: opts.voiceoverCharLimit ?? 10_000, images: opts.imageLimit ?? 30, clips: opts.clipLimit ?? 5, cutoutSeconds: opts.cutoutSecondsLimit ?? 120 };
+  const limits = { chars: opts.voiceoverCharLimit ?? 10_000, images: opts.imageLimit ?? 30, clips: opts.clipLimit ?? 5, cutoutSeconds: opts.cutoutSecondsLimit ?? 120, transcribeSeconds: opts.transcribeSecondsLimit ?? 1800 };
+  const transcripts = new Map<string, TranscriptJob>();
   const jobs = new Map<string, ClipJob>();
   const cutouts = new Map<string, CutoutJob>();
   let cutoutFile: Blob | undefined;
@@ -141,7 +146,7 @@ export async function startFakeApi(opts: { voiceoverCharLimit?: number; imageLim
       const m = meter(userId);
       return {
         userId: userId ?? "u-test", handle: handleOf(userId ?? "u-test"),
-        quota: { voiceoverChars: { used: m.chars, limit: limits.chars }, images: { used: m.images, limit: limits.images }, clips: { used: m.clips, limit: limits.clips }, cutoutSeconds: { used: m.cutoutSeconds, limit: limits.cutoutSeconds }, resetsAt: resetDate() },
+        quota: { voiceoverChars: { used: m.chars, limit: limits.chars }, images: { used: m.images, limit: limits.images }, clips: { used: m.clips, limit: limits.clips }, cutoutSeconds: { used: m.cutoutSeconds, limit: limits.cutoutSeconds }, transcribeSeconds: { used: m.transcribeSeconds, limit: limits.transcribeSeconds }, resetsAt: resetDate() },
         // What the user gave the shared library that was accepted: their own items that are published. One waiting for review does not count.
         contributions: [...store.values()].filter((x) => x.owner === userId && x.committed && x.item.visibility === "published").length,
       };
@@ -281,6 +286,37 @@ export async function startFakeApi(opts: { voiceoverCharLimit?: number; imageLim
       }
       return { id, status: "done", url: fileUrl((cutoutFile ??= makeCutout())), ext: "webm", contentType: "video/webm" };
     },
+    transcribeStart: (input, { userId }) => {
+      const id = nextId("tr");
+      const job: TranscriptJob = { owner: userId ?? "u-test", filename: input.filename, durationSec: input.durationSec };
+      transcripts.set(id, job);
+      const token = secret();
+      uploads.set(token, { contentType: input.contentType, bytes: input.bytes, used: false, sink: { has: () => Boolean(job.file), put: (bytes) => { job.file = bytes; } } });
+      return { id, uploadUrl: `${origin}/upload/${token}` };
+    },
+    transcribeRun: ({ id }, { userId }) => {
+      const job = transcripts.get(id);
+      if (!job || job.owner !== (userId ?? "u-test")) throw new Fail(404, "not_found", `No transcript with id ${id}.`);
+      // Asked again, it answers the same transcript without a second charge.
+      if (job.result) return job.result;
+      if (!job.file) throw new Fail(400, "invalid_request", `Nothing was uploaded for ${id}. Send the audio to the upload URL first.`);
+      const seconds = Math.ceil(job.durationSec);
+      const m = meter(userId);
+      if (m.transcribeSeconds + seconds > limits.transcribeSeconds) throw new Fail(429, "quota_exceeded", `Transcription quota used up. It resets on ${resetDate().slice(0, 10)}.`);
+      // The audio is deleted when the call ends, whatever the result; a failure never keeps the seconds.
+      job.file = undefined;
+      if (job.filename.includes(TRANSCRIBE_FAIL)) throw new Fail(500, "server_error", "The audio could not be transcribed.");
+      m.transcribeSeconds += seconds;
+      usage.transcribeSeconds += seconds;
+      const base = job.filename.replace(/\.[^.]*$/, "").replace(/[^A-Za-z0-9]+/g, " ").trim() || "audio";
+      const half = Math.round((job.durationSec / 2) * 100) / 100;
+      job.result = {
+        id, language: "en", durationSec: job.durationSec,
+        text: `This is ${base}. It ends here.`,
+        segments: [{ text: `This is ${base}.`, startSec: 0, endSec: half }, { text: "It ends here.", startSec: half, endSec: job.durationSec }],
+      };
+      return job.result;
+    },
     publicLibrary: ({ q, kind, page }) => {
       // Published items only. Newest first; with a query, best match first and equal matches newest first.
       const want = q ? words(q) : undefined;
@@ -348,6 +384,8 @@ export async function startFakeApi(opts: { voiceoverCharLimit?: number; imageLim
     setClipLimit(n: number) { limits.clips = n; },
     // The same for the seconds of video a user may have cut out.
     setCutoutLimit(n: number) { limits.cutoutSeconds = n; },
+    // The same for the seconds of audio a user may have transcribed.
+    setTranscribeLimit(n: number) { limits.transcribeSeconds = n; },
     // Stops cutout jobs from finishing (true) or lets them finish again (false).
     holdCutouts(hold: boolean) { cutoutsHeld = hold; },
     approve(userCode: string, userId = "u-test") { for (const d of devices.values()) if (d.userCode === userCode) { d.approved = true; d.userId = userId; } },