Skip to content

AI media harness for planning, generating, and editing locally

TypeScript
10.7 KB
Raw Blame
// @vitest-environment jsdom

import "@testing-library/jest-dom/vitest";
import { act, cleanup, fireEvent, render, screen } from "@testing-library/react";
import { afterEach, describe, expect, it, vi } from "vitest";
import { SUBMENU_HOVER_DELAY, useContextMenu, type MenuEntry } from "./ContextMenu";

afterEach(cleanup);

function Surface({ items, label = "Clip actions" }: { items: MenuEntry[]; label?: string }) {
  const menu = useContextMenu();
  return (
    <>
      <div
        tabIndex={0}
        data-testid="surface"
        onContextMenu={(event) => menu.open(event, items, { "aria-label": label })}
        onKeyDown={(event) => { if (event.key === "F10" && event.shiftKey) menu.open(event, items, { "aria-label": label }); }}
      >
        surface
      </div>
      <button>elsewhere</button>
      {menu.element}
    </>
  );
}

const make = () => {
  const rename = vi.fn();
  const copy = vi.fn();
  const remove = vi.fn();
  const snap = vi.fn();
  const items: MenuEntry[] = [
    { id: "rename", label: "Rename", icon: <span>R</span>, shortcut: "F2", onSelect: rename },
    { id: "copy", label: "Copy", shortcut: "Ctrl+C", onSelect: copy },
    { id: "paste", label: "Paste", disabled: true, onSelect: vi.fn() },
    { separator: true },
    { id: "snap", label: "Snap to grid", checked: true, onSelect: snap },
    { id: "delete", label: "Delete", shortcut: "Delete", danger: true, onSelect: remove },
  ];
  return { items, rename, copy, remove, snap };
};

