Add unit tests for getUvPythonPath and getAvailablePythonVersions

karthiknadig · karthiknadig · commit 76aca521d7b7 · 2026-02-08T11:06:14.000-08:00
Address PR review comment: cover JSON parsing, version prefix
matching, empty output, chunked stdout, process errors, and
non-zero exit code scenarios.
diff --git a/src/test/managers/builtin/uvPythonInstaller.unit.test.ts b/src/test/managers/builtin/uvPythonInstaller.unit.test.ts
@@ -1,6 +1,7 @@
 import assert from 'assert';
 import * as sinon from 'sinon';
 import { LogOutputChannel } from 'vscode';
+import * as childProcessApis from '../../../common/childProcess.apis';
 import { UvInstallStrings } from '../../../common/localize';
 import * as persistentState from '../../../common/persistentState';
 import { EventNames } from '../../../common/telemetry/constants';
@@ -9,11 +10,15 @@ import * as windowApis from '../../../common/window.apis';
 import * as helpers from '../../../managers/builtin/helpers';
 import {
     clearDontAskAgain,
+    getAvailablePythonVersions,
+    getUvPythonPath,
     isDontAskAgainSet,
     promptInstallPythonViaUv,
     UV_INSTALL_PYTHON_DONT_ASK_KEY,
+    UvPythonVersion,
 } from '../../../managers/builtin/uvPythonInstaller';
 import { createMockLogOutputChannel } from '../../mocks/helper';
