Add copy of Python Extension API service for functional tests

src/client/api/pythonApi.ts

@@ -134,8 +134,4 @@ export class InterpreterService implements IInterpreterService {
     public getInterpreterDetails(pythonPath: string, resource?: Uri): Promise<undefined | PythonEnvironment> {
         return this.api.getApi().then((api) => api.getInterpreterDetails(pythonPath, resource));
     }
-
-    public initialize(): void {
-        // Noop.
-    }
 }

src/client/interpreter/contracts.ts

@@ -7,5 +7,4 @@ export interface IInterpreterService {
     getInterpreters(resource?: Uri): Promise<PythonEnvironment[]>;
     getActiveInterpreter(resource?: Uri): Promise<PythonEnvironment | undefined>;
     getInterpreterDetails(pythonPath: string, resource?: Uri): Promise<undefined | PythonEnvironment>;
-    initialize(): void;
 }

src/test/datascience/dataScienceIocContainer.ts

@@ -304,10 +304,17 @@ import {
 } from '../../client/datascience/types';
 import { ProtocolParser } from '../../client/debugger/extension/helpers/protocolParser';
 import { IProtocolParser } from '../../client/debugger/extension/types';
+import { IEnvironmentActivationService } from '../../client/interpreter/activation/types';
+import { IInterpreterSelector } from '../../client/interpreter/configuration/types';
 import { IInterpreterService } from '../../client/interpreter/contracts';
+import { IWindowsStoreInterpreter } from '../../client/interpreter/locators/types';
 import { PythonEnvironment } from '../../client/pythonEnvironments/info';
 import { CodeExecutionHelper } from '../../client/terminals/codeExecution/helper';
 import { ICodeExecutionHelper } from '../../client/terminals/types';
+import { EnvironmentActivationService } from '../interpreters/envActivation';
+import { InterpreterService } from '../interpreters/interpreterService';
+import { InterpreterSelector } from '../interpreters/selector';
+import { WindowsStoreInterpreter } from '../interpreters/winStoreInterpreter';
 import { MockOutputChannel } from '../mockClasses';
 import { UnitTestIocContainer } from '../testing/serviceRegistry';
 import { MockCommandManager } from './mockCommandManager';
