zed-ets-language-server 2.1.0 → 2.2.0

package/index.js

@@ -82,6 +82,43 @@ async function main() {
       serverProcess.send(etsSpecialRequest);
       return;
     }
+
+    // Forward standard formatting requests to custom ets/formatDocument
+    if (message.method === 'textDocument/formatting') {
+      const etsFormatRequest = {
+        jsonrpc: message.jsonrpc,
+        id: message.id,
+        method: 'ets/formatDocument',
+        params: {
+          textDocument: message.params.textDocument,
+          options: message.params.options,
+        },
+      };
+      
+      logger.info(`Forwarding formatting request to ets/formatDocument: ${JSON.stringify(etsFormatRequest)}`);
+      serverProcess.send(etsFormatRequest);
+      return;
+    }
+
+    // Forward range formatting requests to custom ets/formatDocument
+    // Note: ets/formatDocument doesn't support range formatting explicitly,
+    // so we forward it as a full document format request
+    if (message.method === 'textDocument/rangeFormatting') {
+      const etsFormatRequest = {
+        jsonrpc: message.jsonrpc,
+        id: message.id,
+        method: 'ets/formatDocument',
+        params: {
+          textDocument: message.params.textDocument,
+          options: message.params.options,
+        },
+      };
+      
+      logger.info(`Forwarding range formatting request to ets/formatDocument: ${JSON.stringify(etsFormatRequest)}`);
+      serverProcess.send(etsFormatRequest);
+      return;
+    }
+
     // Send message to language server via IPC
     serverProcess.send(message);
   }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zed-ets-language-server",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "ETS language server wrapper for Zed ArkTS extension.",
   "type": "module",
   "main": "index.js",
@@ -8,7 +8,11 @@
     "node": ">=22.12.0"
   },
   "scripts": {
-    "test": "vitest run"
+    "test": "vitest run",
+    "test:unit": "vitest run lib/",
+    "test:integration": "vitest run tests/integration/",
+    "test:formatting": "vitest run tests/integration/formatting.test.js tests/integration/formatting-content.test.js",
+    "test:watch": "vitest"
   },
   "author": "liuyanghejerry <liuyanghejerry@126.com>",
   "license": "MIT",

package/tests/fixtures/formatted.ets

@@ -0,0 +1,21 @@
+// Formatted ArkTS code
+@Entry
+@Component
+struct Index {
+  @State message: string = 'Hello World'
+  @State counter: number = 0
+
+  build() {
+    Column({ space: 20 }) {
+      Text(this.message)
+        .fontSize(30)
+        .fontWeight(FontWeight.Bold)
+      
+      Button('Click')
+        .onClick(() => {
+          this.counter++
+        })
+    }
+    .width('100%')
+  }
+}

package/tests/fixtures/unformatted.ets

@@ -0,0 +1,17 @@
+// Unformatted ArkTS code
+@Entry
+@Component
+struct Index {
+@State message:string='Hello World'
+@State counter:number=0
+
+build() {
+Column({space:20}) {
+Text(this.message).fontSize(30).fontWeight(FontWeight.Bold)
+Button('Click').onClick(()=>{
+this.counter++
+})
+}
+.width('100%')
+}
+}

package/tests/integration/formatting-content.test.js

