Use python folder name as name of virtual env (microsoft#2564)

Author: DonJayamanne

news/2 Fixes/2562.md

@@ -0,0 +1 @@
+Use folder name of the Python interpreter as the name of the virtual environment.

src/client/interpreter/interpreterService.ts

@@ -172,7 +172,7 @@ export class InterpreterService implements Disposable, IInterpreterService {
  * @memberof InterpreterService
  */
  public async getDisplayName(info: Partial<PythonInterpreter>, resource?: Uri): Promise<string> {
- const store = this.persistentStateFactory.createGlobalPersistentState<string>(`${info.path}.interpreter.displayName.v1`, undefined, EXPITY_DURATION);
+ const store = this.persistentStateFactory.createGlobalPersistentState<string>(`${info.path}.interpreter.displayName.v2`, undefined, EXPITY_DURATION);
  if (store.value) {
  return store.value;
  }

src/client/interpreter/virtualEnvs/index.ts

@@ -36,22 +36,7 @@ export class VirtualEnvironmentManager implements IVirtualEnvironmentManager {
  return path.basename(workspaceUri.fsPath);
  }
 
- // https://stackoverflow.com/questions/1871549/determine-if-python-is-running-inside-virtualenv
- // hasattr(sys, 'real_prefix') works for virtualenv while
- // '(hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix))' works for venv
- try {
- const processService = await this.processServiceFactory.create();
- const code = 'import sys\nif hasattr(sys, "real_prefix"):\n print("virtualenv")\nelif hasattr(sys, "base_prefix") and sys.base_prefix != sys.prefix:\n print("venv")';
- const output = await processService.exec(pythonPath, ['-c', code]);
- const envName = output.stdout.trim();
- if (envName.length === 0) {
- return '';
- }
- return envName.toUpperCase() === 'VIRTUALENV' ? grandParentDirName : envName;
- } catch {
- // do nothing.
- }
- return '';
+ return grandParentDirName;
  }
  public async getEnvironmentType(pythonPath: string, resource?: Uri): Promise<InterpreterType> {
  const dir = path.dirname(pythonPath);

src/test/interpreters/virtualEnvManager.unit.test.ts

@@ -4,82 +4,78 @@
 // tslint:disable:no-any
 
 import { expect } from 'chai';
-import { Container } from 'inversify';
 import * as path from 'path';
 import * as TypeMoq from 'typemoq';
 import { Uri, WorkspaceFolder } from 'vscode';
 import { IWorkspaceService } from '../../client/common/application/types';
-import { FileSystem } from '../../client/common/platform/fileSystem';
-import { PlatformService } from '../../client/common/platform/platformService';
-import { IFileSystem, IPlatformService } from '../../client/common/platform/types';
-import { BufferDecoder } from '../../client/common/process/decoder';
-import { ProcessService } from '../../client/common/process/proc';
-import { IBufferDecoder, IProcessService, IProcessServiceFactory } from '../../client/common/process/types';
+import { IFileSystem } from '../../client/common/platform/types';
+import { IProcessServiceFactory } from '../../client/common/process/types';
 import { IPipEnvService } from '../../client/interpreter/contracts';
 import { VirtualEnvironmentManager } from '../../client/interpreter/virtualEnvs';
-import { ServiceContainer } from '../../client/ioc/container';
-import { ServiceManager } from '../../client/ioc/serviceManager';
+import { IServiceContainer } from '../../client/ioc/types';
 
 suite('Virtual environment manager', () => {
- let serviceManager: ServiceManager;
- let serviceContainer: ServiceContainer;
  const virtualEnvFolderName = 'virtual Env Folder Name';
  const pythonPath = path.join('a', 'b', virtualEnvFolderName, 'd', 'python');
- setup(async () => {
- const cont = new Container();
- serviceManager = new ServiceManager(cont);
- serviceContainer = new ServiceContainer(cont);
- });
 
- test('Plain Python environment suffix', async () => testSuffix('', ''));
- test('Plain Python environment suffix with workspace Uri', async () => testSuffix('', '', false, Uri.file(path.join('1', '2', '3', '4'))));
- test('Plain Python environment suffix with PipEnv', async () => testSuffix('', 'workspaceName', true, Uri.file(path.join('1', '2', '3', 'workspaceName'))));
- test('Venv environment suffix', async () => testSuffix('venv', 'venv'));
- test('Virtualenv Python environment suffix', async () => testSuffix('virtualenv', virtualEnvFolderName));
+ test('Plain Python environment suffix', async () => testSuffix(virtualEnvFolderName));
+ test('Plain Python environment suffix with workspace Uri', async () => testSuffix(virtualEnvFolderName, false, Uri.file(path.join('1', '2', '3', '4'))));
+ test('Plain Python environment suffix with PipEnv', async () => testSuffix('workspaceName', true, Uri.file(path.join('1', '2', '3', 'workspaceName'))));
 
- test('Run actual virtual env detection code', async () => {
- const processServiceFactory = TypeMoq.Mock.ofType<IProcessServiceFactory>();
- processServiceFactory.setup(f => f.create(TypeMoq.It.isAny())).returns(() => Promise.resolve(new ProcessService(new BufferDecoder(), process.env as any)));
- serviceManager.addSingletonInstance<IProcessServiceFactory>(IProcessServiceFactory, processServiceFactory.object);
- serviceManager.addSingleton<IBufferDecoder>(IBufferDecoder, BufferDecoder);
- serviceManager.addSingleton<IFileSystem>(IFileSystem, FileSystem);
- serviceManager.addSingleton<IPlatformService>(IPlatformService, PlatformService);
- serviceManager.addSingletonInstance<IPipEnvService>(IPipEnvService, TypeMoq.Mock.ofType<IPipEnvService>().object);
+ test('Use environment folder as env name', async () => {
+ const serviceContainer = TypeMoq.Mock.ofType<IServiceContainer>();
+ serviceContainer.setup(s => s.get(TypeMoq.It.isValue(IPipEnvService))).returns(() => TypeMoq.Mock.ofType<IPipEnvService>().object);
  const workspaceService = TypeMoq.Mock.ofType<IWorkspaceService>();
  workspaceService.setup(w => w.hasWorkspaceFolders).returns(() => false);
- serviceManager.addSingletonInstance<IWorkspaceService>(IWorkspaceService, workspaceService.object);
- const venvManager = new VirtualEnvironmentManager(serviceContainer);
+ serviceContainer.setup(s => s.get(TypeMoq.It.isValue(IWorkspaceService))).returns(() => workspaceService.object);
+
+ const venvManager = new VirtualEnvironmentManager(serviceContainer.object);
+ const name = await venvManager.getEnvironmentName(pythonPath);
+
+ expect(name).to.be.equal(virtualEnvFolderName);
+ });
+
+ test('Use workspacec name as env name', async () => {
+ const serviceContainer = TypeMoq.Mock.ofType<IServiceContainer>();
+ const pipEnvService = TypeMoq.Mock.ofType<IPipEnvService>();
+ pipEnvService
+ .setup(p => p.isRelatedPipEnvironment(TypeMoq.It.isAny(), TypeMoq.It.isValue(pythonPath)))
+ .returns(() => Promise.resolve(true))
+ .verifiable(TypeMoq.Times.once());
+ serviceContainer.setup(s => s.get(TypeMoq.It.isValue(IProcessServiceFactory))).returns(() => TypeMoq.Mock.ofType<IProcessServiceFactory>().object);
+ serviceContainer.setup(s => s.get(TypeMoq.It.isValue(IPipEnvService))).returns(() => pipEnvService.object);
+ serviceContainer.setup(s => s.get(TypeMoq.It.isValue(IFileSystem))).returns(() => TypeMoq.Mock.ofType<IFileSystem>().object);
+ const workspaceUri = Uri.file(path.join('root', 'sub', 'wkspace folder'));
+ const workspaceFolder: WorkspaceFolder = { name: 'wkspace folder', index: 0, uri: workspaceUri };
+ const workspaceService = TypeMoq.Mock.ofType<IWorkspaceService>();
+ workspaceService.setup(w => w.hasWorkspaceFolders).returns(() => true);
+ workspaceService.setup(w => w.workspaceFolders).returns(() => [workspaceFolder]);
+ serviceContainer.setup(s => s.get(TypeMoq.It.isValue(IWorkspaceService))).returns(() => workspaceService.object);
+
+ const venvManager = new VirtualEnvironmentManager(serviceContainer.object);
  const name = await venvManager.getEnvironmentName(pythonPath);
- const result = name === '' || name === 'venv' || name === 'virtualenv';
- expect(result).to.be.equal(true, 'Running venv detection code failed.');
+
+ expect(name).to.be.equal(path.basename(workspaceUri.fsPath));
+ pipEnvService.verifyAll();
  });
 
- async function testSuffix(virtualEnvProcOutput: string, expectedEnvName: string, isPipEnvironment: boolean = false, resource?: Uri) {
- const processService = TypeMoq.Mock.ofType<IProcessService>();
- const processServiceFactory = TypeMoq.Mock.ofType<IProcessServiceFactory>();
- processService.setup((x: any) => x.then).returns(() => undefined);
- processServiceFactory.setup(f => f.create(TypeMoq.It.isAny())).returns(() => Promise.resolve(processService.object));
- serviceManager.addSingletonInstance<IProcessServiceFactory>(IProcessServiceFactory, processServiceFactory.object);
- serviceManager.addSingletonInstance<IFileSystem>(IFileSystem, TypeMoq.Mock.ofType<IFileSystem>().object);
+ async function testSuffix(expectedEnvName: string, isPipEnvironment: boolean = false, resource?: Uri) {
+ const serviceContainer = TypeMoq.Mock.ofType<IServiceContainer>();
+ serviceContainer.setup(s => s.get(TypeMoq.It.isValue(IProcessServiceFactory))).returns(() => TypeMoq.Mock.ofType<IProcessServiceFactory>().object);
+ serviceContainer.setup(s => s.get(TypeMoq.It.isValue(IFileSystem))).returns(() => TypeMoq.Mock.ofType<IFileSystem>().object);
  const pipEnvService = TypeMoq.Mock.ofType<IPipEnvService>();
  pipEnvService.setup(w => w.isRelatedPipEnvironment(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => Promise.resolve(isPipEnvironment));
- serviceManager.addSingletonInstance<IPipEnvService>(IPipEnvService, pipEnvService.object);
+ serviceContainer.setup(s => s.get(TypeMoq.It.isValue(IPipEnvService))).returns(() => pipEnvService.object);
  const workspaceService = TypeMoq.Mock.ofType<IWorkspaceService>();
  workspaceService.setup(w => w.hasWorkspaceFolders).returns(() => false);
  if (resource) {
  const workspaceFolder = TypeMoq.Mock.ofType<WorkspaceFolder>();
  workspaceFolder.setup(w => w.uri).returns(() => resource);
  workspaceService.setup(w => w.getWorkspaceFolder(TypeMoq.It.isAny())).returns(() => workspaceFolder.object);
  }
- serviceManager.addSingletonInstance<IWorkspaceService>(IWorkspaceService, workspaceService.object);
+ serviceContainer.setup(s => s.get(TypeMoq.It.isValue(IWorkspaceService))).returns(() => workspaceService.object);
 
- const venvManager = new VirtualEnvironmentManager(serviceContainer);
- processService
- .setup(x => x.exec(pythonPath, TypeMoq.It.isAny()))
- .returns(() => Promise.resolve({
- stdout: virtualEnvProcOutput,
- stderr: ''
- }));
+ const venvManager = new VirtualEnvironmentManager(serviceContainer.object);
 
  const name = await venvManager.getEnvironmentName(pythonPath, resource);
  expect(name).to.be.equal(expectedEnvName, 'Virtual envrironment name suffix is incorrect.');