test(lsp): add tests for Rename Symbol feature (T006-T008)

- Update CLAUDE.md with prepareRename/rename method documentation
- Add 12 unit tests for TextEdit, WorkspaceEdit, PrepareRenameResult schemas
- Add integration tests for prepareRename and rename LSP requests
- Tests verify both valid rename operations and edge cases

Part of #18

Author: amondnet

packages/lsp/CLAUDE.md

@@ -106,6 +106,12 @@ const symbols = await manager.workspaceSymbol('query')
 // Get document symbols
 const docSymbols = await manager.documentSymbol(uri)
 
+// Prepare rename (validate rename is possible)
+const prepareResult = await manager.prepareRename({ file, line, character })
+
+// Rename symbol
+const workspaceEdit = await manager.rename({ file, line, character, newName: 'newSymbolName' })
+
 // Cleanup
 await manager.shutdown()
 ```
@@ -122,6 +128,8 @@ await manager.shutdown()
 | `completion()` | `textDocument/completion` | Get code completions |
 | `workspaceSymbol()` | `workspace/symbol` | Search workspace symbols |
 | `documentSymbol()` | `textDocument/documentSymbol` | Get document symbols |
+| `prepareRename()` | `textDocument/prepareRename` | Validate rename at position |
+| `rename()` | `textDocument/rename` | Rename symbol, returns WorkspaceEdit |
 | `shutdown()` | `shutdown` | Close all clients |
 
 ### Server Utilities

packages/lsp/test/integration/rename.integration.test.ts

@@ -0,0 +1,179 @@
+/**
+ * Rename Symbol Integration Tests
+ *
+ * These tests verify the prepareRename and rename LSP functionality
+ * using actual TypeScript language server.
+ *
+ * Based on serena reference: ref/serena/src/solidlsp/ls.py:1834-1859
+ */
+
+import path from 'node:path'
+import { afterAll, beforeAll, describe, expect, test } from 'bun:test'
+import { LSPManager } from '../../src/index'
+
+const VUE_PROJECT_PATH = path.join(import.meta.dir, '../fixtures/vue-project')
+const MATH_TS_PATH = path.join(VUE_PROJECT_PATH, 'src/utils/math.ts')
+
+// Check if npm is available for auto-installing LSP dependencies
+const isNpmAvailable = Bun.which('npm') !== null
+
+describe.skipIf(!isNpmAvailable)('Rename Symbol Integration', () => {
+  let manager: LSPManager
+
+  beforeAll(async () => {
+    manager = new LSPManager(VUE_PROJECT_PATH)
+    // Touch the TypeScript file to initialize LSP and wait for diagnostics
+    await manager.touchFile(MATH_TS_PATH, true)
+  }, 120000) // 120s timeout for server startup
+
+  afterAll(async () => {
+    await manager.shutdown()
+  })
+
+  test('prepareRename returns result for function name', async () => {
+    // Test prepareRename on 'add' function name (line 4, character 16: "export function add")
+    const result = await manager.prepareRename({
+      file: MATH_TS_PATH,
+      line: 3, // 0-indexed: line 4 in editor
+      character: 16, // position of 'add' in "export function add"
+    })
+
+    // TypeScript server should return a valid prepare rename result
+    expect(result).toBeDefined()
+    if (result) {
+      // Should be one of the PrepareRenameResult formats
+      // Range format has start/end
+      // Placeholder format has range/placeholder
+      // DefaultBehavior format has defaultBehavior
+      const hasRange = 'start' in result && 'end' in result
+      const hasPlaceholder = 'range' in result && 'placeholder' in result
+      const hasDefaultBehavior = 'defaultBehavior' in result
+
+      expect(hasRange || hasPlaceholder || hasDefaultBehavior).toBe(true)
+    }
+  })
+
+  test('prepareRename returns null for non-renameable position', async () => {
+    // Test prepareRename on a keyword position (line 1, character 0: "/**")
+    const result = await manager.prepareRename({
+      file: MATH_TS_PATH,
+      line: 0, // Comment line
+      character: 0,
+    })
+
+    // Should return null for non-renameable positions
+    expect(result).toBeNull()
+  })
+
+  test('rename returns WorkspaceEdit for valid symbol', async () => {
+    // Test rename on 'power' function (line 35: "export function power")
+    // Using 'power' since it's not used in other files, safer for testing
+    const result = await manager.rename({
+      file: MATH_TS_PATH,
+      line: 34, // 0-indexed: line 35 in editor
+      character: 16, // position of 'power'
+      newName: 'pow',
+    })
+
+    // TypeScript server should return a WorkspaceEdit
+    expect(result).toBeDefined()
+    if (result) {
+      expect(result.changes).toBeDefined()
+      expect(typeof result.changes).toBe('object')
+
+      // Should have at least one file with edits
+      const files = Object.keys(result.changes!)
+      expect(files.length).toBeGreaterThan(0)
+
+      // Each file should have at least one edit
+      for (const file of files) {
+        const edits = result.changes![file]
+        expect(edits.length).toBeGreaterThan(0)
+
+        // Each edit should have range and newText
+        for (const edit of edits) {
+          expect(edit.range).toBeDefined()
+          expect(edit.newText).toBe('pow')
+        }
+      }
+    }
+  })
+
+  test('rename returns null for invalid position', async () => {
+    // Test rename on a whitespace/comment position
+    const result = await manager.rename({
+      file: MATH_TS_PATH,
+      line: 0, // Comment line
+      character: 0,
+      newName: 'newName',
+    })
+
+    // Should return null for non-renameable positions
+    expect(result).toBeNull()
+  })
+
+  test('rename on parameter returns edits', async () => {
+    // Test rename on parameter 'a' in add function (line 4: "add(a: number, b: number)")
+    const result = await manager.rename({
+      file: MATH_TS_PATH,
+      line: 3, // 0-indexed
+      character: 20, // position of 'a' parameter
+      newName: 'num1',
+    })
+
+    // Should return WorkspaceEdit with edits for parameter usages
+    expect(result).toBeDefined()
+    if (result) {
+      expect(result.changes).toBeDefined()
+
+      // Parameter rename should affect at least the definition and usage in return statement
+      const mathTsUri = Object.keys(result.changes!).find(uri => uri.includes('math.ts'))
+      expect(mathTsUri).toBeDefined()
+
+      if (mathTsUri) {
+        const edits = result.changes![mathTsUri]
+        // Should have at least 2 edits: parameter definition and usage in "return a + b"
+        expect(edits.length).toBeGreaterThanOrEqual(2)
+      }
+    }
+  })
+})
+
+// Tests that don't require npm/LSP server
+describe('Rename Symbol Integration (no npm required)', () => {
+  test('fixture file exists', async () => {
+    const mathTs = Bun.file(MATH_TS_PATH)
+    expect(await mathTs.exists()).toBe(true)
+  })
+
+  test('manager exposes prepareRename method', () => {
+    const manager = new LSPManager(VUE_PROJECT_PATH)
+    expect(typeof manager.prepareRename).toBe('function')
+  })
+
+  test('manager exposes rename method', () => {
+    const manager = new LSPManager(VUE_PROJECT_PATH)
+    expect(typeof manager.rename).toBe('function')
+  })
+
+  test('prepareRename returns null when disabled', async () => {
+    const manager = new LSPManager(VUE_PROJECT_PATH, { enabled: false })
+    const result = await manager.prepareRename({
+      file: MATH_TS_PATH,
+      line: 3,
+      character: 16,
+    })
+    expect(result).toBeNull()
+  })
+
+  test('rename returns null when disabled', async () => {
+    const manager = new LSPManager(VUE_PROJECT_PATH, { enabled: false })
+    const result = await manager.rename({
+      file: MATH_TS_PATH,
+      line: 3,
+      character: 16,
+      newName: 'newAdd',
+    })
+    expect(result).toBeNull()
+  })
+})

packages/lsp/test/unit/index.test.ts

@@ -5,7 +5,10 @@ import {
   getLanguageId,
   LANGUAGE_EXTENSIONS,
   LSPManager,
+  PrepareRenameResultSchema,
   SymbolKind,
+  TextEditSchema,
+  WorkspaceEditSchema,
 } from '../../src/index'
 
 describe('LSPManager', () => {
@@ -174,3 +177,120 @@ describe('LANGUAGE_EXTENSIONS', () => {
     expect(LANGUAGE_EXTENSIONS['.yml']).toBe('yaml')
   })
 })
+
+describe('TextEditSchema', () => {
+  test('validates valid TextEdit', () => {
+    const textEdit = {
+      range: {
+        start: { line: 0, character: 5 },
+        end: { line: 0, character: 10 },
+      },
+      newText: 'newName',
+    }
+
+    const result = TextEditSchema.safeParse(textEdit)
+    expect(result.success).toBe(true)
+  })
+
+  test('rejects TextEdit without range', () => {
+    const invalid = { newText: 'newName' }
+
+    const result = TextEditSchema.safeParse(invalid)
+    expect(result.success).toBe(false)
+  })
+
+  test('rejects TextEdit without newText', () => {
+    const invalid = {
+      range: {
+        start: { line: 0, character: 5 },
+        end: { line: 0, character: 10 },
+      },
+    }
+
+    const result = TextEditSchema.safeParse(invalid)
+    expect(result.success).toBe(false)
+  })
+})
+
+describe('WorkspaceEditSchema', () => {
+  test('validates WorkspaceEdit with changes', () => {
+    const workspaceEdit = {
+      changes: {
+        'file:///test.ts': [
+          {
+            range: {
+              start: { line: 0, character: 5 },
+              end: { line: 0, character: 10 },
+            },
+            newText: 'newName',
+          },
+        ],
+      },
+    }
+
+    const result = WorkspaceEditSchema.safeParse(workspaceEdit)
+    expect(result.success).toBe(true)
+  })
+
+  test('validates empty WorkspaceEdit', () => {
+    const emptyEdit = {}
+
+    const result = WorkspaceEditSchema.safeParse(emptyEdit)
+    expect(result.success).toBe(true)
+  })
+
+  test('validates WorkspaceEdit with multiple files', () => {
+    const multiFileEdit = {
+      changes: {
+        'file:///a.ts': [
+          { range: { start: { line: 0, character: 0 }, end: { line: 0, character: 5 } }, newText: 'new1' },
+        ],
+        'file:///b.ts': [
+          { range: { start: { line: 1, character: 0 }, end: { line: 1, character: 5 } }, newText: 'new2' },
+        ],
+      },
+    }
+
+    const result = WorkspaceEditSchema.safeParse(multiFileEdit)
+    expect(result.success).toBe(true)
+  })
+})
+
+describe('PrepareRenameResultSchema', () => {
+  test('validates Range format', () => {
+    const rangeResult = {
+      start: { line: 0, character: 5 },
+      end: { line: 0, character: 10 },
+    }
+
+    const result = PrepareRenameResultSchema.safeParse(rangeResult)
+    expect(result.success).toBe(true)
+  })
+
+  test('validates range + placeholder format', () => {
+    const placeholderResult = {
+      range: {
+        start: { line: 0, character: 5 },
+        end: { line: 0, character: 10 },
+      },
+      placeholder: 'oldName',
+    }
+
+    const result = PrepareRenameResultSchema.safeParse(placeholderResult)
+    expect(result.success).toBe(true)
+  })
+
+  test('validates defaultBehavior format', () => {
+    const defaultResult = { defaultBehavior: true }
+
+    const result = PrepareRenameResultSchema.safeParse(defaultResult)
+    expect(result.success).toBe(true)
+  })
+
+  test('rejects invalid format', () => {
+    const invalid = { invalid: 'format' }
+
+    const result = PrepareRenameResultSchema.safeParse(invalid)
+    expect(result.success).toBe(false)
+  })
+})