Modify resolveEnv()

Author: Kartik Raj

src/client/pythonEnvironments/collection/environmentsResolver.ts

@@ -22,8 +22,16 @@ export class PythonEnvsResolver implements ILocator {
         private readonly environmentInfoService: IEnvironmentInfoService,
     ) {}
 
-    public resolveEnv(env: string | PythonEnvInfo): Promise<PythonEnvInfo | undefined> {
-        return this.pythonEnvsReducer.resolveEnv(env);
+    public async resolveEnv(env: string | PythonEnvInfo): Promise<PythonEnvInfo | undefined> {
+        const environment = await this.pythonEnvsReducer.resolveEnv(env);
+        if (!environment) {
+            return undefined;
+        }
+        const interpreterInfo = await this.environmentInfoService.getEnvironmentInfo(environment.executable.filename);
+        if (!interpreterInfo) {
+            return undefined;
+        }
+        return getResolvedEnv(interpreterInfo, environment);
     }
 
     public iterEnvs(query?: QueryForEvent<PythonEnvsChangedEvent>): IPythonEnvsIterator {
@@ -89,7 +97,7 @@ export class PythonEnvsResolver implements ILocator {
         const interpreterInfo = await this.environmentInfoService.getEnvironmentInfo(
             seen[envIndex].executable.filename,
         );
-        if (interpreterInfo && seen[envIndex]) {
+        if (interpreterInfo) {
             const resolvedEnv = getResolvedEnv(interpreterInfo, seen[envIndex]);
             didUpdate.fire({ old: seen[envIndex], new: resolvedEnv });
             seen[envIndex] = resolvedEnv;

src/test/pythonEnvironments/base/common.ts

@@ -4,13 +4,11 @@
 import { Event } from 'vscode';
 import { createDeferred, flattenIterator, iterable, mapToIterator } from '../../../client/common/utils/async';
 import { Architecture } from '../../../client/common/utils/platform';
-import { EMPTY_VERSION, parseBasicVersionInfo } from '../../../client/common/utils/version';
 import {
     PythonEnvInfo,
     PythonEnvKind,
-    PythonReleaseLevel,
-    PythonVersion
 } from '../../../client/pythonEnvironments/base/info';
+import { parseVersion } from '../../../client/pythonEnvironments/base/info/pythonVersion';
 import { IPythonEnvsIterator, Locator, PythonEnvUpdatedEvent, PythonLocatorQuery } from '../../../client/pythonEnvironments/base/locator';
 import { PythonEnvsChangedEvent } from '../../../client/pythonEnvironments/base/watcher';
 
@@ -46,36 +44,6 @@ export function createEnv(
     };
 }
 
-function parseVersion(versionStr: string): PythonVersion {
-    const parsed = parseBasicVersionInfo<PythonVersion>(versionStr);
-    if (!parsed) {
-        if (versionStr === '') {
-            return EMPTY_VERSION as PythonVersion;
-        }
-        throw Error(`invalid version ${versionStr}`);
-    }
-    const { version, after } = parsed;
-    const match = after.match(/^(a|b|rc)(\d+)$/);
-    if (match) {
-        const [, levelStr, serialStr ] = match;
-        let level: PythonReleaseLevel;
-        if (levelStr === 'a') {
-            level = PythonReleaseLevel.Alpha;
-        } else if (levelStr === 'b') {
-            level = PythonReleaseLevel.Beta;
-        } else if (levelStr === 'rc') {
-            level = PythonReleaseLevel.Candidate;
-        } else {
-            throw Error('unreachable!');
-        }
-        version.release = {
-            level,
-            serial: parseInt(serialStr, 10)
-        };
-    }
-    return version;
-}
-
 export function createLocatedEnv(
     location: string,
     versionStr: string,

src/test/pythonEnvironments/collection/environmentsResolver.unit.test.ts

@@ -14,20 +14,28 @@ import { PythonEnvUpdatedEvent } from '../../../client/pythonEnvironments/base/l
 import { PythonEnvsChangedEvent } from '../../../client/pythonEnvironments/base/watcher';
 import { PythonEnvsResolver } from '../../../client/pythonEnvironments/collection/environmentsResolver';
 import * as ExternalDep from '../../../client/pythonEnvironments/common/externalDependencies';
-import {
-    EnvironmentInfoService,
-    IEnvironmentInfoService,
-} from '../../../client/pythonEnvironments/info/environmentInfoService';
+import { EnvironmentInfoService } from '../../../client/pythonEnvironments/info/environmentInfoService';
 import { sleep } from '../../core';
 import { createEnv, getEnvs, SimpleLocator } from '../base/common';
 
 suite('Environments Resolver', () => {
+    /**
+     * Returns the expected environment to be returned by Environment info service
+     */
+    function createExpectedEnvInfo(env: PythonEnvInfo): PythonEnvInfo {
+        const updatedEnv = cloneDeep(env);
+        updatedEnv.version = {
+            ...parseVersion('3.8.3-final'),
+            sysVersion: '3.8.3 (tags/v3.8.3:6f8c832, May 13 2020, 22:37:02) [MSC v.1924 64 bit (AMD64)]',
+        };
+        updatedEnv.executable.filename = env.executable.filename;
+        updatedEnv.executable.sysPrefix = 'path';
+        updatedEnv.arch = Architecture.x64;
+        return updatedEnv;
+    }
     suite('iterEnvs()', () => {
         let stubShellExec: sinon.SinonStub;
-        let envService: IEnvironmentInfoService;
-
         setup(() => {
-            envService = new EnvironmentInfoService();
             stubShellExec = ImportMock.mockFunction(
                 ExternalDep,
                 'shellExecute',
@@ -44,23 +52,14 @@ suite('Environments Resolver', () => {
             stubShellExec.restore();
         });
 
-        function createExpectedEnvInfo(env: PythonEnvInfo): PythonEnvInfo {
-            const updatedEnv = cloneDeep(env);
-            updatedEnv.version = { ...parseVersion('3.8.3-final'), sysVersion: '3.8.3 (tags/v3.8.3:6f8c832, May 13 2020, 22:37:02) [MSC v.1924 64 bit (AMD64)]' };
-            updatedEnv.executable.filename = env.executable.filename;
-            updatedEnv.executable.sysPrefix = 'path';
-            updatedEnv.arch = Architecture.x64;
-            return updatedEnv;
-        }
-
-        test('Iterator only yields as-is', async () => {
+        test('Iterator yields environments as-is', async () => {
             const env1 = createEnv('env1', '3.5.12b1', PythonEnvKind.Venv, path.join('path', 'to', 'exec1'));
             const env2 = createEnv('env2', '3.8.1', PythonEnvKind.Conda, path.join('path', 'to', 'exec2'));
             const env3 = createEnv('env3', '2.7', PythonEnvKind.System, path.join('path', 'to', 'exec3'));
             const env4 = createEnv('env4', '3.9.0rc2', PythonEnvKind.Unknown, path.join('path', 'to', 'exec2'));
             const environmentsToBeIterated = [env1, env2, env3, env4];
-            const pythonEnvManager = new SimpleLocator(environmentsToBeIterated);
-            const reducer = new PythonEnvsResolver(pythonEnvManager, envService);
+            const pythonEnvReducer = new SimpleLocator(environmentsToBeIterated);
+            const reducer = new PythonEnvsResolver(pythonEnvReducer, new EnvironmentInfoService());
 
             const iterator = reducer.iterEnvs();
             const envs = await getEnvs(iterator);
@@ -73,9 +72,9 @@ suite('Environments Resolver', () => {
             const env1 = createEnv('env1', '3.5.12b1', PythonEnvKind.Unknown, path.join('path', 'to', 'exec1'));
             const env2 = createEnv('env2', '3.8.1', PythonEnvKind.Unknown, path.join('path', 'to', 'exec2'));
             const environmentsToBeIterated = [env1, env2];
-            const pythonEnvManager = new SimpleLocator(environmentsToBeIterated);
+            const pythonEnvReducer = new SimpleLocator(environmentsToBeIterated);
             const onUpdatedEvents: (PythonEnvUpdatedEvent | null)[] = [];
-            const reducer = new PythonEnvsResolver(pythonEnvManager, envService);
+            const reducer = new PythonEnvsResolver(pythonEnvReducer, new EnvironmentInfoService());
 
             const iterator = reducer.iterEnvs(); // Act
 
@@ -108,9 +107,9 @@ suite('Environments Resolver', () => {
             const updatedEnv = createEnv('env1', '3.8.1', PythonEnvKind.System, path.join('path', 'to', 'exec'));
             const environmentsToBeIterated = [env];
             const didUpdate = new EventEmitter<PythonEnvUpdatedEvent | null>();
-            const pythonEnvManager = new SimpleLocator(environmentsToBeIterated, { onUpdated: didUpdate.event });
+            const pythonEnvReducer = new SimpleLocator(environmentsToBeIterated, { onUpdated: didUpdate.event });
             const onUpdatedEvents: (PythonEnvUpdatedEvent | null)[] = [];
-            const reducer = new PythonEnvsResolver(pythonEnvManager, envService);
+            const reducer = new PythonEnvsResolver(pythonEnvReducer, new EnvironmentInfoService());
 
             const iterator = reducer.iterEnvs(); // Act
 
@@ -134,43 +133,112 @@ suite('Environments Resolver', () => {
             // Assert
             // The updates can be anything, even the number of updates, but they should lead to the same final state
             const { length } = onUpdatedEvents;
-            assert.deepEqual(onUpdatedEvents[length - 2]?.new, createExpectedEnvInfo(updatedEnv), 'The final update to environment is incorrect');
+            assert.deepEqual(
+                onUpdatedEvents[length - 2]?.new,
+                createExpectedEnvInfo(updatedEnv),
+                'The final update to environment is incorrect',
+            );
             assert.equal(onUpdatedEvents[length - 1], null, 'Last update should be null');
             didUpdate.dispose();
         });
     });
 
     test('onChanged fires iff onChanged from reducer fires', () => {
-        const pythonEnvManager = new SimpleLocator([]);
+        const pythonEnvReducer = new SimpleLocator([]);
         const event1: PythonEnvsChangedEvent = {};
         const event2: PythonEnvsChangedEvent = { kind: PythonEnvKind.Unknown };
         const expected = [event1, event2];
-        const reducer = new PythonEnvsResolver(pythonEnvManager, new EnvironmentInfoService());
+        const reducer = new PythonEnvsResolver(pythonEnvReducer, new EnvironmentInfoService());
 
         const events: PythonEnvsChangedEvent[] = [];
         reducer.onChanged((e) => events.push(e));
 
-        pythonEnvManager.fire(event1);
-        pythonEnvManager.fire(event2);
+        pythonEnvReducer.fire(event1);
+        pythonEnvReducer.fire(event2);
 
         assert.deepEqual(events, expected);
     });
 
-    test('Calls reducer to resolves environments', async () => {
-        const env = createEnv('env1', '3.8', PythonEnvKind.Unknown, path.join('path', 'to', 'exec'));
-        const resolvedEnv = createEnv('env1', '3.8.1', PythonEnvKind.Conda, 'resolved/path/to/exec');
-        const pythonEnvManager = new SimpleLocator([], {
-            resolve: async (e: PythonEnvInfo) => {
-                if (e === env) {
-                    return resolvedEnv;
-                }
-                return undefined;
-            },
+    suite('resolveEnv()', () => {
+        let stubShellExec: sinon.SinonStub;
+        setup(() => {
+            stubShellExec = ImportMock.mockFunction(
+                ExternalDep,
+                'shellExecute',
+                new Promise<ExecutionResult<string>>((resolve) => {
+                    resolve({
+                        stdout:
+                            '{"versionInfo": [3, 8, 3, "final", 0], "sysPrefix": "path", "sysVersion": "3.8.3 (tags/v3.8.3:6f8c832, May 13 2020, 22:37:02) [MSC v.1924 64 bit (AMD64)]", "is64Bit": true}',
+                    });
+                }),
+            );
+        });
+
+        teardown(() => {
+            stubShellExec.restore();
+        });
+
+        test('Calls into reducer to get resolved environment, then calls environnment service to resolve environment further and return it', async () => {
+            const env = createEnv('env1', '3.8', PythonEnvKind.Unknown, path.join('path', 'to', 'exec'));
+            const resolvedEnvReturnedByReducer = createEnv(
+                'env1',
+                '3.8.1',
+                PythonEnvKind.Conda,
+                'resolved/path/to/exec',
+            );
+            const pythonEnvReducer = new SimpleLocator([], {
+                resolve: async (e: PythonEnvInfo) => {
+                    if (e === env) {
+                        return resolvedEnvReturnedByReducer;
+                    }
+                    throw new Error('Incorrect environment sent to the reducer');
+                },
+            });
+            const reducer = new PythonEnvsResolver(pythonEnvReducer, new EnvironmentInfoService());
+
+            const expected = await reducer.resolveEnv(env);
+
+            assert.deepEqual(expected, createExpectedEnvInfo(resolvedEnvReturnedByReducer));
         });
-        const reducer = new PythonEnvsResolver(pythonEnvManager, new EnvironmentInfoService());
 
-        const expected = await reducer.resolveEnv(env);
+        test('If the reducer resolves environment, but fetching interpreter info returns undefined, return undefined', async () => {
+            stubShellExec.returns(
+                new Promise<ExecutionResult<string>>((_resolve, reject) => {
+                    reject();
+                }),
+            );
+            const env = createEnv('env1', '3.8', PythonEnvKind.Unknown, path.join('path', 'to', 'exec'));
+            const resolvedEnvReturnedByReducer = createEnv(
+                'env1',
+                '3.8.1',
+                PythonEnvKind.Conda,
+                'resolved/path/to/exec',
+            );
+            const pythonEnvReducer = new SimpleLocator([], {
+                resolve: async (e: PythonEnvInfo) => {
+                    if (e === env) {
+                        return resolvedEnvReturnedByReducer;
+                    }
+                    throw new Error('Incorrect environment sent to the reducer');
+                },
+            });
+            const reducer = new PythonEnvsResolver(pythonEnvReducer, new EnvironmentInfoService());
+
+            const expected = await reducer.resolveEnv(env);
+
+            assert.deepEqual(expected, undefined);
+        });
 
-        assert.deepEqual(expected, resolvedEnv);
+        test("If the reducer isn't able to resolve environment, return undefined", async () => {
+            const env = createEnv('env', '3.8', PythonEnvKind.Unknown, path.join('path', 'to', 'exec'));
+            const pythonEnvReducer = new SimpleLocator([], {
+                resolve: async () => undefined,
+            });
+            const reducer = new PythonEnvsResolver(pythonEnvReducer, new EnvironmentInfoService());
+
+            const expected = await reducer.resolveEnv(env);
+
+            assert.deepEqual(expected, undefined);
+        });
     });
 });