microsoft · DonJayamanne · Jan 3, 2018 · Nov 3, 2017 · Nov 9, 2017 · Nov 9, 2017
diff --git a/src/client/common/process/pythonToolService.ts b/src/client/common/process/pythonToolService.ts
@@ -0,0 +1,40 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { inject, injectable } from 'inversify';
+import { Uri } from 'vscode';
+import { IServiceContainer } from '../../ioc/types';
+import { ExecutionInfo } from '../types';
+import { IEnvironmentVariablesProvider } from '../variables/types';
+import { ExecutionResult, IProcessService, IPythonExecutionFactory, IPythonToolExecutionService, ObservableExecutionResult, SpawnOptions } from './types';
+
+@injectable()
+export class PythonToolExecutionService implements IPythonToolExecutionService {
+    constructor( @inject(IServiceContainer) private serviceContainer: IServiceContainer) { }
+    public async execObservable(executionInfo: ExecutionInfo, options: SpawnOptions, resource: Uri): Promise<ObservableExecutionResult<string>> {
+        if (options.env) {
+            throw new Error('Environment variables are not supported');
+        }
+        if (executionInfo.moduleName && executionInfo.moduleName.length > 0) {
+            const pythonExecutionService = await this.serviceContainer.get<IPythonExecutionFactory>(IPythonExecutionFactory).create(resource);
+            return pythonExecutionService.execModuleObservable(executionInfo.moduleName, executionInfo.args, options);
+        } else {
+            const env = await this.serviceContainer.get<IEnvironmentVariablesProvider>(IEnvironmentVariablesProvider).getEnvironmentVariables(resource);
+            const processService = this.serviceContainer.get<IProcessService>(IProcessService);
+            return processService.execObservable(executionInfo.execPath!, executionInfo.args, { ...options, env });
+        }
+    }
+    public async exec(executionInfo: ExecutionInfo, options: SpawnOptions, resource: Uri): Promise<ExecutionResult<string>> {
+        if (options.env) {
+            throw new Error('Environment variables are not supported');
+        }
+        if (executionInfo.moduleName && executionInfo.moduleName.length > 0) {
+            const pythonExecutionService = await this.serviceContainer.get<IPythonExecutionFactory>(IPythonExecutionFactory).create(resource);
+            return pythonExecutionService.execModule(executionInfo.moduleName!, executionInfo.args, options);
+        } else {
+            const env = await this.serviceContainer.get<IEnvironmentVariablesProvider>(IEnvironmentVariablesProvider).getEnvironmentVariables(resource);
+            const processService = this.serviceContainer.get<IProcessService>(IProcessService);
+            return processService.exec(executionInfo.execPath!, executionInfo.args, { ...options, env });
+        }
+    }
+}
diff --git a/src/client/common/process/serviceRegistry.ts b/src/client/common/process/serviceRegistry.ts
@@ -5,10 +5,12 @@ import { IServiceManager } from '../../ioc/types';
 import { BufferDecoder } from './decoder';
 import { ProcessService } from './proc';
 import { PythonExecutionFactory } from './pythonExecutionFactory';
-import { IBufferDecoder, IProcessService, IPythonExecutionFactory } from './types';
+import { PythonToolExecutionService } from './pythonToolService';
+import { IBufferDecoder, IProcessService, IPythonExecutionFactory, IPythonToolExecutionService } from './types';
 
 export function registerTypes(serviceManager: IServiceManager) {
     serviceManager.addSingleton<IBufferDecoder>(IBufferDecoder, BufferDecoder);
     serviceManager.addSingleton<IProcessService>(IProcessService, ProcessService);
     serviceManager.addSingleton<IPythonExecutionFactory>(IPythonExecutionFactory, PythonExecutionFactory);
+    serviceManager.addSingleton<IPythonToolExecutionService>(IPythonToolExecutionService, PythonToolExecutionService);
 }
diff --git a/src/client/common/process/types.ts b/src/client/common/process/types.ts
@@ -4,6 +4,7 @@
 import { ChildProcess, SpawnOptions as ChildProcessSpawnOptions } from 'child_process';
 import * as Rx from 'rxjs';
 import { CancellationToken, Uri } from 'vscode';
