import { readFileSync, writeFileSync } from "node:fs" import { afterEach, describe, expect, it } from "bun:test" import { createWorkspaceEditTestHarness, readEvents, renameTextEdit, waitForEventCount, waitForEventCountBySubscription, } from "./workspace-apply-edit-test-support.js" const harness = createWorkspaceEditTestHarness() afterEach(async () => { await harness.cleanup() }) describe("LspClient workspace mutation lease", () => { it("#given no mutating request #when the server calls applyEdit #then the request is rejected as unscoped", async () => { const context = await harness.makeClient({ unscopedApplyEditOnDidOpen: renameTextEdit("before", "after", { version: 1 }), }) const response = waitForEventCountBySubscription( context.events, (event) => event.type === "clientResponse" && event.method === "workspace/applyEdit", 1, ) await context.client.openFile(context.source) const responses = await response expect(responses[0]?.result).toEqual({ applied: false, failureReason: expect.stringContaining("active workspace mutation"), }) expect(readFileSync(context.source, "utf-8")).toBe("const before = 1;\n") }) it("#given one valid server apply #when the server applies twice #then the repeated request is rejected", async () => { const context = await harness.makeClient({ renameSteps: [ { applyEdit: renameTextEdit("before", "after", { version: 1 }), applyTwice: true, renameResult: "same" }, ], }) await context.client.openFile(context.source) const result = await context.client.rename(context.source, 1, 6, "after") expect(result.apply.success).toBe(true) const responses = readEvents(context.events).filter( (event) => event.type === "clientResponse" && event.method === "workspace/applyEdit", ) expect(responses).toHaveLength(2) expect(responses[0]?.result).toEqual({ applied: true }) expect(responses[1]?.result).toEqual({ applied: false, failureReason: expect.stringContaining("already handled"), }) expect(readFileSync(context.source, "utf-8")).toBe("const after = 1;\n") }) it("#given two concurrent server applies #when one enters commit #then the other is rejected without a second write", async () => { const context = await harness.makeClient({ renameSteps: [ { applyEdit: renameTextEdit("before", "after", { version: 1 }), applyConcurrently: true, renameResult: "same", }, ], }) let writes = 0 context.client.setWorkspaceEditIo({ writeFile(path, content) { writes += 1 writeFileSync(path, content, "utf-8") }, }) await context.client.openFile(context.source) const result = await context.client.rename(context.source, 1, 6, "after") expect(result.apply.success).toBe(true) expect(writes).toBe(1) const responses = readEvents(context.events).filter( (event) => event.type === "clientResponse" && event.method === "workspace/applyEdit", ) expect(responses.map((response) => response.result)).toContainEqual({ applied: true }) const rejection = responses.find( (response) => typeof response.result === "object" && response.result !== null && "failureReason" in response.result, ) expect(rejection?.result).toMatchObject({ applied: false }) expect(JSON.stringify(rejection?.result)).toMatch(/already (?:in progress|handled)/) }) it("#given a rename lease is held #when another rename starts #then it is rejected without a second request", async () => { const context = await harness.makeClient({ renameSteps: [ { renameResult: "edit", renameEdit: renameTextEdit("before", "after", { version: 1 }), responseDelayMs: 150, }, ], }) await context.client.openFile(context.source) const firstPromise = context.client.rename(context.source, 1, 6, "after") await waitForEventCount( context.events, (event) => event.type === "clientRequest" && event.method === "textDocument/rename", 1, ) const concurrent = await context.client.rename(context.source, 1, 6, "other_") const first = await firstPromise expect(concurrent.apply.success).toBe(false) expect(concurrent.apply.errors.join("\n")).toContain("workspace mutation is already in progress") expect(first.apply.success).toBe(true) const requests = readEvents(context.events).filter( (event) => event.type === "clientRequest" && event.method === "textDocument/rename", ) expect(requests).toHaveLength(1) }) it("#given no server apply #when rename directly returns an edit #then it is applied exactly once", async () => { const context = await harness.makeClient({ renameSteps: [{ renameResult: "edit", renameEdit: renameTextEdit("before", "after", { version: 1 }) }], }) await context.client.openFile(context.source) const result = await context.client.rename(context.source, 1, 6, "after") expect(result.apply.success).toBe(true) expect(readFileSync(context.source, "utf-8")).toBe("const after = 1;\n") expect(readEvents(context.events).filter((event) => event.method === "workspace/applyEdit")).toHaveLength(0) }) it("#given cancellation before a delayed server apply #when the rename request is aborted #then no file is mutated", async () => { const controller = new AbortController() const context = await harness.makeClient({ renameSteps: [ { applyEdit: renameTextEdit("before", "after", { version: 1 }), applyDelayMs: 100, renameResult: "same", }, ], }) await context.client.openFile(context.source) const rename = context.client.rename(context.source, 1, 6, "after", controller.signal) await waitForEventCount( context.events, (event) => event.type === "clientRequest" && event.method === "textDocument/rename", 1, ) controller.abort() await expect(rename).rejects.toThrow(/cancel/i) const [cancel] = await waitForEventCount( context.events, (event) => event.type === "clientNotification" && event.method === "$/cancelRequest", 1, ) expect(cancel?.params).toEqual({ id: 2 }) expect(readFileSync(context.source, "utf-8")).toBe("const before = 1;\n") }) it("#given cancellation after the commit gate #when applyEdit finishes #then rename reports one completed late-abort mutation", async () => { const controller = new AbortController() const context = await harness.makeClient({ renameSteps: [{ applyEdit: renameTextEdit("before", "after", { version: 1 }), renameResult: "same" }], }) let writes = 0 context.client.setWorkspaceEditIo({ writeFile(path, content) { writes += 1 writeFileSync(path, content, "utf-8") controller.abort() }, }) await context.client.openFile(context.source) const result = await context.client.rename(context.source, 1, 6, "after", controller.signal) expect(result.apply).toMatchObject({ success: true, lateAbort: true, totalEdits: 1 }) expect(writes).toBe(1) expect(readFileSync(context.source, "utf-8")).toBe("const after = 1;\n") }) it("#given lease-backed and bare clients #when initialized #then applyEdit and annotations are advertised honestly", async () => { const active = await harness.makeClient({}) const inactive = await harness.makeBareConnection({}) const activeCapabilities = initializeCapabilities(active.events) const inactiveCapabilities = initializeCapabilities(inactive.events) expect(activeCapabilities.workspace?.applyEdit).toBe(true) expect(inactiveCapabilities.workspace?.applyEdit).toBeUndefined() expect(activeCapabilities.textDocument?.rename?.honorsChangeAnnotations).toBeUndefined() expect(activeCapabilities.workspace?.workspaceEdit?.changeAnnotationSupport).toBeUndefined() }) }) interface InitializeCapabilities { readonly workspace?: { readonly applyEdit?: boolean readonly workspaceEdit?: { readonly changeAnnotationSupport?: unknown } } readonly textDocument?: { readonly rename?: { readonly honorsChangeAnnotations?: boolean } } } function initializeCapabilities(path: string): InitializeCapabilities { const initialize = readEvents(path).find((event) => event.type === "clientRequest" && event.method === "initialize") return (initialize?.params as { capabilities?: InitializeCapabilities } | undefined)?.capabilities ?? {} }