Get pyenv root directory from central location (microsoft#2619)

For microsoft#1351

Author: DonJayamanne

src/client/interpreter/contracts.ts

@@ -22,7 +22,7 @@ export interface IKnownSearchPathsForInterpreters {
 }
 export const IVirtualEnvironmentsSearchPathProvider = Symbol('IVirtualEnvironmentsSearchPathProvider');
 export interface IVirtualEnvironmentsSearchPathProvider {
- getSearchPaths(resource?: Uri): string[];
+ getSearchPaths(resource?: Uri): Promise<string[]>;
 }
 export const IInterpreterLocatorService = Symbol('IInterpreterLocatorService');
 

src/client/interpreter/locators/services/baseVirtualEnvService.ts

@@ -29,7 +29,7 @@ export class BaseVirtualEnvService extends CacheableLocatorService {
  return this.suggestionsFromKnownVenvs(resource);
  }
  private async suggestionsFromKnownVenvs(resource?: Uri) {
- const searchPaths = this.searchPathsProvider.getSearchPaths(resource);
+ const searchPaths = await this.searchPathsProvider.getSearchPaths(resource);
  return Promise.all(searchPaths.map(dir => this.lookForInterpretersInVenvs(dir, resource)))
  .then(listOfInterpreters => _.flatten(listOfInterpreters));
  }

src/client/interpreter/locators/services/globalVirtualEnvService.ts

@@ -7,9 +7,10 @@ import { inject, injectable, named } from 'inversify';
 import * as os from 'os';
 import * as path from 'path';
 import { Uri } from 'vscode';
-import { IConfigurationService, ICurrentProcess } from '../../../common/types';
+import { IConfigurationService } from '../../../common/types';
 import { IServiceContainer } from '../../../ioc/types';
 import { IVirtualEnvironmentsSearchPathProvider } from '../../contracts';
+import { IVirtualEnvironmentManager } from '../../virtualEnvs/types';
 import { BaseVirtualEnvService } from './baseVirtualEnvService';
 
 @injectable()
@@ -23,31 +24,24 @@ export class GlobalVirtualEnvService extends BaseVirtualEnvService {
 
 @injectable()
 export class GlobalVirtualEnvironmentsSearchPathProvider implements IVirtualEnvironmentsSearchPathProvider {
- private readonly process: ICurrentProcess;
  private readonly config: IConfigurationService;
+ private readonly virtualEnvMgr: IVirtualEnvironmentManager;
 
  constructor(@inject(IServiceContainer) serviceContainer: IServiceContainer) {
- this.process = serviceContainer.get<ICurrentProcess>(ICurrentProcess);
  this.config = serviceContainer.get<IConfigurationService>(IConfigurationService);
+ this.virtualEnvMgr = serviceContainer.get<IVirtualEnvironmentManager>(IVirtualEnvironmentManager);
  }
 
- public getSearchPaths(resource?: Uri): string[] {
+ public async getSearchPaths(resource?: Uri): Promise<string[]> {
  const homedir = os.homedir();
  const venvFolders = this.config.getSettings(resource).venvFolders;
  const folders = venvFolders.map(item => path.join(homedir, item));
 
  // tslint:disable-next-line:no-string-literal
- const pyenvRoot = this.process.env['PYENV_ROOT'];
+ const pyenvRoot = await this.virtualEnvMgr.getPyEnvRoot(resource);
  if (pyenvRoot) {
  folders.push(pyenvRoot);
  folders.push(path.join(pyenvRoot, 'versions'));
- } else {
- // Check if .pyenv/versions is in the list
- const pyenvVersions = path.join('.pyenv', 'versions');
- if (venvFolders.indexOf('.pyenv') >= 0 && venvFolders.indexOf(pyenvVersions) < 0) {
- // if .pyenv is in the list, but .pyenv/versions is not, add it.
- folders.push(path.join(homedir, pyenvVersions));
- }
  }
  return folders;
  }

src/client/interpreter/locators/services/workspaceVirtualEnvService.ts

@@ -28,7 +28,7 @@ export class WorkspaceVirtualEnvironmentsSearchPathProvider implements IVirtualE
  public constructor(@inject(IServiceContainer) private serviceContainer: IServiceContainer) {
 
  }
- public getSearchPaths(resource?: Uri): string[] {
+ public async getSearchPaths(resource?: Uri): Promise<string[]> {
  const configService = this.serviceContainer.get<IConfigurationService>(IConfigurationService);
  const paths: string[] = [];
  const venvPath = configService.getSettings(resource).venvPath;

src/client/interpreter/virtualEnvs/index.ts

@@ -4,9 +4,11 @@
 import { inject, injectable } from 'inversify';
 import * as path from 'path';
 import { Uri } from 'vscode';
+import { noop } from '../../../utils/misc';
 import { IWorkspaceService } from '../../common/application/types';
 import { IFileSystem } from '../../common/platform/types';
 import { IProcessServiceFactory } from '../../common/process/types';
+import { ICurrentProcess, IPathUtils } from '../../common/types';
 import { IServiceContainer } from '../../ioc/types';
 import { InterpreterType, IPipEnvService } from '../contracts';
 import { IVirtualEnvironmentManager } from './types';
@@ -20,7 +22,7 @@ export class VirtualEnvironmentManager implements IVirtualEnvironmentManager {
  private fs: IFileSystem;
  private pyEnvRoot?: string;
  private workspaceService: IWorkspaceService;
- constructor(@inject(IServiceContainer) serviceContainer: IServiceContainer) {
+ constructor(@inject(IServiceContainer) private readonly serviceContainer: IServiceContainer) {
  this.processServiceFactory = serviceContainer.get<IProcessServiceFactory>(IProcessServiceFactory);
  this.fs = serviceContainer.get<IFileSystem>(IFileSystem);
  this.pipEnvService = serviceContainer.get<IPipEnvService>(IPipEnvService);
@@ -66,16 +68,27 @@ export class VirtualEnvironmentManager implements IVirtualEnvironmentManager {
  // Lets not try to determine whether this is a conda environment or not.
  return InterpreterType.Unknown;
  }
- private async getPyEnvRoot(resource?: Uri): Promise<string | undefined> {
+ public async getPyEnvRoot(resource?: Uri): Promise<string | undefined> {
  if (this.pyEnvRoot) {
  return this.pyEnvRoot;
  }
+
+ const currentProccess = this.serviceContainer.get<ICurrentProcess>(ICurrentProcess);
+ const pyenvRoot = currentProccess.env.PYENV_ROOT;
+ if (pyenvRoot) {
+ return this.pyEnvRoot = pyenvRoot;
+ }
+
  try {
  const processService = await this.processServiceFactory.create(resource);
  const output = await processService.exec('pyenv', ['root']);
- return this.pyEnvRoot = output.stdout.trim();
+ if (output.stdout.trim().length > 0) {
+ return this.pyEnvRoot = output.stdout.trim();
+ }
  } catch {
- return;
+ noop();
  }
+ const pathUtils = this.serviceContainer.get<IPathUtils>(IPathUtils);
+ return this.pyEnvRoot = path.join(pathUtils.home, '.pyenv');
  }
 }

src/client/interpreter/virtualEnvs/types.ts

@@ -8,4 +8,5 @@ export const IVirtualEnvironmentManager = Symbol('VirtualEnvironmentManager');
 export interface IVirtualEnvironmentManager {
  getEnvironmentName(pythonPath: string, resource?: Uri): Promise<string>;
  getEnvironmentType(pythonPath: string, resource?: Uri): Promise<InterpreterType>;
+ getPyEnvRoot(resource?: Uri): Promise<string | undefined>;
 }

src/test/interpreters/venv.unit.test.ts

@@ -10,9 +10,9 @@ import { Uri, WorkspaceFolder } from 'vscode';
 import { IWorkspaceService } from '../../client/common/application/types';
 import { PlatformService } from '../../client/common/platform/platformService';
 import { IConfigurationService, ICurrentProcess, IPythonSettings } from '../../client/common/types';
-import { EnvironmentVariables } from '../../client/common/variables/types';
 import { GlobalVirtualEnvironmentsSearchPathProvider } from '../../client/interpreter/locators/services/globalVirtualEnvService';
 import { WorkspaceVirtualEnvironmentsSearchPathProvider } from '../../client/interpreter/locators/services/workspaceVirtualEnvService';
+import { IVirtualEnvironmentManager } from '../../client/interpreter/virtualEnvs/types';
 import { ServiceContainer } from '../../client/ioc/container';
 import { ServiceManager } from '../../client/ioc/serviceManager';
 
@@ -23,6 +23,7 @@ suite('Virtual environments', () => {
  let config: TypeMoq.IMock<IConfigurationService>;
  let workspace: TypeMoq.IMock<IWorkspaceService>;
  let process: TypeMoq.IMock<ICurrentProcess>;
+ let virtualEnvMgr: TypeMoq.IMock<IVirtualEnvironmentManager>;
 
  setup(() => {
  const cont = new Container();
@@ -33,39 +34,36 @@ suite('Virtual environments', () => {
  config = TypeMoq.Mock.ofType<IConfigurationService>();
  workspace = TypeMoq.Mock.ofType<IWorkspaceService>();
  process = TypeMoq.Mock.ofType<ICurrentProcess>();
+ virtualEnvMgr = TypeMoq.Mock.ofType<IVirtualEnvironmentManager>();
 
  config.setup(x => x.getSettings(TypeMoq.It.isAny())).returns(() => settings.object);
 
  serviceManager.addSingletonInstance<IConfigurationService>(IConfigurationService, config.object);
  serviceManager.addSingletonInstance<IWorkspaceService>(IWorkspaceService, workspace.object);
  serviceManager.addSingletonInstance<ICurrentProcess>(ICurrentProcess, process.object);
+ serviceManager.addSingletonInstance<IVirtualEnvironmentManager>(IVirtualEnvironmentManager, virtualEnvMgr.object);
  });
 
  test('Global search paths', async () => {
  const pathProvider = new GlobalVirtualEnvironmentsSearchPathProvider(serviceContainer);
 
  const homedir = os.homedir();
- const folders = ['Envs', '.virtualenvs', '.pyenv'];
+ const folders = ['Envs', '.virtualenvs'];
  settings.setup(x => x.venvFolders).returns(() => folders);
-
- let paths = pathProvider.getSearchPaths();
+ virtualEnvMgr.setup(v => v.getPyEnvRoot(TypeMoq.It.isAny())).returns(() => Promise.resolve(undefined));
+ let paths = await pathProvider.getSearchPaths();
  let expected = folders.map(item => path.join(homedir, item));
- expected.push(path.join(homedir, '.pyenv', 'versions'));
 
+ virtualEnvMgr.verifyAll();
  expect(paths).to.deep.equal(expected, 'Global search folder list is incorrect.');
 
- const envMap: EnvironmentVariables = {};
- process.setup(x => x.env).returns(() => envMap);
-
- const customFolder = path.join(homedir, 'some_folder');
- // tslint:disable-next-line:no-string-literal
- envMap['PYENV_ROOT'] = customFolder;
- paths = pathProvider.getSearchPaths();
+ virtualEnvMgr.reset();
+ virtualEnvMgr.setup(v => v.getPyEnvRoot(TypeMoq.It.isAny())).returns(() => Promise.resolve('pyenv_path'));
+ paths = await pathProvider.getSearchPaths();
 
- expected = folders.map(item => path.join(homedir, item));
- expected.push(customFolder);
- expected.push(path.join(customFolder, 'versions'));
- expect(paths).to.deep.equal(expected, 'PYENV_ROOT not resolved correctly.');
+ virtualEnvMgr.verifyAll();
+ expected = expected.concat(['pyenv_path', path.join('pyenv_path', 'versions')]);
+ expect(paths).to.deep.equal(expected, 'pyenv path not resolved correctly.');
  });
 
  test('Workspace search paths', async () => {
@@ -81,7 +79,7 @@ suite('Virtual environments', () => {
  workspace.setup(x => x.workspaceFolders).returns(() => [wsRoot.object, folder1.object]);
 
  const pathProvider = new WorkspaceVirtualEnvironmentsSearchPathProvider(serviceContainer);
- const paths = pathProvider.getSearchPaths(Uri.file(''));
+ const paths = await pathProvider.getSearchPaths(Uri.file(''));
 
  const homedir = os.homedir();
  const isWindows = new PlatformService();

src/test/interpreters/virtualEnvs/index.unit.test.ts

@@ -0,0 +1,87 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+'use strict';
+
+// tslint:disable:no-any
+
+import { expect } from 'chai';
+import * as path from 'path';
+import * as TypeMoq from 'typemoq';
+import { IProcessService, IProcessServiceFactory } from '../../../client/common/process/types';
+import { ICurrentProcess, IPathUtils } from '../../../client/common/types';
+import { VirtualEnvironmentManager } from '../../../client/interpreter/virtualEnvs';
+import { IVirtualEnvironmentManager } from '../../../client/interpreter/virtualEnvs/types';
+import { IServiceContainer } from '../../../client/ioc/types';
+
+suite('Virtual Environment Manager', () => {
+ let process: TypeMoq.IMock<ICurrentProcess>;
+ let processService: TypeMoq.IMock<IProcessService>;
+ let pathUtils: TypeMoq.IMock<IPathUtils>;
+ let virtualEnvMgr: IVirtualEnvironmentManager;
+
+ setup(() => {
+ const serviceContainer = TypeMoq.Mock.ofType<IServiceContainer>();
+ process = TypeMoq.Mock.ofType<ICurrentProcess>();
+ processService = TypeMoq.Mock.ofType<IProcessService>();
+ const processFactory = TypeMoq.Mock.ofType<IProcessServiceFactory>();
+ pathUtils = TypeMoq.Mock.ofType<IPathUtils>();
+
+ processService.setup(p => (p as any).then).returns(() => undefined);
+ processFactory.setup(p => p.create(TypeMoq.It.isAny())).returns(() => Promise.resolve(processService.object));
+ serviceContainer.setup(c => c.get(TypeMoq.It.isValue(IProcessServiceFactory))).returns(() => processFactory.object);
+ serviceContainer.setup(c => c.get(TypeMoq.It.isValue(ICurrentProcess))).returns(() => process.object);
+ serviceContainer.setup(c => c.get(TypeMoq.It.isValue(IPathUtils))).returns(() => pathUtils.object);
+
+ virtualEnvMgr = new VirtualEnvironmentManager(serviceContainer.object);
+ });
+
+ test('Get PyEnv Root from PYENV_ROOT', async () => {
+ process
+ .setup(p => p.env)
+ .returns(() => { return { PYENV_ROOT: 'yes' }; })
+ .verifiable(TypeMoq.Times.once());
+
+ const pyenvRoot = await virtualEnvMgr.getPyEnvRoot();
+
+ process.verifyAll();
+ expect(pyenvRoot).to.equal('yes');
+ });
+
+ test('Get PyEnv Root from current PYENV_ROOT', async () => {
+ process
+ .setup(p => p.env)
+ .returns(() => { return {}; })
+ .verifiable(TypeMoq.Times.once());
+ processService
+ .setup(p => p.exec(TypeMoq.It.isValue('pyenv'), TypeMoq.It.isValue(['root'])))
+ .returns(() => Promise.resolve({ stdout: 'PROC' }))
+ .verifiable(TypeMoq.Times.once());
+
+ const pyenvRoot = await virtualEnvMgr.getPyEnvRoot();
+
+ process.verifyAll();
+ processService.verifyAll();
+ expect(pyenvRoot).to.equal('PROC');
+ });
+
+ test('Get default PyEnv Root path', async () => {
+ process
+ .setup(p => p.env)
+ .returns(() => { return {}; })
+ .verifiable(TypeMoq.Times.once());
+ processService
+ .setup(p => p.exec(TypeMoq.It.isValue('pyenv'), TypeMoq.It.isValue(['root'])))
+ .returns(() => Promise.resolve({ stdout: '', stderr: 'err' }))
+ .verifiable(TypeMoq.Times.once());
+ pathUtils
+ .setup(p => p.home)
+ .returns(() => 'HOME')
+ .verifiable(TypeMoq.Times.once());
+ const pyenvRoot = await virtualEnvMgr.getPyEnvRoot();
+
+ process.verifyAll();
+ processService.verifyAll();
+ expect(pyenvRoot).to.equal(path.join('HOME', '.pyenv'));
+ });
+});