Skip to content

AI media harness for planning, generating, and editing locally

TypeScript
21.7 KB
Raw Blame
// @vitest-environment jsdom
import { act, cleanup, fireEvent, render, screen, within, waitFor } from "@testing-library/react";
import { useState } from "react";
import { afterEach, describe, expect, it, vi } from "vitest";
import { timelineClipSchema, type TimelineClip } from "../../lib/project";
import { DEFAULT_CREATIVE, DEFAULT_WHEELS, parseCube } from "../../lib/effectSettings";
import { ClipEffects } from "./ClipEffects";
import { choose } from "./comboTestUtils";

vi.mock("@tauri-apps/api/core", () => ({ invoke: vi.fn() }));

afterEach(cleanup);
const original: TimelineClip = {
  id: "clip", assetId: "asset", trackId: "video", label: "Clip", startMs: 0,
  durationMs: 2000, sourceStartMs: 0, status: "approved",
};
function Harness() {
  const [clip, setClip] = useState(original);
  return <><ClipEffects clip={clip} disabled={false} onChange={(patch) => setClip((current) => timelineClipSchema.parse({ ...current, ...patch }))} /><output data-testid="saved">{JSON.stringify(clip)}</output></>;
}
const saved = () => JSON.parse(screen.getByTestId("saved").textContent!);
const add = (name: string) => {
  fireEvent.click(screen.getByRole("button", { name: "Add effect" }));
  fireEvent.click(within(screen.getByRole("group", { name: "Available effects" })).getByRole("button", { name }));
};
const remove = (name: string) => {
  fireEvent.click(screen.getByRole("button", { name: `${name} options` }));
  fireEvent.click(screen.getByRole("menuitem", { name: /Remove/ }));
};

/* pickFile and readLutFile both go through invoke once the page believes it is
   inside Tauri: pick_file answers with a path, read_lut_file with its text. */
async function inTauri(answers: Record<string, (args: unknown) => unknown>, body: () => Promise<void>) {
  const { invoke } = await import("@tauri-apps/api/core");
  (window as unknown as Record<string, unknown>).__TAURI_INTERNALS__ = {};
  vi.mocked(invoke).mockImplementation(async (command: string, args?: unknown) => answers[command]?.(args) as never);
  try { await body(); } finally {
    delete (window as unknown as Record<string, unknown>).__TAURI_INTERNALS__;
    vi.mocked(invoke).mockReset();
  }
}

const CUBE = "LUT_3D_SIZE 2\n0 0 0\n1 0 0\n0 1 0\n1 1 0\n0 0 1\n1 0 1\n0 1 1\n1 1 1";