+import { MockChildProcess } from '../../mocks/mockChildProcess';
 
 suite('uvPythonInstaller - promptInstallPythonViaUv', () => {
     let mockLog: LogOutputChannel;
@@ -173,3 +178,341 @@ suite('uvPythonInstaller - isDontAskAgainSet and clearDontAskAgain', () => {
 // NOTE: Installation functions (installUv, installPythonViaUv, installPythonWithUv) require
 // VS Code's Task API which cannot be fully mocked in unit tests.
 // These should be tested via integration tests in a real VS Code environment.
+
+/**
+ * Helper to build a UvPythonVersion object for testing.
+ */
+function makeUvPythonVersion(overrides: Partial<UvPythonVersion> & { version: string }): UvPythonVersion {
+    const parts = overrides.version.split('.').map(Number);
+    return {
+        key: overrides.key ?? `cpython-${overrides.version}`,
+        version: overrides.version,
+        version_parts: overrides.version_parts ?? { major: parts[0], minor: parts[1], patch: parts[2] ?? 0 },
+        path: overrides.path ?? null,
+        url: overrides.url ?? null,
+        os: overrides.os ?? 'linux',
+        variant: overrides.variant ?? 'default',
+        implementation: overrides.implementation ?? 'cpython',
+        arch: overrides.arch ?? 'x86_64',
+    };
+}
+
+suite('uvPythonInstaller - getUvPythonPath', () => {
+    let spawnStub: sinon.SinonStub;
+
+    setup(() => {
+        spawnStub = sinon.stub(childProcessApis, 'spawnProcess');
+    });
+
+    teardown(() => {
+        sinon.restore();
+    });
+
+    test('should return the latest installed Python path when no version specified', async () => {
+        const versions: UvPythonVersion[] = [
+            makeUvPythonVersion({ version: '3.13.1', path: '/usr/bin/python3.13' }),
+            makeUvPythonVersion({ version: '3.12.8', path: '/usr/bin/python3.12' }),
+        ];
+
+        const mockProcess = new MockChildProcess('uv', [
+            'python',
+            'list',
+            '--only-installed',
+            '--managed-python',
+            '--output-format',
+            'json',
+        ]);
+        spawnStub.returns(mockProcess);
+
+        const resultPromise = getUvPythonPath();
+
+        setTimeout(() => {
+            mockProcess.stdout?.emit('data', JSON.stringify(versions));
+            mockProcess.emit('exit', 0, null);
+        }, 10);
+
+        const result = await resultPromise;
+
+        assert.strictEqual(result, '/usr/bin/python3.13', 'Should return the first (latest) installed Python');
+    });
+
+    test('should return matching Python path when version is specified', async () => {
+        const versions: UvPythonVersion[] = [
+            makeUvPythonVersion({ version: '3.13.1', path: '/usr/bin/python3.13' }),
+            makeUvPythonVersion({ version: '3.12.8', path: '/usr/bin/python3.12' }),
+        ];
+
+        const mockProcess = new MockChildProcess('uv', [
+            'python',
+            'list',
+            '--only-installed',
+            '--managed-python',
+            '--output-format',
+            'json',
+        ]);
+        spawnStub.returns(mockProcess);
+
+        const resultPromise = getUvPythonPath('3.12');
+
+        setTimeout(() => {
+            mockProcess.stdout?.emit('data', JSON.stringify(versions));
+            mockProcess.emit('exit', 0, null);
+        }, 10);
+
+        const result = await resultPromise;
+
+        assert.strictEqual(result, '/usr/bin/python3.12', 'Should return the matching version');
+    });
+
+    test('should return undefined when specified version is not found', async () => {
+        const versions: UvPythonVersion[] = [makeUvPythonVersion({ version: '3.13.1', path: '/usr/bin/python3.13' })];
+
+        const mockProcess = new MockChildProcess('uv', [
+            'python',
+            'list',
+            '--only-installed',
+            '--managed-python',
+            '--output-format',
+            'json',
+        ]);
+        spawnStub.returns(mockProcess);
+
+        const resultPromise = getUvPythonPath('3.11');
+
+        setTimeout(() => {
+            mockProcess.stdout?.emit('data', JSON.stringify(versions));
+            mockProcess.emit('exit', 0, null);
+        }, 10);
+
+        const result = await resultPromise;
+
+        assert.strictEqual(result, undefined, 'Should return undefined when version not found');
+    });
+
+    test('should return undefined when no Pythons are installed', async () => {
+        const mockProcess = new MockChildProcess('uv', [
+            'python',
+            'list',
+            '--only-installed',
+            '--managed-python',
+            '--output-format',
+            'json',
+        ]);
+        spawnStub.returns(mockProcess);
+
+        const resultPromise = getUvPythonPath();
+
+        setTimeout(() => {
+            mockProcess.stdout?.emit('data', JSON.stringify([]));
+            mockProcess.emit('exit', 0, null);
+        }, 10);
+
+        const result = await resultPromise;
+
+        assert.strictEqual(result, undefined, 'Should return undefined for empty versions list');
+    });
+
+    test('should return undefined when process exits with non-zero code', async () => {
+        const mockProcess = new MockChildProcess('uv', [
+            'python',
+            'list',
+            '--only-installed',
+            '--managed-python',
+            '--output-format',
+            'json',
+        ]);
+        spawnStub.returns(mockProcess);
+
+        const resultPromise = getUvPythonPath();
+
+        setTimeout(() => {
+            mockProcess.emit('exit', 1, null);
+        }, 10);
+
+        const result = await resultPromise;
+
+        assert.strictEqual(result, undefined, 'Should return undefined on non-zero exit');
+    });
+
+    test('should return undefined when process emits error', async () => {
+        const mockProcess = new MockChildProcess('uv', [
+            'python',
+            'list',
+            '--only-installed',
+            '--managed-python',
+            '--output-format',
+            'json',
+        ]);
+        spawnStub.returns(mockProcess);
+
+        const resultPromise = getUvPythonPath();
+
+        setTimeout(() => {
+            mockProcess.emit('error', new Error('spawn uv ENOENT'));
+        }, 10);
+
+        const result = await resultPromise;
+
+        assert.strictEqual(result, undefined, 'Should return undefined on process error');
+    });
+
+    test('should return undefined when output is invalid JSON', async () => {
+        const mockProcess = new MockChildProcess('uv', [
+            'python',
+            'list',
+            '--only-installed',
+            '--managed-python',
+            '--output-format',
+            'json',
+        ]);
+        spawnStub.returns(mockProcess);
+
+        const resultPromise = getUvPythonPath();
+
+        setTimeout(() => {
+            mockProcess.stdout?.emit('data', 'not valid json{{{');
+            mockProcess.emit('exit', 0, null);
+        }, 10);
+
+        const result = await resultPromise;
+
+        assert.strictEqual(result, undefined, 'Should return undefined on JSON parse failure');
+    });
+
+    test('should skip versions without a path', async () => {
+        const versions: UvPythonVersion[] = [
+            makeUvPythonVersion({ version: '3.13.1', path: null }),
+            makeUvPythonVersion({ version: '3.12.8', path: '/usr/bin/python3.12' }),
+        ];
+
+        const mockProcess = new MockChildProcess('uv', [
+            'python',
+            'list',
+            '--only-installed',
+            '--managed-python',
+            '--output-format',
+            'json',
+        ]);
+        spawnStub.returns(mockProcess);
+
+        const resultPromise = getUvPythonPath();
+
+        setTimeout(() => {
+            mockProcess.stdout?.emit('data', JSON.stringify(versions));
+            mockProcess.emit('exit', 0, null);
+        }, 10);
+
+        const result = await resultPromise;
+
+        assert.strictEqual(result, '/usr/bin/python3.12', 'Should skip entries with null path');
+    });
+
+    test('should handle chunked stdout data', async () => {
+        const versions: UvPythonVersion[] = [makeUvPythonVersion({ version: '3.13.1', path: '/usr/bin/python3.13' })];
+        const fullJson = JSON.stringify(versions);
+        const mid = Math.floor(fullJson.length / 2);
+
+        const mockProcess = new MockChildProcess('uv', [
+            'python',
+            'list',
+            '--only-installed',
+            '--managed-python',
+            '--output-format',
+            'json',
+        ]);
+        spawnStub.returns(mockProcess);
+
+        const resultPromise = getUvPythonPath();
+
+        setTimeout(() => {
+            mockProcess.stdout?.emit('data', fullJson.slice(0, mid));
+            mockProcess.stdout?.emit('data', fullJson.slice(mid));
+            mockProcess.emit('exit', 0, null);
+        }, 10);
+
+        const result = await resultPromise;
+
+        assert.strictEqual(result, '/usr/bin/python3.13', 'Should correctly reassemble chunked data');
+    });
+});
+
+suite('uvPythonInstaller - getAvailablePythonVersions', () => {
+    let spawnStub: sinon.SinonStub;
+
+    setup(() => {
+        spawnStub = sinon.stub(childProcessApis, 'spawnProcess');
+    });
+
+    teardown(() => {
+        sinon.restore();
+    });
+
+    test('should return all versions from uv python list', async () => {
+        const versions: UvPythonVersion[] = [
+            makeUvPythonVersion({ version: '3.13.1', path: '/usr/bin/python3.13' }),
+            makeUvPythonVersion({ version: '3.12.8', path: null }),
+        ];
+
+        const mockProcess = new MockChildProcess('uv', ['python', 'list', '--output-format', 'json']);
+        spawnStub.returns(mockProcess);
+
+        const resultPromise = getAvailablePythonVersions();
+
+        setTimeout(() => {
+            mockProcess.stdout?.emit('data', JSON.stringify(versions));
+            mockProcess.emit('exit', 0, null);
+        }, 10);
+
+        const result = await resultPromise;
+
+        assert.strictEqual(result.length, 2, 'Should return all versions');
+        assert.strictEqual(result[0].version, '3.13.1');
+        assert.strictEqual(result[1].version, '3.12.8');
+    });
+
+    test('should return empty array on process error', async () => {
+        const mockProcess = new MockChildProcess('uv', ['python', 'list', '--output-format', 'json']);
+        spawnStub.returns(mockProcess);
+
+        const resultPromise = getAvailablePythonVersions();
+
+        setTimeout(() => {
+            mockProcess.emit('error', new Error('spawn uv ENOENT'));
+        }, 10);
+
+        const result = await resultPromise;
+
+        assert.deepStrictEqual(result, [], 'Should return empty array on error');
+    });
+
+    test('should return empty array on non-zero exit code', async () => {
+        const mockProcess = new MockChildProcess('uv', ['python', 'list', '--output-format', 'json']);
+        spawnStub.returns(mockProcess);
+
+        const resultPromise = getAvailablePythonVersions();
+
+        setTimeout(() => {
+            mockProcess.emit('exit', 1, null);
+        }, 10);
+
+        const result = await resultPromise;
+
+        assert.deepStrictEqual(result, [], 'Should return empty array on non-zero exit');
+    });
+
+    test('should return empty array on invalid JSON output', async () => {
+        const mockProcess = new MockChildProcess('uv', ['python', 'list', '--output-format', 'json']);
+        spawnStub.returns(mockProcess);
+
+        const resultPromise = getAvailablePythonVersions();
+
+        setTimeout(() => {
+            mockProcess.stdout?.emit('data', '{{invalid json');
+            mockProcess.emit('exit', 0, null);
+        }, 10);
+
+        const result = await resultPromise;
+
+        assert.deepStrictEqual(result, [], 'Should return empty array on JSON parse failure');
+    });
+});
