Skip to content

The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.

9.7 KB
Raw Blame
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { CLIENT_SETTINGS_KEYS } from "./clientSettings";
import { commands, call, type Settings } from "./ipc";
import { loadSettings, useProject } from "./project";
import { connectRemote, disableRemote, enableRemote, isRemoteWindow, remoteRouting } from "./remote";
import { invoke as routedInvoke } from "./tauriCore";

const handlers = vi.hoisted(() => new Map<string, () => void>());
vi.mock("./ipc", async (original) => ({
  ...(await original<typeof import("./ipc")>()),
  onIdeEvent: (event: string, handler: () => void) => {
    handlers.set(event, handler);
    return () => handlers.delete(event);
  },
}));
import { trackRuntimeSettings } from "@/features/settings/runtime";

const local = {
  keymap: "my-map",
  keymapOverrides: { "editor.copy": ["Meta+J"] },
  customKeymaps: {
    "my-map": { name: "Mine", parent: "vscode-macos", overrides: { "editor.paste": ["Meta+K"] } },
  },
  appearance: { theme: "dark" },
  editor: { fontSize: 19, tabSize: 8 },
  terminal: { fontSize: 18, shellPath: "/local" },
};
const remote = {
  keymap: "intellij-linux",
  keymapOverrides: {},
  customKeymaps: {},
  appearance: { theme: "light" },
  editor: { fontSize: 13, tabSize: 2 },
  terminal: { fontSize: 13, shellPath: "/remote" },
};
const served = new Set(["settings_get", "settings_set", "project_current"]);
let invoke: ReturnType<typeof vi.fn>;

beforeEach(() => {
  useProject.setState({ opening: true });
  invoke = vi.fn(async (cmd: string, _args?: unknown, _options?: unknown) =>
    cmd === "remote_invoke" ? JSON.stringify(remote) : local,
  );
  Object.assign(window, { __TAURI_INTERNALS__: { invoke, transformCallback: () => 1 } });
  enableRemote({
    target: { kind: "ssh", config: "test" },
    root: "/remote",
    host: "test",
    os: "linux",
    commands: [...served],
  });
});
afterEach(() => {
  disableRemote();
  useProject.setState({ opening: false, settings: null });
});

