/** * Tests of the command store and the palette: registering the UI commands * with the engine, the global keymap, running engine and UI commands * (error toasts for failures, disabled commands doing nothing), `uiCommand` * events from the engine, and the palette's keyboard handling, ranking, * shortcuts, dimmed disabled rows and recent commands. The engine is a * fake behind the mocked Tauri `invoke` and `listen`. */ import { flushPromises, mount, type VueWrapper } from "@vue/test-utils"; import { createPinia, setActivePinia, type Pinia } from "pinia"; import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"; import { defineComponent, h } from "vue"; const invoke = vi.hoisted(() => vi.fn()); const listen = vi.hoisted(() => vi.fn()); vi.mock("@tauri-apps/api/core", () => ({ invoke })); vi.mock("@tauri-apps/api/event", () => ({ listen })); import { useCommandsStore } from "../../src/commands/store"; import { UI_COMMANDS } from "../../src/commands/uiCommands"; import CommandPalette from "../../src/components/palette/CommandPalette.vue"; import { useNotificationsStore } from "../../src/stores/notifications"; /** Engine commands the fake lists. */ const ENGINE_COMMANDS = [ { id: "app.quit", label: "Quit", menuPath: "File/Quit", defaultShortcut: "Mod+Q", params: "", enabled: true, ui: false }, { id: "project.close", label: "Close Project", menuPath: "File/Close Project", defaultShortcut: null, params: "", enabled: false, ui: false }, { id: "project.openDialog", label: "Open Folder…", menuPath: "File/Open Folder…", defaultShortcut: "Mod+O", params: "", enabled: true, ui: false }, { id: "buffer.edit", label: "Edit Buffer", menuPath: null, defaultShortcut: null, params: "", enabled: true, ui: false }, ]; /** Every `engine_execute` call, in order. */ let calls: { command: string; params: unknown }[]; /** Engine commands that fail, with their error code. */ let failing: Map; /** The engine event callback the store subscribed with. */ let deliver: ((payload: unknown) => void) | null; /** Pinia of the current test. */ let pinia: Pinia; /** Mounted components, unmounted after each test. */ let mounted: VueWrapper[]; /** * The fake engine's listing: its commands plus the registered UI commands. */ function listing(): unknown[] { const registered = calls.find((c) => c.command === "ui.registerCommands")?.params as | { commands: { id: string; labelKey: string; defaultShortcut?: string }[] } | undefined; const ui = (registered?.commands ?? []).map((c) => ({ id: c.id, label: c.labelKey, labelKey: c.labelKey, menuPath: null, defaultShortcut: c.defaultShortcut ?? null, params: "", enabled: true, ui: true, })); return [...ENGINE_COMMANDS, ...ui]; } /** * Sends an engine event to the store. * * @param payload - the event. */ async function emit(payload: unknown): Promise { deliver?.(payload); await flushPromises(); } /** * Presses a key on the focused element (or the body). * * @param init - key event properties. */ async function press(init: KeyboardEventInit): Promise { const target = document.activeElement ?? document.body; target.dispatchEvent(new KeyboardEvent("keydown", { bubbles: true, cancelable: true, ...init })); await flushPromises(); } /** Ctrl+Shift+P, the palette's shortcut off macOS. */ const PALETTE_KEY = { key: "P", code: "KeyP", ctrlKey: true, shiftKey: true }; /** A focusable button standing in for the editor. */ const Host = defineComponent({ setup: () => () => h("button", { id: "host-button" }, "host"), }); /** Mounts the palette next to a focusable button and starts the store. */ async function mountPalette(): Promise { const host = mount(Host, { attachTo: document.body }); const wrapper = mount(CommandPalette, { attachTo: document.body, global: { plugins: [pinia] } }); mounted.push(host, wrapper); await useCommandsStore(pinia).start(); await flushPromises(); return wrapper; } /** * The ids of the palette's rows, in order. * * @param wrapper - the palette. */ function rows(wrapper: VueWrapper): string[] { return wrapper.findAll("[data-test=palette-row]").map((row) => row.attributes("data-command") ?? ""); } /** * Types into the palette's search field. * * @param wrapper - the palette. * @param text - the query. */ async function type(wrapper: VueWrapper, text: string): Promise { await wrapper.find("[data-test=palette-input]").setValue(text); await flushPromises(); } beforeEach(() => { pinia = createPinia(); setActivePinia(pinia); calls = []; failing = new Map(); deliver = null; mounted = []; Element.prototype.scrollIntoView = () => undefined; invoke.mockReset(); listen.mockReset(); listen.mockImplementation((_name: string, callback: (event: { payload: unknown }) => void) => { deliver = (payload) => { callback({ payload }); }; return Promise.resolve(() => undefined); }); invoke.mockImplementation((cmd: string, args?: { command: string; params: unknown }) => { if (cmd === "engine_list_commands") { return Promise.resolve(listing()); } if (cmd === "engine_execute" && args) { calls.push({ command: args.command, params: args.params }); const code = failing.get(args.command); if (code !== undefined) { return Promise.reject(Object.assign(new Error(code), { code, message: `${args.command} broke` })); } return Promise.resolve(null); } return Promise.resolve(null); }); }); afterEach(() => { useCommandsStore(pinia).stop(); for (const wrapper of mounted) { wrapper.unmount(); } }); describe("command store", () => { it("registers the UI commands and lists them from the engine", async () => { await mountPalette(); const store = useCommandsStore(pinia); expect(calls[0]).toEqual({ command: "ui.registerCommands", params: { commands: UI_COMMANDS.map((c) => ({ ...c })) } }); expect(store.infos.filter((c) => c.ui === true).map((c) => c.id)).toEqual(UI_COMMANDS.map((c) => c.id)); expect(store.entries.map((e) => e.id)).not.toContain("buffer.edit"); const toggle = store.entries.find((e) => e.id === "view.toggleProjectTree"); expect(toggle).toEqual({ id: "view.toggleProjectTree", label: "Show or Hide Project", shortcut: "Ctrl+1", enabled: false }); }); it("keeps the UI commands when the engine refuses them, with an error toast", async () => { failing.set("ui.registerCommands", "invalid_params"); await mountPalette(); const store = useCommandsStore(pinia); expect(store.entries.map((e) => e.id)).toContain("palette.open"); expect(useNotificationsStore(pinia).toasts.map((t) => t.text)).toEqual([ "ui.registerCommands failed: ui.registerCommands broke", ]); }); it("runs engine commands from their shortcut and reports failures", async () => { await mountPalette(); failing.set("project.openDialog", "failed"); await press({ key: "o", code: "KeyO", ctrlKey: true }); expect(calls.at(-1)).toEqual({ command: "project.openDialog", params: {} }); expect(useNotificationsStore(pinia).toasts.map((t) => t.text)).toEqual([ "project.openDialog failed: project.openDialog broke", ]); }); it("runs provided handlers and skips disabled commands", async () => { await mountPalette(); const store = useCommandsStore(pinia); let toggled = 0; let allowed = false; const withdraw = store.provide("view.toggleProjectTree", { run: () => { toggled += 1; }, enabled: () => allowed, }); const event = new KeyboardEvent("keydown", { key: "1", code: "Digit1", ctrlKey: true, bubbles: true, cancelable: true }); window.dispatchEvent(event); await flushPromises(); expect(toggled).toBe(0); expect(event.defaultPrevented).toBe(true); allowed = true; await press({ key: "1", code: "Digit1", ctrlKey: true }); expect(toggled).toBe(1); withdraw(); await press({ key: "1", code: "Digit1", ctrlKey: true }); expect(toggled).toBe(1); expect(calls.map((c) => c.command)).toEqual(["ui.registerCommands"]); }); it("runs a uiCommand from the engine and warns about one nobody handles", async () => { await mountPalette(); const store = useCommandsStore(pinia); const seen: unknown[] = []; store.provide("view.toggleProjectTree", { run: (params) => { seen.push(params); }, }); await emit({ kind: "uiCommand", id: "view.toggleProjectTree", params: { from: "agent" } }); expect(seen).toEqual([{ from: "agent" }]); await emit({ kind: "uiCommand", id: "settings.open", params: {} }); expect(useNotificationsStore(pinia).toasts.map((t) => t.text)).toEqual(["settings.open cannot run right now"]); expect(store.recent).toEqual(["view.toggleProjectTree"]); }); it("reports a handler that throws", async () => { await mountPalette(); const store = useCommandsStore(pinia); store.provide("view.toggleProjectTree", { run: () => { throw new Error("boom"); }, }); await store.execute("view.toggleProjectTree"); expect(useNotificationsStore(pinia).toasts.map((t) => t.text)).toEqual(["view.toggleProjectTree failed: boom"]); }); it("reloads the enabled states when a project opens", async () => { await mountPalette(); const before = invoke.mock.calls.filter(([cmd]) => cmd === "engine_list_commands").length; await emit({ kind: "projectOpened", root: "/p", name: "p" }); expect(invoke.mock.calls.filter(([cmd]) => cmd === "engine_list_commands").length).toBe(before + 1); }); }); describe("CommandPalette", () => { it("opens with Mod+Shift+P and lists commands with shortcuts", async () => { const wrapper = await mountPalette(); expect(wrapper.find("[data-test=palette]").exists()).toBe(false); await press(PALETTE_KEY); expect(wrapper.find("[data-test=palette]").exists()).toBe(true); expect(document.activeElement).toBe(wrapper.find("[data-test=palette-input]").element); expect(rows(wrapper)).toEqual([ "project.close", "palette.open", "project.openDialog", "app.quit", "editor.reveal", "settings.open", "view.toggleProjectTree", ]); const quit = wrapper.find("[data-command='app.quit']"); expect(quit.find("[data-test=palette-shortcut]").text()).toBe("Ctrl+Q"); expect(quit.text()).toContain("Quit"); }); it("opens from a uiCommand the engine sends (control channel)", async () => { const wrapper = await mountPalette(); await emit({ kind: "uiCommand", id: "palette.open", params: {} }); expect(wrapper.find("[data-test=palette]").exists()).toBe(true); }); it("filters and moves with the arrow keys, runs with Enter", async () => { const wrapper = await mountPalette(); await press(PALETTE_KEY); await type(wrapper, "o"); expect(rows(wrapper).slice(0, 2)).toEqual(["project.openDialog", "palette.open"]); await type(wrapper, "open f"); expect(rows(wrapper)[0]).toBe("project.openDialog"); await press({ key: "ArrowDown" }); await press({ key: "ArrowUp" }); expect(wrapper.find("[aria-selected=true]").attributes("data-command")).toBe("project.openDialog"); await press({ key: "Enter" }); expect(wrapper.find("[data-test=palette]").exists()).toBe(false); expect(calls.at(-1)).toEqual({ command: "project.openDialog", params: {} }); }); it("wraps around with the arrow keys", async () => { const wrapper = await mountPalette(); await press(PALETTE_KEY); await press({ key: "ArrowUp" }); expect(wrapper.find("[aria-selected=true]").attributes("data-command")).toBe("view.toggleProjectTree"); await press({ key: "ArrowDown" }); expect(wrapper.find("[aria-selected=true]").attributes("data-command")).toBe("project.close"); }); it("dims disabled commands, which Enter and clicks do not run", async () => { const wrapper = await mountPalette(); await press(PALETTE_KEY); await type(wrapper, "close proj"); const row = wrapper.find("[data-command='project.close']"); expect(row.attributes("aria-disabled")).toBe("true"); expect(row.classes()).toContain("palette__row--disabled"); await press({ key: "Enter" }); await row.trigger("click"); expect(wrapper.find("[data-test=palette]").exists()).toBe(true); expect(calls.map((c) => c.command)).not.toContain("project.close"); await type(wrapper, "settings"); expect(wrapper.find("[data-command='settings.open']").attributes("aria-disabled")).toBe("true"); }); it("closes with Escape and gives the focus back", async () => { const wrapper = await mountPalette(); const button = document.getElementById("host-button"); button?.focus(); await press(PALETTE_KEY); expect(document.activeElement).not.toBe(button); await press({ key: "Escape" }); expect(wrapper.find("[data-test=palette]").exists()).toBe(false); expect(document.activeElement).toBe(button); expect(calls.map((c) => c.command)).toEqual(["ui.registerCommands"]); }); it("shows recently run commands first", async () => { const wrapper = await mountPalette(); await press(PALETTE_KEY); await type(wrapper, "quit"); await press({ key: "Enter" }); await press(PALETTE_KEY); expect(rows(wrapper)[0]).toBe("app.quit"); await wrapper.find("[data-command='project.openDialog']").trigger("click"); await flushPromises(); await press(PALETTE_KEY); expect(rows(wrapper).slice(0, 2)).toEqual(["project.openDialog", "app.quit"]); }); it("says when nothing matches", async () => { const wrapper = await mountPalette(); await press(PALETTE_KEY); await type(wrapper, "zzzz"); expect(rows(wrapper)).toEqual([]); expect(wrapper.find("[data-test=palette-empty]").text()).toBe("No matching commands"); }); });