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.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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 ({ workbenchawait 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.tsindex 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 pagediff --git a/e2e/openProject.spec.ts b/e2e/openProject.spec.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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: pawait 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");+});