zed-ets-language-server 2.3.4 → 3.1.0

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

@@ -1,18 +1,36 @@
 import { describe, it, expect, beforeAll, afterAll } from 'vitest';
 import { spawn } from 'child_process';
+import { mkdtempSync } from 'fs';
+import { tmpdir } from 'os';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
+const serverPath = join(__dirname, '../../index.js');
+const mockServerPath = join(__dirname, '../mocks/mock-ets-server.js');
+const bundledTsdk = join(__dirname, '../../node_modules/ohos-typescript/lib');
+
+// Hermetic env: never inherit ambient tsdk/sdk settings from the shell.
+function baseEnv(overrides = {}) {
+  return {
+    ...process.env,
+    ETS_LANG_SERVER: mockServerPath,
+    TSDK: '',
+    ZED_ETS_TSDK: '',
+    OHOS_SDK_PATH: '',
+    ZED_ETS_OHOS_SDK_PATH: '',
+    ...overrides,
+  };
+}
+
 /**
  * 创建 LSP 消息
  */
 function createLSPMessage(content) {
-  const json = JSON.stringify(content);
-  const contentLength = Buffer.byteLength(json, 'utf8');
-  return `Content-Length: ${contentLength}\r\n\r\n${json}`;
+  const contentLength = Buffer.byteLength(JSON.stringify(content));
+  return `Content-Length: ${contentLength}\r\n\r\n${JSON.stringify(content)}`;
 }
 
 /**
@@ -22,7 +40,7 @@ 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) {
@@ -30,28 +48,77 @@ function parseLSPResponse(data) {
   }
 }
 
+/**
+ * 等待特定响应
+ */
+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'));
+      }
+    }, 50);
+  });
+}
+
+function startWrapper(env) {
+  const serverProcess = spawn('node', [serverPath], {
+    stdio: ['pipe', 'pipe', 'pipe'],
+    env,
+  });
+
+  const responses = [];
+  let stdoutBuffer = Buffer.alloc(0);
+  serverProcess.stdout.on('data', (data) => {
+    stdoutBuffer = Buffer.concat([stdoutBuffer, data]);
+    // SDK discovery can make initialize responses span multiple pipe chunks.
+    while (true) {
+      const headerEnd = stdoutBuffer.indexOf('\r\n\r\n');
+      if (headerEnd < 0) return;
+      const header = stdoutBuffer.subarray(0, headerEnd).toString('ascii');
+      const lengthMatch = header.match(/Content-Length:\s*(\d+)/i);
+      if (!lengthMatch) throw new Error('Invalid LSP response header');
+      const bodyStart = headerEnd + 4;
+      const bodyEnd = bodyStart + Number(lengthMatch[1]);
+      if (stdoutBuffer.length < bodyEnd) return;
+      responses.push(JSON.parse(stdoutBuffer.subarray(bodyStart, bodyEnd).toString('utf8')));
+      stdoutBuffer = stdoutBuffer.subarray(bodyEnd);
+    }
+  });
+
+  serverProcess.stderr.on('data', (data) => {
+    console.error(`LSP Server Error: ${data}`);
+  });
+
+  return { serverProcess, responses };
+}
+
+function initializeMessage(id) {
+  return createLSPMessage({
+    jsonrpc: '2.0',
+    id,
+    method: 'initialize',
+    params: {
+      processId: null,
+      rootUri: null,
+      capabilities: {},
+    },
+  });
+}
+
 describe('LSP Server Integration Tests', () => {
   let serverProcess;
   let responses = [];
+  let messageId = 1;
 
   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}`);
-    });
+    ({ serverProcess, responses } = startWrapper(baseEnv()));
   });
 
   afterAll(() => {
@@ -60,65 +127,78 @@ describe('LSP Server Integration Tests', () => {
     }
   });
 
-  it('should respond to initialize request', (done) => {
-    const initRequest = {
-      jsonrpc: '2.0',
-      id: 1,
-      method: 'initialize',
-      params: {
-        processId: process.pid,
-        rootUri: null,
-        capabilities: {}
-      }
-    };
+  it('should respond to initialize request', async () => {
+    serverProcess.stdin.write(initializeMessage(messageId));
+    const initResponse = await waitForResponse(responses, (r) => r.id === messageId);
+    messageId++;
+
+    expect(initResponse.result).toBeDefined();
+    expect(initResponse.result.capabilities).toBeDefined();
+  });
 
-    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 auto-detect the bundled tsdk when none is configured', async () => {
+    serverProcess.stdin.write(initializeMessage(messageId));
+    const initResponse = await waitForResponse(responses, (r) => r.id === messageId);
+    messageId++;
+
+    expect(initResponse.result.initializationOptions.typescript.tsdk).toBe(bundledTsdk);
   });
 
-  it('should accept initialized notification', (done) => {
-    const initializedNotif = {
+  it('should accept initialized notification', async () => {
+    serverProcess.stdin.write(createLSPMessage({
       jsonrpc: '2.0',
       method: 'initialized',
-      params: {}
-    };
-
-    const message = createLSPMessage(initializedNotif);
-    serverProcess.stdin.write(message);
+      params: {},
+    }));
 
     // 通知不需要响应，只需确保不崩溃
-    setTimeout(() => {
-      expect(serverProcess.killed).toBe(false);
-      done();
-    }, 500);
+    await new Promise((resolve) => setTimeout(resolve, 300));
+    expect(serverProcess.exitCode).toBeNull();
   });
 
-  it('should handle shutdown request', (done) => {
-    const shutdownRequest = {
+  it('should handle shutdown request', async () => {
+    serverProcess.stdin.write(createLSPMessage({
       jsonrpc: '2.0',
       id: 99,
       method: 'shutdown',
-      params: null
-    };
+      params: null,
+    }));
+
+    const shutdownResponse = await waitForResponse(responses, (r) => r.id === 99);
+    // 某些 LSP 服务器可能返回 null result
+    expect(shutdownResponse).toBeDefined();
+  });
+});
+
+describe('LSP tsdk fallback', () => {
+  // A tsdk without lib/typescript.js (e.g. the native TypeScript 7 line)
+  // used to hang the real server inside initialize. The wrapper must
+  // substitute the bundled ohos-typescript instead of forwarding it.
+  it('substitutes a broken TSDK env value with the bundled ohos-typescript', async () => {
+    const brokenTsdkDir = mkdtempSync(join(tmpdir(), 'zed-ets-broken-tsdk-'));
+    const { serverProcess, responses } = startWrapper(baseEnv({ TSDK: brokenTsdkDir }));
+
+    try {
+      serverProcess.stdin.write(initializeMessage(1));
+      const initResponse = await waitForResponse(responses, (r) => r.id === 1);
+
+      expect(initResponse.result.initializationOptions.typescript.tsdk).toBe(bundledTsdk);
+    } finally {
+      serverProcess.kill();
+    }
+  });
+
+  it('forwards a valid TSDK unchanged', async () => {
+    const { serverProcess, responses } = startWrapper(baseEnv({ TSDK: bundledTsdk }));
 
-    const message = createLSPMessage(shutdownRequest);
-    serverProcess.stdin.write(message);
+    try {
+      serverProcess.stdin.write(initializeMessage(1));
+      const initResponse = await waitForResponse(responses, (r) => r.id === 1);
 
-    setTimeout(() => {
-      const shutdownResponse = responses.find(r => r.id === 99);
-      // 某些 LSP 服务器可能返回 null result
-      expect(shutdownResponse).toBeDefined();
-      done();
-    }, 1000);
+      expect(initResponse.result.initializationOptions.typescript.tsdk).toBe(bundledTsdk);
+    } finally {
+      serverProcess.kill();
+    }
   });
 });
 
@@ -126,7 +206,7 @@ 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));
@@ -140,7 +220,7 @@ describe('LSP Message Protocol', () => {
     };
     const data = createLSPMessage(mockResponse);
     const parsed = parseLSPResponse(Buffer.from(data));
-    
+
     expect(parsed).toEqual(mockResponse);
   });
 });

package/tests/integration/sdk-initialization.test.js

@@ -0,0 +1,167 @@
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { spawn } from 'node:child_process';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const testDirectory = path.dirname(fileURLToPath(import.meta.url));
+let fixtureDirectory;
+let sdkRoot;
+let hmsSdkRoot;
+let serverProcess;
+let stdoutBuffer = Buffer.alloc(0);
+const responses = [];
+
+function encodeLspMessage(message) {
+  const body = Buffer.from(JSON.stringify(message));
+  return Buffer.concat([
+    Buffer.from(`Content-Length: ${body.length}\r\n\r\n`),
+    body,
+  ]);
+}
+
+function collectLspMessages(chunk) {
+  stdoutBuffer = Buffer.concat([stdoutBuffer, chunk]);
+
+  while (true) {
+    const headerEnd = stdoutBuffer.indexOf('\r\n\r\n');
+    if (headerEnd === -1) return;
+
+    const header = stdoutBuffer.subarray(0, headerEnd).toString('ascii');
+    const lengthMatch = header.match(/Content-Length:\s*(\d+)/i);
+    if (!lengthMatch) return;
+
+    const bodyStart = headerEnd + 4;
+    const bodyLength = Number(lengthMatch[1]);
+    if (stdoutBuffer.length < bodyStart + bodyLength) return;
+
+    const body = stdoutBuffer.subarray(bodyStart, bodyStart + bodyLength);
+    responses.push(JSON.parse(body.toString('utf8')));
+    stdoutBuffer = stdoutBuffer.subarray(bodyStart + bodyLength);
+  }
+}
+
+async function waitForResponse(predicate, timeout = 3000) {
+  const deadline = Date.now() + timeout;
+  while (Date.now() < deadline) {
+    const response = responses.find(predicate);
+    if (response) return response;
+    await new Promise((resolve) => setTimeout(resolve, 25));
+  }
+  throw new Error('Timed out waiting for LSP response');
+}
+
+beforeAll(async () => {
+  fixtureDirectory = await fs.mkdtemp(path.join(os.tmpdir(), 'zed-arkts-deveco-'));
+  sdkRoot = path.join(fixtureDirectory, 'Contents', 'sdk', 'default', 'openharmony');
+  await fs.mkdir(path.join(sdkRoot, 'ets', 'api'), { recursive: true });
+  await fs.mkdir(path.join(sdkRoot, 'ets', 'kits'), { recursive: true });
+  await fs.mkdir(path.join(sdkRoot, 'ets', 'component'), { recursive: true });
+  await fs.mkdir(path.join(sdkRoot, 'ets', 'build-tools', 'ets-loader', 'declarations'), {
+    recursive: true,
+  });
+  await fs.writeFile(
+    path.join(sdkRoot, 'ets', 'build-tools', 'ets-loader', 'tsconfig.json'),
+    '{}\n',
+  );
+  await fs.writeFile(
+    path.join(sdkRoot, 'ets', 'kits', '@kit.AbilityKit.d.ts'),
+    'export declare class UIAbility {}\n',
+  );
+  hmsSdkRoot = path.join(fixtureDirectory, 'Contents', 'sdk', 'default', 'hms');
+  await fs.mkdir(path.join(hmsSdkRoot, 'ets', 'api'), { recursive: true });
+  await fs.mkdir(path.join(hmsSdkRoot, 'ets', 'kits'), { recursive: true });
+  await fs.writeFile(
+    path.join(hmsSdkRoot, 'ets', 'kits', '@kit.TestHmsKit.d.ts'),
+    'export declare const hmsApi: string;\n',
+  );
+  const placeholderSiblingHms = path.join(fixtureDirectory, 'hms');
+  await fs.mkdir(path.join(placeholderSiblingHms, 'ets', 'api'), { recursive: true });
+  await fs.mkdir(path.join(placeholderSiblingHms, 'ets', 'kits'), { recursive: true });
+
+  const wrapperPath = path.join(testDirectory, '..', '..', 'index.js');
+  const mockServerPath = path.join(testDirectory, '..', 'mocks', 'mock-ets-server.js');
+  const tsdk = path.join(testDirectory, '..', '..', 'node_modules', 'ohos-typescript', 'lib');
+  const env = { ...process.env };
+  delete env.ZED_ETS_OHOS_SDK_PATH;
+  delete env.OHOS_SDK_PATH;
+  delete env.HARMONYOS_SDK_HOME;
+  delete env.OPENHARMONY_SDK_HOME;
+  delete env.DEVECO_SDK_HOME;
+  delete env.ZED_ETS_HMS_SDK_PATH;
+  delete env.HMS_SDK_PATH;
+  Object.assign(env, {
+    ETS_LANG_SERVER: mockServerPath,
+    ZED_ETS_TSDK: tsdk,
+    DEVECO_STUDIO_HOME: fixtureDirectory,
+    TMPDIR: fixtureDirectory,
+  });
+
+  serverProcess = spawn(process.execPath, [wrapperPath], {
+    env,
+    stdio: ['pipe', 'pipe', 'pipe'],
+  });
+  serverProcess.stdout.on('data', collectLspMessages);
+});
+
+afterAll(async () => {
+  serverProcess?.kill();
+  await fs.rm(fixtureDirectory, { recursive: true, force: true });
+});
+
+describe('SDK initialization', () => {
+  it('injects the DevEco OpenHarmony SDK into ArkTS initialization', async () => {
+    serverProcess.stdin.write(
+      encodeLspMessage({
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'initialize',
+        params: {
+          processId: process.pid,
+          rootUri: 'file:///tmp/harmony-project',
+          capabilities: {},
+          initializationOptions: {},
+        },
+      }),
+    );
+
+    const response = await waitForResponse((message) => message.id === 1);
+    const initializationOptions = response.result.initializationOptions;
+
+    expect(initializationOptions.ohos.sdkPath).toBe(sdkRoot);
+    expect(initializationOptions.ets.sdkPath).toBe(sdkRoot);
+    expect(initializationOptions.ohos.baseUrl).toBe(path.join(sdkRoot, 'ets'));
+    expect(initializationOptions.ets.hmsPath).toBe(hmsSdkRoot);
+    expect(initializationOptions.ohos.hmsSdkPath).toBe(hmsSdkRoot);
+    expect(initializationOptions.ohos.paths['*']).toContain(
+      path.join(hmsSdkRoot, 'ets', 'kits', '*'),
+    );
+  });
+
+  it('does not infer an HMS SDK from the placeholder OpenHarmony SDK', async () => {
+    serverProcess.stdin.write(
+      encodeLspMessage({
+        jsonrpc: '2.0',
+        id: 2,
+        method: 'initialize',
+        params: {
+          processId: process.pid,
+          rootUri: 'file:///tmp/harmony-project',
+          capabilities: {},
+          initializationOptions: {
+            ohosSdkPath: path.join(fixtureDirectory, 'invalid-openharmony'),
+          },
+        },
+      }),
+    );
+
+    const response = await waitForResponse((message) => message.id === 2);
+    const initializationOptions = response.result.initializationOptions;
+
+    expect(initializationOptions.ets.sdkPath).toBe(
+      path.join(fixtureDirectory, 'zed-ets-empty-ohos-sdk'),
+    );
+    expect(initializationOptions.ets.hmsPath).toBeUndefined();
+  });
+});

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

@@ -91,10 +91,12 @@ struct Test {
           textDocumentSync: 1,
           documentFormattingProvider: true,
           documentRangeFormattingProvider: true
-        }
+        },
+        // Echo what the wrapper forwarded so tests can assert on it.
+        initializationOptions: message.params?.initializationOptions ?? {}
       }
     };
-    
+
     process.send(response);
   }