@@ -0,0 +1,472 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { spawn } from 'child_process';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/**
+ * 创建 LSP 消息
+ */
+function createLSPMessage(content) {
+  const json = JSON.stringify(content);
+  const contentLength = Buffer.byteLength(json, 'utf8');
+  return `Content-Length: ${contentLength}\r\n\r\n${json}`;
+}
+
+/**
+ * 解析 LSP 响应
+ */
+function parseLSPResponse(data) {
+  const text = data.toString();
+  const match = text.match(/Content-Length: (\d+)\r\n\r\n(.*)/s);
+  if (!match) return null;
+  
+  try {
+    return JSON.parse(match[2]);
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * 等待特定响应
+ */
+function waitForResponse(responses, predicate, timeout = 3000) {
+  return new Promise((resolve, reject) => {
+    const startTime = Date.now();
+    const checkInterval = setInterval(() => {
+      const response = responses.find(predicate);
+      if (response) {
+        clearInterval(checkInterval);
+        resolve(response);
+      } else if (Date.now() - startTime > timeout) {
+        clearInterval(checkInterval);
+        reject(new Error('Timeout waiting for response'));
+      }
+    }, 100);
+  });
+}
+
+/**
+ * 应用 TextEdit 到文本内容
+ */
+function applyTextEdits(originalText, textEdits) {
+  if (!textEdits || textEdits.length === 0) {
+    return originalText;
+  }
+
+  // 将文本分割成行
+  const lines = originalText.split('\n');
+  
+  // 按照逆序应用编辑（从后往前），避免位置偏移问题
+  const sortedEdits = [...textEdits].sort((a, b) => {
+    if (a.range.start.line !== b.range.start.line) {
+      return b.range.start.line - a.range.start.line;
+    }
+    return b.range.start.character - a.range.start.character;
+  });
+
+  for (const edit of sortedEdits) {
+    const { range, newText } = edit;
+    const { start, end } = range;
+
+    // 提取需要替换的部分
+    const startLine = lines[start.line] || '';
+    const endLine = lines[end.line] || '';
+    
+    const before = startLine.substring(0, start.character);
+    const after = endLine.substring(end.character);
+    
+    // 删除被替换的行
+    lines.splice(start.line, end.line - start.line + 1);
+    
+    // 插入新文本
+    const newLines = (before + newText + after).split('\n');
+    lines.splice(start.line, 0, ...newLines);
+  }
+
+  return lines.join('\n');
+}
+
+describe('Code Formatting Content Validation Tests', () => {
+  let serverProcess;
+  let responses = [];
+  let messageId = 1;
+  const fixturesDir = join(__dirname, '../fixtures');
+
+  beforeAll(() => {
+    // 启动 LSP 服务器
+    const serverPath = join(__dirname, '../../index.js');
+    
+    // 设置环境变量，指向模拟的 ETS 语言服务器
+    const env = {
+      ...process.env,
+      ETS_LANG_SERVER: join(__dirname, '../mocks/mock-ets-server.js')
+    };
+
+    serverProcess = spawn('node', [serverPath], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env
+    });
+
+    // 收集响应
+    serverProcess.stdout.on('data', (data) => {
+      const response = parseLSPResponse(data);
+      if (response) {
+        responses.push(response);
+      }
+    });
+
+    serverProcess.stderr.on('data', (data) => {
+      console.error(`LSP Server Error: ${data}`);
+    });
+  });
+
+  afterAll(() => {
+    if (serverProcess) {
+      serverProcess.kill();
+    }
+  });
+
+  it('should format unformatted code correctly', async () => {
+    const unformattedContent = readFileSync(
+      join(fixturesDir, 'unformatted.ets'),
+      'utf8'
+    );
+    const expectedFormattedContent = readFileSync(
+      join(fixturesDir, 'formatted.ets'),
+      'utf8'
+    );
+
+    const currentId = messageId++;
+    const formattingRequest = {
+      jsonrpc: '2.0',
+      id: currentId,
+      method: 'textDocument/formatting',
+      params: {
+        textDocument: {
+          uri: 'file:///unformatted.ets'
+        },
+        options: {
+          tabSize: 2,
+          insertSpaces: true
+        }
+      }
+    };
+
+    const message = createLSPMessage(formattingRequest);
+    serverProcess.stdin.write(message);
+
+    // 等待格式化响应
+    const response = await waitForResponse(
+      responses,
+      r => r.id === currentId
+    );
+
+    expect(response).toBeDefined();
+    expect(response.result).toBeDefined();
+    expect(Array.isArray(response.result)).toBe(true);
+    expect(response.result.length).toBeGreaterThan(0);
+
+    // 验证 TextEdit 结构
+    const textEdit = response.result[0];
+    expect(textEdit).toHaveProperty('range');
+    expect(textEdit).toHaveProperty('newText');
+    expect(textEdit.range).toHaveProperty('start');
+    expect(textEdit.range).toHaveProperty('end');
+
+    // 应用 TextEdit 并验证结果
+    const formattedContent = applyTextEdits(unformattedContent, response.result);
+    
+    // 验证格式化后的内容与预期一致
+    expect(formattedContent.trim()).toBe(expectedFormattedContent.trim());
+  });
+
+  it('should return proper TextEdit for formatting', async () => {
+    const currentId = messageId++;
+    const formattingRequest = {
+      jsonrpc: '2.0',
+      id: currentId,
+      method: 'textDocument/formatting',
+      params: {
+        textDocument: {
+          uri: 'file:///test.ets'
+        },
+        options: {
+          tabSize: 2,
+          insertSpaces: true
+        }
+      }
+    };
+
+    const message = createLSPMessage(formattingRequest);
+    serverProcess.stdin.write(message);
+
+    const response = await waitForResponse(
+      responses,
+      r => r.id === currentId
+    );
+
+    expect(response).toBeDefined();
+    expect(response.result).toBeDefined();
+    expect(Array.isArray(response.result)).toBe(true);
+
+    // 验证返回的 TextEdit 包含有效的格式化内容
+    const textEdit = response.result[0];
+    expect(textEdit.newText).toBeDefined();
+    expect(textEdit.newText.length).toBeGreaterThan(0);
+    
+    // 验证格式化内容包含正确的结构
+    expect(textEdit.newText).toContain('@Entry');
+    expect(textEdit.newText).toContain('@Component');
+    expect(textEdit.newText).toContain('struct');
+  });
+
+  it('should preserve indentation with insertSpaces option', async () => {
+    const currentId = messageId++;
+    const formattingRequest = {
+      jsonrpc: '2.0',
+      id: currentId,
+      method: 'textDocument/formatting',
+      params: {
+        textDocument: {
+          uri: 'file:///test.ets'
+        },
+        options: {
+          tabSize: 2,
+          insertSpaces: true
+        }
+      }
+    };
+
+    const message = createLSPMessage(formattingRequest);
+    serverProcess.stdin.write(message);
+
+    const response = await waitForResponse(
+      responses,
+      r => r.id === currentId
+    );
+
+    expect(response).toBeDefined();
+    const textEdit = response.result[0];
+    
+    // 验证使用空格缩进（2个空格）
+    const lines = textEdit.newText.split('\n');
+    const indentedLines = lines.filter(line => line.startsWith('  '));
+    expect(indentedLines.length).toBeGreaterThan(0);
+    
+    // 验证使用了空格而不是制表符
+    expect(textEdit.newText).not.toContain('\t');
+  });
+
+  it('should format with different tab sizes', async () => {
+    const currentId = messageId++;
+    const formattingRequest = {
+      jsonrpc: '2.0',
+      id: currentId,
+      method: 'textDocument/formatting',
+      params: {
+        textDocument: {
+          uri: 'file:///test.ets'
+        },
+        options: {
+          tabSize: 4,
+          insertSpaces: true
+        }
+      }
+    };
+
+    const message = createLSPMessage(formattingRequest);
+    serverProcess.stdin.write(message);
+
+    const response = await waitForResponse(
+      responses,
+      r => r.id === currentId
+    );
+
+    expect(response).toBeDefined();
+    expect(response.result).toBeDefined();
+    
+    const textEdit = response.result[0];
+    expect(textEdit.newText).toBeDefined();
+    expect(textEdit.newText.length).toBeGreaterThan(0);
+  });
+
+  it('should handle range formatting and return proper content', async () => {
+    const currentId = messageId++;
+    const rangeFormattingRequest = {
+      jsonrpc: '2.0',
+      id: currentId,
+      method: 'textDocument/rangeFormatting',
+      params: {
+        textDocument: {
+          uri: 'file:///test.ets'
+        },
+        range: {
+          start: { line: 0, character: 0 },
+          end: { line: 10, character: 0 }
+        },
+        options: {
+          tabSize: 2,
+          insertSpaces: true
+        }
+      }
+    };
+
+    const message = createLSPMessage(rangeFormattingRequest);
+    serverProcess.stdin.write(message);
+
+    const response = await waitForResponse(
+      responses,
+      r => r.id === currentId
+    );
+
+    expect(response).toBeDefined();
+    expect(response.result).toBeDefined();
+    
+    const textEdit = response.result[0];
+    expect(textEdit.newText).toBeDefined();
+    expect(textEdit.range).toBeDefined();
+  });
+
+  it('should return formatted content that is syntactically valid', async () => {
+    const currentId = messageId++;
+    const formattingRequest = {
+      jsonrpc: '2.0',
+      id: currentId,
+      method: 'textDocument/formatting',
+      params: {
+        textDocument: {
+          uri: 'file:///test.ets'
+        },
+        options: {
+          tabSize: 2,
+          insertSpaces: true
+        }
+      }
+    };
+
+    const message = createLSPMessage(formattingRequest);
+    serverProcess.stdin.write(message);
+
+    const response = await waitForResponse(
+      responses,
+      r => r.id === currentId
+    );
+
+    expect(response).toBeDefined();
+    const textEdit = response.result[0];
+    const formattedCode = textEdit.newText;
+    
+    // 验证格式化后的代码包含必要的ArkTS元素
+    expect(formattedCode).toContain('@Entry');
+    expect(formattedCode).toContain('@Component');
+    expect(formattedCode).toContain('struct');
+    expect(formattedCode).toContain('build()');
+    
+    // 验证代码结构完整（有开始和结束的大括号）
+    const openBraces = (formattedCode.match(/{/g) || []).length;
+    const closeBraces = (formattedCode.match(/}/g) || []).length;
+    expect(openBraces).toBe(closeBraces);
+  });
+
+  it('should handle multiple consecutive formatting requests with correct results', async () => {
+    const results = [];
+    
+    for (let i = 0; i < 3; i++) {
+      const currentId = messageId++;
+      const formattingRequest = {
+        jsonrpc: '2.0',
+        id: currentId,
+        method: 'textDocument/formatting',
+        params: {
+          textDocument: {
+            uri: `file:///test${i}.ets`
+          },
+          options: {
+            tabSize: 2,
+            insertSpaces: true
+          }
+        }
+      };
+
+      const message = createLSPMessage(formattingRequest);
+      serverProcess.stdin.write(message);
+
+      const response = await waitForResponse(
+        responses,
+        r => r.id === currentId
+      );
+
+      expect(response).toBeDefined();
+      expect(response.result).toBeDefined();
+      
+      const textEdit = response.result[0];
+      expect(textEdit.newText).toBeDefined();
+      results.push(textEdit.newText);
+    }
+
+    // 验证所有格式化结果都是有效的
+    results.forEach(formattedContent => {
+      expect(formattedContent.length).toBeGreaterThan(0);
+      expect(formattedContent).toContain('struct');
+    });
+  });
+});
+
+describe('Formatting TextEdit Application', () => {
+  it('should correctly apply TextEdit to replace entire document', () => {
+    const originalText = 'Line 1\nLine 2\nLine 3';
+    const textEdit = {
+      range: {
+        start: { line: 0, character: 0 },
+        end: { line: 2, character: 6 }
+      },
+      newText: 'New Line 1\nNew Line 2\nNew Line 3'
+    };
+
+    const result = applyTextEdits(originalText, [textEdit]);
+    expect(result).toBe('New Line 1\nNew Line 2\nNew Line 3');
+  });
+
+  it('should correctly apply TextEdit to replace partial content', () => {
+    const originalText = 'Hello World\nTest Line';
+    const textEdit = {
+      range: {
+        start: { line: 0, character: 6 },
+        end: { line: 0, character: 11 }
+      },
+      newText: 'ArkTS'
+    };
+
+    const result = applyTextEdits(originalText, [textEdit]);
+    expect(result).toBe('Hello ArkTS\nTest Line');
+  });
+
+  it('should handle multiple TextEdits', () => {
+    const originalText = 'Line 1\nLine 2\nLine 3';
+    const textEdits = [
+      {
+        range: {
+          start: { line: 0, character: 0 },
+          end: { line: 0, character: 6 }
+        },
+        newText: 'First'
+      },
+      {
+        range: {
+          start: { line: 2, character: 0 },
+          end: { line: 2, character: 6 }
+        },
+        newText: 'Third'
+      }
+    ];
+
+    const result = applyTextEdits(originalText, textEdits);
+    expect(result).toContain('First');
+    expect(result).toContain('Third');
+  });
+});

package/tests/integration/formatting.test.js

@@ -0,0 +1,409 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/**
+ * 创建 LSP 消息
+ */
+function createLSPMessage(content) {
+  const json = JSON.stringify(content);
+  const contentLength = Buffer.byteLength(json, 'utf8');
+  return `Content-Length: ${contentLength}\r\n\r\n${json}`;
+}
+
+/**
+ * 解析 LSP 响应
+ */
+function parseLSPResponse(data) {
+  const text = data.toString();
+  const match = text.match(/Content-Length: (\d+)\r\n\r\n(.*)/s);
+  if (!match) return null;
+  
+  try {
+    return JSON.parse(match[2]);
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * 等待特定响应
+ */
+function waitForResponse(responses, predicate, timeout = 2000) {
+  return new Promise((resolve, reject) => {
+    const startTime = Date.now();
+    const checkInterval = setInterval(() => {
+      const response = responses.find(predicate);
+      if (response) {
+        clearInterval(checkInterval);
+        resolve(response);
+      } else if (Date.now() - startTime > timeout) {
+        clearInterval(checkInterval);
+        reject(new Error('Timeout waiting for response'));
+      }
+    }, 100);
+  });
+}
+
+describe('Code Formatting Tests', () => {
+  let serverProcess;
+  let responses = [];
+  let messageId = 1;
+
+  beforeAll(() => {
+    // 启动 LSP 服务器
+    const serverPath = join(__dirname, '../../index.js');
+    
+    // 设置环境变量，指向模拟的 ETS 语言服务器
+    const env = {
+      ...process.env,
+      ETS_LANG_SERVER: join(__dirname, '../mocks/mock-ets-server.js')
+    };
+
+    serverProcess = spawn('node', [serverPath], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env
+    });
+
+    // 收集响应
+    serverProcess.stdout.on('data', (data) => {
+      const response = parseLSPResponse(data);
+      if (response) {
+        responses.push(response);
+      }
+    });
+
+    serverProcess.stderr.on('data', (data) => {
+      console.error(`LSP Server Error: ${data}`);
+    });
+  });
+
+  afterAll(() => {
+    if (serverProcess) {
+      serverProcess.kill();
+    }
+  });
+
+  it('should forward textDocument/formatting to ets/formatDocument', async () => {
+    const formattingRequest = {
+      jsonrpc: '2.0',
+      id: messageId++,
+      method: 'textDocument/formatting',
+      params: {
+        textDocument: {
+          uri: 'file:///test.ets'
+        },
+        options: {
+          tabSize: 2,
+          insertSpaces: true
+        }
+      }
+    };
+
+    const message = createLSPMessage(formattingRequest);
+    serverProcess.stdin.write(message);
+
+    // 由于我们转发到 ets/formatDocument，验证请求被正确转发
+    // 在实际实现中，这会返回 TextEdit[] 数组
+    await new Promise(resolve => setTimeout(resolve, 500));
+    
+    // 验证服务器仍在运行（没有因为错误崩溃）
+    expect(serverProcess.killed).toBe(false);
+  });
+
+  it('should forward textDocument/rangeFormatting to ets/formatDocument', async () => {
+    const rangeFormattingRequest = {
+      jsonrpc: '2.0',
+      id: messageId++,
+      method: 'textDocument/rangeFormatting',
+      params: {
+        textDocument: {
+          uri: 'file:///test.ets'
+        },
+        range: {
+          start: { line: 0, character: 0 },
+          end: { line: 10, character: 0 }
+        },
+        options: {
+          tabSize: 2,
+          insertSpaces: true
+        }
+      }
+    };
+
+    const message = createLSPMessage(rangeFormattingRequest);
+    serverProcess.stdin.write(message);
+
+    // 验证请求被转发
+    await new Promise(resolve => setTimeout(resolve, 500));
+    
+    // 验证服务器仍在运行
+    expect(serverProcess.killed).toBe(false);
+  });
+
+  it('should preserve formatting options when forwarding', async () => {
+    const formattingRequest = {
+      jsonrpc: '2.0',
+      id: messageId++,
+      method: 'textDocument/formatting',
+      params: {
+        textDocument: {
+          uri: 'file:///test.ets'
+        },
+        options: {
+          tabSize: 4,
+          insertSpaces: false,
+          trimTrailingWhitespace: true,
+          insertFinalNewline: true,
+          trimFinalNewlines: true
+        }
+      }
+    };
+
+    const message = createLSPMessage(formattingRequest);
+    serverProcess.stdin.write(message);
+
+    await new Promise(resolve => setTimeout(resolve, 500));
+    
+    // 验证服务器正常处理带有完整选项的请求
+    expect(serverProcess.killed).toBe(false);
+  });
+
+  it('should handle formatting request with minimal options', async () => {
+    const formattingRequest = {
+      jsonrpc: '2.0',
+      id: messageId++,
+      method: 'textDocument/formatting',
+      params: {
+        textDocument: {
+          uri: 'file:///simple.ets'
+        },
+        options: {
+          tabSize: 2,
+          insertSpaces: true
+        }
+      }
+    };
+
+    const message = createLSPMessage(formattingRequest);
+    serverProcess.stdin.write(message);
+
+    await new Promise(resolve => setTimeout(resolve, 500));
+    
+    expect(serverProcess.killed).toBe(false);
+  });
+
+  it('should handle multiple formatting requests sequentially', async () => {
+    const files = ['file1.ets', 'file2.ets', 'file3.ets'];
+    
+    for (const file of files) {
+      const formattingRequest = {
+        jsonrpc: '2.0',
+        id: messageId++,
+        method: 'textDocument/formatting',
+        params: {
+          textDocument: {
+            uri: `file:///${file}`
+          },
+          options: {
+            tabSize: 2,
+            insertSpaces: true
+          }
+        }
+      };
+
+      const message = createLSPMessage(formattingRequest);
+      serverProcess.stdin.write(message);
+      
+      // 给每个请求一些处理时间
+      await new Promise(resolve => setTimeout(resolve, 200));
+    }
+
+    // 验证服务器处理了所有请求而没有崩溃
+    expect(serverProcess.killed).toBe(false);
+  });
+
+  it('should handle formatting request with different tab sizes', async () => {
+    const tabSizes = [2, 4, 8];
+    
+    for (const tabSize of tabSizes) {
+      const formattingRequest = {
+        jsonrpc: '2.0',
+        id: messageId++,
+        method: 'textDocument/formatting',
+        params: {
+          textDocument: {
+            uri: 'file:///test.ets'
+          },
+          options: {
+            tabSize: tabSize,
+            insertSpaces: true
+          }
+        }
+      };
+
+      const message = createLSPMessage(formattingRequest);
+      serverProcess.stdin.write(message);
+      
+      await new Promise(resolve => setTimeout(resolve, 200));
+    }
+
+    expect(serverProcess.killed).toBe(false);
+  });
+
+  it('should handle formatting with tabs instead of spaces', async () => {
+    const formattingRequest = {
+      jsonrpc: '2.0',
+      id: messageId++,
+      method: 'textDocument/formatting',
+      params: {
+        textDocument: {
+          uri: 'file:///test.ets'
+        },
+        options: {
+          tabSize: 2,
+          insertSpaces: false // Use tabs
+        }
+      }
+    };
+
+    const message = createLSPMessage(formattingRequest);
+    serverProcess.stdin.write(message);
+
+    await new Promise(resolve => setTimeout(resolve, 500));
+    
+    expect(serverProcess.killed).toBe(false);
+  });
+});
+
+describe('Formatting Message Structure', () => {
+  it('should create valid formatting request message', () => {
+    const request = {
+      jsonrpc: '2.0',
+      id: 1,
+      method: 'textDocument/formatting',
+      params: {
+        textDocument: { uri: 'file:///test.ets' },
+        options: { tabSize: 2, insertSpaces: true }
+      }
+    };
+
+    const message = createLSPMessage(request);
+    
+    expect(message).toContain('Content-Length:');
+    expect(message).toContain('textDocument/formatting');
+    expect(message).toContain('file:///test.ets');
+  });
+
+  it('should create valid range formatting request message', () => {
+    const request = {
+      jsonrpc: '2.0',
+      id: 2,
+      method: 'textDocument/rangeFormatting',
+      params: {
+        textDocument: { uri: 'file:///test.ets' },
+        range: {
+          start: { line: 0, character: 0 },
+          end: { line: 10, character: 0 }
+        },
+        options: { tabSize: 2, insertSpaces: true }
+      }
+    };
+
+    const message = createLSPMessage(request);
+    
+    expect(message).toContain('Content-Length:');
+    expect(message).toContain('textDocument/rangeFormatting');
+    expect(message).toContain('"start"');
+    expect(message).toContain('"end"');
+  });
+
+  it('should validate formatting options structure', () => {
+    const options = {
+      tabSize: 2,
+      insertSpaces: true,
+      trimTrailingWhitespace: true,
+      insertFinalNewline: true,
+      trimFinalNewlines: true
+    };
+
+    expect(options.tabSize).toBeGreaterThan(0);
+    expect(typeof options.insertSpaces).toBe('boolean');
+    expect(typeof options.trimTrailingWhitespace).toBe('boolean');
+    expect(typeof options.insertFinalNewline).toBe('boolean');
+    expect(typeof options.trimFinalNewlines).toBe('boolean');
+  });
+});
+
+describe('Formatting Edge Cases', () => {
+  it('should handle formatting request for empty file', () => {
+    const request = {
+      jsonrpc: '2.0',
+      id: 1,
+      method: 'textDocument/formatting',
+      params: {
+        textDocument: { uri: 'file:///empty.ets' },
+        options: { tabSize: 2, insertSpaces: true }
+      }
+    };
+
+    const message = createLSPMessage(request);
+    expect(message).toBeDefined();
+  });
+
+  it('should handle formatting request for large files', () => {
+    const request = {
+      jsonrpc: '2.0',
+      id: 1,
+      method: 'textDocument/formatting',
+      params: {
+        textDocument: { uri: 'file:///large-file.ets' },
+        options: { tabSize: 2, insertSpaces: true }
+      }
+    };
+
+    const message = createLSPMessage(request);
+    expect(message).toBeDefined();
+  });
+
+  it('should handle range formatting with zero-width range', () => {
+    const request = {
+      jsonrpc: '2.0',
+      id: 1,
+      method: 'textDocument/rangeFormatting',
+      params: {
+        textDocument: { uri: 'file:///test.ets' },
+        range: {
+          start: { line: 5, character: 10 },
+          end: { line: 5, character: 10 }
+        },
+        options: { tabSize: 2, insertSpaces: true }
+      }
+    };
+
+    const message = createLSPMessage(request);
+    expect(message).toBeDefined();
+  });
+
+  it('should handle formatting options with edge values', () => {
+    const request = {
+      jsonrpc: '2.0',
+      id: 1,
+      method: 'textDocument/formatting',
+      params: {
+        textDocument: { uri: 'file:///test.ets' },
+        options: {
+          tabSize: 1,  // Minimum tab size
+          insertSpaces: true
+        }
+      }
+    };
+
+    const message = createLSPMessage(request);
+    expect(message).toBeDefined();
+  });
+});

package/tests/integration/lsp-server.test.js

@@ -0,0 +1,146 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/**
+ * 创建 LSP 消息
+ */
+function createLSPMessage(content) {
+  const json = JSON.stringify(content);
+  const contentLength = Buffer.byteLength(json, 'utf8');
+  return `Content-Length: ${contentLength}\r\n\r\n${json}`;
+}
+
+/**
+ * 解析 LSP 响应
+ */
+function parseLSPResponse(data) {
+  const text = data.toString();
+  const match = text.match(/Content-Length: (\d+)\r\n\r\n(.*)/s);
+  if (!match) return null;
+  
+  try {
+    return JSON.parse(match[2]);
+  } catch (e) {
+    return null;
+  }
+}
+
+describe('LSP Server Integration Tests', () => {
+  let serverProcess;
+  let responses = [];
+
+  beforeAll(() => {
+    // 启动 LSP 服务器
+    const serverPath = join(__dirname, '../../index.js');
+    serverProcess = spawn('node', [serverPath], {
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+
+    // 收集响应
+    serverProcess.stdout.on('data', (data) => {
+      const response = parseLSPResponse(data);
+      if (response) {
+        responses.push(response);
+      }
+    });
+
+    serverProcess.stderr.on('data', (data) => {
+      console.error(`LSP Server Error: ${data}`);
+    });
+  });
+
+  afterAll(() => {
+    if (serverProcess) {
+      serverProcess.kill();
+    }
+  });
+
+  it('should respond to initialize request', (done) => {
+    const initRequest = {
+      jsonrpc: '2.0',
+      id: 1,
+      method: 'initialize',
+      params: {
+        processId: process.pid,
+        rootUri: null,
+        capabilities: {}
+      }
+    };
+
+    const message = createLSPMessage(initRequest);
+    serverProcess.stdin.write(message);
+
+    // 等待响应
+    setTimeout(() => {
+      const initResponse = responses.find(r => r.id === 1);
+      expect(initResponse).toBeDefined();
+      expect(initResponse.result).toBeDefined();
+      expect(initResponse.result.capabilities).toBeDefined();
+      done();
+    }, 1000);
+  });
+
+  it('should accept initialized notification', (done) => {
+    const initializedNotif = {
+      jsonrpc: '2.0',
+      method: 'initialized',
+      params: {}
+    };
+
+    const message = createLSPMessage(initializedNotif);
+    serverProcess.stdin.write(message);
+
+    // 通知不需要响应，只需确保不崩溃
+    setTimeout(() => {
+      expect(serverProcess.killed).toBe(false);
+      done();
+    }, 500);
+  });
+
+  it('should handle shutdown request', (done) => {
+    const shutdownRequest = {
+      jsonrpc: '2.0',
+      id: 99,
+      method: 'shutdown',
+      params: null
+    };
+
+    const message = createLSPMessage(shutdownRequest);
+    serverProcess.stdin.write(message);
+
+    setTimeout(() => {
+      const shutdownResponse = responses.find(r => r.id === 99);
+      // 某些 LSP 服务器可能返回 null result
+      expect(shutdownResponse).toBeDefined();
+      done();
+    }, 1000);
+  });
+});
+
+describe('LSP Message Protocol', () => {
+  it('should format messages correctly', () => {
+    const content = { jsonrpc: '2.0', method: 'test' };
+    const message = createLSPMessage(content);
+    
+    expect(message).toContain('Content-Length:');
+    expect(message).toContain('\r\n\r\n');
+    expect(message).toContain(JSON.stringify(content));
+  });
+
+  it('should parse responses correctly', () => {
+    const mockResponse = {
+      jsonrpc: '2.0',
+      id: 1,
+      result: { success: true }
+    };
+    const data = createLSPMessage(mockResponse);
+    const parsed = parseLSPResponse(Buffer.from(data));
+    
+    expect(parsed).toEqual(mockResponse);
+  });
+});

package/tests/mocks/mock-ets-server.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+
+/**
+ * Mock ETS Language Server for testing
+ * This simulates the behavior of the actual ETS language server
+ * for formatting requests.
+ */
+
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Load test fixtures
+const fixturesDir = join(__dirname, '../fixtures');
+
+process.on('message', (message) => {
+  // Handle ets/formatDocument requests
+  if (message.method === 'ets/formatDocument') {
+    const uri = message.params.textDocument.uri;
+    
+    // Simulate realistic formatting by returning TextEdit that formats the content
+    // For testing, we'll simulate formatting unformatted.ets to formatted.ets
+    let formattedContent;
+    
+    try {
+      // In a real scenario, the server would format based on the actual file content
+      // For testing, we return a predefined formatted version
+      if (uri.includes('unformatted')) {
+        formattedContent = readFileSync(join(fixturesDir, 'formatted.ets'), 'utf8');
+      } else {
+        // For other files, simulate basic formatting
+        formattedContent = `// Formatted by mock ETS server
+@Entry
+@Component
+struct Test {
+  @State value: string = 'test'
+  
+  build() {
+    Column() {
+      Text(this.value)
+    }
+  }
+}
+`;
+      }
+      
+      // Count lines in the formatted content to calculate proper end position
+      const lines = formattedContent.split('\n');
+      const lastLineIndex = lines.length - 1;
+      const lastLineLength = lines[lastLineIndex].length;
+      
+      const response = {
+        jsonrpc: message.jsonrpc,
+        id: message.id,
+        result: [
+          {
+            range: {
+              start: { line: 0, character: 0 },
+              end: { line: lastLineIndex, character: lastLineLength }
+            },
+            newText: formattedContent
+          }
+        ]
+      };
+      
+      process.send(response);
+    } catch (error) {
+      // Return error response if something goes wrong
+      const errorResponse = {
+        jsonrpc: message.jsonrpc,
+        id: message.id,
+        error: {
+          code: -32603,
+          message: `Formatting error: ${error.message}`
+        }
+      };
+      process.send(errorResponse);
+    }
+  }
+  
+  // Handle initialize request
+  else if (message.method === 'initialize') {
+    const response = {
+      jsonrpc: message.jsonrpc,
+      id: message.id,
+      result: {
+        capabilities: {
+          textDocumentSync: 1,
+          documentFormattingProvider: true,
+          documentRangeFormattingProvider: true
+        }
+      }
+    };
+    
+    process.send(response);
+  }
+  
+  // Handle shutdown request
+  else if (message.method === 'shutdown') {
+    const response = {
+      jsonrpc: message.jsonrpc,
+      id: message.id,
+      result: null
+    };
+    
+    process.send(response);
+  }
+  
+  // Handle exit notification
+  else if (message.method === 'exit') {
+    process.exit(0);
+  }
+});
+
+// Keep the process alive
+process.stdin.resume();