Skip to content

Open source CapCut alternative.

TypeScript
8.1 KB
Raw Blame
import { describe, expect, mock, test } from "bun:test";
import type { prisma } from "@/lib/prisma";
import { SETTINGS } from "@/lib/config/registry";
import { projectTools } from "@/clients/chatgpt/server/projects";

// A preview's playback URL is signed, so the status tools reach the media CDN.
// The value is never asserted, but it has to exist: without it the CDN refuses
// to sign and the tools throw. A developer's .env carries one and CI does not,
// so naming it here is what keeps the two honest.
process.env.CUT_MEDIA_SIGNING_SECRET = "test-media-signing-secret";

const config = SETTINGS.chatgptApp.schema.parse(SETTINGS.chatgptApp.default);
function createTestContext(scopes: string[] = ["projects:read"]) {
  const project = { id: "mine", userId: "owner", name: "My video", version: 4, previewKey: "proxy" };
  const jobs = mock(async (args: unknown) => {
    void args;
    return null as unknown;
  });
  const db = {
    cutProject: {
      findFirst: mock(
        async ({ where }: { where: { id: string; userId: string } }) =>
          where.id === project.id && where.userId === project.userId
            ? project
            : null,
      ),
      findMany: mock(async (args: unknown) => {
        void args;
        return [project];
      }),
    },
    cutRenderJob: { findFirst: jobs },
    chatgptToken: {
      create: mock(async (args: { data: { hash: string; grantId: string; kind: string } }) => args.data),
    },
    cutMediaObject: {
      findFirst: mock(async (args: unknown) => {
        void args;
        return null as unknown;
      }),
    },
  };
  return {
    db,
    tools: projectTools(
      { userId: "owner", scopes, grantId: "grant" },
      config,
      db as unknown as typeof prisma,
    ),
  };
}