describe("clip effects", () => {
  it("accepts typed effect values, enforces bounds, and resets both controls", () => {
    render(<Harness />);
    add("Basic Corrections");
    const number = screen.getByRole("spinbutton", { name: "Exposure value" }) as HTMLInputElement;
    fireEvent.change(number, { target: { value: "-1.3" } });
    expect(saved().colorCorrection.exposure).toBe(-1.3);
    expect((screen.getByRole("slider", { name: "Exposure" }) as HTMLInputElement).value).toBe("-1.3");
    fireEvent.change(number, { target: { value: "9" } });
    fireEvent.blur(number);
    expect(saved().colorCorrection.exposure).toBe(4);
    fireEvent.click(screen.getByRole("button", { name: "Reset exposure" }));
    expect(number.value).toBe("0");
    add("Transition");
    const duration = screen.getByRole("spinbutton", { name: "Transition duration value" });
    fireEvent.change(duration, { target: { value: "725.5" } });
    fireEvent.blur(duration);
    expect(saved().transition.durationMs).toBe(726);
  });
  it("selects backdrop presets, keeps matte levels valid, and bypasses without losing controls", () => {
    render(<Harness />);
    add("Chroma key");
    choose("Chroma key backdrop", "Blue");
    expect(saved().chromaKey).toMatchObject({ backdrop: "blue", color: "#0000ff" });
    expect(screen.queryByRole("slider", { name: "Chroma key tolerance" })).toBeNull();
    fireEvent.change(screen.getByRole("slider", { name: "Chroma key clip black" }), { target: { value: "98" } });
    expect(saved().chromaKey).toMatchObject({ clipBlack: 98, clipWhite: 99 });
    fireEvent.click(screen.getByRole("checkbox", { name: "Fill tiny holes" }));
    expect(saved().chromaKey.fillHoles).toBe(true);
    fireEvent.click(screen.getByRole("checkbox", { name: "Chroma key on" }));
    expect(saved().chromaKey).toMatchObject({ enabled: false, backdrop: "blue", fillHoles: true });
    expect(screen.getByRole("slider", { name: "Chroma key screen gain" })).toBeTruthy();
    fireEvent.click(screen.getByRole("checkbox", { name: "Chroma key on" }));
    choose("Chroma key backdrop", "Black");
    expect(saved().chromaKey.color).toBe("#000000");
    expect(screen.queryByRole("slider", { name: "Chroma key despill" })).toBeNull();
    choose("Chroma key backdrop", "Custom color");
    expect(screen.getByRole("slider", { name: "Chroma key tolerance" })).toBeTruthy();
  });
  it("disables Paste settings until settings have been copied", () => {
    render(<ClipEffects clip={{ ...original, sharpen: { amount: 50 } }} disabled={false} onChange={vi.fn()} />);
    fireEvent.click(screen.getByRole("button", { name: "Sharpen options" }));
    expect((screen.getByRole("menuitem", { name: "Paste settings" }) as HTMLButtonElement).disabled).toBe(true);
  });

  it.each([
    { name: "Opacity", patch: { look: { opacity: 65, enabled: false } } },
    { name: "Transition", patch: { transition: { type: "wipe-left", durationMs: 1200 } } },
    { name: "Chroma key", patch: { chromaKey: { color: "#123456", tolerance: 43 } } },
    { name: "Sharpen", patch: { sharpen: { amount: 125 } } },
    { name: "Gaussian blur", patch: { blur: { radius: 8.5 } } },
    { name: "Basic Corrections", patch: { colorCorrection: { exposure: -1.2, brightness: 35, contrast: 20, saturation: 75 } } },
    { name: "Vignette", patch: { vignette: { amount: 75 } } },
    { name: "Creative", patch: { creative: { ...DEFAULT_CREATIVE, look: "Night", intensity: 45 } } },
    { name: "Curves", patch: { curves: { rgb: [[0, 0], [.4, .6], [1, 1]], enabled: false } } },
    { name: "Color Wheels", patch: { colorWheels: { ...DEFAULT_WHEELS, shadows: { x: .2, y: -.4, lightness: 10 } } } },
    { name: "3D LUT", patch: { lut: { intensity: 45, table: parseCube(CUBE, "identity.cube") } } },
  ] satisfies { name: string; patch: Partial<TimelineClip> }[])("copies $name settings to another clip as one independent edit", ({ name, patch }) => {
    const onChange = vi.fn();
    const source = timelineClipSchema.parse({ ...original, ...patch });
    const view = render(<ClipEffects clip={source} disabled={false} onChange={onChange} />);
    fireEvent.click(screen.getByRole("button", { name: `${name} options` }));
    fireEvent.click(screen.getByRole("menuitem", { name: "Copy settings" }));
    expect(onChange).not.toHaveBeenCalled();
    // Clipboard survives leaving the inspector, including a different clip.
    view.unmount();
    const target = timelineClipSchema.parse({ ...source, id: "target", label: "Target clip", startMs: 3000 });
    render(<ClipEffects clip={target} disabled={false} onChange={onChange} />);
    fireEvent.click(screen.getByRole("button", { name: `${name} options` }));
    fireEvent.click(screen.getByRole("menuitem", { name: "Paste settings" }));
    expect(onChange.mock.calls).toEqual([[patch, undefined]]);
    const applied = timelineClipSchema.parse({ ...target, ...onChange.mock.calls[0][0] });
    expect(applied).toMatchObject({ ...patch, id: "target", label: "Target clip", startMs: 3000 });
    const key = Object.keys(patch)[0] as keyof TimelineClip;
    expect(onChange.mock.calls[0][0][key]).not.toBe(source[key]);
  });

  it("does not paste settings into a different effect type", () => {
    render(<Harness />);
    add("Sharpen");
    add("Gaussian blur");
    fireEvent.click(screen.getByRole("button", { name: "Sharpen options" }));
    fireEvent.click(screen.getByRole("menuitem", { name: "Copy settings" }));
    fireEvent.click(screen.getByRole("button", { name: "Gaussian blur options" }));
    const paste = screen.getByRole("menuitem", { name: "Paste settings" }) as HTMLButtonElement;
    expect(paste.disabled).toBe(true);
    fireEvent.click(paste);
    expect(saved().blur).toEqual({ radius: 4 });
  });

  it("keeps LUT snapshots independent of the source and previous pastes", () => {
    const lut = { intensity: 45, table: parseCube(CUBE, "identity.cube") };
    const expected = structuredClone(lut);
    const onChange = vi.fn();
    const view = render(<ClipEffects clip={{ ...original, lut }} disabled={false} onChange={onChange} />);
    fireEvent.click(screen.getByRole("button", { name: "3D LUT options" }));
    fireEvent.click(screen.getByRole("menuitem", { name: "Copy settings" }));
    lut.table.values[0] = 0.9;
    view.rerender(<ClipEffects clip={{ ...original, id: "target", lut: { intensity: 100 } }} disabled={false} onChange={onChange} />);
    for (let index = 0; index < 2; index++) {
      fireEvent.click(screen.getByRole("button", { name: "3D LUT options" }));
      fireEvent.click(screen.getByRole("menuitem", { name: "Paste settings" }));
      const pasted = onChange.mock.calls.at(-1)![0].lut;
      expect(pasted).toEqual(expected);
      pasted.table.values[0] = 0.5;
    }
  });

  it("closes the settings menu when the clip changes or becomes locked", () => {
    const clip = { ...original, sharpen: { amount: 50 } };
    const onChange = vi.fn();
    const view = render(<ClipEffects clip={clip} disabled={false} onChange={onChange} />);
    fireEvent.click(screen.getByRole("button", { name: "Sharpen options" }));
    view.rerender(<ClipEffects clip={{ ...clip, id: "target" }} disabled={false} onChange={onChange} />);
    expect(screen.queryByRole("menu")).toBeNull();
    fireEvent.click(screen.getByRole("button", { name: "Sharpen options" }));
    view.rerender(<ClipEffects clip={{ ...clip, id: "target" }} disabled onChange={onChange} />);
    expect(screen.queryByRole("menu")).toBeNull();
    fireEvent.click(screen.getByRole("button", { name: "Sharpen options" }));
    expect(screen.queryByRole("menu")).toBeNull();
    expect(onChange).not.toHaveBeenCalled();
  });

  it("bypasses an effect from its header checkbox, keeping its settings", () => {
    render(<Harness />);
    add("Sharpen");
    add("Opacity");
    fireEvent.change(screen.getByLabelText("Sharpen amount"), { target: { value: "120" } });
    const sharpenOn = screen.getByRole("checkbox", { name: "Sharpen on" }) as HTMLInputElement;
    expect(sharpenOn.checked).toBe(true);
    // A fresh effect carries no flag at all: the file keeps its old shape.
    expect(saved().sharpen).toEqual({ amount: 120 });
    fireEvent.click(sharpenOn);
    expect(saved().sharpen).toEqual({ amount: 120, enabled: false });
    expect(screen.getByRole("region", { name: "Sharpen effect" }).className).toContain("clip-effect--bypassed");
    // Editing or resetting a bypassed effect leaves it off.
    fireEvent.change(screen.getByLabelText("Sharpen amount"), { target: { value: "80" } });
    expect(saved().sharpen).toEqual({ amount: 80, enabled: false });
    fireEvent.click(screen.getByRole("button", { name: "Reset Sharpen" }));
    expect(saved().sharpen).toEqual({ amount: 50, enabled: false });
    fireEvent.click(sharpenOn);
    expect(saved().sharpen).toEqual({ amount: 50 });
    fireEvent.click(screen.getByRole("checkbox", { name: "Opacity on" }));
    expect(saved().look).toMatchObject({ enabled: false });
  });

  it("adds, edits and removes effects independently", () => {
    render(<Harness />);
    for (const name of ["Sharpen", "Gaussian blur", "Basic Corrections", "Vignette"]) add(name);
    fireEvent.change(screen.getByLabelText("Sharpen amount"), { target: { value: "120" } });
    fireEvent.change(screen.getByLabelText("Blur radius"), { target: { value: "6.5" } });
    fireEvent.change(screen.getByLabelText("Exposure"), { target: { value: "-1.2" } });
    expect((screen.getByLabelText("Brightness") as HTMLInputElement).value).toBe("0");
    fireEvent.change(screen.getByLabelText("Brightness"), { target: { value: "-25" } });
    fireEvent.change(screen.getByLabelText("Saturation"), { target: { value: "0" } });
    fireEvent.change(screen.getByLabelText("Vignette amount"), { target: { value: "75" } });
    expect(saved()).toMatchObject({
      sharpen: { amount: 120 }, blur: { radius: 6.5 }, colorCorrection: { exposure: -1.2, brightness: -25, saturation: 0 }, vignette: { amount: 75 },
    });
    fireEvent.click(screen.getByRole("button", { name: "Reset brightness" }));
    expect(saved().colorCorrection).toEqual({ exposure: -1.2, brightness: 0, contrast: 0, saturation: 0 });
    remove("Gaussian blur");
    expect(saved().blur).toBeUndefined();
    expect(screen.getByLabelText("Sharpen amount")).toBeTruthy();
  });

  it("gives each effect a collapsible header with Reset", () => {
    render(<Harness />);
    add("Vignette");
    fireEvent.change(screen.getByLabelText("Vignette amount"), { target: { value: "80" } });
    fireEvent.click(screen.getByRole("button", { name: "Reset Vignette" }));
    expect(saved().vignette).toEqual({ amount: 35 });
    const toggle = screen.getByRole("button", { name: "Vignette" });
    expect(toggle.getAttribute("aria-expanded")).toBe("true");
    fireEvent.click(toggle);
    expect(screen.queryByLabelText("Vignette amount")).toBeNull();
  });

  it("edits new basic, Creative and vignette controls", () => {
    render(<Harness />);
    for (const name of ["Basic Corrections", "Creative", "Vignette"]) add(name);
    for (const label of ["Temperature", "Tint", "Highlights", "Shadows", "Whites", "Blacks"]) {
      fireEvent.change(screen.getByLabelText(label), { target: { value: "25" } });
      expect(saved().colorCorrection[label.toLowerCase()]).toBe(25);
    }
    fireEvent.keyDown(screen.getByRole("combobox", { name: "Creative look" }), { key: "End" });
    expect(saved().creative.look).toBe("Night");
    for (const [label, key] of [["Creative intensity", "intensity"], ["Faded film", "fadedFilm"], ["Creative sharpen", "sharpen"], ["Vibrance", "vibrance"]]) {
      fireEvent.change(screen.getByLabelText(label), { target: { value: "30" } });
      expect(saved().creative[key]).toBe(30);
    }
    for (const key of ["amount", "midpoint", "roundness", "feather"]) {
      fireEvent.change(screen.getByLabelText(`Vignette ${key}`), { target: { value: "20" } });
      expect(saved().vignette[key]).toBe(20);
    }
    fireEvent.click(screen.getByRole("checkbox", { name: "Creative on" }));
    fireEvent.click(screen.getByRole("button", { name: "Reset Creative" }));
    expect(saved().creative).toEqual({ ...DEFAULT_CREATIVE, enabled: false });
  });

  it("adds, moves, removes and resets curve points with keyboard and numeric controls", () => {
    render(<Harness />); add("Curves");
    fireEvent.click(screen.getByRole("button", { name: "Add point" }));
    expect(saved().curves.rgb).toEqual([[0, 0], [.5, .5], [1, 1]]);
    fireEvent.change(screen.getByLabelText("Curve point output"), { target: { value: "75" } });
    expect(saved().curves.rgb[1]).toEqual([.5, .75]);
    fireEvent.keyDown(screen.getByRole("slider", { name: "RGB point 2" }), { key: "ArrowLeft", shiftKey: true });
    expect(saved().curves.rgb[1]).toEqual([.4, .75]);
    fireEvent.click(screen.getByRole("button", { name: "Remove point" }));
    expect(saved().curves.rgb).toEqual([[0, 0], [1, 1]]);
    const combo = screen.getByRole("combobox", { name: "Curve channel" });
    for (let i = 0; i < 4; i++) fireEvent.keyDown(combo, { key: "ArrowDown" });
    fireEvent.change(screen.getByLabelText("Curve point output"), { target: { value: "70" } });
    expect(saved().curves.hueVsSat).toEqual([[0, .7], [1, .7]]);
    fireEvent.click(screen.getByRole("button", { name: "Reset curve" }));
    expect(saved().curves.hueVsSat).toEqual([[0, .5], [1, .5]]);
  });

  it("edits each wheel independently and prevents locked wheel and curve changes", () => {
    const view = render(<Harness />); add("Color Wheels");
    for (const name of ["Shadows", "Midtones", "Highlights"]) {
      fireEvent.keyDown(screen.getByRole("slider", { name: `${name} color` }), { key: "ArrowRight", shiftKey: true });
      fireEvent.change(screen.getByLabelText(`${name} lightness`), { target: { value: "-25" } });
      expect(saved().colorWheels[name.toLowerCase()]).toEqual({ x: .1, y: 0, lightness: -25 });
    }
    fireEvent.keyDown(screen.getByRole("slider", { name: "Shadows color" }), { key: "Home" });
    expect(saved().colorWheels.shadows).toEqual({ x: 0, y: 0, lightness: -25 });
    const clip = saved(); view.unmount(); const change = vi.fn();
    render(<ClipEffects clip={{ ...clip, curves: {} }} disabled onChange={change} />);
    fireEvent.keyDown(screen.getByRole("slider", { name: "Shadows color" }), { key: "ArrowRight" });
    fireEvent.keyDown(screen.getByRole("slider", { name: "RGB point 1" }), { key: "ArrowUp" });
    expect(change).not.toHaveBeenCalled();
  });

  it("describes each effect in a tooltip rather than a second line", () => {
    render(<Harness />);
    fireEvent.click(screen.getByRole("button", { name: "Add effect" }));
    const item = within(screen.getByRole("group", { name: "Available effects" })).getByRole("button", { name: "Sharpen" });
    expect(item.getAttribute("data-tooltip")).toBe("Enhance fine edges and detail");
  });

  it("imports a LUT through the native Open dialog, and keeps it after a bad replacement", async () => {
    await inTauri({
      pick_file: () => "C:\\Looks\\identity.cube",
      read_lut_file: (args) => ((args as { path: string }).path.endsWith("identity.cube") ? CUBE : "oops"),
    }, async () => {
      render(<Harness />);
      add("3D LUT");
      fireEvent.click(screen.getByRole("button", { name: "Import LUT" }));
      await screen.findByText("identity.cube · 2³");
      const { invoke } = await import("@tauri-apps/api/core");
      expect(vi.mocked(invoke)).toHaveBeenCalledWith("pick_file", { title: "Import LUT", filters: [{ name: "Cube LUT", extensions: ["cube"] }] });
      fireEvent.change(screen.getByLabelText("LUT intensity"), { target: { value: "45" } });
      vi.mocked(invoke).mockImplementation(async (command: string) => (command === "pick_file" ? "C:\\Looks\\bad.cube" : "oops") as never);
      fireEvent.click(screen.getByRole("button", { name: "Replace LUT" }));
      await screen.findByRole("alert");
      expect(saved().lut).toMatchObject({ intensity: 45, table: { name: "identity.cube", size: 2 } });
    });
  });

  it("does not apply an outstanding LUT import to a different clip", async () => {
    let resolve!: (text: string) => void;
    const pending = new Promise<string>((done) => { resolve = done; });
    await inTauri({ pick_file: () => "C:\\Looks\\identity.cube", read_lut_file: () => pending }, async () => {
      const onChange = vi.fn();
      const view = render(<ClipEffects clip={{ ...original, lut: { intensity: 100 } }} disabled={false} onChange={onChange} />);
      fireEvent.click(screen.getByRole("button", { name: "Import LUT" }));
      await screen.findByRole("status");
      view.rerender(<ClipEffects clip={{ ...original, id: "other", lut: { intensity: 100 } }} disabled={false} onChange={onChange} />);
      await act(async () => { resolve("LUT_3D_SIZE 2\n" + "0 0 0\n".repeat(8)); });
      await waitFor(() => expect(screen.queryByRole("status")).toBeNull());
      expect(onChange).not.toHaveBeenCalled();
    });
  });

  it("picks a chroma key colour from a swatch and a hex field", () => {
    render(<Harness />);
    add("Chroma key");
    fireEvent.click(screen.getByRole("button", { name: "Chroma key colour" }));
    fireEvent.change(screen.getByLabelText("Hex"), { target: { value: "#123456" } });
    fireEvent.change(screen.getByLabelText("Chroma key tolerance"), { target: { value: "43" } });
    expect(saved()).toMatchObject({ chromaKey: { color: "#123456", tolerance: 43 } });
    expect(screen.getByLabelText("Hue")).toBeTruthy();
    expect(screen.getByRole("slider", { name: "Saturation and brightness" })).toBeTruthy();
  });

  it("adds only chosen effects, and removes them without changing other effects", () => {
    render(<Harness />);
    expect(screen.queryByRole("heading", { name: "Opacity" })).toBeNull();
    add("Chroma key");
    fireEvent.click(screen.getByRole("button", { name: "Add effect" }));
    const picker = screen.getByRole("group", { name: "Available effects" });
    expect(within(picker).queryByRole("button", { name: "Chroma key" })).toBeNull();
    fireEvent.click(within(picker).getByRole("button", { name: "Opacity" }));
    fireEvent.change(screen.getByLabelText("Clip opacity"), { target: { value: "65" } });
    remove("Chroma key");
    expect(saved().chromaKey).toBeUndefined();
    expect(saved().look.opacity).toBe(65);
  });

  it("keeps existing effects editable and moves through the picker with the arrow keys", () => {
    render(<ClipEffects clip={{ ...original, transition: { type: "wipe-left", durationMs: 800 } }} disabled={false} onChange={vi.fn()} />);
    expect(screen.getByRole("combobox", { name: "Clip transition" }).textContent).toContain("Wipe from left");
    fireEvent.click(screen.getByRole("button", { name: "Add effect" }));
    expect(document.activeElement?.textContent).toBe("3D LUT");
    fireEvent.keyDown(document.activeElement!, { key: "ArrowDown" });
    expect(document.activeElement?.textContent).toBe("Basic Corrections");
  });

  it("disables effects for locked or nonvisual clips and closes the picker when selection changes", () => {
    const props = { onChange: vi.fn(), clip: original, disabled: false };
    const view = render(<ClipEffects {...props} />);
    fireEvent.click(screen.getByRole("button", { name: "Add effect" }));
    view.rerender(<ClipEffects {...props} clip={{ ...original, id: "next" }} />);
    expect(screen.queryByRole("group", { name: "Available effects" })).toBeNull();
    view.rerender(<ClipEffects {...props} disabled clip={{ ...original, chromaKey: { color: "#00ff00", tolerance: 20 } }} />);
    expect((screen.getByRole("button", { name: "Add effect" }) as HTMLButtonElement).disabled).toBe(true);
    expect((screen.getByRole("button", { name: "Chroma key options" }) as HTMLButtonElement).disabled).toBe(true);
    fireEvent.change(screen.getByLabelText("Chroma key tolerance"), { target: { value: "40" } });
    expect(props.onChange).not.toHaveBeenCalled();
  });
});