Fix where non-virtual env was treated as a virtualenv (#2616)

Fixes #1351

Author: DonJayamanne

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

@@ -6,7 +6,6 @@ import { IProcessServiceFactory } from '../../../common/process/types';
 import { IConfigurationService } from '../../../common/types';
 import { IServiceContainer } from '../../../ioc/types';
 import { IInterpreterHelper, InterpreterType, PythonInterpreter } from '../../contracts';
-import { IVirtualEnvironmentManager } from '../../virtualEnvs/types';
 import { CacheableLocatorService } from './cacheableLocatorService';
 
 /**
@@ -20,7 +19,6 @@ export class CurrentPathService extends CacheableLocatorService {
     private readonly fs: IFileSystem;
 
     public constructor(
-        @inject(IVirtualEnvironmentManager) private virtualEnvMgr: IVirtualEnvironmentManager,
         @inject(IInterpreterHelper) private helper: IInterpreterHelper,
         @inject(IProcessServiceFactory) private readonly processServiceFactory: IProcessServiceFactory,
         @inject(IServiceContainer) serviceContainer: IServiceContainer
@@ -60,28 +58,23 @@ export class CurrentPathService extends CacheableLocatorService {
             .then(listOfInterpreters => _.flatten(listOfInterpreters))
             .then(interpreters => interpreters.filter(item => item.length > 0))
             // tslint:disable-next-line:promise-function-async
-            .then(interpreters => Promise.all(interpreters.map(interpreter => this.getInterpreterDetails(interpreter, resource))))
+            .then(interpreters => Promise.all(interpreters.map(interpreter => this.getInterpreterDetails(interpreter))))
             .then(interpreters => interpreters.filter(item => !!item).map(item => item!));
     }
 
     /**
      * Return the information about the identified interpreter binary.
      */
-    private async getInterpreterDetails(interpreter: string, resource?: Uri): Promise<PythonInterpreter | undefined> {
-        return Promise.all([
-            this.helper.getInterpreterInformation(interpreter),
-            this.virtualEnvMgr.getEnvironmentName(interpreter, resource),
-            this.virtualEnvMgr.getEnvironmentType(interpreter, resource)
-        ]).
-            then(([details, virtualEnvName, type]) => {
+    private async getInterpreterDetails(interpreter: string): Promise<PythonInterpreter | undefined> {
+        return this.helper.getInterpreterInformation(interpreter)
+            .then(details => {
                 if (!details) {
                     return;
                 }
                 return {
                     ...(details as PythonInterpreter),
-                    envName: virtualEnvName,
                     path: interpreter,
-                    type: type ? type : InterpreterType.Unknown
+                    type: details.type ? details.type : InterpreterType.Unknown
                 };
             });
     }

src/test/interpreters/currentPathService.unit.test.ts

@@ -49,16 +49,13 @@ suite('Interpreters CurrentPath Service', () => {
         serviceContainer.setup(c => c.get(TypeMoq.It.isValue(IPersistentStateFactory), TypeMoq.It.isAny())).returns(() => persistentStateFactory.object);
         serviceContainer.setup(c => c.get(TypeMoq.It.isValue(IConfigurationService), TypeMoq.It.isAny())).returns(() => configurationService.object);
 
-        currentPathService = new CurrentPathService(virtualEnvironmentManager.object, interpreterHelper.object, procServiceFactory.object, serviceContainer.object);
+        currentPathService = new CurrentPathService(interpreterHelper.object, procServiceFactory.object, serviceContainer.object);
     });
 
     test('Interpreters that do not exist on the file system are not excluded from the list', async () => {
         // Specific test for 1305
         const version = 'mockVersion';
-        const envName = 'mockEnvName';
         interpreterHelper.setup(v => v.getInterpreterInformation(TypeMoq.It.isAny())).returns(() => Promise.resolve({ version }));
-        virtualEnvironmentManager.setup(v => v.getEnvironmentName(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => Promise.resolve(envName));
-        virtualEnvironmentManager.setup(v => v.getEnvironmentType(TypeMoq.It.isAny(), TypeMoq.It.isAny())).returns(() => Promise.resolve(InterpreterType.VirtualEnv));
 
         const execArgs = ['-c', 'import sys;print(sys.executable)'];
         pythonSettings.setup(p => p.pythonPath).returns(() => 'root:Python');
@@ -75,8 +72,9 @@ suite('Interpreters CurrentPath Service', () => {
         const interpreters = await currentPathService.getInterpreters();
         processService.verifyAll();
         fileSystem.verifyAll();
+
         expect(interpreters).to.be.of.length(2);
-        expect(interpreters).to.deep.include({ version, envName, path: 'c:/root:python', type: InterpreterType.VirtualEnv });
-        expect(interpreters).to.deep.include({ version, envName, path: 'c:/python3', type: InterpreterType.VirtualEnv });
+        expect(interpreters).to.deep.include({ version, path: 'c:/root:python', type: InterpreterType.Unknown });
+        expect(interpreters).to.deep.include({ version, path: 'c:/python3', type: InterpreterType.Unknown });
     });
 });