describe("ContextMenu", () => {
  it("opens at the pointer, labelled, with formatted accelerators, separators and checks", () => {
    const { items } = make();
    render(<Surface items={items} />);
    fireEvent.contextMenu(screen.getByTestId("surface"), { clientX: 40, clientY: 50 });
    const menu = screen.getByRole("menu", { name: "Clip actions" });
    expect(menu.parentElement).toBe(document.body);
    expect(screen.getByRole("menuitem", { name: /Copy/ })).toHaveTextContent("Ctrl+C");
    expect(screen.getByRole("menuitem", { name: /Paste/ })).toBeDisabled();
    expect(screen.getByRole("separator")).toBeInTheDocument();
    expect(screen.getByRole("menuitemcheckbox", { name: /Snap/ })).toHaveAttribute("aria-checked", "true");
    // Opened with the mouse: the menu holds focus, not the first item.
    expect(menu).toHaveFocus();
  });

  it("focuses the first item when opened from the keyboard, and navigates skipping disabled items", () => {
    const { items } = make();
    render(<Surface items={items} />);
    const surface = screen.getByTestId("surface");
    surface.focus();
    fireEvent.keyDown(surface, { key: "F10", shiftKey: true });
    const rename = screen.getByRole("menuitem", { name: /Rename/ });
    expect(rename).toHaveFocus();
    fireEvent.keyDown(rename, { key: "ArrowDown" });
    fireEvent.keyDown(document.activeElement!, { key: "ArrowDown" });
    expect(screen.getByRole("menuitemcheckbox", { name: /Snap/ })).toHaveFocus();
    fireEvent.keyDown(document.activeElement!, { key: "End" });
    expect(screen.getByRole("menuitem", { name: /Delete/ })).toHaveFocus();
    fireEvent.keyDown(document.activeElement!, { key: "ArrowDown" });
    expect(rename).toHaveFocus();
    fireEvent.keyDown(document.activeElement!, { key: "ArrowUp" });
    expect(screen.getByRole("menuitem", { name: /Delete/ })).toHaveFocus();
    fireEvent.keyDown(document.activeElement!, { key: "Home" });
    expect(rename).toHaveFocus();
    fireEvent.keyDown(document.activeElement!, { key: "c" });
    expect(screen.getByRole("menuitem", { name: /Copy/ })).toHaveFocus();
  });

  it("runs an item on click or Enter, closes, and returns focus to the opener", () => {
    const { items, rename, copy } = make();
    render(<Surface items={items} />);
    const surface = screen.getByTestId("surface");
    surface.focus();
    fireEvent.keyDown(surface, { key: "F10", shiftKey: true });
    fireEvent.keyDown(document.activeElement!, { key: "Enter" });
    expect(rename).toHaveBeenCalledTimes(1);
    expect(screen.queryByRole("menu")).not.toBeInTheDocument();
    expect(surface).toHaveFocus();
    fireEvent.contextMenu(surface, { clientX: 5, clientY: 5 });
    fireEvent.click(screen.getByRole("menuitem", { name: /Copy/ }));
    expect(copy).toHaveBeenCalledTimes(1);
  });

  it("honours an item's own shortcut while open", () => {
    const { items, remove } = make();
    render(<Surface items={items} />);
    fireEvent.contextMenu(screen.getByTestId("surface"), { clientX: 5, clientY: 5 });
    fireEvent.keyDown(screen.getByRole("menu"), { key: "Delete" });
    expect(remove).toHaveBeenCalledTimes(1);
    expect(screen.queryByRole("menu")).not.toBeInTheDocument();
  });

  it("closes on Esc (anywhere), Tab, and a press outside, without running anything", () => {
    const { items, rename, copy, remove } = make();
    render(<Surface items={items} />);
    const surface = screen.getByTestId("surface");
    fireEvent.contextMenu(surface, { clientX: 5, clientY: 5 });
    fireEvent.keyDown(window, { key: "Escape" });
    expect(screen.queryByRole("menu")).not.toBeInTheDocument();
    fireEvent.contextMenu(surface, { clientX: 5, clientY: 5 });
    fireEvent.keyDown(screen.getByRole("menu"), { key: "Tab" });
    expect(screen.queryByRole("menu")).not.toBeInTheDocument();
    fireEvent.contextMenu(surface, { clientX: 5, clientY: 5 });
    fireEvent.pointerDown(screen.getByText("elsewhere"));
    expect(screen.queryByRole("menu")).not.toBeInTheDocument();
    expect(rename).not.toHaveBeenCalled();
    expect(copy).not.toHaveBeenCalled();
    expect(remove).not.toHaveBeenCalled();
  });

  it("does not let keys leak to the surface behind it", () => {
    const { items } = make();
    const behind = vi.fn();
    render(<div onKeyDown={behind}><Surface items={items} /></div>);
    fireEvent.contextMenu(screen.getByTestId("surface"), { clientX: 5, clientY: 5 });
    fireEvent.keyDown(screen.getByRole("menu"), { key: "ArrowDown" });
    expect(behind).not.toHaveBeenCalled();
  });

  describe("submenus", () => {
    const cascade = () => {
      const first = vi.fn();
      const second = vi.fn();
      const top = vi.fn();
      const items: MenuEntry[] = [
        { id: "top", label: "Duplicate", onSelect: top },
        { id: "move", label: "Move to", items: [
          { id: "a", label: "Opening", onSelect: first },
          { id: "b", label: "Finale", onSelect: second },
        ] },
      ];
      return { items, first, second, top };
    };

    it("marks the item with a chevron and opens on Right, with focus on the first entry", () => {
      const { items, second } = cascade();
      render(<Surface items={items} />);
      const surface = screen.getByTestId("surface");
      surface.focus();
      fireEvent.keyDown(surface, { key: "F10", shiftKey: true });
      fireEvent.keyDown(document.activeElement!, { key: "ArrowDown" });
      const move = screen.getByRole("menuitem", { name: "Move to" });
      expect(move).toHaveFocus();
      expect(move).toHaveAttribute("aria-haspopup", "menu");
      expect(move).toHaveAttribute("aria-expanded", "false");
      expect(move.querySelector(".ui-menu__chevron")).not.toBeNull();
      fireEvent.keyDown(move, { key: "ArrowRight" });
      const sub = screen.getByRole("menu", { name: "Move to" });
      expect(move).toHaveAttribute("aria-expanded", "true");
      expect(screen.getByRole("menuitem", { name: "Opening" })).toHaveFocus();
      fireEvent.keyDown(document.activeElement!, { key: "ArrowDown" });
      fireEvent.keyDown(document.activeElement!, { key: "Enter" });
      expect(second).toHaveBeenCalledTimes(1);
      expect(sub).not.toBeInTheDocument();
      expect(screen.queryByRole("menu")).not.toBeInTheDocument();
      expect(surface).toHaveFocus();
    });

    it("closes one level with Left or Esc and puts focus back on its item", () => {
      const { items, first } = cascade();
      render(<Surface items={items} />);
      const surface = screen.getByTestId("surface");
      surface.focus();
      fireEvent.keyDown(surface, { key: "F10", shiftKey: true });
      fireEvent.keyDown(document.activeElement!, { key: "End" });
      const move = screen.getByRole("menuitem", { name: "Move to" });
      fireEvent.keyDown(move, { key: "Enter" });
      expect(screen.getByRole("menu", { name: "Move to" })).toBeInTheDocument();
      fireEvent.keyDown(document.activeElement!, { key: "ArrowLeft" });
      expect(screen.queryByRole("menu", { name: "Move to" })).toBeNull();
      expect(screen.getByRole("menu", { name: "Clip actions" })).toBeInTheDocument();
      expect(move).toHaveFocus();
      fireEvent.keyDown(move, { key: "ArrowRight" });
      fireEvent.keyDown(window, { key: "Escape" });
      expect(screen.queryByRole("menu", { name: "Move to" })).toBeNull();
      expect(screen.getByRole("menu", { name: "Clip actions" })).toBeInTheDocument();
      expect(move).toHaveFocus();
      expect(first).not.toHaveBeenCalled();
    });

    it("opens on hover after a pause, closes when another item is hovered, and runs a click", () => {
      vi.useFakeTimers();
      try {
        const { items, first } = cascade();
        render(<Surface items={items} />);
        fireEvent.contextMenu(screen.getByTestId("surface"), { clientX: 5, clientY: 5 });
        const move = screen.getByRole("menuitem", { name: "Move to" });
        fireEvent.mouseEnter(move);
        expect(screen.queryByRole("menu", { name: "Move to" })).toBeNull();
        act(() => { vi.advanceTimersByTime(SUBMENU_HOVER_DELAY); });
        expect(screen.getByRole("menu", { name: "Move to" })).toBeInTheDocument();
        // Hovered, not keyed: focus stays on the parent item.
        expect(move).toHaveFocus();
        fireEvent.mouseEnter(screen.getByRole("menuitem", { name: "Duplicate" }));
        act(() => { vi.advanceTimersByTime(SUBMENU_HOVER_DELAY); });
        expect(screen.queryByRole("menu", { name: "Move to" })).toBeNull();
        fireEvent.click(move);
        fireEvent.click(screen.getByRole("menuitem", { name: "Opening" }));
        expect(first).toHaveBeenCalledTimes(1);
        expect(screen.queryByRole("menu")).not.toBeInTheDocument();
      } finally { vi.useRealTimers(); }
    });

    it("flips to the left of its item when there is no room on the right", () => {
      const { items } = cascade();
      render(<Surface items={items} />);
      fireEvent.contextMenu(screen.getByTestId("surface"), { clientX: 5, clientY: 5 });
      const move = screen.getByRole("menuitem", { name: "Move to" });
      const width = window.innerWidth;
      vi.spyOn(move, "getBoundingClientRect").mockReturnValue({ left: width - 180, right: width - 20, top: 100, bottom: 132, width: 160, height: 32, x: width - 180, y: 100, toJSON: () => ({}) });
      fireEvent.click(move);
      const sub = screen.getByRole("menu", { name: "Move to" });
      expect(parseFloat(sub.style.left)).toBeLessThan(width - 180);
    });
  });
});