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.

19.6 KB
Raw Blame
import { afterEach, describe, expect, it, vi } from "vitest";
import { EditorController, openFilePaths, useEditorStatus, useTabs } from "./controller";
import { createMemoryBackend } from "./backend";
import { initialTabsState } from "./model/tabs";
import { useDocMeta } from "./model/document";
import { resetDistractionFree, setDistractionFree } from "@/workbench/distractionFree";
import { registerTextEditorWrapper, setProjectViewLead, useProjectViewLead } from "@/workbench/contributions";
import { registerActions } from "@/platform/actions";
import { useProject } from "@/platform/project";
import { useRemote } from "@/platform/remote";
import { hideContextMenu, resolveMenuItems, useContextMenuStore } from "@/ui";
import { getContext, setContext } from "@/platform/context";
import { installKeyboardDispatcher } from "@/platform/keymap";
import { TEXT_WHEN } from "./actions";

let ctrl: EditorController | null = null;

afterEach(() => {
  ctrl?.stop();
  ctrl = null;
  useTabs.setState(initialTabsState(), true);
  useEditorStatus.setState({ status: null });
});

describe("EditorController", () => {
  it("returns navigation context to the editor when activating a non-text tab", async () => {
    ctrl = new EditorController(createMemoryBackend({ "/p/a.ts": "one\n" }));
    ctrl.start();
    await ctrl.openFile("/p/a.ts", { focus: false });
    setProjectViewLead({ path: "/p/src", dir: true });
    await ctrl.openInput({ kind: "agent-session", key: "task" });
    expect(useProjectViewLead.getState().lead).toBeNull();
  });

  it("autosaves on blur, but not while focus is in a popup over the editor", async () => {
    const backend = createMemoryBackend({ "/p/a.c": "int main() {\n    \n}\n" });
    const save = vi.spyOn(backend, "save");
    ctrl = new EditorController(backend);
    ctrl.start();
    await ctrl.openFile("/p/a.c", { focus: false });
    const slot = ctrl.activeSlot!;
    const host = document.createElement("div");
    const popup = document.createElement("div");
    popup.setAttribute("data-popup", "");
    const popupList = document.createElement("button");
    popup.appendChild(popupList);
    const elsewhere = document.createElement("button");
    document.body.append(host, popup, elsewhere);
    try {
      const view = slot.mount(host);
      ctrl.onMounted(slot);
      const type = () => view.dispatch({ changes: { from: 0, insert: "x" }, userEvent: "input.type" });
      // Into a popup (⌥↵ intentions): nothing is saved while it is open.
      view.focus();
      type();
      popupList.focus();
      await new Promise((r) => setTimeout(r, 20));
      expect(save).not.toHaveBeenCalled();
      // Back to the editor (popup closed): still nothing.
      view.focus();
      await new Promise((r) => setTimeout(r, 20));
      expect(save).not.toHaveBeenCalled();
      // From the popup elsewhere: saved then.
      popupList.focus();
      await new Promise((r) => setTimeout(r, 20));
      elsewhere.focus();
      await vi.waitFor(() => expect(save).toHaveBeenCalledTimes(1));
      // Straight elsewhere: saved.
      view.focus();
      type();
      elsewhere.focus();
      await vi.waitFor(() => expect(save).toHaveBeenCalledTimes(2));
    } finally {
      host.remove();
      popup.remove();
      elsewhere.remove();
    }
  });

  it("leaves modified Enter to a non-text editor after switching from a focused file", async () => {
    ctrl = new EditorController(createMemoryBackend({ "/p/a.ts": "one\ntwo\n" }));
    ctrl.start();
    await ctrl.openFile("/p/a.ts", { focus: false });
    const slot = ctrl.activeSlot!;
    const host = document.createElement("div");
    document.body.appendChild(host);
    const view = slot.mount(host);
    ctrl.onMounted(slot);
    view.focus();
    await vi.waitFor(() => expect(getContext().editorTextFocus).toBe(true));

    const splitLine = vi.fn();
    const dispose = registerActions([
      {
        id: "code.splitLine",
        title: "Split Line",
        when: TEXT_WHEN,
        run: splitLine,
      },
    ]);
    const uninstall = installKeyboardDispatcher(window);
    const message = document.createElement("textarea");
    const send = vi.fn();
    message.addEventListener("keydown", send);
    try {
      await ctrl.openInput({ kind: "agent-session", key: "task" });
      slot.unmount();
      host.appendChild(message);
      message.focus();
      message.dispatchEvent(
        new KeyboardEvent("keydown", {
          key: "Enter",
          code: "Enter",
          metaKey: true,
          bubbles: true,
          cancelable: true,
        }),
      );
      expect(splitLine).not.toHaveBeenCalled();
      expect(send).toHaveBeenCalledOnce();
      expect(getContext().editorTextFocus).toBe(false);

      await ctrl.openFile("/p/a.ts", { focus: false });
      const reopened = slot.mount(host);
      ctrl.onMounted(slot);
      reopened.focus();
      await vi.waitFor(() => expect(getContext().editorTextFocus).toBe(true));
      reopened.contentDOM.dispatchEvent(
        new KeyboardEvent("keydown", {
          key: "Enter",
          code: "Enter",
          metaKey: true,
          bubbles: true,
          cancelable: true,
        }),
      );
      expect(splitLine).toHaveBeenCalledOnce();
    } finally {
      uninstall();
      dispose();
      slot.unmount();
      host.remove();
    }
  });

  it("updates the caret status synchronously on programmatic selection changes", async () => {
    ctrl = new EditorController(createMemoryBackend({ "/p/a.ts": "one\ntwo\nthree\n" }));
    ctrl.start();
    await ctrl.openFile("/p/a.ts", { focus: false });
    const s = useTabs.getState();
    const slot = ctrl.slotFor(s.panes[s.activePane]!.active!)!;
    const host = document.createElement("div");
    document.body.appendChild(host);
    const view = slot.mount(host);
    ctrl.onMounted(slot);
    view.dispatch({ selection: { anchor: 6 } });
    expect(useEditorStatus.getState().status).toMatchObject({ path: "/p/a.ts", line: 1, col: 2, offset: 6 });
    view.dispatch({ selection: { anchor: 4, head: 9 } });
    expect(useEditorStatus.getState().status).toMatchObject({ line: 2, col: 1, selectedChars: 5, selectedLines: 1 });
    slot.unmount();
    host.remove();
  });

  it("reconfigures open editors when Distraction Free Mode toggles", async () => {
    ctrl = new EditorController(createMemoryBackend({ "/p/a.ts": "one\ntwo\n" }));
    ctrl.start();
    await ctrl.openFile("/p/a.ts", { focus: false });
    const s = useTabs.getState();
    const slot = ctrl.slotFor(s.panes[s.activePane]!.active!)!;
    const host = document.createElement("div");
    document.body.appendChild(host);
    const view = slot.mount(host);
    expect(view.dom.querySelector(".cm-lineNumbers")).not.toBeNull();
    setDistractionFree(true);
    expect(view.dom.querySelector(".cm-lineNumbers")).toBeNull();
    expect(view.dom.classList.contains("cm-openidea-distractionFree")).toBe(true);
    setDistractionFree(false);
    expect(view.dom.querySelector(".cm-lineNumbers")).not.toBeNull();
    expect(view.dom.classList.contains("cm-openidea-distractionFree")).toBe(false);
    resetDistractionFree();
    slot.unmount();
    host.remove();
  });

  it("lists open file paths across panes", async () => {
    ctrl = new EditorController(createMemoryBackend());
    ctrl.start();
    await ctrl.openFile("/p/a.ts", { focus: false });
    await ctrl.openFile("/p/b.ts", { focus: false, side: true });
    await ctrl.openFile("/p/a.ts", { focus: false, side: true });
    expect(openFilePaths(useTabs.getState())).toEqual(["/p/a.ts", "/p/b.ts"]);
  });

  it("opens a copy of a tab in the opposite group, splitting when there is none", async () => {
    ctrl = new EditorController(createMemoryBackend({ "/p/a.ts": "", "/p/b.ts": "" }));
    ctrl.start();
    await ctrl.openFile("/p/a.ts", { focus: false });
    await ctrl.openFile("/p/b.ts", { focus: false });
    const paths = (paneId: string) => useTabs.getState().panes[paneId]!.tabs.map((t) => t.input.path);
    const first = useTabs.getState().activePane;
    const tabA = useTabs.getState().panes[first]!.tabs[0]!.id;
    ctrl.openInOpposite(first, tabA);
    const second = useTabs.getState().activePane;
    expect(second).not.toBe(first);
    expect(paths(second)).toEqual(["/p/a.ts"]);
    ctrl.openInOpposite(first, useTabs.getState().panes[first]!.tabs[1]!.id);
    expect(paths(second)).toEqual(["/p/a.ts", "/p/b.ts"]);
    expect(paths(first)).toEqual(["/p/a.ts", "/p/b.ts"]);
  });

  it("closes read-only tabs and keeps a preview tab open from the tab menu", async () => {
    ctrl = new EditorController(createMemoryBackend({ "/p/a.ts": "", "/p/b.ts": "", "/p/c.ts": "" }));
    ctrl.start();
    await ctrl.openFile("/p/a.ts", { focus: false });
    await ctrl.openFile("/p/b.ts", { focus: false });
    await ctrl.openFile("/p/c.ts", { focus: false, preview: true });
    const pane = () => useTabs.getState().panes[useTabs.getState().activePane]!;
    const labels = () => resolveMenuItems(ctrl!.tabMenu(pane().id, pane().tabs[2]!)).map((i) => i.label);
    expect(labels()).toContain("Keep Tab Open");
    expect(labels()).not.toContain("Close All Read-Only Tabs");
    ctrl.keepTab(pane().id, pane().tabs[2]!.id);
    expect(pane().tabs[2]!.preview).toBe(false);
    useDocMeta.setState({ "/p/b.ts": { ...useDocMeta.getState()["/p/b.ts"]!, readOnly: true } });
    expect(labels()).toContain("Close All Read-Only Tabs");
    await ctrl.closeReadOnly(pane().id);
    expect(pane().tabs.map((t) => t.input.path)).toEqual(["/p/a.ts", "/p/c.ts"]);
  });

  it("keeps editor tabs and unsaved documents through attach and detach", async () => {
    const settings = {};
    useProject.setState({
      project: { root: "/attach-a", name: "A", trusted: true, isGit: false, settings },
      settings,
      lightEdit: false,
    });
    ctrl = new EditorController(createMemoryBackend({ "/attach-a/one.txt": "one", "/attach-a/two.txt": "two" }));
    ctrl.start();
    await ctrl.openFile("/attach-a/one.txt", { focus: false, preview: false });
    await ctrl.openFile("/attach-a/two.txt", { focus: false, preview: false });
    const slot = ctrl.activeSlot!;
    const host = document.createElement("div");
    const view = slot.mount(host);
    ctrl.onMounted(slot);
    view.dispatch({ changes: { from: 0, insert: "unsaved " }, userEvent: "input.type" });
    const tabs = useTabs.getState();
    useProject.setState({
      project: {
        root: "/attach-a",
        name: "A, attach-b",
        trusted: true,
        isGit: false,
        settings,
        workspace: { version: 1, name: "A", projects: ["/attach-a", "/attach-b"] },
      },
    });
    expect(useTabs.getState()).toBe(tabs);
    expect(ctrl.activeSlot).toBe(slot);
    expect(view.state.doc.toString()).toContain("unsaved ");
    expect(openFilePaths(useTabs.getState())).toEqual(["/attach-a/one.txt", "/attach-a/two.txt"]);
    useProject.setState({ project: { root: "/attach-a", name: "A", trusted: true, isGit: false, settings } });
    expect(useTabs.getState()).toBe(tabs);
    expect(ctrl.activeSlot).toBe(slot);
    expect(view.state.doc.toString()).toContain("unsaved ");
    host.remove();
    useProject.setState({ project: null });
  });

  it("reopens the LightEdit files the next time a window switches to LightEdit", async () => {
    ctrl = new EditorController(createMemoryBackend({ "/x/a.txt": "a", "/y/b.md": "b" }));
    ctrl.start();
    useProject.setState({ lightEdit: true });
    await ctrl.openFile("/x/a.txt", { focus: false });
    await ctrl.openFile("/y/b.md", { focus: false });
    // The LightEdit window closes with its tabs open.
    useProject.setState({ lightEdit: false });
    expect(openFilePaths(useTabs.getState())).toEqual([]);
    useProject.setState({ lightEdit: true });
    await vi.waitFor(() => expect(openFilePaths(useTabs.getState())).toEqual(["/x/a.txt", "/y/b.md"]));
    // Clearing the session must not resurrect its other files on the next explicit open.
    await ctrl.closeEverything();
    useProject.setState({ lightEdit: false });
    useProject.setState({ lightEdit: true });
    await ctrl.openFile("/x/a.txt", { focus: false });
    expect(openFilePaths(useTabs.getState())).toEqual(["/x/a.txt"]);
    useProject.setState({ lightEdit: false });
  });

  it("opens a file requested while the LightEdit session is being restored", async () => {
    ctrl = new EditorController(createMemoryBackend({ "/x/a.txt": "a", "/y/b.md": "b", "/z/launch.lua": "l" }));
    ctrl.start();
    useProject.setState({ lightEdit: true });
    await ctrl.openFile("/x/a.txt", { focus: false });
    await ctrl.openFile("/y/b.md", { focus: false });
    useProject.setState({ lightEdit: false });
    // A launch with a file path: LightEdit starts and the file opens before the old tabs are back.
    useProject.setState({ lightEdit: true });
    await ctrl.openFile("/z/launch.lua", { focus: false });
    expect(openFilePaths(useTabs.getState())).toEqual(["/x/a.txt", "/y/b.md", "/z/launch.lua"]);
    const s = useTabs.getState();
    const active = s.panes[s.activePane]!;
    expect(active.tabs.find((t) => t.id === active.active)?.input.path).toBe("/z/launch.lua");
    await ctrl.closeEverything();
    useProject.setState({ lightEdit: false });
  });

  it("closes a tab by its input key", async () => {
    ctrl = new EditorController(createMemoryBackend());
    ctrl.start();
    await ctrl.openFile("/p/a.ts", { focus: false });
    await ctrl.openFile("/p/b.ts", { focus: false });
    const key = Object.values(useTabs.getState().panes)
      .flatMap((p) => p.tabs)
      .find((t) => t.input.path === "/p/b.ts")!.input.key;
    await ctrl.closeInput(key);
    expect(openFilePaths(useTabs.getState())).toEqual(["/p/a.ts"]);
  });

  it("builds IDEA's editor tab menu", async () => {
    useProject.setState({
      project: { name: "p", root: "/p", trusted: true, isGit: true, settings: {} } as never,
      settings: {} as never,
    });
    const ids = [
      "navigate.selectIn",
      "project.revealInFinder",
      "vcs.localHistory",
      "vcs.commit",
      "project.copyAbsolutePath",
      "project.rename",
      "file.settings",
    ];
    const dispose = registerActions(ids.map((id) => ({ id, title: id, run: () => undefined })));
    ctrl = new EditorController(createMemoryBackend({ "/p/a.ts": "", "/p/b.ts": "" }));
    ctrl.start();
    await ctrl.openFile("/p/a.ts", { focus: false });
    await ctrl.openFile("/p/b.ts", { focus: false });
    const s = useTabs.getState();
    const pane = s.panes[s.activePane]!;
    const items = resolveMenuItems(ctrl.tabMenu(pane.id, pane.tabs[0]!));
    expect(items.find((i) => i.label === "Close Tabs to the Left")?.disabled).toBe(true);
    expect(items.find((i) => i.label === "Close Tabs to the Right")?.disabled).toBe(false);
    const tabMenu = () => ctrl!.tabMenu(pane.id, pane.tabs[0]!);
    const openIn = () => resolveMenuItems(resolveMenuItems(tabMenu()).find((i) => i.label === "Open In")!.submenu!);
    const reveal = "project.revealInFinder|/p/a.ts";
    expect(openIn().map((i) => i.key)).toContain(reveal);
    useRemote.setState({
      session: { target: { kind: "ssh", config: "box" }, root: "/p", host: "box", os: "linux", commands: [] },
    });
    expect(openIn().map((i) => i.key)).not.toContain(reveal);
    useRemote.setState({ session: null });
    dispose();
    useProject.setState({ project: null, settings: null });
  });

  it.each(["editor", "tab"])(
    "offers grouped Git actions in the %s menu and preserves action enablement",
    async (menu) => {
      const groups = [
        ["vcs.commit", "vcs.addToVcs"],
        [
          "vcs.annotate",
          "vcs.showDiff",
          "vcs.compareWithBranch",
          "vcs.compareWithRevision",
          "vcs.showHistory",
          "vcs.showCurrentRevision",
          "vcs.showHistoryForSelection",
          "vcs.rollback",
        ],
        ["vcs.push", "vcs.update", "vcs.fetch"],
        ["vcs.merge", "vcs.rebase"],
        ["vcs.branches", "vcs.newBranch", "vcs.newTag", "vcs.resetHead"],
        ["vcs.stash", "vcs.unstash"],
        ["GitHub", "vcs.manageRemotes", "vcs.clone"],
      ];
      const github = [
        "github.pullRequests",
        "github.createPullRequest",
        "github.checkoutPullRequest",
        "github.openInBrowser",
      ];
      const ids = [...groups.flat().filter((id) => id !== "GitHub"), ...github];
      const dispose = registerActions(
        ids.map((id) => ({
          id,
          title: id,
          when: id === "vcs.clone" ? undefined : id.startsWith("github.") ? "projectOpen" : "vcsAvailable",
          run: () => undefined,
        })),
      );
      useProject.setState({ project: { name: "p", root: "/p", trusted: true, isGit: true, settings: {} } as never });
      ctrl = new EditorController(createMemoryBackend({ "/p/a.ts": "one\n" }));
      ctrl.start();
      await ctrl.openFile("/p/a.ts", { focus: false });
      const slot = ctrl.activeSlot!;
      const host = document.createElement("div");
      document.body.appendChild(host);
      const view = slot.mount(host);
      vi.spyOn(view, "posAtCoords").mockReturnValue(null);
      const items = () => {
        if (menu === "editor") {
          ctrl!.onContextMenu(slot, new MouseEvent("contextmenu"));
          return useContextMenuStore.getState().menu!.items;
        }
        const state = useTabs.getState();
        const pane = state.panes[state.activePane]!;
        return ctrl!.tabMenu(pane.id, pane.tabs[0]!);
      };
      const gitItems = () => resolveMenuItems(items()).find((item) => item.label === "Git")!.submenu!;
      try {
        setContext("projectOpen", true);
        setContext("vcsAvailable", true);
        expect(
          gitItems().map((item) =>
            item.kind === "separator" ? "-" : item.kind === "action" ? item.action : item.label,
          ),
        ).toEqual(groups.flatMap((group, i) => (i ? ["-", ...group] : group)));
        const resolved = resolveMenuItems(gitItems());
        expect(resolved.filter((item) => item.kind === "item").every((item) => !item.disabled)).toBe(true);
        const githubItems = resolved.find((item) => item.label === "GitHub")!.submenu!;
        expect(resolveMenuItems(githubItems).map((item) => item.key)).toEqual(github);
        expect(gitItems()).toContainEqual({
          kind: "action",
          action: "vcs.compareWithBranch",
          arg: { path: "/p/a.ts" },
        });

        setContext("vcsAvailable", false);
        expect(
          resolveMenuItems(gitItems())
            .filter((item) => item.kind === "item" && item.key.startsWith("vcs.") && item.key !== "vcs.clone")
            .every((item) => item.disabled),
        ).toBe(true);
        expect(resolveMenuItems(gitItems()).find((item) => item.key === "vcs.clone")?.disabled).toBe(false);
        setContext("projectOpen", false);
        expect(resolveMenuItems(githubItems).every((item) => item.disabled)).toBe(true);
      } finally {
        dispose();
        hideContextMenu();
        slot.unmount();
        host.remove();
        useProject.setState({ project: null, settings: null });
        setContext("vcsAvailable", false);
        setContext("projectOpen", false);
      }
    },
  );

  it("switches an open image tab to a text tab when a matching text editor wrapper registers", async () => {
    ctrl = new EditorController(createMemoryBackend({ "/p/arch.diagram.svg": "<svg/>" }));
    ctrl.start();
    await ctrl.openInput({ kind: "image", key: "image:/p/arch.diagram.svg", path: "/p/arch.diagram.svg" });
    expect(openFilePaths(useTabs.getState())).toEqual([]);
    const offWrapper = registerTextEditorWrapper({
      id: "plugin.acme.diagram.canvas",
      matches: (p) => p.endsWith(".diagram.svg"),
      component: () => null,
    });
    try {
      expect(openFilePaths(useTabs.getState())).toEqual(["/p/arch.diagram.svg"]);
      await vi.waitFor(() => expect(ctrl?.activeSlot?.model.path).toBe("/p/arch.diagram.svg"));
    } finally {
      offWrapper();
    }
  });
});