test: add unit tests for isNativeAvailable in nativeWorker.ts (#235)

Co-authored-by: google-labs-jules[bot] <161369871+google-labs-jules[bot]@users.noreply.github.com>

Author: zknpr

src/nativeWorker.ts

@@ -14,6 +14,8 @@ import * as fs from 'fs';
 import { spawn, ChildProcess } from 'child_process';
 import * as v8 from 'node:v8';
 
+import { uiKindToString } from './helpers';
+
 import type { TelemetryReporter } from '@vscode/extension-telemetry';
 import type { DatabaseConnectionBundle } from './connectionTypes';
 import type {
@@ -393,6 +395,9 @@ export function mapRowsByName<T = Record<string, CellValue>>(result: NativeQuery
  * @returns True if native binary is available
  */
 export async function isNativeAvailable(extensionPath: string): Promise<boolean> {
+  if (uiKindToString(vsc.env.uiKind) === 'web') {
+    return false;
+  }
   return (await getNativeBinaryPath(extensionPath)) !== null;
 }
 

tests/unit/mocks/vscode.ts

@@ -129,7 +129,12 @@ export const mockVscode = {
         uriScheme: 'vscode',
         appName: 'VS Code',
         language: 'en',
-        remoteName: undefined as string | undefined
+        remoteName: undefined as string | undefined,
+        uiKind: 2 // Desktop
+    },
+    UIKind: {
+        Desktop: 2,
+        Web: 1
     },
     ColorThemeKind: {
         Light: 1,

tests/unit/nativeWorker.test.ts

@@ -0,0 +1,103 @@
+import './vscode_mock_setup';
+import { describe, it, mock, afterEach, beforeEach } from 'node:test';
+import assert from 'node:assert';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as vscode from 'vscode';
+import { isNativeAvailable } from '../../src/nativeWorker';
+
+describe('isNativeAvailable', () => {
+    let originalPlatform: string;
+    let originalArch: string;
+
+    beforeEach(() => {
+        originalPlatform = process.platform;
+        originalArch = process.arch;
+        vscode.env.uiKind = 2; // Desktop
+    });
+
+    afterEach(() => {
+        Object.defineProperty(process, 'platform', { value: originalPlatform });
+        Object.defineProperty(process, 'arch', { value: originalArch });
+        vscode.env.uiKind = 2; // Desktop
+        mock.restoreAll();
+    });
+
+    it('should return false when UI kind is web', async () => {
+        vscode.env.uiKind = 1; // Web
+
+        const result = await isNativeAvailable('/ext/path');
+        assert.strictEqual(result, false);
+    });
+
+    it('should return false when platform is unsupported', async () => {
+        Object.defineProperty(process, 'platform', { value: 'freebsd' });
+
+        const result = await isNativeAvailable('/ext/path');
+        assert.strictEqual(result, false);
+    });
+
+    it('should return false when binary does not exist', async () => {
+        Object.defineProperty(process, 'platform', { value: 'linux' });
+        Object.defineProperty(process, 'arch', { value: 'x64' });
+
+        mock.method(fs.promises, 'access', async () => {
+            throw new Error('ENOENT');
+        });
+
+        const result = await isNativeAvailable('/ext/path');
+        assert.strictEqual(result, false);
+    });
+
+    it('should return true when binary exists on linux x64', async () => {
+        Object.defineProperty(process, 'platform', { value: 'linux' });
+        Object.defineProperty(process, 'arch', { value: 'x64' });
+
+        const accessMock = mock.method(fs.promises, 'access', async () => {});
+
+        const result = await isNativeAvailable('/ext/path');
+        assert.strictEqual(result, true);
+
+        const expectedPath = path.join('/ext/path', 'natives', 'x86_64-linux-gnu', 'tjs');
+        assert.strictEqual(accessMock.mock.calls[0].arguments[0], expectedPath);
+    });
+
+    it('should return true when binary exists on linux arm64', async () => {
+        Object.defineProperty(process, 'platform', { value: 'linux' });
+        Object.defineProperty(process, 'arch', { value: 'arm64' });
+
+        const accessMock = mock.method(fs.promises, 'access', async () => {});
+
+        const result = await isNativeAvailable('/ext/path');
+        assert.strictEqual(result, true);
+
+        const expectedPath = path.join('/ext/path', 'natives', 'aarch64-linux-gnu', 'tjs');
+        assert.strictEqual(accessMock.mock.calls[0].arguments[0], expectedPath);
+    });
+
+    it('should return true when binary exists on darwin arm64', async () => {
+        Object.defineProperty(process, 'platform', { value: 'darwin' });
+        Object.defineProperty(process, 'arch', { value: 'arm64' });
+
+        const accessMock = mock.method(fs.promises, 'access', async () => {});
+
+        const result = await isNativeAvailable('/ext/path');
+        assert.strictEqual(result, true);
+
+        const expectedPath = path.join('/ext/path', 'natives', 'aarch64-macos', 'tjs');
+        assert.strictEqual(accessMock.mock.calls[0].arguments[0], expectedPath);
+    });
+
+    it('should return true when binary exists on win32', async () => {
+        Object.defineProperty(process, 'platform', { value: 'win32' });
+        Object.defineProperty(process, 'arch', { value: 'x64' });
+
+        const accessMock = mock.method(fs.promises, 'access', async () => {});
+
+        const result = await isNativeAvailable('/ext/path');
+        assert.strictEqual(result, true);
+
+        const expectedPath = path.join('/ext/path', 'natives', 'x86_64-windows', 'tjs.exe');
+        assert.strictEqual(accessMock.mock.calls[0].arguments[0], expectedPath);
+    });
+});