describe("remote client settings", () => {
  it("routes window reports through the commands advertised by the remote host", async () => {
    enableRemote({
      target: { kind: "ssh", config: "test" },
      root: "/remote",
      host: "test",
      os: "linux",
      commands: ["mcp_set_open_editors", "mcp_set_focused_editor", "mcp_report_problems"],
    });
    invoke.mockResolvedValue("null");
    await call(commands.mcpSetOpenEditors(["/remote/a.txt"]));
    await call(commands.mcpSetFocusedEditor(null, true));
    const files = [{ path: "/remote/a.txt", items: [] }];
    await call(commands.mcpReportProblems(true, files));
    await call(commands.mcpReportProblems(false, files));
    const reports = invoke.mock.calls.map(([cmd, args]) => [
      cmd,
      (args as { cmd: string }).cmd,
      JSON.parse((args as { args: string }).args),
    ]);
    expect(reports).toEqual([
      ["remote_invoke", "mcp_set_open_editors", { paths: ["/remote/a.txt"] }],
      ["remote_invoke", "mcp_set_focused_editor", { editor: null, focused: true }],
      ["remote_invoke", "mcp_report_problems", { reset: true, files }],
      ["remote_invoke", "mcp_report_problems", { reset: false, files }],
    ]);
  });

  it.each([
    { gradle: { dir: "app", projects: [] }, expected: [{ dir: "app", projects: [] }] },
    {
      gradle: [
        { dir: "one", projects: [] },
        { dir: "two", projects: [] },
      ],
      expected: [
        { dir: "one", projects: [] },
        { dir: "two", projects: [] },
      ],
    },
    { gradle: null, expected: null },
  ])("accepts the released and current remote Gradle build models: $gradle", async ({ gradle, expected }) => {
    for (const command of ["build_model", "build_sync", "gradle_link_projects", "gradle_unlink_projects"]) {
      enableRemote({
        target: { kind: "wsl", distro: "Ubuntu" },
        root: "/remote",
        host: "Ubuntu",
        os: "linux",
        commands: [command],
      });
      invoke.mockResolvedValue(JSON.stringify({ gradle, maven: null }));
      expect(await routedInvoke(command)).toEqual({ gradle: expected, maven: null });
    }
  });

  it("ends remote routing before a successful local open is published, even at the same path", async () => {
    invoke.mockResolvedValueOnce({ root: "/remote", settings: local });
    await call(commands.openProject("/remote"));
    expect(isRemoteWindow()).toBe(false);
    await loadSettings();
    expect(useProject.getState().settings).toEqual(local);
    expect(invoke.mock.calls.map(([cmd]) => cmd)).toEqual(["open_project", "settings_get"]);
  });

  it("preserves remote routing when opening a local project fails", async () => {
    invoke.mockRejectedValueOnce({ kind: "notFound", message: "missing folder" });
    await expect(call(commands.openProject("/missing"))).rejects.toThrow("missing folder");
    expect(isRemoteWindow()).toBe(true);
    await loadSettings();
    expect(useProject.getState().settings?.editor?.tabSize).toBe(2);
  });

  it.each([...CLIENT_SETTINGS_KEYS, "customKeymaps.mine", "keymapOverrides.editor.copy", "appearance.theme"])(
    "keeps %s writes local in either scope",
    (key) => {
      for (const scope of ["global", "project"])
        expect(remoteRouting("settings_set", { scope, key, value: "null" }, served)).toBe("local");
    },
  );
  it.each([
    "editor.tabSize",
    "editor.formatOnSave",
    "editor.codeStyle.languages",
    "terminal.shellPath",
    "terminal.env",
    "tools.node",
    "languages.python.interpreter",
    "keymapExtra",
  ])("preserves routing for host setting %s", (key) => {
    expect(remoteRouting("settings_set", { scope: "project", key }, served)).toBe("remote");
    expect(remoteRouting("settings_set", { scope: "global", key }, served)).toBe("both");
  });
  it("merges settings before publishing a newly connected project", async () => {
    disableRemote();
    invoke.mockImplementation(async (cmd: string) =>
      cmd === "remote_connect"
        ? {
            target: { kind: "ssh", config: "test" },
            root: "/remote",
            host: "test",
            commands: [...served],
            project: { root: "/remote", name: "remote", settings: remote },
          }
        : cmd === "remote_invoke"
          ? "null"
          : local,
    );
    await connectRemote({ kind: "ssh", config: "test" }, "/remote");
    expect(useProject.getState().settings).toMatchObject({ keymap: "my-map", editor: { tabSize: 2, fontSize: 19 } });
  });
  it("overlays the project snapshot used by the settings window", async () => {
    invoke.mockImplementation(async (cmd: string) =>
      cmd === "remote_invoke" ? JSON.stringify({ root: "/remote", settings: remote }) : local,
    );
    expect((await commands.projectCurrent())?.settings).toMatchObject({
      keymap: "my-map",
      editor: { tabSize: 2, fontSize: 19 },
    });
  });
  it("keeps client preferences after a remote tooling write", async () => {
    expect(await call(commands.settingsSet("project", "editor.tabSize", "2"))).toMatchObject({
      keymap: "my-map",
      editor: { fontSize: 19, tabSize: 2 },
    });
    expect(invoke.mock.calls.some(([cmd]) => cmd === "settings_set")).toBe(false);
  });
  it("keeps local overrides through a settingsChanged runtime reload", async () => {
    vi.useFakeTimers();
    await loadSettings();
    const stop = trackRuntimeSettings();
    try {
      handlers.get("settingsChanged")!();
      await vi.advanceTimersByTimeAsync(40);
      expect(useProject.getState().settings?.keymapOverrides).toEqual(local.keymapOverrides);
      expect(useProject.getState().settings?.keymap).toBe("my-map");
    } finally {
      stop();
      vi.useRealTimers();
    }
  });
  it("reloads local preferences instead of retaining stale or remote overrides", async () => {
    await loadSettings();
    invoke.mockImplementation(async (cmd: string) =>
      cmd === "remote_invoke" ? JSON.stringify(remote) : { ...local, keymapOverrides: {} },
    );
    await loadSettings();
    expect(useProject.getState().settings?.keymapOverrides).toEqual({});
  });
  it("does not inherit remote UI values when a local field is absent", async () => {
    invoke.mockImplementation(async (cmd: string) => (cmd === "remote_invoke" ? JSON.stringify(remote) : {}));
    await loadSettings();
    expect(useProject.getState().settings?.keymap).toBeUndefined();
    expect(useProject.getState().settings?.editor?.tabSize).toBe(2);
  });
  it("leaves local windows unchanged", async () => {
    disableRemote();
    await loadSettings();
    expect(useProject.getState().settings).toEqual(local);
    expect(invoke).toHaveBeenCalledTimes(1);
  });
  it("preserves client keymaps and UI settings when loading remote settings", async () => {
    await loadSettings();
    const settings = useProject.getState().settings as Settings;
    expect(settings).toMatchObject({
      ...local,
      editor: { fontSize: 19, tabSize: 2 },
      terminal: { fontSize: 18, shellPath: "/remote" },
    });
    expect(invoke).toHaveBeenCalledWith("settings_get_global", {}, undefined);
  });
  it("shows client preferences in the global settings dialog snapshot", async () => {
    expect(await commands.settingsGetGlobal()).toMatchObject({
      keymap: "my-map",
      editor: { fontSize: 19, tabSize: 8 },
    });
  });
  it("writes a client preference only to local global settings and returns merged settings", async () => {
    const settings = await call(commands.settingsSet("project", "editor.fontSize", "19"));
    expect(invoke).toHaveBeenCalledWith(
      "settings_set",
      { scope: "global", key: "editor.fontSize", value: "19" },
      undefined,
    );
    expect(
      invoke.mock.calls.filter(
        ([cmd, args]) => cmd === "remote_invoke" && (args as { cmd?: string })?.cmd === "settings_set",
      ),
    ).toHaveLength(0);
    expect(settings).toMatchObject({ keymap: "my-map", editor: { fontSize: 19, tabSize: 2 } });
  });
});