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.

test(e2e): cover the core editing, code intelligence, VCS, run and debug flows (#1277)

l0ng-aiaa33d2eeabc0
diff --git a/e2e/codeInsight.spec.ts b/e2e/codeInsight.spec.ts
new file mode 100644
index 000000000..ed4e4c7f6
--- /dev/null
+++ b/e2e/codeInsight.spec.ts
@@ -0,0 +1,219 @@
+/**
+ * Code intelligence through the editor: completion, navigation, usages, rename, quick fixes and
+ * diagnostics. The language server is stubbed at the IPC layer; the servers themselves are covered
+ * by `crates/ide-lsp/tests`.
+ */
+import type { Locator, Page } from "@playwright/test";
+import { expect, ipcCalls, openFromTree, stubDesktop, test } from "./fixtures";
+
+const ROOT = "/dev/acme-api";
+const FILE = `${ROOT}/build.gradle.kts`;
+
+const at = (line: number, col: number) => ({ line, col });
+const range = (line: number, from: number, to: number) => ({ start: at(line, from), end: at(line, to) });
+
+/** Puts the caret just before `word` on the line containing `text`. */
+async function caretAt(editor: Locator, page: Page, text: string, word: string) {
+ const line = editor.locator(".cm-line", { hasText: text });
+ await line.click();
+ await page.keyboard.press("Home");
+ const content = (await line.textContent()) ?? "";
+ const indent = content.length - content.trimStart().length;
+ for (let i = indent; i < content.indexOf(word); i++) await page.keyboard.press("ArrowRight");
+}
+
+async function openSample(page: Page) {
+ const editor = await openFromTree(page, "build.gradle.kts");
+ await stubDesktop(page);
+ return editor;
+}
+
+test("completion lists the server's items and inserts the chosen one", async ({ workbench: page }) => {
+ const editor = await openSample(page);
+ await page.evaluate(() => {
+ const item = (label: string, kind: string, detail: string, insertText: string) => ({
+ label,
+ labelDetail: null,
+ detail,
+ kind,
+ documentation: null,
+ sortText: null,
+ filterText: null,
+ preselect: false,
+ deprecated: false,
+ insertText,
+ isSnippet: false,
+ replaceRange: null,
+ replaceRangeTab: null,
+ additionalEdits: [],
+ commitCharacters: [],
+ command: null,
+ data: null,
+ server: "kotlin",
+ });
+ window.__ipc.handlers.lsp_completion = () => ({
+ isIncomplete: false,
+ items: [item("toDto", "method", "OrderDto", "toDto()"), item("total", "property", "BigDecimal", "total")],
+ });
+ });
+ await editor.locator(".cm-line", { hasText: "return order.toDto()" }).click();
+ await page.keyboard.press("End");
+ await page.keyboard.press("Enter");
+ await page.keyboard.type("order.");
+ await page.keyboard.press("Control+Space");
+ const popup = page.locator(".cm-tooltip-autocomplete");
+ await expect(popup.getByText("total", { exact: true })).toBeVisible();
+ await expect(popup.getByText("toDto", { exact: true })).toBeVisible();
+ await page.keyboard.type("toD");
+ await expect(popup.getByText("total", { exact: true })).toBeHidden();
+ await page.keyboard.press("Enter");
+ await expect(popup).toBeHidden();
+ await expect(editor.locator(".cm-activeLine")).toHaveText(/^\s*order\.toDto\(\)$/);
+ expect((await ipcCalls(page, "lsp_completion")).length).toBeGreaterThan(0);
+});
+
+test("⌘B goes to the declaration in another file", async ({ workbench: page }) => {
+ const editor = await openSample(page);
+ await page.evaluate(
+ ({ path, target }) => {
+ window.__ipc.handlers.lsp_goto = () => [{ path, range: target }];
+ },
+ { path: `${ROOT}/settings.gradle.kts`, target: range(20, 12, 17) },
+ );
+ await caretAt(editor, page, "val order: Order", "service");
+ await page.keyboard.press("Meta+b");
+ const tabs = page.getByRole("tablist", { name: "Editor tabs" });
+ await expect(tabs.getByRole("tab", { name: "settings.gradle.kts" })).toHaveAttribute("aria-selected", "true");
+ const target = page.locator(".cm-editor").filter({ has: page.locator(".cm-activeLine") });
+ await expect(target.locator(".cm-activeLine")).toContainText("val order: Order = service.create(req)");
+ const [args] = await ipcCalls(page, "lsp_goto");
+ expect(args).toMatchObject({ pos: at(20, 27), kind: "definition" });
+});
+
+test("Find Usages lists every usage by file and opens one", async ({ workbench: page }) => {
+ const editor = await openSample(page);
+ await page.evaluate(
+ ({ file, other }) => {
+ const loc = (path: string, line: number, from: number, to: number) => ({
+ path,
+ range: { start: { line, col: from }, end: { line, col: to } },
+ });
+ window.__ipc.handlers.lsp_references = () => ({
+ locations: [loc(file, 16, 8, 15), loc(file, 20, 27, 34), loc(other, 16, 8, 15)],
+ incomplete: null,
+ });
+ },
+ { file: FILE, other: `${ROOT}/settings.gradle.kts` },
+ );
+ await caretAt(editor, page, "val order: Order", "service");
+ await page.keyboard.press("Alt+F7");
+ const usages = page.getByRole("tree", { name: /usages/i });
+ await expect(usages.getByRole("treeitem", { name: "Found usages 3 results" })).toBeVisible();
+ await expect(usages.getByRole("treeitem", { name: "build.gradle.kts 2 usages" })).toBeVisible();
+ await expect(usages.getByRole("treeitem", { name: /^17 service\.find\(status/ })).toBeVisible();
+ await expect(usages.getByRole("treeitem", { name: /^21 val order: Order = service\.create/ })).toBeVisible();
+ const other = usages.getByRole("treeitem", { name: "settings.gradle.kts 1 usage" });
+ await expect(other).toBeVisible();
+ // Double-clicking a usage in another file opens that file.
+ await usages.getByRole("treeitem", { name: /^17/ }).last().dblclick();
+ await expect(
+ page.getByRole("tablist", { name: "Editor tabs" }).getByRole("tab", { name: "settings.gradle.kts" }),
+ ).toHaveAttribute("aria-selected", "true");
+});
+
+test("⇧F6 renames in place and sends the server's edit to be applied", async ({ workbench: page }) => {
+ const editor = await openSample(page);
+ await page.evaluate(
+ ({ file, prepared, uses }) => {
+ window.__ipc.handlers.lsp_prepare_rename = () => prepared;
+ window.__ipc.handlers.lsp_rename = (args) => ({
+ edit: {
+ files: [
+ {
+ kind: "edit",
+ path: file,
+ edits: uses.map((range) => ({ range, new_text: args.newName })),
+ },
+ ],
+ },
+ incomplete: null,
+ });
+ },
+ { file: FILE, prepared: range(20, 12, 17), uses: [range(20, 12, 17), range(21, 15, 20)] },
+ );
+ await caretAt(editor, page, "val order: Order", "order");
+ await page.keyboard.press("Shift+F6");
+ await expect(page.getByText(/Press ⇧F6 to show dialog/)).toBeVisible();
+ // The name starts selected; occurrences follow as it's typed.
+ await page.keyboard.type("placed");
+ await expect(editor.locator(".cm-line", { hasText: "val placed: Order" })).toBeVisible();
+ await page.keyboard.press("Enter");
+ await expect.poll(() => ipcCalls(page, "apply_workspace_edit")).toHaveLength(1);
+ const [rename] = await ipcCalls(page, "lsp_rename");
+ expect(rename).toMatchObject({ pos: at(20, 12), newName: "placed" });
+ const [apply] = await ipcCalls(page, "apply_workspace_edit");
+ expect(JSON.stringify(apply)).toContain('"new_text":"placed"');
+});
+
+test("diagnostics underline the range and ⌥⏎ applies the preferred quick fix", async ({ workbench: page }) => {
+ const editor = await openSample(page);
+ await page.evaluate(
+ ({ file, bad }) => {
+ window.__ipc.handlers.lsp_code_actions = () => [
+ {
+ title: "Import 'com.acme.orders.model.Order'",
+ kind: "quickfix",
+ isPreferred: true,
+ disabledReason: null,
+ edit: {
+ files: [
+ {
+ kind: "edit",
+ path: file,
+ edits: [
+ {
+ range: { start: { line: 4, col: 0 }, end: { line: 4, col: 0 } },
+ new_text: "import com.acme.orders.model.Order\n",
+ },
+ ],
+ },
+ ],
+ },
+ command: null,
+ data: null,
+ server: "kotlin",
+ },
+ {
+ title: "Create class 'Order'",
+ kind: "quickfix",
+ isPreferred: false,
+ disabledReason: null,
+ edit: null,
+ command: null,
+ data: null,
+ server: "kotlin",
+ },
+ ];
+ window.__ipc.emit({
+ type: "diagnostics",
+ path: file,
+ source: "kotlin",
+ items: [
+ { range: bad, severity: "error", message: "Unresolved reference: Order", source: "kotlin", code: null },
+ ],
+ });
+ },
+ { file: FILE, bad: range(20, 19, 24) },
+ );
+ const squiggle = editor.locator(".cm-lintRange-error");
+ await expect(squiggle).toHaveText("Order");
+ await caretAt(editor, page, "val order: Order", "Order ");
+ await page.keyboard.press("Alt+Enter");
+ const fix = page.getByRole("option", { name: /Import 'com\.acme\.orders\.model\.Order'/ });
+ await expect(fix).toBeVisible();
+ await expect(page.getByRole("option", { name: /Create class 'Order'/ })).toBeVisible();
+ await fix.click();
+ await expect.poll(() => ipcCalls(page, "lsp_execute_code_action")).toHaveLength(1);
+ const [applied] = await ipcCalls(page, "lsp_execute_code_action");
+ expect(applied).toMatchObject({ action: { title: "Import 'com.acme.orders.model.Order'" } });
+});
diff --git a/e2e/commit.spec.ts b/e2e/commit.spec.ts
new file mode 100644
index 000000000..6d0c18526
--- /dev/null
+++ b/e2e/commit.spec.ts
@@ -0,0 +1,75 @@
+/**
+ * Committing from the Commit tool window. Git is stubbed at the IPC layer; the repository side is
+ * covered by `crates/ide-vcs` against real repositories.
+ */
+import type { Page } from "@playwright/test";
+import { expect, ipcCalls, openFromTree, stubDesktop, test } from "./fixtures";
+
+const ROOT = "/dev/acme-api";
+
+/** A repository with a modified tracked file and an untracked one; `vcs_commit` clears both. */
+async function stubRepository(page: Page) {
+ await stubDesktop(page);
+ await page.evaluate(async (root) => {
+ let committed = false;
+ const changes = [
+ {
+ path: `${root}/build.gradle.kts`,
+ relPath: "build.gradle.kts",
+ staged: null,
+ unstaged: "modified",
+ renamedFrom: null,
+ },
+ { path: `${root}/notes.txt`, relPath: "notes.txt", staged: null, unstaged: "untracked", renamedFrom: null },
+ ];
+ const h = window.__ipc.handlers;
+ h.vcs_roots = () => [{ root, operation: null, head: "main", headCommit: "1111111" }];
+ h.vcs_branch_info = () => ({
+ head: "main",
+ headCommit: "1111111",
+ upstream: null,
+ ahead: 0,
+ behind: 0,
+ operation: null,
+ });
+ h.vcs_status = () => (committed ? [] : changes);
+ h.vcs_stage = () => null;
+ h.vcs_unstage = () => null;
+ h.vcs_commit = () => {
+ committed = true;
+ return "2222222";
+ };
+ const vcsModule = "/src/features/vcs/store.ts";
+ const { useVcs, refreshNow } = await import(/* @vite-ignore */ vcsModule);
+ useVcs.setState({ available: true, root, repo: root, branchesLoaded: false, stashesLoaded: false });
+ await refreshNow();
+ }, ROOT);
+}
+
+test("⌘K commits the checked changes with the typed message", async ({ workbench: page }) => {
+ await openFromTree(page, "build.gradle.kts");
+ await stubRepository(page);
+ await page.keyboard.press("Meta+k");
+ const panel = page.getByRole("region", { name: "Commit", exact: true });
+ const commit = panel.getByRole("button", { name: "Commit", exact: true });
+ const changes = panel.getByRole("tree", { name: "Changes" });
+ // Tracked changes start included; unversioned files start excluded.
+ await expect(changes.getByRole("checkbox", { name: "Include build.gradle.kts in commit" })).toBeChecked();
+ await expect(changes.getByRole("checkbox", { name: "Include Unversioned Files in commit" })).not.toBeChecked();
+ const message = panel.getByRole("textbox", { name: "Commit message" });
+ await expect(message).toBeFocused();
+
+ // Committing without a message is refused.
+ await commit.click();
+ await expect(panel.getByRole("alert")).toHaveText("Specify commit message");
+ expect(await ipcCalls(page, "vcs_commit")).toHaveLength(0);
+
+ await message.fill("Return order DTOs from create");
+ await commit.click();
+ await expect(page.getByText(/1 file committed: Return order DTOs from create/)).toBeVisible();
+ const [committed] = await ipcCalls(page, "vcs_commit");
+ expect(committed).toMatchObject({ repo: ROOT, message: "Return order DTOs from create" });
+ const staged = (await ipcCalls(page, "vcs_stage")).flatMap((a) => a.paths as string[]);
+ expect(staged).toEqual([`${ROOT}/build.gradle.kts`]);
+ await expect(changes.getByRole("checkbox", { name: "Include build.gradle.kts in commit" })).toBeHidden();
+});
diff --git a/e2e/debug.spec.ts b/e2e/debug.spec.ts
new file mode 100644
index 000000000..1af77663b
--- /dev/null
+++ b/e2e/debug.spec.ts
@@ -0,0 +1,115 @@
+/**
+ * A debugging session: a breakpoint set in the editor reaches the adapter, the session stops there
+ * with its frames and variables, and stepping and resuming go back to the adapter. The adapter is
+ * stubbed at the IPC layer; `crates/ide-dap/tests` drives real ones.
+ */
+import { expect, ipcCalls, openFromTree, stubDesktop, test } from "./fixtures";
+
+const ROOT = "/dev/acme-api";
+const FILE = `${ROOT}/build.gradle.kts`;
+const SESSION = 3;
+
+test("stops at a breakpoint, shows frames and variables, steps and resumes", async ({ workbench: page }) => {
+ const editor = await openFromTree(page, "build.gradle.kts");
+ await stubDesktop(page);
+ await page.evaluate(
+ async ({ file, root, session }) => {
+ const config = {
+ id: "python:app",
+ name: "app",
+ kind: "python",
+ command: "python3",
+ args: ["app.py"],
+ cwd: root,
+ env: {},
+ detected: false,
+ isTest: false,
+ debugAdapter: "debugpy",
+ };
+ const h = window.__ipc.handlers;
+ const debug = (event: Record<string, unknown>) => window.__ipc.emit({ type: "debug", session, event });
+ const stopAt = (line: number) => {
+ h.debug_stack_trace = () => [
+ { id: 11, name: "create", path: file, line, column: 0, presentationHint: null },
+ { id: 12, name: "handle", path: file, line: 16, column: 0, presentationHint: null },
+ ];
+ debug({ kind: "stopped", threadId: 1, reason: "breakpoint", description: null, allThreadsStopped: true });
+ };
+ h.run_configs = () => [config];
+ h.run_apply_settings = (args) => args.configs;
+ h.debug_set_breakpoints = (args) =>
+ (args.breakpoints as { line: number }[]).map((b, i) => ({
+ id: i + 1,
+ verified: true,
+ line: b.line,
+ message: null,
+ }));
+ h.debug_start = () => {
+ setTimeout(() => {
+ debug({ kind: "started", name: config.name, adapter: "debugpy", parent: null });
+ debug({ kind: "initialized" });
+ stopAt(20);
+ }, 50);
+ return session;
+ };
+ h.debug_threads = () => [{ id: 1, name: "MainThread" }];
+ h.debug_scopes = () => [{ name: "Locals", variablesReference: 100, expensive: false }];
+ h.debug_variables = () => [
+ {
+ name: "req",
+ value: "CreateOrderRequest(sku='A-1', qty=2)",
+ typeName: "CreateOrderRequest",
+ variablesReference: 0,
+ evaluateName: "req",
+ },
+ { name: "qty", value: "2", typeName: "int", variablesReference: 0, evaluateName: "qty" },
+ ];
+ h.debug_step = () => {
+ setTimeout(() => {
+ debug({ kind: "continued", threadId: 1, allThreadsContinued: true });
+ stopAt(21);
+ }, 50);
+ return null;
+ };
+ h.debug_resume = () => {
+ setTimeout(() => {
+ debug({ kind: "continued", threadId: 1, allThreadsContinued: true });
+ debug({ kind: "exited", code: 0 });
+ debug({ kind: "terminated" });
+ }, 50);
+ return null;
+ };
+ const runModule = "/src/features/run/store.ts";
+ const { loadConfigs, selectConfig } = await import(/* @vite-ignore */ runModule);
+ await loadConfigs();
+ selectConfig(config.id);
+ },
+ { file: FILE, root: ROOT, session: SESSION },
+ );
+
+ // Breakpoint and execution lines carry CSS-module classes (`_bpLine_<hash>`).
+ const line = (text: string) => editor.locator(".cm-line", { hasText: text });
+ await line("val order: Order").click();
+ await page.keyboard.press("Meta+F8");
+ await expect(line("val order: Order")).toHaveClass(/_bpLine_/);
+
+ await page.keyboard.press("Control+d");
+ await expect.poll(() => ipcCalls(page, "debug_start")).toHaveLength(1);
+ const set = (await ipcCalls(page, "debug_set_breakpoints")).filter((a) => a.path === FILE).at(-1);
+ expect(set?.breakpoints).toEqual([expect.objectContaining({ line: 20 })]);
+
+ const debug = page.getByRole("region", { name: "Debug", exact: true });
+ await expect(debug.getByText("create", { exact: true })).toBeVisible();
+ await expect(debug.getByText("handle", { exact: true })).toBeVisible();
+ await expect(debug.getByText("CreateOrderRequest(sku='A-1', qty=2)")).toBeVisible();
+ await expect(line("val order: Order")).toHaveClass(/_execLine_/);
+
+ await page.keyboard.press("F8");
+ await expect.poll(() => ipcCalls(page, "debug_step")).toEqual([{ session: SESSION, threadId: 1, kind: "over" }]);
+ await expect(line("return order.toDto()")).toHaveClass(/_execLine_/);
+ await expect(line("val order: Order")).not.toHaveClass(/_execLine_/);
+
+ await page.keyboard.press("F9");
+ await expect.poll(() => ipcCalls(page, "debug_resume")).toHaveLength(1);
+ await expect(debug.getByText("CreateOrderRequest(sku='A-1', qty=2)")).toBeHidden();
+});
diff --git a/e2e/editor.spec.ts b/e2e/editor.spec.ts
index 4f8163dfc..4f609c9a0 100644
--- a/e2e/editor.spec.ts
+++ b/e2e/editor.spec.ts
@@ -1,3 +1,4 @@
+import type { Page } from "@playwright/test";
import { expect, openFromTree, test } from "./fixtures";
test("opens a file from the project tree and types into it", async ({ workbench: page }) => {
@@ -59,3 +60,44 @@ test("breadcrumbs follow the caret into the symbol under it", async ({ workbench
await page.keyboard.press("Escape");
await expect(bar).toBeHidden();
});
+
+/** What the in-memory backend has saved for `path`. */
+const saved = (page: Page, path: string) =>
+ page.evaluate(async (path) => {
+ const backendModule = "/src/editor/core/backend.ts";
+ const { docBackend } = await import(/* @vite-ignore */ backendModule);
+ return (docBackend() as { files: Map<string, string> }).files.get(path) ?? null;
+ }, path);
+
+test("an edit marks the tab modified and ⌘S saves it", async ({ workbench: page }) => {
+ const editor = await openFromTree(page, "build.gradle.kts");
+ // The only tab; its modified dot sits next to its close button.
+ const tabs = page.getByRole("tablist", { name: "Editor tabs" });
+ await expect(tabs.getByLabel("Modified")).toHaveCount(0);
+ await editor.locator(".cm-line", { hasText: "return order.toDto()" }).click();
+ await page.keyboard.press("End");
+ await page.keyboard.press("Enter");
+ await page.keyboard.type("// saved by e2e");
+ await expect(tabs.getByLabel("Modified")).toHaveCount(1);
+ expect(await saved(page, "/dev/acme-api/build.gradle.kts")).toBeNull();
+ await page.keyboard.press("Meta+s");
+ await expect(tabs.getByLabel("Modified")).toHaveCount(0);
+ expect(await saved(page, "/dev/acme-api/build.gradle.kts")).toContain("// saved by e2e");
+});
+
+test("⌘R replaces every match in the file", async ({ workbench: page }) => {
+ const editor = await openFromTree(page, "build.gradle.kts");
+ await editor.locator(".cm-content").click();
+ await page.keyboard.press("Meta+r");
+ const bar = page.getByRole("search", { name: "Replace in file" });
+ await bar.getByRole("textbox", { name: "Find" }).fill("OrderDto");
+ await bar.getByRole("textbox", { name: "Replace" }).fill("OrderView");
+ await bar.getByRole("button", { name: "Replace All" }).click();
+ const content = editor.locator(".cm-content");
+ await expect(content).not.toContainText("OrderDto");
+ await expect(editor.locator(".cm-line", { hasText: "OrderView" })).toHaveCount(2);
+ // One undo step takes the whole replacement back.
+ await content.click();
+ await page.keyboard.press("Meta+z");
+ await expect(editor.locator(".cm-line", { hasText: "OrderDto" })).toHaveCount(2);
+});
diff --git a/e2e/fixtures.ts b/e2e/fixtures.ts
index 05369faf2..71cda429b 100644
--- a/e2e/fixtures.ts
+++ b/e2e/fixtures.ts
@@ -23,6 +23,97 @@ export const test = base.extend<{ workbench: Page }>({
export { expect };
+/** What `stubDesktop` installs on `window.__ipc`; handlers are defined inside `page.evaluate`. */
+export interface IpcStub {
+ /** Command name as the backend registers it (`lsp_goto`) → its answer; throw `{ kind, message }` for an `IdeError`. */
+ handlers: Record<string, (args: Record<string, unknown>) => unknown>;
+ calls: { cmd: string; args: Record<string, unknown> }[];
+ /** Sends one message down a `Channel` passed to a command. */
+ send(channel: unknown, message: unknown): void;
+ /** Emits an `IdeEvent` the way the backend does. */
+ emit(event: { type: string } & Record<string, unknown>): void;
+}
+
+declare global {
+ interface Window {
+ __ipc: IpcStub;
+ }
+}
+
+/**
+ * Switches the page into desktop mode over a stubbed native layer: commands with a handler answer,
+ * every other command fails as unavailable, the way a backend without that feature does. Documents
+ * keep their in-memory backend; the project tree keeps its sample only while it isn't reloaded, so
+ * open files from it before stubbing.
+ */
+export async function stubDesktop(page: Page) {
+ await page.evaluate(async () => {
+ // Documents stay in memory: the editor's backend is chosen once, on first use.
+ const backendModule = "/src/editor/core/backend.ts";
+ const { docBackend } = await import(/* @vite-ignore */ backendModule);
+ docBackend();
+ const callbacks = new Map<number, (message: unknown) => void>();
+ const channelIndex = new Map<number, number>();
+ const listeners: { event: string; handler: number }[] = [];
+ let nextCallback = 1;
+ const ipc: IpcStub = {
+ // This window is the only one.
+ handlers: { "plugin:window|get_all_windows": () => [] },
+ calls: [],
+ send(channel, message) {
+ const id = (channel as { id: number }).id;
+ const index = channelIndex.get(id) ?? 0;
+ channelIndex.set(id, index + 1);
+ callbacks.get(id)?.({ index, message });
+ },
+ emit(event) {
+ for (const l of listeners)
+ if (l.event === "ide://event") callbacks.get(l.handler)?.({ event: l.event, id: 0, payload: event });
+ },
+ };
+ window.__ipc = ipc;
+ Object.defineProperty(window, "__TAURI_EVENT_PLUGIN_INTERNALS__", {
+ configurable: true,
+ value: { unregisterListener: () => {} },
+ });
+ Object.defineProperty(window, "__TAURI_INTERNALS__", {
+ configurable: true,
+ value: {
+ metadata: { currentWindow: { label: "main" }, currentWebview: { label: "main", windowLabel: "main" } },
+ transformCallback(cb: (message: unknown) => void) {
+ const id = nextCallback++;
+ callbacks.set(id, cb);
+ return id;
+ },
+ unregisterCallback(id: number) {
+ callbacks.delete(id);
+ },
+ convertFileSrc: (path: string) => path,
+ async invoke(cmd: string, args: Record<string, unknown> = {}) {
+ ipc.calls.push({ cmd, args });
+ if (cmd === "plugin:event|listen") {
+ listeners.push({ event: args.event as string, handler: args.handler as number });
+ return listeners.length;
+ }
+ const handler = ipc.handlers[cmd];
+ // Tauri plugin calls (windows, events) succeed quietly; app commands are what tests stub.
+ if (!handler && cmd.startsWith("plugin:")) return null;
+ if (!handler) throw { kind: "unavailable", message: `${cmd} is not stubbed`, detail: null };
+ return handler(args);
+ },
+ },
+ });
+ const ipcModule = "/src/platform/ipc.ts";
+ const { ideEventsReady } = await import(/* @vite-ignore */ ipcModule);
+ await ideEventsReady();
+ });
+}
+
+/** The commands the page has invoked so far under `stubDesktop`, by name. */
+export async function ipcCalls(page: Page, cmd: string): Promise<Record<string, unknown>[]> {
+ return page.evaluate((cmd) => window.__ipc.calls.filter((c) => c.cmd === cmd).map((c) => c.args), cmd);
+}
+
/** Tool windows currently laid out (visible) in the workbench. */
export async function visibleToolWindows(page: Page): Promise<string[]> {
return page
diff --git a/e2e/openProject.spec.ts b/e2e/openProject.spec.ts
new file mode 100644
index 000000000..12445bd10
--- /dev/null
+++ b/e2e/openProject.spec.ts
@@ -0,0 +1,71 @@
+/**
+ * Closing a project returns to the Welcome screen, and a recent project opens from there into the
+ * workbench. The backend's project handling is stubbed at the IPC layer; `crates/ide-host/tests`
+ * covers opening and closing real projects.
+ */
+import { doubleShift, expect, ipcCalls, stubDesktop, test } from "./fixtures";
+
+const BILLING = "/dev/billing";
+
+test("Close Project shows the Welcome screen; a recent project opens from it once trusted", async ({
+ workbench: page,
+}) => {
+ await stubDesktop(page);
+ await page.evaluate((root) => {
+ const entry = (name: string, kind: string) => ({
+ name,
+ path: `${root}/${name}`,
+ kind,
+ size: 0,
+ mtimeMs: null,
+ ignored: false,
+ excluded: false,
+ });
+ const h = window.__ipc.handlers;
+ h.close_project = () => null;
+ h.app_info = () => ({ version: "1.0.0", platform: "macos", configDir: "/Users/dev/.openidea", wayland: false });
+ h.recent_projects = () => [
+ { path: root, name: "billing", openedAtMs: Date.now() - 3_600_000, branch: "main" },
+ { path: "/dev/acme-api", name: "acme-api", openedAtMs: Date.now(), branch: "main" },
+ ];
+ let trusted = false;
+ h.project_trust_status = (args) => ({ root: args.path, trusted, decided: trusted });
+ h.project_trust_set = (args) => {
+ trusted = Boolean(args.trusted);
+ return null;
+ };
+ h.open_project = (args) => ({
+ trusted: true,
+ root: args.path,
+ name: String(args.path).split("/").pop(),
+ isGit: false,
+ settings: {},
+ });
+ h.fs_read_dir = (args) =>
+ args.path === root ? [entry("src", "dir"), entry("package.json", "file"), entry("README.md", "file")] : [];
+ }, BILLING);
+
+ await doubleShift(page);
+ const search = page.getByRole("dialog", { name: "Search Everywhere" });
+ await search.getByRole("combobox").fill("Close Project");
+ await expect(search.getByRole("option", { name: /^Close Project/ }).first()).toBeVisible();
+ await page.keyboard.press("Enter");
+
+ const projects = page.getByRole("region", { name: "Projects" });
+ await expect(page.getByRole("tree", { name: "Project" })).toBeHidden();
+ await expect(projects.getByRole("option", { name: /^billing/ })).toBeVisible();
+ expect(await ipcCalls(page, "close_project")).toHaveLength(1);
+
+ await projects.getByRole("option", { name: /^billing/ }).click();
+ // A project not yet trusted asks first.
+ const trust = page.getByRole("dialog", { name: "Trust and Open Project?" });
+ await expect(trust).toBeVisible();
+ expect(await ipcCalls(page, "open_project")).toHaveLength(0);
+ await trust.getByRole("button", { name: "Trust Project" }).click();
+ await expect(trust).toBeHidden();
+ expect(await ipcCalls(page, "project_trust_set")).toEqual([{ path: BILLING, trusted: true, folder: false }]);
+ await expect.poll(() => ipcCalls(page, "open_project")).toEqual([{ path: BILLING }]);
+ const tree = page.getByRole("tree", { name: "Project" });
+ await expect(tree.getByRole("treeitem", { name: /^billing/ })).toBeVisible();
+ await expect(tree.getByRole("treeitem", { name: "package.json" })).toBeVisible();
+});
diff --git a/e2e/run.spec.ts b/e2e/run.spec.ts
new file mode 100644
index 000000000..75596434e
--- /dev/null
+++ b/e2e/run.spec.ts
@@ -0,0 +1,82 @@
+/**
+ * Running a configuration: output streams into the Run tool window, the exit shows, and Stop ends
+ * the process. Processes are stubbed at the IPC layer; `crates/ide-run` covers spawning them.
+ */
+import type { Page } from "@playwright/test";
+import { expect, ipcCalls, stubDesktop, test } from "./fixtures";
+
+const RUN_ID = 7;
+
+/** One saved `npm run dev` configuration; `run_start` prints `output` and exits with `exit` unless null. */
+async function stubRun(page: Page, output: { kind: string; text: string }[], exit: number | null) {
+ await stubDesktop(page);
+ await page.evaluate(
+ async ({ output, exit, runId }) => {
+ const config = {
+ id: "npm:dev",
+ name: "dev",
+ kind: "npm",
+ command: "npm",
+ args: ["run", "dev"],
+ cwd: "/dev/acme-api",
+ env: {},
+ detected: false,
+ isTest: false,
+ debugAdapter: null,
+ };
+ const h = window.__ipc.handlers;
+ h.run_configs = () => [config];
+ h.run_apply_settings = (args) => args.configs;
+ h.run_start = (args) => {
+ setTimeout(() => {
+ for (const chunk of output) window.__ipc.send(args.onOutput, chunk);
+ if (exit !== null) setTimeout(() => window.__ipc.emit({ type: "runExited", run: runId, code: exit }), 50);
+ }, 50);
+ return { id: runId, configId: config.id, name: config.name, pid: 4242, running: true, pty: false };
+ };
+ h.run_stop = () => {
+ setTimeout(() => window.__ipc.emit({ type: "runExited", run: runId, code: 143 }), 50);
+ return null;
+ };
+ const runModule = "/src/features/run/store.ts";
+ const { loadConfigs, selectConfig } = await import(/* @vite-ignore */ runModule);
+ await loadConfigs();
+ selectConfig(config.id);
+ },
+ { output, exit, runId: RUN_ID },
+ );
+}
+
+test("⌃R runs the selected configuration and shows its output and exit", async ({ workbench: page }) => {
+ await stubRun(
+ page,
+ [
+ { kind: "stdout", text: "> [email protected] dev\n" },
+ { kind: "stdout", text: "Server listening on http://localhost:8080\n" },
+ { kind: "stderr", text: "warning: config/dev.json not found, using defaults\n" },
+ ],
+ 0,
+ );
+ await page.keyboard.press("Control+r");
+ const run = page.getByRole("region", { name: "Run", exact: true });
+ await expect(run).toBeVisible();
+ await expect(run.getByText("Server listening on http://localhost:8080")).toBeVisible();
+ await expect(run.getByText("warning: config/dev.json not found, using defaults")).toBeVisible();
+ // Once the process exits, Stop is off and the session's tab tells the exit code.
+ await expect(run.getByRole("button", { name: "Stop" })).toBeDisabled();
+ await expect(run.getByRole("tab", { name: "dev" })).toHaveAttribute("data-tooltip", /exit code 0$/);
+ const [started] = await ipcCalls(page, "run_start");
+ expect(started).toMatchObject({ config: { id: "npm:dev", command: "npm", args: ["run", "dev"] } });
+});
+
+test("⌘F2 stops a running process", async ({ workbench: page }) => {
+ await stubRun(page, [{ kind: "stdout", text: "Watching for changes…\n" }], null);
+ await page.keyboard.press("Control+r");
+ const run = page.getByRole("region", { name: "Run", exact: true });
+ await expect(run.getByText("Watching for changes…")).toBeVisible();
+ await expect(run.getByRole("button", { name: "Stop" })).toBeEnabled();
+ await page.keyboard.press("Meta+F2");
+ await expect.poll(() => ipcCalls(page, "run_stop")).toEqual([{ id: RUN_ID }]);
+ await expect(run.getByRole("button", { name: "Stop" })).toBeDisabled();
+ await expect(run.getByRole("tab", { name: "dev" })).toHaveAttribute("data-tooltip", /exit code 143$/);
+});
diff --git a/e2e/search.spec.ts b/e2e/search.spec.ts
index cdf4fefc8..e27aedc92 100644
--- a/e2e/search.spec.ts
+++ b/e2e/search.spec.ts
@@ -1,4 +1,4 @@
-import { doubleShift, expect, test } from "./fixtures";
+import { doubleShift, expect, ipcCalls, stubDesktop, test } from "./fixtures";
test("double Shift opens Search Everywhere with its tabs; Escape closes it", async ({ workbench: page }) => {
await doubleShift(page);
@@ -23,15 +23,92 @@ test("Search Everywhere finds and runs an action", async ({ workbench: page }) =
await expect(page.getByRole("list", { name: /language servers/i })).toBeVisible();
});
+const ROOT = "/dev/acme-api";
+const SERVICE = `${ROOT}/src/main/kotlin/com/acme/orders/service/OrderService.kt`;
+
test("Search Everywhere finds a file and opens it", async ({ workbench: page }) => {
- // TODO(search): plain-browser mode has no in-memory `findFiles`, so the Files
- // source returns nothing. Un-fixme once search/everywhere gets browser deps
- // (e.g. backed by the project-tree sample file system).
- test.fixme(true, "Search Everywhere has no in-memory file source in browser mode");
+ // The project's file index is stubbed at the IPC layer.
+ await stubDesktop(page);
+ await page.evaluate((path) => {
+ window.__ipc.handlers.find_files = (args) =>
+ String(args.query).startsWith("OrderSer")
+ ? [{ path, relPath: path.slice("/dev/acme-api/".length), score: 100, indices: [] }]
+ : [];
+ }, SERVICE);
await doubleShift(page);
const dialog = page.getByRole("dialog", { name: "Search Everywhere" });
await dialog.getByRole("combobox").fill("OrderService");
await expect(dialog.getByRole("option", { name: /OrderService\.kt/ })).toBeVisible();
await page.keyboard.press("Enter");
- await expect(page.getByRole("tab", { name: "OrderService.kt" })).toBeVisible();
+ await expect(page.getByRole("tab", { name: "OrderService.kt" })).toHaveAttribute("aria-selected", "true");
+ await expect(page.getByRole("textbox", { name: `Editor for ${SERVICE}` })).toBeVisible();
+});
+
+test("Find in Files streams matches by file and opens the chosen one at its line", async ({ workbench: page }) => {
+ await stubDesktop(page);
+ await page.evaluate(
+ ({ root, service }) => {
+ const match = (line: number, text: string, word: string) => ({
+ line,
+ text,
+ ranges: [[text.indexOf(word), text.indexOf(word) + word.length]],
+ textOffset: 0,
+ });
+ window.__ipc.handlers.search_validate = () => null;
+ window.__ipc.handlers.search_start = (args) => {
+ const send = (event: unknown) => window.__ipc.send(args.onEvent, event);
+ setTimeout(() => {
+ send({
+ type: "file",
+ file: {
+ path: `${root}/build.gradle.kts`,
+ relPath: "build.gradle.kts",
+ matches: [
+ match(7, "class OrderController(private val service: OrderService) {", "OrderService"),
+ match(3, "import com.acme.orders.service.OrderService", "OrderService"),
+ ],
+ },
+ });
+ send({
+ type: "file",
+ file: {
+ path: service,
+ relPath: service.slice(root.length + 1),
+ matches: [match(0, "// OrderService", "OrderService")],
+ },
+ });
+ send({
+ type: "done",
+ summary: { files: 2, matches: 3, limitHit: false, cancelled: false, elapsedMs: 4 },
+ });
+ }, 20);
+ return null;
+ };
+ },
+ { root: ROOT, service: SERVICE },
+ );
+ await page.keyboard.press("Meta+Shift+f");
+ const dialog = page.getByRole("dialog", { name: "Find in Files" });
+ await dialog.getByRole("textbox", { name: "Text to find" }).fill("OrderService");
+ const matches = dialog.getByRole("listbox", { name: "Matches" });
+ await expect(matches.getByRole("option")).toHaveCount(3);
+ await expect
+ .poll(async () => (await ipcCalls(page, "search_start")).at(-1)?.query)
+ .toMatchObject({
+ pattern: "OrderService",
+ });
+ await matches.getByRole("option", { name: /import com\.acme\.orders\.service\.OrderService/ }).dblclick();
+ await expect(page.getByRole("tab", { name: "build.gradle.kts" })).toHaveAttribute("aria-selected", "true");
+ const caretLine = () =>
+ page.evaluate((label) => {
+ const content = document.querySelector(`.cm-content[aria-label="${label}"]`) as unknown as {
+ cmTile: {
+ view: { state: { doc: { lineAt(pos: number): { text: string } }; selection: { main: { head: number } } } };
+ };
+ } | null;
+ if (!content) return null;
+ const { state } = content.cmTile.view;
+ return state.doc.lineAt(state.selection.main.head).text;
+ }, `Editor for ${ROOT}/build.gradle.kts`);
+ await expect.poll(caretLine).toBe("import com.acme.orders.service.OrderService");
});
diff --git a/e2e/toolwindows.spec.ts b/e2e/toolwindows.spec.ts
index e8eb67d93..2c1beaf81 100644
--- a/e2e/toolwindows.spec.ts
+++ b/e2e/toolwindows.spec.ts
@@ -1,4 +1,4 @@
-import { expect, test, visibleToolWindows } from "./fixtures";
+import { expect, ipcCalls, stubDesktop, test, visibleToolWindows } from "./fixtures";
test("⌘1 focuses, hides and re-shows the Project tool window", async ({ workbench: page }) => {
const project = page.getByRole("region", { name: "Project" });
@@ -80,3 +80,47 @@ test("⌘⇧F12 hides all tool windows and restores them", async ({ workbench: p
await expect(page.getByRole("region", { name: "Project" })).toBeVisible();
await expect(page.getByRole("region", { name: "Problems" })).toBeVisible();
});
+
+test("the Terminal sends typed commands to the shell and shows its output", async ({ workbench: page }) => {
+ // The shell is stubbed at the IPC layer: it echoes input and answers `echo`.
+ await stubDesktop(page);
+ await page.evaluate(() => {
+ let output: unknown = null;
+ let line = "";
+ const out = (text: string) => window.__ipc.send(output, text);
+ const h = window.__ipc.handlers;
+ h.term_default_shell = () => "/bin/zsh";
+ h.term_available_shells = () => ["/bin/zsh"];
+ h.term_spawn = (args) => {
+ output = args.onOutput;
+ setTimeout(() => out("acme-api % "), 20);
+ return { id: 5, title: "zsh", pid: 99 };
+ };
+ h.term_resize = () => null;
+ h.term_is_busy = () => false;
+ h.term_write = (args) => {
+ for (const ch of String(args.data)) {
+ if (ch === "\r") {
+ const said = /^echo (.*)$/.exec(line);
+ out(`\r\n${said ? `${said[1]}\r\n` : ""}acme-api % `);
+ line = "";
+ } else {
+ line += ch;
+ out(ch);
+ }
+ }
+ return null;
+ };
+ });
+ await page.keyboard.press("Alt+F12");
+ const terminal = page.getByRole("region", { name: "Terminal", exact: true });
+ const rows = terminal.locator(".xterm-rows");
+ await expect(rows).toContainText("acme-api %");
+ await terminal.locator(".xterm-screen").click();
+ await expect(terminal.getByRole("textbox", { name: "Terminal input" })).toBeFocused();
+ await page.keyboard.type("echo hello from e2e");
+ await page.keyboard.press("Enter");
+ await expect(rows.locator("div", { hasText: /^hello from e2e\s*$/ })).toHaveCount(1);
+ const written = (await ipcCalls(page, "term_write")).map((a) => a.data).join("");
+ expect(written).toBe("echo hello from e2e\r");
+});