Path settings get Kind::Path, checked by check_path in the engine: the one validator for settings.set from agents, the CLI and the dialog. settings.list marks them with path: true; the dialog uses that flag for Browse and shows the engine's reason (userMessage drops the invalid-params prefix). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
453 lines
19 KiB
TypeScript
453 lines
19 KiB
TypeScript
/**
|
|
* Tests of the settings store and dialog: opening through `settings.open`
|
|
* (`Mod+,`), rendering from a mocked `settings.list` (sections, controls by
|
|
* type, catalog labels), search, changes through `settings.set`, inline
|
|
* errors (refused here and by the engine), reset, live updates on
|
|
* `settingsChanged`, the editor font size token, focus trap and Escape.
|
|
* 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 SettingsDialog from "../../src/components/settings/SettingsDialog.vue";
|
|
import {
|
|
FONT_SIZE_TOKEN,
|
|
matchesQuery,
|
|
toSettingDefs,
|
|
useSettingsStore,
|
|
valueLabel,
|
|
type SettingDef,
|
|
} from "../../src/stores/settings";
|
|
import { applyTheme, setTokenOverride } from "../../src/theme";
|
|
|
|
/** What the fake engine's `settings.list` returns. */
|
|
const LIST = [
|
|
{
|
|
key: "appearance.theme",
|
|
type: "enum",
|
|
default: "system",
|
|
enumValues: ["lutra-dark", "lutra-light", "system"],
|
|
labelKey: "settings.appearance.theme.label",
|
|
descriptionKey: "settings.appearance.theme.description",
|
|
section: "appearance",
|
|
},
|
|
{
|
|
key: "editor.fontSize",
|
|
type: "int",
|
|
default: 14,
|
|
min: 8,
|
|
max: 48,
|
|
labelKey: "settings.editor.fontSize.label",
|
|
descriptionKey: "settings.editor.fontSize.description",
|
|
section: "editor",
|
|
},
|
|
{
|
|
key: "ui.language",
|
|
type: "enum",
|
|
default: "en",
|
|
enumValues: ["en"],
|
|
labelKey: "settings.ui.language.label",
|
|
descriptionKey: "settings.ui.language.description",
|
|
section: "appearance",
|
|
},
|
|
{
|
|
key: "editor.softWrap",
|
|
type: "bool",
|
|
default: false,
|
|
labelKey: "settings.editor.softWrap.label",
|
|
descriptionKey: "settings.editor.softWrap.description",
|
|
section: "editor",
|
|
},
|
|
];
|
|
|
|
/** The fake engine's values. */
|
|
let values: Record<string, unknown>;
|
|
/** Every `engine_execute` call, in order. */
|
|
let calls: { command: string; params: unknown }[];
|
|
/** Commands that fail, with their error. */
|
|
let failing: Map<string, { code: string; message: string }>;
|
|
/** The engine event callbacks, one per subscription. */
|
|
let listeners: ((payload: unknown) => void)[];
|
|
/** Pinia of the current test. */
|
|
let pinia: Pinia;
|
|
/** Mounted components, unmounted after each test. */
|
|
let mounted: VueWrapper[];
|
|
|
|
/**
|
|
* Sends an engine event to every subscriber.
|
|
*
|
|
* @param payload - the event.
|
|
*/
|
|
async function emit(payload: unknown): Promise<void> {
|
|
for (const listener of listeners) {
|
|
listener(payload);
|
|
}
|
|
await flushPromises();
|
|
}
|
|
|
|
/**
|
|
* An error as the shell rejects with: an `Error` carrying `code` and `message`.
|
|
*
|
|
* @param code - the error code.
|
|
* @param message - the message.
|
|
*/
|
|
function engineError(code: string, message: string): Error {
|
|
return Object.assign(new Error(message), { code, message });
|
|
}
|
|
|
|
/**
|
|
* The fake engine's answer to a command.
|
|
*
|
|
* @param command - the command id.
|
|
* @param params - its params.
|
|
*/
|
|
function answer(command: string, params: Record<string, unknown>): unknown {
|
|
const def = LIST.find((d) => d.key === params.key);
|
|
switch (command) {
|
|
case "settings.list":
|
|
return LIST;
|
|
case "settings.get": {
|
|
const keys = Array.isArray(params.keys) ? (params.keys as string[]) : Object.keys(values);
|
|
return { values: Object.fromEntries(keys.map((k) => [k, values[k]])) };
|
|
}
|
|
case "settings.set":
|
|
if (def?.type === "int" && (typeof params.value !== "number" || params.value < 8 || params.value > 48)) {
|
|
throw engineError("invalid_params", "editor.fontSize: expected an integer from 8 to 48");
|
|
}
|
|
values[params.key as string] = params.value;
|
|
return { value: params.value };
|
|
case "settings.reset":
|
|
values[params.key as string] = def?.default;
|
|
return { value: def?.default };
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/** A focusable button standing in for the editor. */
|
|
const Host = defineComponent({
|
|
setup: () => () => h("button", { id: "host-button" }, "host"),
|
|
});
|
|
|
|
/** Mounts the dialog next to a focusable button and starts the stores. */
|
|
async function mountDialog(): Promise<VueWrapper> {
|
|
const host = mount(Host, { attachTo: document.body });
|
|
const wrapper = mount(SettingsDialog, { attachTo: document.body, global: { plugins: [pinia] } });
|
|
mounted.push(host, wrapper);
|
|
await useCommandsStore(pinia).start();
|
|
await useSettingsStore(pinia).start();
|
|
await flushPromises();
|
|
return wrapper;
|
|
}
|
|
|
|
/**
|
|
* 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();
|
|
}
|
|
|
|
/**
|
|
* Opens the dialog with `Ctrl+,`.
|
|
*
|
|
* @param wrapper - the dialog.
|
|
*/
|
|
async function open(wrapper: VueWrapper): Promise<void> {
|
|
document.getElementById("host-button")?.focus();
|
|
await press({ key: ",", code: "Comma", ctrlKey: true });
|
|
await wrapper.vm.$nextTick();
|
|
}
|
|
|
|
/**
|
|
* The keys of the shown settings, in order.
|
|
*
|
|
* @param wrapper - the dialog.
|
|
*/
|
|
function rows(wrapper: VueWrapper): string[] {
|
|
return wrapper.findAll("[data-test=settings-row]").map((row) => row.attributes("data-key") ?? "");
|
|
}
|
|
|
|
/**
|
|
* A setting's row.
|
|
*
|
|
* @param wrapper - the dialog.
|
|
* @param key - the setting.
|
|
*/
|
|
function row(wrapper: VueWrapper, key: string) {
|
|
return wrapper.find(`[data-test=settings-row][data-key="${key}"]`);
|
|
}
|
|
|
|
beforeEach(() => {
|
|
pinia = createPinia();
|
|
setActivePinia(pinia);
|
|
values = { "appearance.theme": "system", "editor.fontSize": 14, "ui.language": "en", "editor.softWrap": false };
|
|
calls = [];
|
|
failing = new Map();
|
|
listeners = [];
|
|
mounted = [];
|
|
document.documentElement.removeAttribute("style");
|
|
listen.mockReset();
|
|
listen.mockImplementation((_name: string, callback: (event: { payload: unknown }) => void) => {
|
|
listeners.push((payload) => {
|
|
callback({ payload });
|
|
});
|
|
return Promise.resolve(() => undefined);
|
|
});
|
|
invoke.mockReset();
|
|
invoke.mockImplementation((cmd: string, args?: { command: string; params: Record<string, unknown> }) => {
|
|
if (cmd === "engine_list_commands") {
|
|
return Promise.resolve([]);
|
|
}
|
|
if (cmd === "engine_execute" && args) {
|
|
calls.push({ command: args.command, params: args.params });
|
|
const error = failing.get(args.command);
|
|
if (error) {
|
|
return Promise.reject(engineError(error.code, error.message));
|
|
}
|
|
try {
|
|
return Promise.resolve(answer(args.command, args.params));
|
|
} catch (reason: unknown) {
|
|
return Promise.reject(reason instanceof Error ? reason : new Error(String(reason)));
|
|
}
|
|
}
|
|
return Promise.resolve(null);
|
|
});
|
|
});
|
|
|
|
afterEach(() => {
|
|
useCommandsStore(pinia).stop();
|
|
useSettingsStore(pinia).stop();
|
|
for (const wrapper of mounted) {
|
|
wrapper.unmount();
|
|
}
|
|
setTokenOverride(FONT_SIZE_TOKEN, null);
|
|
});
|
|
|
|
describe("settings helpers", () => {
|
|
it("reads settings.list defensively", () => {
|
|
expect(toSettingDefs("nope")).toBeNull();
|
|
const defs = toSettingDefs([...LIST, null, { key: 1 }, { ...LIST[0], type: "color" }, { ...LIST[0], enumValues: [] }]);
|
|
expect(defs?.map((d) => d.key)).toEqual(["appearance.theme", "editor.fontSize", "ui.language", "editor.softWrap"]);
|
|
expect(defs?.[1]).toMatchObject({ min: 8, max: 48, enumValues: [] });
|
|
});
|
|
|
|
it("matches label, description, key and section, every word", () => {
|
|
const [theme, size] = toSettingDefs(LIST) as SettingDef[];
|
|
expect(matchesQuery(size as SettingDef, "font")).toBe(true);
|
|
expect(matchesQuery(size as SettingDef, "PIXELS")).toBe(true);
|
|
expect(matchesQuery(size as SettingDef, "editor.fontsize")).toBe(true);
|
|
expect(matchesQuery(theme as SettingDef, "appearance")).toBe(true);
|
|
expect(matchesQuery(theme as SettingDef, "colours system")).toBe(true);
|
|
expect(matchesQuery(theme as SettingDef, "colours font")).toBe(false);
|
|
});
|
|
|
|
it("names enum values from the catalog, else the value", () => {
|
|
const [theme] = toSettingDefs(LIST) as SettingDef[];
|
|
expect(valueLabel(theme as SettingDef, "lutra-dark")).toBe("Lutra Dark");
|
|
expect(valueLabel(theme as SettingDef, "system")).toBe("Same as system");
|
|
expect(valueLabel(theme as SettingDef, "solarized")).toBe("solarized");
|
|
});
|
|
});
|
|
|
|
describe("settings dialog", () => {
|
|
it("is disabled until mounted and opens with Mod+, built from settings.list", async () => {
|
|
expect(useCommandsStore(pinia).isEnabled("settings.open")).toBe(false);
|
|
const wrapper = await mountDialog();
|
|
expect(useCommandsStore(pinia).isEnabled("settings.open")).toBe(true);
|
|
expect(wrapper.find("[data-test=settings]").exists()).toBe(false);
|
|
await open(wrapper);
|
|
expect(wrapper.find("[role=dialog]").attributes("aria-modal")).toBe("true");
|
|
expect(document.activeElement).toBe(wrapper.find("[data-test=settings-search]").element);
|
|
expect(wrapper.findAll("[data-test=settings-section]").map((s) => s.text())).toEqual(["Appearance", "Editor"]);
|
|
expect(rows(wrapper)).toEqual(["appearance.theme", "ui.language"]);
|
|
const theme = row(wrapper, "appearance.theme");
|
|
expect(theme.find("label").text()).toBe("Theme");
|
|
expect(theme.find("select").findAll("option").map((o) => o.text())).toEqual([
|
|
"Lutra Dark",
|
|
"Lutra Light",
|
|
"Same as system",
|
|
]);
|
|
expect((theme.find("select").element as HTMLSelectElement).value).toBe("system");
|
|
expect(theme.find("[data-test=settings-reset]").attributes("disabled")).toBeDefined();
|
|
|
|
await wrapper.find("[data-section=editor]").trigger("click");
|
|
expect(rows(wrapper)).toEqual(["editor.fontSize", "editor.softWrap"]);
|
|
const size = row(wrapper, "editor.fontSize").find("input");
|
|
expect(size.attributes()).toMatchObject({ type: "number", min: "8", max: "48" });
|
|
expect((size.element as HTMLInputElement).value).toBe("14");
|
|
const wrap = row(wrapper, "editor.softWrap").find("[role=switch]");
|
|
expect(wrap.attributes("aria-checked")).toBe("false");
|
|
expect(row(wrapper, "editor.softWrap").find("label").text()).toBe("editor.softWrap");
|
|
});
|
|
|
|
it("filters by search across sections and says when nothing matches", async () => {
|
|
const wrapper = await mountDialog();
|
|
await open(wrapper);
|
|
await wrapper.find("[data-test=settings-search]").setValue("font");
|
|
expect(rows(wrapper)).toEqual(["editor.fontSize"]);
|
|
expect(wrapper.find("[data-section=appearance]").classes()).toContain("settings__section--dim");
|
|
await wrapper.find("[data-test=settings-search]").setValue("language interface");
|
|
expect(rows(wrapper)).toEqual(["ui.language"]);
|
|
await wrapper.find("[data-test=settings-search]").setValue("e");
|
|
expect(rows(wrapper)).toEqual(["appearance.theme", "ui.language", "editor.fontSize", "editor.softWrap"]);
|
|
await wrapper.find("[data-test=settings-search]").setValue("zebra");
|
|
expect(rows(wrapper)).toEqual([]);
|
|
expect(wrapper.find("[data-test=settings-empty]").text()).toBe("No settings match your search");
|
|
});
|
|
|
|
it("switches the theme at once through settings.set", async () => {
|
|
const wrapper = await mountDialog();
|
|
await open(wrapper);
|
|
await row(wrapper, "appearance.theme").find("select").setValue("lutra-light");
|
|
await flushPromises();
|
|
expect(calls.at(-1)).toEqual({ command: "settings.set", params: { key: "appearance.theme", value: "lutra-light" } });
|
|
expect(useSettingsStore(pinia).values["appearance.theme"]).toBe("lutra-light");
|
|
expect(row(wrapper, "appearance.theme").find("[data-test=settings-reset]").attributes("disabled")).toBeUndefined();
|
|
});
|
|
|
|
it("applies the font size to the editor token, above the theme", async () => {
|
|
const wrapper = await mountDialog();
|
|
const root = document.documentElement;
|
|
expect(root.style.getPropertyValue(FONT_SIZE_TOKEN)).toBe("14px");
|
|
await open(wrapper);
|
|
await wrapper.find("[data-section=editor]").trigger("click");
|
|
await row(wrapper, "editor.fontSize").find("input").setValue("18");
|
|
await flushPromises();
|
|
expect(calls.at(-1)).toEqual({ command: "settings.set", params: { key: "editor.fontSize", value: 18 } });
|
|
expect(root.style.getPropertyValue(FONT_SIZE_TOKEN)).toBe("18px");
|
|
applyTheme({ id: "lutra-light", dark: false, tokens: { [FONT_SIZE_TOKEN]: "14px", "--lt-bg": "#fff" } });
|
|
expect(root.style.getPropertyValue(FONT_SIZE_TOKEN)).toBe("18px");
|
|
expect(root.style.getPropertyValue("--lt-bg")).toBe("#fff");
|
|
setTokenOverride(FONT_SIZE_TOKEN, null);
|
|
expect(root.style.getPropertyValue(FONT_SIZE_TOKEN)).toBe("14px");
|
|
});
|
|
|
|
it("shows refused values inline and keeps the typed text", async () => {
|
|
const wrapper = await mountDialog();
|
|
await open(wrapper);
|
|
await wrapper.find("[data-section=editor]").trigger("click");
|
|
const input = () => row(wrapper, "editor.fontSize").find("input");
|
|
await input().setValue("99");
|
|
await flushPromises();
|
|
expect(calls.some((c) => c.command === "settings.set")).toBe(false);
|
|
expect(row(wrapper, "editor.fontSize").find("[data-test=settings-error]").text()).toBe(
|
|
"Enter a whole number from 8 to 48",
|
|
);
|
|
expect(input().attributes("aria-invalid")).toBe("true");
|
|
expect((input().element as HTMLInputElement).value).toBe("99");
|
|
|
|
failing.set("settings.set", { code: "failed", message: "disk full" });
|
|
await input().setValue("20");
|
|
await flushPromises();
|
|
expect(row(wrapper, "editor.fontSize").find("[data-test=settings-error]").text()).toBe("disk full");
|
|
expect(useSettingsStore(pinia).values["editor.fontSize"]).toBe(14);
|
|
|
|
failing.clear();
|
|
await input().setValue("20");
|
|
await flushPromises();
|
|
expect(row(wrapper, "editor.fontSize").find("[data-test=settings-error]").exists()).toBe(false);
|
|
expect((input().element as HTMLInputElement).value).toBe("20");
|
|
});
|
|
|
|
it("shows the engine's error for a value it refuses, without the key the row already names", async () => {
|
|
const wrapper = await mountDialog();
|
|
await open(wrapper);
|
|
await useSettingsStore(pinia).set("editor.fontSize", 2);
|
|
await wrapper.find("[data-section=editor]").trigger("click");
|
|
expect(row(wrapper, "editor.fontSize").find("[data-test=settings-error]").text()).toBe(
|
|
"expected an integer from 8 to 48",
|
|
);
|
|
});
|
|
|
|
it("resets a setting to its default", async () => {
|
|
values["editor.fontSize"] = 20;
|
|
const wrapper = await mountDialog();
|
|
await open(wrapper);
|
|
await wrapper.find("[data-section=editor]").trigger("click");
|
|
const reset = row(wrapper, "editor.fontSize").find("[data-test=settings-reset]");
|
|
expect(reset.attributes("aria-label")).toBe("Reset Editor font size to default");
|
|
await reset.trigger("click");
|
|
await flushPromises();
|
|
expect(calls.at(-1)).toEqual({ command: "settings.reset", params: { key: "editor.fontSize" } });
|
|
expect((row(wrapper, "editor.fontSize").find("input").element as HTMLInputElement).value).toBe("14");
|
|
expect(document.documentElement.style.getPropertyValue(FONT_SIZE_TOKEN)).toBe("14px");
|
|
});
|
|
|
|
it("follows settingsChanged from elsewhere while open", async () => {
|
|
const wrapper = await mountDialog();
|
|
await open(wrapper);
|
|
await wrapper.find("[data-section=editor]").trigger("click");
|
|
await row(wrapper, "editor.fontSize").find("input").setValue("99");
|
|
await flushPromises();
|
|
values["editor.fontSize"] = 22;
|
|
values["editor.softWrap"] = true;
|
|
await emit({ kind: "settingsChanged", keys: ["editor.fontSize", "editor.softWrap", 7] });
|
|
expect(calls.at(-1)).toEqual({ command: "settings.get", params: { keys: ["editor.fontSize", "editor.softWrap"] } });
|
|
expect((row(wrapper, "editor.fontSize").find("input").element as HTMLInputElement).value).toBe("22");
|
|
expect(row(wrapper, "editor.fontSize").find("[data-test=settings-error]").exists()).toBe(false);
|
|
expect(row(wrapper, "editor.softWrap").find("[role=switch]").attributes("aria-checked")).toBe("true");
|
|
expect(document.documentElement.style.getPropertyValue(FONT_SIZE_TOKEN)).toBe("22px");
|
|
await emit({ kind: "settingsChanged", keys: "nope" });
|
|
});
|
|
|
|
it("flips a switch", async () => {
|
|
const wrapper = await mountDialog();
|
|
await open(wrapper);
|
|
await wrapper.find("[data-section=editor]").trigger("click");
|
|
await row(wrapper, "editor.softWrap").find("[role=switch]").trigger("click");
|
|
await flushPromises();
|
|
expect(calls.at(-1)).toEqual({ command: "settings.set", params: { key: "editor.softWrap", value: true } });
|
|
expect(row(wrapper, "editor.softWrap").find("[role=switch]").attributes("aria-checked")).toBe("true");
|
|
});
|
|
|
|
it("traps the focus, closes with Escape and gives the focus back", async () => {
|
|
const wrapper = await mountDialog();
|
|
await open(wrapper);
|
|
const dialog = wrapper.find("[data-test=settings-dialog]").element as HTMLElement;
|
|
const reachable = [
|
|
...dialog.querySelectorAll<HTMLElement>("button:not([disabled]), input, select"),
|
|
];
|
|
const last = reachable.at(-1) as HTMLElement;
|
|
last.focus();
|
|
await press({ key: "Tab" });
|
|
expect(document.activeElement).toBe(reachable[0]);
|
|
await press({ key: "Tab", shiftKey: true });
|
|
expect(document.activeElement).toBe(last);
|
|
document.getElementById("host-button")?.focus();
|
|
expect(document.activeElement).toBe(wrapper.find("[data-test=settings-search]").element);
|
|
const above = document.createElement("div");
|
|
above.setAttribute("aria-modal", "true");
|
|
const field = document.createElement("input");
|
|
above.append(field);
|
|
document.body.append(above);
|
|
field.focus();
|
|
expect(document.activeElement).toBe(field);
|
|
above.remove();
|
|
(wrapper.find("[data-test=settings-search]").element as HTMLElement).focus();
|
|
await press({ key: "Escape" });
|
|
expect(wrapper.find("[data-test=settings]").exists()).toBe(false);
|
|
expect(document.activeElement?.id).toBe("host-button");
|
|
});
|
|
|
|
it("opens from a uiCommand event and shows a load failure", async () => {
|
|
const wrapper = await mountDialog();
|
|
failing.set("settings.list", { code: "internal", message: "boom" });
|
|
await emit({ kind: "uiCommand", id: "settings.open", params: {} });
|
|
expect(wrapper.find("[data-test=settings]").exists()).toBe(true);
|
|
expect(wrapper.find("[data-test=settings-load-error]").text()).toBe("Settings could not be loaded: boom");
|
|
await wrapper.find("[data-test=settings-close]").trigger("click");
|
|
expect(wrapper.find("[data-test=settings]").exists()).toBe(false);
|
|
});
|
|
});
|