describe("ChatGPT cloud projects", () => {
  test("foreign projects and cursors fail before reading previews or listing", async () => {
    const { tools, db } = createTestContext();
    await expect(tools.status("foreign", "preview")).rejects.toThrow(
      "Project not found",
    );
    await expect(tools.list("foreign")).rejects.toThrow("Project not found");
    expect(db.cutRenderJob.findFirst).not.toHaveBeenCalled();
    expect(db.cutProject.findMany).not.toHaveBeenCalled();
  });
  test("opening a project the account no longer has answers a typed missing view", async () => {
    const { tools, db } = createTestContext(["projects:read", "projects:write"]);
    const gone = await tools.withEditor(await tools.open("foreign"));
    expect(gone.view).toMatchObject({ view: "missing", project: null, missing: { id: "foreign" } });
    expect(gone.editor).toBeUndefined();
    expect(db.cutRenderJob.findFirst).not.toHaveBeenCalled();
    const opened = await tools.open("mine");
    expect(opened.view).toMatchObject({ view: "project", project: { id: "mine" }, missing: null });
  });
  test("read scope cannot enqueue renders or edits", async () => {
    const { tools } = createTestContext();
    await expect(tools.render("mine")).rejects.toThrow("permission");
    await expect(tools.edit("mine", [{ name: "set_aspect", input: { aspect: "9:16" } }])).rejects.toThrow("permission");
    await expect(tools.undo("mine")).rejects.toThrow("permission");
    await expect(tools.exportVideo("mine", "original")).rejects.toThrow("permission");
  });
  test("a batch names only catalog commands, and inspection stays read-only", async () => {
    const { tools } = createTestContext(["projects:read", "projects:write"]);
    await expect(tools.edit("mine", [{ name: "not_a_command", input: {} }])).rejects.toThrow("Unknown command: not_a_command");
    await expect(tools.edit("foreign", [{ name: "set_aspect", input: {} }])).rejects.toThrow("Project not found");
    await expect(tools.inspect("mine", [{ name: "set_aspect", input: { aspect: "9:16" } }])).rejects.toThrow("reads only");
  });
  test("status is constrained to the owner, selected project, and preview kind", async () => {
    const { tools, db } = createTestContext();
    await expect(tools.status("mine", "foreign-job")).rejects.toThrow(
      "Preview not found",
    );
    expect(db.cutRenderJob.findFirst.mock.calls[0][0]).toMatchObject({
      where: {
        userId: "owner",
        projectId: "mine",
        kind: "preview",
        id: "foreign-job",
      },
    });
  });
  test("an export that never asked for stems reports none, even beside an older zip of its name", async () => {
    const { tools, db } = createTestContext();
    const row = { id: "job", kind: "export", projectId: "mine", state: "done", progress: 1, outputKey: "cut/owner/mine/exports/Trip.mp4", outName: "Trip.mp4" };
    db.cutRenderJob.findFirst.mockResolvedValue({ ...row, spec: { fromDoc: { preset: "original" } } });
    db.cutMediaObject.findFirst.mockImplementation(async (args: unknown) => {
      const where = (args as { where: { r2Key?: string; fileName?: string } }).where;
      return where.r2Key ? { r2Key: where.r2Key } : { fileName: where.fileName };
    });
    expect((await tools.exportStatus("job")).view.export?.stems).toBeUndefined();
    db.cutRenderJob.findFirst.mockResolvedValue({ ...row, spec: { fromDoc: { preset: "original", stems: true } } });
    expect((await tools.exportStatus("job")).view.export?.stems).toBe("Trip stems.zip");
  });
  test("collected artifacts are reported as expired with no playback URL", async () => {
    const { tools, db } = createTestContext();
    db.cutRenderJob.findFirst.mockResolvedValue({
      id: "job",
      state: "done",
      progress: 1,
      outputKey: "old-preview",
      spec: { revision: "cloud:3" },
    });
    const result = await tools.status("mine", "job");
    expect(result.view.preview?.status).toBe("expired");
    expect(result.playback).toBeNull();
    expect(result.view.project?.revision).toBe("cloud:4");
  });
  test("the editor's proxy is the current preview, so render plays it without queueing", async () => {
    const { tools, db } = createTestContext(["projects:read", "previews:render"]);
    db.cutRenderJob.findFirst.mockResolvedValue({ id: "job", state: "done", progress: 1, outputKey: "proxy", spec: { spec: {} }, updatedAt: new Date() });
    db.cutMediaObject.findFirst.mockResolvedValue({ r2Key: "proxy" });
    const opened = await tools.status("mine");
    expect(opened.view.preview?.revision).toBe("cloud:4");
    expect(opened.playback?.url).toContain("proxy");
    const rendered = await tools.render("mine");
    expect(rendered.view.preview?.id).toBe("job");
    expect(rendered.playback?.url).toContain("proxy");
  });
  test("a card with write scope carries a one-use link to the editor or the projects home; read scope gets none", async () => {
    const readOnly = createTestContext();
    expect((await readOnly.tools.withEditor(await readOnly.tools.status("mine"))).editor).toBeUndefined();
    expect((await readOnly.tools.withEditor(await readOnly.tools.list())).editor).toBeUndefined();
    expect(readOnly.db.chatgptToken.create).not.toHaveBeenCalled();
    const { tools, db } = createTestContext(["projects:read", "projects:write"]);
    const home = await tools.withEditor(await tools.list());
    expect(/^https:\/\/donkeycut\.com\/api\/chatgpt\/embed\?code=[A-Za-z0-9_-]{43}$/.test(home.editor?.url ?? "")).toBe(true);
    const result = await tools.withEditor(await tools.status("mine"));
    expect(/^https:\/\/donkeycut\.com\/api\/chatgpt\/embed\?code=[A-Za-z0-9_-]{43}&project=mine$/.test(result.editor?.url ?? "")).toBe(true);
    expect(db.chatgptToken.create.mock.calls[0][0].data).toMatchObject({ grantId: "grant", kind: "embed" });
    expect(result.view.project?.id).toBe("mine");
  });
  test("list returns only public project metadata and paging state", async () => {
    const { tools, db } = createTestContext();
    const result = await tools.list();
    expect(result.view.projects).toEqual([
      {
        id: "mine",
        name: "My video",
        revision: "cloud:4",
        url: "https://donkeycut.com/app/p/mine",
      },
    ]);
    expect(db.cutProject.findMany.mock.calls[0][0]).toMatchObject({
      where: { userId: "owner" },
      orderBy: [{ updatedAt: "desc" }, { id: "desc" }],
      take: 21,
      select: { id: true, name: true, version: true },
    });
    expect(result.view.canRender).toBe(false);
  });
});