+import { ExecutionInfo } from '../types';
 import { EnvironmentVariables } from '../variables/types';
 
 export const IBufferDecoder = Symbol('IBufferDecoder');
@@ -69,3 +70,10 @@ export class StdErrError extends Error {
 export interface IExecutionEnvironmentVariablesService {
     getEnvironmentVariables(resource?: Uri): Promise<EnvironmentVariables | undefined>;
 }
+
+export const IPythonToolExecutionService = Symbol('IPythonToolRunnerService');
+
+export interface IPythonToolExecutionService {
+    execObservable(executionInfo: ExecutionInfo, options: SpawnOptions, resource: Uri): Promise<ObservableExecutionResult<string>>;
+    exec(executionInfo: ExecutionInfo, options: SpawnOptions, resource: Uri): Promise<ExecutionResult<string>>;
+}
diff --git a/src/client/formatters/baseFormatter.ts b/src/client/formatters/baseFormatter.ts
@@ -4,6 +4,7 @@ import * as vscode from 'vscode';
 import { OutputChannel, TextEdit, Uri } from 'vscode';
 import { STANDARD_OUTPUT_CHANNEL } from '../common/constants';
 import { isNotInstalledError } from '../common/helpers';
+import { IPythonToolExecutionService } from '../common/process/types';
 import { IProcessService, IPythonExecutionFactory } from '../common/process/types';
 import { IInstaller, IOutputChannel, Product } from '../common/types';
 import { IEnvironmentVariablesProvider } from '../common/variables/types';
@@ -53,21 +54,11 @@ export abstract class BaseFormatter {
             return [];
         }
 
-        let executionPromise: Promise<string>;
         const executionInfo = this.helper.getExecutionInfo(this.product, args, document.uri);
-        // Check if required to run as a module or executable.
-        if (executionInfo.moduleName) {
-            executionPromise = this.serviceContainer.get<IPythonExecutionFactory>(IPythonExecutionFactory).create(document.uri)
-                .then(pythonExecutionService => pythonExecutionService.execModule(executionInfo.moduleName!, executionInfo.args.concat([filePath]), { cwd, throwOnStdErr: true, token }))
-                .then(output => output.stdout);
-        } else {
-            const executionService = this.serviceContainer.get<IProcessService>(IProcessService);
-            executionPromise = this.serviceContainer.get<IEnvironmentVariablesProvider>(IEnvironmentVariablesProvider).getEnvironmentVariables(document.uri)
-                .then(env => executionService.exec(executionInfo.execPath!, executionInfo.args.concat([filePath]), { cwd, env, throwOnStdErr: true, token }))
-                .then(output => output.stdout);
-        }
-
-        const promise = executionPromise
+        executionInfo.args.push(filePath);
+        const pythonToolsExecutionService = this.serviceContainer.get<IPythonToolExecutionService>(IPythonToolExecutionService);
+        const promise = pythonToolsExecutionService.exec(executionInfo, { cwd, throwOnStdErr: true, token }, document.uri)
+            .then(output => output.stdout)
             .then(data => {
                 if (token && token.isCancellationRequested) {
                     return [] as TextEdit[];

diff --git a/src/client/linters/baseLinter.ts b/src/client/linters/baseLinter.ts
@@ -1,8 +1,9 @@
 import * as path from 'path';
-import { CancellationToken, OutputChannel, TextDocument, Uri } from 'vscode';
 import * as vscode from 'vscode';
+import { CancellationToken, OutputChannel, TextDocument, Uri } from 'vscode';
 import { IPythonSettings, PythonSettings } from '../common/configSettings';
 import '../common/extensions';
+import { IPythonToolExecutionService } from '../common/process/types';
 import { ExecutionResult, IProcessService, IPythonExecutionFactory } from '../common/process/types';
 import { ExecutionInfo, IInstaller, ILogger, Product } from '../common/types';
 import { IEnvironmentVariablesProvider } from '../common/variables/types';
@@ -117,19 +118,9 @@ export abstract class BaseLinter {
     protected async run(args: string[], document: vscode.TextDocument, cancellation: vscode.CancellationToken, regEx: string = REGEX): Promise<ILintMessage[]> {
         const executionInfo = this.helper.getExecutionInfo(this.product, args, document.uri);
         const cwd = this.getWorkspaceRootPath(document);
-        let executionPromise: Promise<ExecutionResult<string>>;
-
-        // Check if required to run as a module or executable.
-        if (executionInfo.moduleName) {
-            const pythonExecutionService = await this.serviceContainer.get<IPythonExecutionFactory>(IPythonExecutionFactory).create(document.uri);
-            executionPromise = pythonExecutionService.execModule(executionInfo.moduleName!, executionInfo.args, { cwd, mergeStdOutErr: true, token: cancellation });
-        } else {
-            const env = await this.serviceContainer.get<IEnvironmentVariablesProvider>(IEnvironmentVariablesProvider).getEnvironmentVariables(document.uri);
-            const executionService = this.serviceContainer.get<IProcessService>(IProcessService);
-            executionPromise = executionService.exec(executionInfo.execPath!, executionInfo.args, { cwd, env, token: cancellation, mergeStdOutErr: true });
-        }
+        const pythonToolsExecutionService = this.serviceContainer.get<IPythonToolExecutionService>(IPythonToolExecutionService);
         try {
-            const result = await executionPromise;
+            const result = await pythonToolsExecutionService.exec(executionInfo, {cwd, token: cancellation, mergeStdOutErr: true}, document.uri);
             this.displayLinterResultHeader(result.stdout);
             return await this.parseMessages(result.stdout, document, cancellation, regEx);
         } catch (error) {

diff --git a/src/client/unittests/common/runner.ts b/src/client/unittests/common/runner.ts
@@ -3,17 +3,19 @@ import { CancellationToken, OutputChannel, Uri } from 'vscode';
 import { IPythonSettings, PythonSettings } from '../../common/configSettings';
 import { ErrorUtils } from '../../common/errors/errorUtils';
 import { ModuleNotInstalledError } from '../../common/errors/moduleNotInstalledError';
+import { IPythonToolExecutionService } from '../../common/process/types';
 import {
     IProcessService,
     IPythonExecutionFactory,
     IPythonExecutionService,
     ObservableExecutionResult,
     SpawnOptions
 } from '../../common/process/types';
+import { ExecutionInfo } from '../../common/types';
 import { IEnvironmentVariablesProvider } from '../../common/variables/types';
 import { IServiceContainer } from '../../ioc/types';
 import { NOSETEST_PROVIDER, PYTEST_PROVIDER, UNITTEST_PROVIDER } from './constants';
-import { TestProvider } from './types';
+import { ITestsHelper, TestProvider } from './types';
 
 export type Options = {
     workspaceFolder: Uri;
@@ -36,21 +38,17 @@ export async function run(serviceContainer: IServiceContainer, testProvider: Tes
         // Unit tests have a special way of being executed
         const pythonServiceFactory = serviceContainer.get<IPythonExecutionFactory>(IPythonExecutionFactory);
         pythonExecutionServicePromise = pythonServiceFactory.create(options.workspaceFolder);
-        promise = pythonExecutionServicePromise.then(executionService => {
-            return executionService.execObservable(options.args, { ...spawnOptions });
-        });
-    } else if (testExecutablePath) {
-        const processService = serviceContainer.get<IProcessService>(IProcessService);
-        const envVarsService = serviceContainer.get<IEnvironmentVariablesProvider>(IEnvironmentVariablesProvider);
-        promise = envVarsService.getEnvironmentVariables(options.workspaceFolder).then(executionService => {
-            return processService.execObservable(testExecutablePath, options.args, { ...spawnOptions });
-        });
+        promise = pythonExecutionServicePromise.then(executionService => executionService.execObservable(options.args, { ...spawnOptions }));
     } else {
-        const pythonServiceFactory = serviceContainer.get<IPythonExecutionFactory>(IPythonExecutionFactory);
-        pythonExecutionServicePromise = pythonServiceFactory.create(options.workspaceFolder);
-        promise = pythonExecutionServicePromise.then(executionService => {
-            return executionService.execModuleObservable(moduleName, options.args, { ...spawnOptions });
-        });
+        const pythonToolsExecutionService = serviceContainer.get<IPythonToolExecutionService>(IPythonToolExecutionService);
+        const testHelper = serviceContainer.get<ITestsHelper>(ITestsHelper);
+        const executionInfo: ExecutionInfo = {
+            execPath: testExecutablePath,
+            args: options.args,
+            moduleName: testExecutablePath && testExecutablePath.length > 0 ? undefined : moduleName,
+            product: testHelper.parseProduct(testProvider)
+        };
+        promise = pythonToolsExecutionService.execObservable(executionInfo, spawnOptions, options.workspaceFolder);
     }
 
     return promise.then(result => {

diff --git a/src/client/unittests/common/testUtils.ts b/src/client/unittests/common/testUtils.ts
@@ -55,6 +55,16 @@ export class TestsHelper implements ITestsHelper {
             }
         }
     }
+    public parseProduct(provider: TestProvider): UnitTestProduct {
+        switch (provider) {
+            case 'nosetest': return Product.nosetest;
+            case 'pytest': return Product.pytest;
+            case 'unittest': return Product.unittest;
+            default: {
+                throw new Error(`Unknown Test Provider ${provider}`);
+            }
+        }
+    }
     public getSettingsPropertyNames(product: UnitTestProduct): TestSettingsPropertyNames {
         const id = this.parseProviderName(product);
         switch (id) {

diff --git a/src/client/unittests/common/types.ts b/src/client/unittests/common/types.ts
@@ -156,6 +156,7 @@ export const ITestsHelper = Symbol('ITestsHelper');
 
 export interface ITestsHelper {
     parseProviderName(product: UnitTestProduct): TestProvider;
+    parseProduct(provider: TestProvider): UnitTestProduct;
     getSettingsPropertyNames(product: Product): TestSettingsPropertyNames;
     flattenTestFiles(testFiles: TestFile[]): Tests;
     placeTestFilesIntoFolders(tests: Tests): void;

diff --git a/src/test/serviceRegistry.ts b/src/test/serviceRegistry.ts
@@ -10,8 +10,9 @@ import { PathUtils } from '../client/common/platform/pathUtils';
 import { BufferDecoder } from '../client/common/process/decoder';
 import { ProcessService } from '../client/common/process/proc';
 import { PythonExecutionFactory } from '../client/common/process/pythonExecutionFactory';
+import { PythonToolExecutionService } from '../client/common/process/pythonToolService';
 import { registerTypes as processRegisterTypes } from '../client/common/process/serviceRegistry';
-import { IBufferDecoder, IProcessService, IPythonExecutionFactory } from '../client/common/process/types';
+import { IBufferDecoder, IProcessService, IPythonExecutionFactory, IPythonToolExecutionService } from '../client/common/process/types';
 import { registerTypes as commonRegisterTypes } from '../client/common/serviceRegistry';
 import { GLOBAL_MEMENTO, ICurrentProcess, IDisposableRegistry, ILogger, IMemento, IOutputChannel, IPathUtils, Is64Bit, IsWindows, WORKSPACE_MEMENTO } from '../client/common/types';
 import { registerTypes as variableRegisterTypes } from '../client/common/variables/serviceRegistry';
@@ -86,6 +87,7 @@ export class IocContainer {
         this.serviceManager.addSingleton<IProcessService>(IOriginalProcessService, ProcessService);
         this.serviceManager.addSingleton<IProcessService>(IProcessService, MockProcessService);
         this.serviceManager.addSingleton<IPythonExecutionFactory>(IPythonExecutionFactory, PythonExecutionFactory);
+        this.serviceManager.addSingleton<IPythonToolExecutionService>(IPythonToolExecutionService, PythonToolExecutionService);
     }
 
     public registerMockProcess() {