@@ -905,6 +912,16 @@ export class DataScienceIocContainer extends UnitTestIocContainer {
             this.serviceManager.addSingletonInstance<KernelService>(KernelService, instance(this.kernelServiceMock));
         } else {
             this.serviceManager.addSingleton<IInstaller>(IInstaller, ProductInstaller);
+            this.serviceManager.addSingleton<IInterpreterService>(IInterpreterService, InterpreterService);
+            this.serviceManager.addSingleton<IInterpreterSelector>(IInterpreterSelector, InterpreterSelector);
+            this.serviceManager.addSingleton<IWindowsStoreInterpreter>(
+                IWindowsStoreInterpreter,
+                WindowsStoreInterpreter
+            );
+            this.serviceManager.addSingleton<IEnvironmentActivationService>(
+                IEnvironmentActivationService,
+                EnvironmentActivationService
+            );
             this.serviceManager.addSingleton<KernelService>(KernelService, KernelService);
             this.serviceManager.addSingleton<IProcessServiceFactory>(IProcessServiceFactory, ProcessServiceFactory);
             this.serviceManager.addSingleton<IPythonExecutionFactory>(IPythonExecutionFactory, PythonExecutionFactory);
@@ -975,7 +992,7 @@ export class DataScienceIocContainer extends UnitTestIocContainer {
         when(this.applicationShell.onDidChangeWindowState).thenReturn(eventCallback);
         when(this.applicationShell.withProgress(anything(), anything())).thenCall((_o, c) => c());
 
-        const interpreterManager = this.serviceContainer.get<IInterpreterService>(IInterpreterService);
+        const interpreterManager = this.serviceContainer.get<InterpreterService>(IInterpreterService);
         interpreterManager.initialize();
 
         if (this.mockJupyter) {

src/test/datascience/notebook.functional.test.ts

@@ -560,12 +560,6 @@ suite('DataScience notebook tests', () => {
                     // Rewire our data we use to search for processes
                     @injectable()
                     class EmptyInterpreterService implements IInterpreterService {
-                        public get hasInterpreters(): Promise<boolean> {
-                            return Promise.resolve(true);
-                        }
-                        public onDidChangeInterpreterConfiguration(): Disposable {
-                            return { dispose: noop };
-                        }
                         public onDidChangeInterpreter(
                             _listener: (e: void) => any,
                             _thisArgs?: any,
@@ -577,27 +571,12 @@ suite('DataScience notebook tests', () => {
                         public getInterpreters(_resource?: Uri): Promise<PythonEnvironment[]> {
                             return Promise.resolve([]);
                         }
-                        public autoSetInterpreter(): Promise<void> {
-                            throw new Error('Method not implemented');
-                        }
                         public getActiveInterpreter(_resource?: Uri): Promise<PythonEnvironment | undefined> {
                             return Promise.resolve(undefined);
                         }
                         public getInterpreterDetails(_pythonPath: string, _resoure?: Uri): Promise<PythonEnvironment> {
                             throw new Error('Method not implemented');
                         }
-                        public refresh(_resource: Uri): Promise<void> {
-                            throw new Error('Method not implemented');
-                        }
-                        public initialize(): void {
-                            throw new Error('Method not implemented');
-                        }
-                        public getDisplayName(_interpreter: Partial<PythonEnvironment>): Promise<string> {
-                            throw new Error('Method not implemented');
-                        }
-                        public shouldAutoSetInterpreter(): Promise<boolean> {
-                            throw new Error('Method not implemented');
-                        }
                     }
                     ioc.serviceManager.rebind<IInterpreterService>(IInterpreterService, EmptyInterpreterService);
                     await createNotebook(undefined, undefined, true);

src/test/interpreters/envActivation.ts

@@ -0,0 +1,19 @@
+import { injectable } from 'inversify';
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { getActivatedEnvVariables } from '.';
+import { Resource } from '../../client/common/types';
+import { IEnvironmentActivationService } from '../../client/interpreter/activation/types';
+import { PythonEnvironment } from '../../client/pythonEnvironments/info';
+
+@injectable()
+export class EnvironmentActivationService implements IEnvironmentActivationService {
+    public getActivatedEnvironmentVariables(
+        _resource: Resource,
+        interpreter?: PythonEnvironment,
+        _allowExceptions?: boolean
+    ): Promise<NodeJS.ProcessEnv | undefined> {
+        return getActivatedEnvVariables(interpreter?.path || process.env.CI_PYTHON_PATH || 'python');
+    }
+}

src/test/interpreters/index.ts

@@ -2,38 +2,95 @@
 // Licensed under the MIT License.
 
 import * as path from 'path';
+import '../../client/common/extensions';
 import { traceError } from '../../client/common/logger';
 import { BufferDecoder } from '../../client/common/process/decoder';
 import { PythonEnvInfo } from '../../client/common/process/internal/scripts';
 import { ProcessService } from '../../client/common/process/proc';
 import { PythonEnvironment } from '../../client/pythonEnvironments/info';
+import { getOSType, OSType } from '../common';
 import { EXTENSION_ROOT_DIR_FOR_TESTS } from '../constants';
 import { isCondaEnvironment } from './condaLocator';
 import { getCondaEnvironment, getCondaFile, isCondaAvailable } from './condaService';
 import { parsePythonVersion } from './pythonVersion';
 
 const SCRIPTS_DIR = path.join(EXTENSION_ROOT_DIR_FOR_TESTS, 'pythonFiles');
+const defaultShells = {
+    [OSType.Windows]: 'cmd',
+    [OSType.OSX]: 'bash',
+    [OSType.Linux]: 'bash',
+    [OSType.Unknown]: undefined
+};
 
+const defaultShell = defaultShells[getOSType()];
+
+const interpreterInfoCache = new Map<string, Promise<PythonEnvironment | undefined>>();
 export async function getInterpreterInfo(pythonPath: string): Promise<PythonEnvironment | undefined> {
-    const cli = await getPythonCli(pythonPath);
-    const processService = new ProcessService(new BufferDecoder());
-    const argv = [...cli, path.join(SCRIPTS_DIR, 'interpreterInfo.py')];
-    // Concat these together to make a set of quoted strings
-    const quoted = argv.reduce((p, c) => (p ? `${p} "${c}"` : `"${c.replace('\\', '\\\\')}"`), '');
+    if (interpreterInfoCache.has(pythonPath)) {
+        return interpreterInfoCache.get(pythonPath);
+    }
+
+    const promise = (async () => {
+        try {
+            const cli = await getPythonCli(pythonPath);
+            const processService = new ProcessService(new BufferDecoder());
+            const argv = [...cli, path.join(SCRIPTS_DIR, 'interpreterInfo.py').fileToCommandArgument()];
+            const cmd = argv.reduce((p, c) => (p ? `${p} "${c}"` : `"${c.replace('\\', '/')}"`), '');
+            const result = await processService.shellExec(cmd, {
+                timeout: 1_500,
+                env: process.env,
+                shell: defaultShell
+            });
+            if (result.stderr && result.stderr.length) {
+                traceError(`Failed to parse interpreter information for ${argv} stderr: ${result.stderr}`);
+                return;
+            }
+            const json: PythonEnvInfo = JSON.parse(result.stdout.trim());
+            const rawVersion = `${json.versionInfo.slice(0, 3).join('.')}-${json.versionInfo[3]}`;
+            return {
+                path: pythonPath,
+                version: parsePythonVersion(rawVersion),
+                sysVersion: json.sysVersion,
+                sysPrefix: json.sysPrefix
+            };
+        } catch (ex) {
+            traceError('Failed to get Activated env Variables');
+            return undefined;
+        }
+    })();
+    interpreterInfoCache.set(pythonPath, promise);
+    return promise;
+}
 
-    const result = await processService.shellExec(quoted, { timeout: 1_500 });
-    if (result.stderr) {
-        traceError(`Failed to parse interpreter information for ${argv} stderr: ${result.stderr}`);
-        return;
+const envVariables = new Map<string, Promise<NodeJS.ProcessEnv | undefined>>();
+export async function getActivatedEnvVariables(pythonPath: string): Promise<NodeJS.ProcessEnv | undefined> {
+    if (envVariables.has(pythonPath)) {
+        return envVariables.get(pythonPath);
     }
-    const json: PythonEnvInfo = JSON.parse(result.stdout.trim());
-    const rawVersion = `${json.versionInfo.slice(0, 3).join('.')}-${json.versionInfo[3]}`;
-    return {
-        path: pythonPath,
-        version: parsePythonVersion(rawVersion),
-        sysVersion: json.sysVersion,
-        sysPrefix: json.sysPrefix
-    };
+    const promise = (async () => {
+        const cli = await getPythonCli(pythonPath);
+        const processService = new ProcessService(new BufferDecoder());
+        const argv = [...cli, path.join(SCRIPTS_DIR, 'printEnvVariables.py')];
+        const cmd = argv.reduce((p, c) => (p ? `${p} "${c}"` : `"${c.replace('\\', '/')}"`), '');
+        const result = await processService.shellExec(cmd, {
+            timeout: 1_500,
+            maxBuffer: 1000 * 1000,
+            throwOnStdErr: false,
+            env: process.env,
+            shell: defaultShell
+        });
+        if (result.stderr && result.stderr.length) {
+            traceError(`Failed to parse interpreter information for ${argv} stderr: ${result.stderr}`);
+            return;
+        }
+        try {
+            return JSON.parse(result.stdout.trim());
+        } catch (ex) {
+            traceError(`Failed to parse interpreter information for ${argv}`, ex);
+        }
+    })();
+    envVariables.set(pythonPath, promise);
+    return promise;
 }
 
 async function getPythonCli(pythonPath: string) {
@@ -55,11 +112,11 @@ async function getPythonCli(pythonPath: string) {
             }
 
             const condaFile = await getCondaFile();
-            return [condaFile, ...runArgs, 'python'];
+            return [condaFile.fileToCommandArgument(), ...runArgs, 'python'];
         } catch {
             // Noop.
         }
         traceError('Using Conda Interpreter, but no conda');
     }
-    return [pythonPath];
+    return [pythonPath.fileToCommandArgument()];
 }

src/test/interpreters/interpreterService.ts

@@ -1,3 +1,4 @@
+import { injectable } from 'inversify';
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
@@ -6,12 +7,23 @@ import { getInterpreterInfo } from '.';
 import { IInterpreterService } from '../../client/interpreter/contracts';
 import { PythonEnvironment } from '../../client/pythonEnvironments/info';
 
+@injectable()
 export class InterpreterService implements IInterpreterService {
     public readonly onDidChangeInterpreter = new EventEmitter<void>().event;
 
-    public async getInterpreters(resource?: Uri): Promise<PythonEnvironment[]> {
-        const active = await this.getActiveInterpreter(resource);
-        return active ? [active] : [];
+    public async getInterpreters(_resource?: Uri): Promise<PythonEnvironment[]> {
+        const [active, globalInterpreter] = await Promise.all([
+            getInterpreterInfo(process.env.CI_PYTHON_PATH as string),
+            getInterpreterInfo('python')
+        ]);
+        const interpreters: PythonEnvironment[] = [];
+        if (active) {
+            interpreters.push(active);
+        }
+        if (globalInterpreter) {
+            interpreters.push(globalInterpreter);
+        }
+        return interpreters;
     }
 
     public async getActiveInterpreter(_resource?: Uri): Promise<PythonEnvironment | undefined> {

src/test/interpreters/selector.ts

@@ -0,0 +1,23 @@
+import { inject, injectable } from 'inversify';
+import { Resource } from '../../client/common/types';
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { IInterpreterQuickPickItem, IInterpreterSelector } from '../../client/interpreter/configuration/types';
+import { IInterpreterService } from '../../client/interpreter/contracts';
+
+@injectable()
+export class InterpreterSelector implements IInterpreterSelector {
+    constructor(@inject(IInterpreterService) private readonly interpreterService: IInterpreterService) {}
+
+    public async getSuggestions(resource: Resource): Promise<IInterpreterQuickPickItem[]> {
+        const interpreters = await this.interpreterService.getInterpreters(resource);
+        return interpreters.map((item) => ({
+            label: item.displayName || item.path,
+            description: item.displayName || item.path,
+            detail: item.displayName || item.path,
+            path: item.path,
+            interpreter: item
+        }));
+    }
+}

src/test/interpreters/winStoreInterpreter.ts

@@ -0,0 +1,24 @@
+import { injectable } from 'inversify';
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { IWindowsStoreInterpreter } from '../../client/interpreter/locators/types';
+
+@injectable()
+export class WindowsStoreInterpreter implements IWindowsStoreInterpreter {
+    /**
+     * Whether this is a Windows Store/App Interpreter.
+     *
+     * @param {string} pythonPath
+     * @returns {boolean}
+     * @memberof WindowsStoreInterpreter
+     */
+    public async isWindowsStoreInterpreter(pythonPath: string): Promise<boolean> {
+        const pythonPathToCompare = pythonPath.toUpperCase().replace(/\//g, '\\');
+        return (
+            pythonPathToCompare.includes('\\Microsoft\\WindowsApps\\'.toUpperCase()) ||
+            pythonPathToCompare.includes('\\Program Files\\WindowsApps\\'.toUpperCase()) ||
+            pythonPathToCompare.includes('\\Microsoft\\WindowsApps\\PythonSoftwareFoundation'.toUpperCase())
+        );
+    }
+}