Owner decision D23: Lutra runs fetch, pull (merge or rebase per the new git.pull.mode setting), push (upstream set on the first push) and clone through the user's git. Any HTTPS or SSH server works; sign-in stays with git's credential helper (its own window is allowed for network calls only) and the ssh agent. Terminal prompts stay off, ext:: is refused, and URL userinfo is redacted in every message, progress line and remote listing. - vcs: Call::network with a 30 min timeout, a stderr progress sink and a Cancel flag that kills git's process group; remote.rs with clone_repo, fetch, pull, push (--porcelain rejections), remotes and add/set-url/ remove; explained refusals (rejected push, sign-in, host key, not found, unreachable, no upstream, local changes, conflicts). - engine: git.fetch/pull/push/clone/cancel/remotes/remoteAdd/remoteSetUrl/ remoteRemove, one network call at a time, gitProgress events, gitChanged after changes. - ui: status-bar progress with Cancel and ahead/behind, vcs.fetch/pull/ push/clone/manageRemotes (Git menu, no default shortcuts), Clone Repository and Manage Remotes dialogs; desktop pick_dir IPC. - Tests against local bare repositories only (vcs 8, engine 3, Vitest 11) plus unit and property tests; docs updated. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
378 lines
14 KiB
TypeScript
378 lines
14 KiB
TypeScript
/**
|
|
* 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<string, string>;
|
|
/** 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; menuPath?: string; defaultShortcut?: string }[] }
|
|
| undefined;
|
|
const ui = (registered?.commands ?? []).map((c) => ({
|
|
id: c.id,
|
|
label: c.labelKey,
|
|
labelKey: c.labelKey,
|
|
menuPath: c.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<void> {
|
|
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<void> {
|
|
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<VueWrapper> {
|
|
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<void> {
|
|
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, menuPath: "View/Project", ui: true });
|
|
});
|
|
|
|
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([
|
|
"vcs.branches",
|
|
"vcs.openChanges",
|
|
"vcs.checkout",
|
|
"vcs.clone",
|
|
"project.close",
|
|
"palette.open",
|
|
"vcs.commit",
|
|
"editor.complete",
|
|
"vcs.fetch",
|
|
"find.open",
|
|
"goto.classOpen",
|
|
"goto.fileOpen",
|
|
"goto.symbolOpen",
|
|
"vcs.showLog",
|
|
"vcs.manageRemotes",
|
|
"vcs.newBranch",
|
|
"vcs.nextChange",
|
|
"project.openDialog",
|
|
"menu.open",
|
|
"editor.parameterInfo",
|
|
"vcs.previousChange",
|
|
"problems.open",
|
|
"vcs.pull",
|
|
"vcs.push",
|
|
"editor.quickDocumentation",
|
|
"app.quit",
|
|
"vcs.refresh",
|
|
"editor.reveal",
|
|
"settings.open",
|
|
"vcs.showDiff",
|
|
"vcs.showHistory",
|
|
"view.toggleProjectTree",
|
|
"view.toggleStructure",
|
|
"terminal.open",
|
|
]);
|
|
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, 3)).toEqual(["project.openDialog", "menu.open", "find.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("terminal.open");
|
|
await press({ key: "ArrowDown" });
|
|
expect(wrapper.find("[aria-selected=true]").attributes("data-command")).toBe("vcs.branches");
|
|
});
|
|
|
|
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");
|
|
});
|
|
});
|