AI media harness for planning, generating, and editing locally
TypeScript
// @vitest-environment jsdom
import "@testing-library/jest-dom/vitest";
import { afterEach, beforeEach, expect, it, vi } from "vitest";
import { cleanup, fireEvent, render, screen, waitFor, within } from "@testing-library/react";
import { useState } from "react";
import { MusicView } from "./MusicView";
import { choose, comboValue } from "./comboTestUtils";
import { createProjectConfig, type ProjectConfig } from "../../lib/project";
import { newMusicFolder, newSong, newSongVariation } from "../../lib/music";
import { readMediaFileUrl } from "../../lib/persistence";
import { loadGeneratorTemplateSettings, musicTemplates, saveGeneratorTemplateSettings } from "../../lib/settings";
import type { WorkItem } from "../../lib/workQueue";
vi.mock("../../lib/persistence", async (original) => ({ ...await original<typeof import("../../lib/persistence")>(), isTauri: () => true, readMediaFileUrl: vi.fn(async () => "blob:song") }));
let latest: ProjectConfig;
const generate = vi.fn();
const generateCover = vi.fn();
const createConfig = () => createProjectConfig({ name: "Music", prompt: "", aspectRatio: "16:9", resolution: "416p", targetDurationSeconds: 30 });
function Harness({ initial = createConfig(), workItems = [] }: { initial?: ProjectConfig; workItems?: WorkItem[] }) {
const [config, setConfig] = useState(initial); latest = config;
return <MusicView config={config} folderPath="C:/Music" onChange={setConfig} onGenerate={generate} onGenerateCover={generateCover} onCancel={() => {}} workItems={workItems} />;
}
beforeEach(() => {
vi.clearAllMocks(); localStorage.clear();
vi.mocked(readMediaFileUrl).mockResolvedValue("blob:song");
const settings = loadGeneratorTemplateSettings();
saveGeneratorTemplateSettings({ ...settings, templates: settings.templates.map((template) => template.id === "yue2" ? { ...template, paths: { ...template.paths, transformer: "C:/weights/yue2.safetensors" }, sources: {} } : template) });
vi.spyOn(HTMLMediaElement.prototype, "pause").mockImplementation(() => {});
vi.spyOn(HTMLMediaElement.prototype, "play").mockResolvedValue();
vi.stubGlobal("URL", Object.assign(URL, { revokeObjectURL: vi.fn() }));
});
it.each(["Grid", "List"])("clears song selection on empty %s space and allows selecting again", (mode) => {
const songs = [{ ...newSong(), title: "First" }, { ...newSong(), title: "Second" }];
render(<Harness initial={{ ...createConfig(), musicSongs: songs }} />);
fireEvent.click(screen.getByRole("button", { name: `${mode} view` }));
const first = screen.getByRole("button", { name: "Select First" });
const second = screen.getByRole("button", { name: "Select Second" });
for (const surface of [screen.getByLabelText("Music library"), screen.getByRole("list", { name: "Music contents" }), within(screen.getByLabelText("Music library")).getByText("2 songs")]) {
fireEvent.click(second.querySelector("strong")!);
fireEvent.click(screen.getByLabelText("Song title"));
expect(second).toHaveAttribute("aria-pressed", "true");
fireEvent.click(surface);
expect(first).toHaveAttribute("aria-pressed", "false");
expect(second).toHaveAttribute("aria-pressed", "false");
expect(screen.queryByLabelText("Song title")).not.toBeInTheDocument();
expect(screen.queryByRole("button", { name: "Generate" })).not.toBeInTheDocument();
fireEvent.click(screen.getByRole("button", { name: `${mode} view` }));
expect(screen.getByText("Select a song to edit its lyrics, style and generation settings.")).toBeInTheDocument();
}
fireEvent.click(first);
fireEvent.click(screen.getByRole("button", { name: "New folder" }));
fireEvent.click(screen.getByLabelText("Folder name"));
expect(first).toHaveAttribute("aria-pressed", "true");
expect(screen.getByLabelText("Song title")).toHaveValue("First");
});
it("starts YuE2 at six steps and lets the song select the Midpoint baseline", () => {
render(<Harness />);
fireEvent.click(within(screen.getByRole("toolbar", { name: "Music tools" })).getByRole("button", { name: "New song" }));
expect(latest.musicSongs![0]).toMatchObject({ steps: 6, settings: { flow_sampler: "dpmpp_2m" } });
fireEvent.click(screen.getByRole("button", { name: "Advanced" }));
expect(comboValue(screen.getByRole("combobox", { name: "Music flow sampler" }))).toBe("dpmpp_2m");
choose("Music flow sampler", "Midpoint");
expect(latest.musicSongs![0].settings.flow_sampler).toBe("midpoint");
const saved = latest;
cleanup(); render(<Harness initial={saved} />);
expect(latest.musicSongs![0].settings.flow_sampler).toBe("midpoint");
});
it("generates artwork for the context-menu song and displays saved covers in both views", async () => {
const songs = [{ ...newSong(), title: "First" }, { ...newSong(), title: "Second", coverRelativePath: "media/generated/cover.jpg" }];
render(<Harness initial={{ ...createConfig(), musicSongs: songs }} />);
fireEvent.contextMenu(screen.getByRole("button", { name: "Select Second" }));
fireEvent.click(screen.getByRole("menuitem", { name: "Regenerate album cover" }));
expect(generateCover).toHaveBeenCalledWith(songs[1].id);
expect(generate).not.toHaveBeenCalled();
await waitFor(() => expect(screen.getByRole("button", { name: "Select Second" }).querySelector("img")).toHaveAttribute("src", "blob:song"));
fireEvent.click(screen.getByRole("button", { name: "List view" }));
expect(screen.getByRole("button", { name: "Select Second" }).querySelector("img")).toBeInTheDocument();
fireEvent.contextMenu(screen.getByRole("button", { name: "Select First" }));
fireEvent.click(screen.getByRole("menuitem", { name: "Generate album cover" }));
expect(generateCover).toHaveBeenLastCalledWith(songs[0].id);
});
it.each(["Grid", "List"])("duplicates the context-menu song as a selected draft in %s view", (mode) => {
const folder = newMusicFolder("Jazz", null);
const original = { ...newSong("yue2", 24, folder.id), title: "Evening", style: "Soft jazz", seed: 42,
status: "completed" as const, assetId: "audio", error: "Old error", coverRelativePath: "media/cover.jpg" };
original.settings.lyrics = "[Verse]\nGood evening";
original.generation = { generatorId: original.generatorId, style: original.style, settings: { ...original.settings }, steps: original.steps, seed: 42 };
const other = { ...newSong("yue2", 6, folder.id), title: "Other" };
render(<Harness initial={{ ...createConfig(), musicFolders: [folder], musicSongs: [other, original] }} />);
fireEvent.click(screen.getByRole("button", { name: `Open Jazz` }));
fireEvent.click(screen.getByRole("button", { name: `${mode} view` }));
fireEvent.contextMenu(screen.getByRole("button", { name: "Select Evening" }));
fireEvent.click(screen.getByRole("menuitem", { name: "Duplicate" }));
expect(latest.musicSongs).toHaveLength(3);
expect(latest.musicSongs!.slice(0, 2)).toEqual([other, original]);
const draft = latest.musicSongs![2];
expect(draft).toEqual({ ...original, id: expect.any(String), createdAt: expect.any(String), status: "draft", assetId: null, error: null, generation: null });
expect(draft.id).not.toBe(original.id);
expect(draft.settings).not.toBe(original.settings);
expect(screen.getAllByRole("button", { name: "Select Evening" })[1]).toHaveAttribute("aria-pressed", "true");
expect(screen.getByLabelText("Music lyrics")).toHaveValue(original.settings.lyrics);
expect(screen.getByRole("button", { name: "Generate" })).toBeEnabled();
expect(generate).not.toHaveBeenCalled();
});
it("selects a song variation count, validates it and resets after generating", () => {
const song = { ...newSong(), style: "Jazz" };
render(<Harness initial={{ ...createConfig(), musicSongs: [song] }} />);
const options = screen.getByRole("button", { name: "Generation options" });
fireEvent.click(options);
const input = screen.getByRole("spinbutton", { name: "Count" });
expect(input).toHaveFocus();
for (const value of ["", "0", "1.5", "101"]) {
fireEvent.change(input, { target: { value } });
expect(input).toHaveAttribute("aria-invalid", "true");
expect(screen.getByRole("button", { name: "Generate" })).toBeDisabled();
expect(options).toBeEnabled();
}
fireEvent.change(input, { target: { value: "3" } });
fireEvent.click(options);
fireEvent.click(screen.getByRole("button", { name: "Generate (3)" }));
expect(generate).toHaveBeenCalledWith(song.id, expect.objectContaining({ id: "yue2" }), 3);
expect(screen.queryByRole("dialog", { name: "Generation options" })).not.toBeInTheDocument();
expect(screen.getByRole("button", { name: "Generate" })).toBeEnabled();
fireEvent.click(options);
expect(screen.getByRole("spinbutton", { name: "Count" })).toHaveValue(1);
});
it("keeps the variation count when generation cannot be queued", () => {
generate.mockImplementationOnce(() => { throw new Error("Cannot queue music"); });
render(<Harness initial={{ ...createConfig(), musicSongs: [{ ...newSong(), style: "Jazz" }] }} />);
fireEvent.click(screen.getByRole("button", { name: "Generation options" }));
fireEvent.change(screen.getByRole("spinbutton", { name: "Count" }), { target: { value: "4" } });
fireEvent.click(screen.getByRole("button", { name: "Generate (4)" }));
expect(screen.getByText("Error: Cannot queue music")).toBeInTheDocument();
expect(screen.getByRole("button", { name: "Generate (4)" })).toBeEnabled();
});
it("reports missing cover generators without changing the song", () => {
const song = newSong();
generateCover.mockImplementationOnce(() => { throw new Error("Choose an album cover generator in Settings."); });
render(<Harness initial={{ ...createConfig(), musicSongs: [song] }} />);
fireEvent.contextMenu(screen.getByRole("button", { name: "Select New song" }));
fireEvent.click(screen.getByRole("menuitem", { name: "Generate album cover" }));
expect(screen.getByText("Error: Choose an album cover generator in Settings.")).toBeInTheDocument();
expect(latest.musicSongs).toEqual([song]);
});
it("creates songs in the browsed folder and moves them between folders by drag and drop", () => {
render(<Harness />);
const createFolder = (name: string) => {
fireEvent.click(screen.getByRole("button", { name: "New folder" }));
fireEvent.change(screen.getByLabelText("Folder name"), { target: { value: name } });
fireEvent.click(screen.getByRole("button", { name: "Create folder" }));
};
createFolder("Jazz");
fireEvent.click(screen.getAllByRole("button", { name: "New song" })[0]);
const jazz = latest.musicFolders![0];
expect(latest.musicSongs![0].folderId).toBe(jazz.id);
createFolder("Piano");
fireEvent.click(screen.getAllByRole("button", { name: "New song" })[0]);
const piano = latest.musicFolders![1], song = latest.musicSongs![1];
expect(piano.parentId).toBe(jazz.id);
expect(song.folderId).toBe(piano.id);
const data = new Map<string, string>();
const dataTransfer = { effectAllowed: "", dropEffect: "", types: ["application/x-slopus-music-song"],
setData: (type: string, value: string) => data.set(type, value), getData: (type: string) => data.get(type) ?? "" };
fireEvent.dragStart(screen.getByRole("listitem"), { dataTransfer });
const destination = within(screen.getByRole("navigation", { name: "Music path" })).getByRole("button", { name: "Jazz" });
fireEvent.dragOver(destination, { dataTransfer });
expect(destination).toHaveAttribute("data-drop-target", "true");
fireEvent.drop(destination, { dataTransfer });
expect(latest.musicSongs![1].folderId).toBe(jazz.id);
expect(screen.getByText("This folder is empty")).toBeInTheDocument();
fireEvent.click(destination);
expect(screen.getAllByRole("listitem")).toHaveLength(3);
fireEvent.dragStart(screen.getAllByRole("button", { name: "Select New song" })[1].closest('[role="listitem"]')!, { dataTransfer });
const root = within(screen.getByRole("navigation", { name: "Music path" })).getByRole("button", { name: "Music" });
fireEvent.drop(root, { dataTransfer });
expect(latest.musicSongs![1].folderId).toBeNull();
fireEvent.click(root);
fireEvent.dragStart(screen.getByRole("button", { name: "Select New song" }).closest('[role="listitem"]')!, { dataTransfer });
const folderCard = screen.getByRole("button", { name: "Open Jazz" }).closest('[role="listitem"]')!;
fireEvent.dragOver(folderCard, { dataTransfer });
expect(folderCard).toHaveAttribute("data-drop-target", "true");
fireEvent.drop(folderCard, { dataTransfer });
expect(latest.musicSongs![1].folderId).toBe(jazz.id);
});
it.each(["Grid", "List"])("browses folders as %s items with a Music path header and only the current contents", (view) => {
const parent = newMusicFolder("Jazz", null), child = newMusicFolder("Piano", parent.id);
const rootSong = { ...newSong(), title: "Root song" }, nestedSong = { ...newSong("yue2", 32, child.id), title: "Piano song" };
render(<Harness initial={{ ...createConfig(), musicFolders: [parent, child], musicSongs: [rootSong, nestedSong] }} />);
fireEvent.click(screen.getByRole("button", { name: `${view} view` }));
expect(screen.getByRole("heading", { name: "Music", level: 2 })).toBeInTheDocument();
expect(screen.getByRole("list", { name: "Music contents" })).toHaveClass(`music-songs--${view.toLowerCase()}`);
const folder = screen.getByRole("button", { name: "Open Jazz" });
expect(folder).toHaveClass("music-song__select");
expect(folder.querySelector(".music-song__art svg")).toBeInTheDocument();
expect(screen.queryByRole("button", { name: "Open Piano" })).not.toBeInTheDocument();
fireEvent.click(folder);
expect(screen.getByRole("heading", { name: "Music / Jazz", level: 2 })).toBeInTheDocument();
expect(screen.queryByRole("button", { name: "Select Root song" })).not.toBeInTheDocument();
expect(screen.queryByText("This folder is empty")).not.toBeInTheDocument();
expect(screen.getAllByRole("listitem")).toHaveLength(1);
fireEvent.click(screen.getByRole("button", { name: "Open Piano" }));
expect(screen.getByRole("heading", { name: "Music / Jazz / Piano", level: 2 })).toBeInTheDocument();
expect(screen.getByRole("button", { name: "Select Piano song" })).toBeInTheDocument();
const path = within(screen.getByRole("navigation", { name: "Music path" }));
fireEvent.click(path.getByRole("button", { name: "Music" }));
expect(screen.getByRole("button", { name: "Select Root song" })).toBeInTheDocument();
expect(screen.queryByRole("navigation", { name: "Music folders" })).not.toBeInTheDocument();
});
it("creates songs and folders from the library and song context menus in the current folder", () => {
render(<Harness />);
fireEvent.contextMenu(screen.getByLabelText("Music library"));
fireEvent.click(screen.getByRole("menuitem", { name: "New folder" }));
fireEvent.change(screen.getByLabelText("Folder name"), { target: { value: "Jazz" } });
fireEvent.click(screen.getByRole("button", { name: "Create folder" }));
fireEvent.keyDown(screen.getByLabelText("Music library"), { key: "F10", shiftKey: true });
fireEvent.click(screen.getByRole("menuitem", { name: "New song" }));
expect(latest.musicSongs![0].folderId).toBe(latest.musicFolders![0].id);
fireEvent.click(screen.getByRole("button", { name: "List view" }));
fireEvent.contextMenu(screen.getByRole("listitem"));
expect(screen.getByRole("menuitem", { name: "New folder" })).toBeInTheDocument();
fireEvent.click(screen.getByRole("menuitem", { name: "New song" }));
expect(latest.musicSongs).toHaveLength(2);
expect(latest.musicSongs![1].folderId).toBe(latest.musicFolders![0].id);
});
it("removes the context-clicked folder and moves its contents to the parent", () => {
const parent = newMusicFolder("Jazz", null), folder = newMusicFolder("Piano", parent.id), child = newMusicFolder("Solo", folder.id);
const song = newSong("yue2", 32, folder.id), nested = newSong("yue2", 32, child.id);
render(<Harness initial={{ ...createConfig(), musicFolders: [parent, folder, child], musicSongs: [song, nested] }} />);
const navigation = within(screen.getByRole("navigation", { name: "Music path" }));
fireEvent.click(screen.getByRole("button", { name: "Open Jazz" }));
fireEvent.click(screen.getByRole("button", { name: "Open Piano" }));
fireEvent.keyDown(navigation.getByRole("button", { name: "Piano" }), { key: "ContextMenu" });
fireEvent.click(screen.getByRole("menuitem", { name: "Remove folder" }));
expect(latest.musicFolders).toEqual([parent, { ...child, parentId: parent.id }]);
expect(latest.musicSongs).toEqual([{ ...song, folderId: parent.id }, nested]);
expect(navigation.getByRole("button", { name: "Jazz" })).toHaveAttribute("aria-current", "page");
expect(screen.getByRole("button", { name: "Open Solo" })).toBeInTheDocument();
fireEvent.contextMenu(navigation.getByRole("button", { name: "Music" }));
expect(screen.queryByRole("menuitem", { name: "Remove folder" })).not.toBeInTheDocument();
});
it("removes the context-clicked playing song, stops playback and preserves timeline media", async () => {
const first = { ...newSong(), title: "First", assetId: "audio" }, second = { ...newSong(), title: "Second" };
const asset = { id: "audio", kind: "audio" as const, mimeType: "audio/wav", name: "First", relativePath: "media/first.wav", durationMs: 30000, createdAt: first.createdAt };
const config = { ...createConfig(), musicSongs: [first, second], assets: [asset] };
const { container } = render(<Harness initial={config} />);
fireEvent.click(screen.getByRole("button", { name: "Play First" }));
await waitFor(() => expect(container.querySelector("audio")).toHaveAttribute("src", "blob:song"));
fireEvent.click(screen.getByRole("button", { name: "Select Second" }));
fireEvent.contextMenu(screen.getByRole("button", { name: "Select First" }));
fireEvent.click(screen.getByRole("menuitem", { name: "Remove song" }));
expect(latest.musicSongs).toEqual([second]);
expect(latest.assets).toEqual(config.assets);
expect(latest.timeline).toEqual(config.timeline);
expect(screen.getByLabelText("Song title")).toHaveValue("Second");
await waitFor(() => expect(container.querySelector("audio")).not.toHaveAttribute("src"));
expect(screen.getByRole("button", { name: "Next song" })).toBeDisabled();
});
it("disables removal for a song with active generation", () => {
const song = newSong();
render(<Harness initial={{ ...createConfig(), musicSongs: [song] }} workItems={[{ sceneId: song.id, status: "queued", detail: "Waiting", progress: 0 } as WorkItem]} />);
fireEvent.contextMenu(screen.getByRole("listitem"));
expect(screen.getByRole("menuitem", { name: "Remove song" })).toBeDisabled();
fireEvent.click(screen.getByRole("menuitem", { name: "Remove song" }));
expect(latest.musicSongs).toEqual([song]);
});
it("automatically plays the next generated song in the starting folder even after browsing elsewhere", async () => {
const jazz = newMusicFolder("Jazz", null), other = newMusicFolder("Other", null);
const songs = [
{ ...newSong("yue2", 32, jazz.id), title: "First", assetId: "first" },
{ ...newSong("yue2", 32, jazz.id), title: "Draft" },
{ ...newSong("yue2", 32, jazz.id), title: "Second", assetId: "second" },
{ ...newSong("yue2", 32, other.id), title: "Elsewhere", assetId: "other" },
];
const assets = songs.flatMap((song) => song.assetId ? [{ id: song.assetId, kind: "audio" as const, name: song.title,
relativePath: `media/${song.assetId}.wav`, durationMs: 30000, mimeType: "audio/wav", createdAt: song.createdAt }] : []);
vi.mocked(readMediaFileUrl).mockImplementation(async (_, asset) => `blob:${asset.relativePath}`);
const { container } = render(<Harness initial={{ ...createConfig(), musicFolders: [jazz, other], musicSongs: songs, assets }} />);
const path = within(screen.getByRole("navigation", { name: "Music path" }));
fireEvent.click(screen.getByRole("button", { name: "Open Jazz" }));
fireEvent.click(screen.getByRole("button", { name: "Play First" }));
const audio = container.querySelector("audio")!;
await waitFor(() => expect(audio).toHaveAttribute("src", "blob:media/first.wav"));
fireEvent.canPlay(audio);
fireEvent.click(path.getByRole("button", { name: "Music" }));
fireEvent.click(screen.getByRole("button", { name: "Open Other" }));
fireEvent.ended(audio);
await waitFor(() => expect(audio).toHaveAttribute("src", "blob:media/second.wav"));
fireEvent.canPlay(audio);
expect(HTMLMediaElement.prototype.play).toHaveBeenCalledTimes(2);
fireEvent.ended(audio);
expect(readMediaFileUrl).toHaveBeenCalledTimes(2);
expect(screen.getByRole("button", { name: "Select Elsewhere" })).toBeInTheDocument();
});
afterEach(() => { cleanup(); vi.restoreAllMocks(); vi.unstubAllGlobals(); });
it("adds songs, edits lyrics and style, switches layout and queues the selected song", () => {
render(<Harness />);
fireEvent.click(screen.getAllByRole("button", { name: "New song" })[0]);
fireEvent.change(screen.getByLabelText("Song title"), { target: { value: "Night drive" } });
fireEvent.change(screen.getByLabelText("Music style"), { target: { value: "Synth pop" } });
fireEvent.change(screen.getByLabelText("Music lyrics"), { target: { value: "[Verse]\nCity lights" } });
expect(latest.musicSongs![0]).toMatchObject({ title: "Night drive", style: "Synth pop", settings: { lyrics: "[Verse]\nCity lights" } });
fireEvent.click(screen.getByRole("button", { name: "List view" }));
expect(screen.getByRole("list", { name: "Music contents" })).toHaveClass("music-songs--list");
fireEvent.click(screen.getByRole("button", { name: "Generate" }));
expect(generate).toHaveBeenCalledWith(latest.musicSongs![0].id, expect.objectContaining({ modelType: "yue2" }), 1);
});
it("shows missing downloads in the shared selector and status bar, outside the inspector", () => {
saveGeneratorTemplateSettings({ ...loadGeneratorTemplateSettings(), templates: musicTemplates() });
render(<Harness initial={{ ...createConfig(), musicSongs: [{ ...newSong(), style: "Jazz" }] }} />);
const toolbar = screen.getByRole("toolbar", { name: "Music tools" });
expect(within(toolbar).getByText("Generator:")).toBeInTheDocument();
expect(within(toolbar).getByRole("img", { name: "Model weights missing" })).toHaveAttribute("data-tooltip", expect.stringContaining("Settings"));
expect(screen.getByLabelText("Music status")).toHaveTextContent("Download or select music model weights");
const inspector = screen.getByRole("complementary", { name: "Song settings" });
expect(within(inspector).queryByText(/Download or select/)).not.toBeInTheDocument();
expect(within(inspector).getByRole("button", { name: "Generate" })).toBeDisabled();
expect(within(inspector).getByRole("button", { name: "Generate" })).toHaveClass("primary-button");
const selector = within(toolbar).getByRole("combobox", { name: "Generator" });
expect(selector).toHaveClass("generator-template");
fireEvent.click(selector);
expect(screen.getAllByRole("option").every((option) => option.getAttribute("aria-disabled") === "true")).toBe(true);
expect(screen.getAllByText("Download in Settings")).toHaveLength(2);
});
it("selects the new song returned by generation while keeping the original visible", () => {
const original = { ...newSong(), title: "Evening", style: "Jazz", status: "completed" as const, assetId: "original" };
const variation = newSongVariation(original, [original]);
function VariationHarness() {
const [config, setConfig] = useState<ProjectConfig>({ ...createConfig(), musicSongs: [original] });
return <MusicView config={config} folderPath="C:/Music" onChange={setConfig} workItems={[]} onCancel={() => {}}
onGenerate={() => { setConfig((current) => ({ ...current, musicSongs: [...current.musicSongs!, variation] })); return variation.id; }} />;
}
render(<VariationHarness />);
fireEvent.click(screen.getByRole("button", { name: "Generate" }));
expect(screen.getByRole("button", { name: "Select Evening (2)" })).toHaveAttribute("aria-pressed", "true");
expect(screen.getByRole("button", { name: "Select Evening" })).toHaveAttribute("aria-pressed", "false");
expect(screen.getByLabelText("Song title")).toHaveValue("Evening (2)");
});
it.each([
["Music style", "Acoustic folk"], ["Music lyrics", "[Verse]\nA new day"], ["Music seed", "12"],
["Music steps", "16"], ["Song duration", "45"], ["Song title", "Morning"],
])("creates one selected draft when editing %s on generated music", (label, value) => {
const folder = newMusicFolder("Jazz", null);
const original = { ...newSong("yue2", 32, folder.id), title: "Evening", style: "Jazz", status: "completed" as const, assetId: "original" };
original.generation = { generatorId: original.generatorId, style: original.style, settings: { ...original.settings }, steps: original.steps, seed: 42 };
const asset = { id: "original", kind: "audio" as const, name: "Evening", relativePath: "media/evening.wav", durationMs: 30000, mimeType: "audio/wav", createdAt: original.createdAt };
render(<Harness initial={{ ...createConfig(), musicFolders: [folder], musicSongs: [original], assets: [asset] }} />);
fireEvent.click(screen.getByRole("button", { name: "Open Jazz" }));
// Focusing and committing an unchanged number must not create a copy.
fireEvent.blur(screen.getByLabelText("Music steps"));
expect(latest.musicSongs).toEqual([original]);
fireEvent.change(screen.getByLabelText(label), { target: { value } });
expect(latest.musicSongs).toHaveLength(2);
expect(latest.musicSongs![0]).toEqual(original);
const draft = latest.musicSongs![1];
expect(draft.id).not.toBe(original.id);
expect(draft).toMatchObject({ folderId: folder.id, status: "draft", assetId: null, generation: null, error: null });
expect(screen.getByRole("button", { name: `Select ${draft.title}` })).toHaveAttribute("aria-pressed", "true");
expect(screen.getByLabelText(label)).toHaveValue(["Music seed", "Music steps", "Song duration"].includes(label) ? Number(value) : value);
fireEvent.change(screen.getByLabelText("Music style"), { target: { value: "Acoustic folk with strings" } });
fireEvent.change(screen.getByLabelText("Music lyrics"), { target: { value: "Keep writing" } });
expect(latest.musicSongs).toHaveLength(2);
expect(latest.musicSongs![0]).toEqual(original);
expect(latest.musicSongs![1]).toMatchObject({ id: draft.id, style: "Acoustic folk with strings", settings: { lyrics: "Keep writing" } });
expect(latest.assets).toEqual([asset]);
fireEvent.click(screen.getByRole("button", { name: "Generate" }));
expect(generate).toHaveBeenCalledWith(draft.id, expect.objectContaining({ id: "yue2" }), 1);
});
it("copies generated music to a draft when changing its generator", () => {
const settings = loadGeneratorTemplateSettings(), source = settings.templates.find((template) => template.id === "yue2")!;
saveGeneratorTemplateSettings({ ...settings, templates: [...settings.templates, { ...source, id: "other-music", name: "Other music generator", defaultSteps: 16 }] });
const original = { ...newSong(), title: "Evening", style: "Jazz", status: "completed" as const, assetId: "original" };
render(<Harness initial={{ ...createConfig(), musicSongs: [original] }} />);
fireEvent.click(screen.getByRole("combobox", { name: "Generator" }));
fireEvent.click(screen.getByRole("option", { name: /Other music generator/ }));
expect(latest.musicSongs).toHaveLength(2);
expect(latest.musicSongs![0]).toEqual(original);
expect(latest.musicSongs![1]).toMatchObject({ generatorId: "other-music", steps: 16, status: "draft", assetId: null });
fireEvent.click(screen.getByRole("button", { name: "Select Evening" }));
expect(screen.getByRole("combobox", { name: "Generator" })).toHaveAttribute("data-value", "other-music");
fireEvent.click(screen.getByRole("button", { name: "Generate" }));
expect(generate).toHaveBeenCalledWith(original.id, expect.objectContaining({ id: "other-music" }), 1);
const saved = latest;
cleanup(); render(<Harness initial={saved} />);
expect(screen.getByRole("combobox", { name: "Generator" })).toHaveAttribute("data-value", "other-music");
});
it.each(["Grid", "List"])("distinguishes playable songs from drafts and missing audio in %s view", (view) => {
const original = { ...newSong(), title: "Evening", status: "completed" as const, assetId: "original" };
const draft = newSongVariation(original, [original]);
const missing = { ...newSong(), title: "Missing", status: "completed" as const, assetId: "missing" };
const asset = { id: "original", kind: "audio" as const, name: "Evening", relativePath: "media/evening.wav", durationMs: 30000, mimeType: "audio/wav", createdAt: original.createdAt };
render(<Harness initial={{ ...createConfig(), musicSongs: [original, draft, missing], assets: [asset] }} />);
fireEvent.click(screen.getByRole("button", { name: `${view} view` }));
const readyCard = screen.getByRole("button", { name: "Select Evening" }).closest('[role="listitem"]')!;
const draftCard = screen.getByRole("button", { name: "Select Evening (2)" }).closest('[role="listitem"]')!;
expect(readyCard).toHaveClass("music-song--playable");
expect(within(readyCard as HTMLElement).getByText("Ready · 0:30")).toBeInTheDocument();
expect(within(readyCard as HTMLElement).getByRole("button", { name: "Play Evening" })).toBeEnabled();
expect(draftCard).toHaveClass("music-song--draft");
expect(within(draftCard as HTMLElement).getByText("Draft · Not generated")).toBeInTheDocument();
expect(screen.queryByRole("button", { name: "Play Evening (2)" })).not.toBeInTheDocument();
expect(screen.getByText("Audio unavailable")).toBeInTheDocument();
expect(screen.queryByRole("button", { name: "Play Missing" })).not.toBeInTheDocument();
});
it("keeps the original audio playing when editing creates a draft", async () => {
const original = { ...newSong(), title: "Evening", style: "Jazz", status: "completed" as const, assetId: "original" };
const asset = { id: "original", kind: "audio" as const, name: "Evening", relativePath: "media/evening.wav", durationMs: 30000, mimeType: "audio/wav", createdAt: original.createdAt };
const { container } = render(<Harness initial={{ ...createConfig(), musicSongs: [original], assets: [asset] }} />);
fireEvent.click(screen.getByRole("button", { name: "Play Evening" }));
await waitFor(() => expect(container.querySelector("audio")).toHaveAttribute("src", "blob:song"));
fireEvent.canPlay(container.querySelector("audio")!);
fireEvent.play(container.querySelector("audio")!);
const pauses = vi.mocked(HTMLMediaElement.prototype.pause).mock.calls.length;
fireEvent.change(screen.getByLabelText("Music lyrics"), { target: { value: "New lyrics" } });
expect(HTMLMediaElement.prototype.pause).toHaveBeenCalledTimes(pauses);
expect(readMediaFileUrl).toHaveBeenCalledOnce();
expect(screen.getByRole("button", { name: "Pause music" })).toBeEnabled();
expect(latest.musicSongs![0]).toEqual(original);
});
it("plays generated audio and creates a reference for the context-clicked song", async () => {
const first = { ...newSong(), title: "First", status: "completed" as const, assetId: "song-a" };
const second = { ...newSong(), title: "Second", status: "completed" as const, assetId: "song-b" };
const config = { ...createConfig(), musicSongs: [first, second], assets: [first, second].map((song) => ({ id: song.assetId, kind: "audio" as const, name: song.title, relativePath: `media/${song.assetId}.wav`, durationMs: 30000, mimeType: "audio/wav", createdAt: song.createdAt })) };
const { container } = render(<Harness initial={config} />);
fireEvent.click(screen.getByRole("button", { name: "Play First" }));
await waitFor(() => expect(container.querySelector("audio")).toHaveAttribute("src", "blob:song"));
fireEvent.canPlay(container.querySelector("audio")!);
expect(HTMLMediaElement.prototype.play).toHaveBeenCalled();
fireEvent.play(container.querySelector("audio")!);
expect(screen.getByRole("button", { name: "Pause music" })).toBeEnabled();
fireEvent.click(screen.getByRole("button", { name: "Select Second" }));
expect(readMediaFileUrl).toHaveBeenCalledTimes(1);
fireEvent.contextMenu(screen.getByRole("button", { name: "Select First" }));
fireEvent.click(screen.getByRole("menuitem", { name: "Create Reference" }));
expect(latest.references.at(-1)).toMatchObject({ kind: "audio", name: "First", relativePath: "media/song-a.wav", audio: { startSeconds: 0, durationSeconds: 15 } });
});