Add more tests

Author: Kartik Raj

src/client/common/process/proc.ts

@@ -7,6 +7,7 @@ import { IDisposable } from '../types';
 import { EnvironmentVariables } from '../variables/types';
 import { execObservable, killPid, plainExec, shellExec } from './rawProcessApis';
 import { ExecutionResult, IProcessService, ObservableExecutionResult, ShellOptions, SpawnOptions } from './types';
+import { workerPlainExec, workerShellExec } from './worker/rawProcessApiWrapper';
 
 export class ProcessService extends EventEmitter implements IProcessService {
     private processesToKill = new Set<IDisposable>();
@@ -47,14 +48,20 @@ export class ProcessService extends EventEmitter implements IProcessService {
     }
 
     public exec(file: string, args: string[], options: SpawnOptions = {}): Promise<ExecutionResult<string>> {
+        this.emit('exec', file, args, options);
+        if (options.useWorker) {
+            return workerPlainExec(file, args, options);
+        }
         const execOptions = { ...options, doNotLog: true };
         const promise = plainExec(file, args, execOptions, this.env, this.processesToKill);
-        this.emit('exec', file, args, options);
         return promise;
     }
 
     public shellExec(command: string, options: ShellOptions = {}): Promise<ExecutionResult<string>> {
         this.emit('exec', command, undefined, options);
+        if (options.useWorker) {
+            return workerShellExec(command, options);
+        }
         const disposables = new Set<IDisposable>();
         const shellOptions = { ...options, doNotLog: true };
         return shellExec(command, shellOptions, this.env, disposables).finally(() => {

src/client/common/process/types.ts

@@ -26,9 +26,10 @@ export type SpawnOptions = ChildProcessSpawnOptions & {
     extraVariables?: NodeJS.ProcessEnv;
     outputChannel?: OutputChannel;
     stdinStr?: string;
+    useWorker?: boolean;
 };
 
-export type ShellOptions = ExecOptions & { throwOnStdErr?: boolean };
+export type ShellOptions = ExecOptions & { throwOnStdErr?: boolean; useWorker?: boolean };
 
 export type ExecutionResult<T extends string | Buffer> = {
     stdout: T;

src/client/common/process/worker/rawProcessApiWrapper.ts

@@ -3,16 +3,10 @@
 
 import { SpawnOptions } from 'child_process';
 import * as path from 'path';
-import { IProcessLogger } from '../types';
 import { executeWorkerFile } from './main';
 import { ExecutionResult, ShellOptions } from './types';
 
-export function workerShellExec(
-    command: string,
-    options: ShellOptions,
-    processLogger: IProcessLogger,
-): Promise<ExecutionResult<string>> {
-    processLogger.logProcess(command, undefined, options);
+export function workerShellExec(command: string, options: ShellOptions): Promise<ExecutionResult<string>> {
     return executeWorkerFile(path.join(__dirname, 'shellExecWorker.js'), {
         command,
         options,
@@ -23,9 +17,7 @@ export function workerPlainExec(
     file: string,
     args: string[],
     options: SpawnOptions = {},
-    processLogger: IProcessLogger,
 ): Promise<ExecutionResult<string>> {
-    processLogger.logProcess(file, args, options);
     return executeWorkerFile(path.join(__dirname, 'plainExecWorker.js'), {
         file,
         args,

src/client/pythonEnvironments/common/externalDependencies.ts

@@ -5,21 +5,13 @@ import * as fsapi from 'fs-extra';
 import * as path from 'path';
 import * as vscode from 'vscode';
 import { IWorkspaceService } from '../../common/application/types';
-import {
-    ExecutionResult,
-    IProcessLogger,
-    IProcessServiceFactory,
-    ShellOptions,
-    SpawnOptions,
-} from '../../common/process/types';
+import { ExecutionResult, IProcessServiceFactory, ShellOptions, SpawnOptions } from '../../common/process/types';
 import { IDisposable, IConfigurationService, IExperimentService } from '../../common/types';
 import { chain, iterable } from '../../common/utils/async';
 import { getOSType, OSType } from '../../common/utils/platform';
 import { IServiceContainer } from '../../ioc/types';
 import { traceError, traceVerbose } from '../../logging';
 import { DiscoveryUsingWorkers } from '../../common/experiments/groups';
-import { workerPlainExec, workerShellExec } from '../../common/process/worker/rawProcessApiWrapper';
-import { IEnvironmentVariablesProvider } from '../../common/variables/types';
 
 let internalServiceContainer: IServiceContainer;
 export function initializeExternalDependencies(serviceContainer: IServiceContainer): void {
@@ -29,32 +21,21 @@ export function initializeExternalDependencies(serviceContainer: IServiceContain
 // processes
 
 export async function shellExecute(command: string, options: ShellOptions = {}): Promise<ExecutionResult<string>> {
-    if (!inExperiment(DiscoveryUsingWorkers.experiment)) {
-        const service = await internalServiceContainer.get<IProcessServiceFactory>(IProcessServiceFactory).create();
-        return service.shellExec(command, options);
-    }
-    const logger = internalServiceContainer.get<IProcessLogger>(IProcessLogger);
-    const envVarsService = internalServiceContainer.get<IEnvironmentVariablesProvider>(IEnvironmentVariablesProvider);
-    const envs = await envVarsService.getEnvironmentVariables();
-    options.env = { ...options.env, ...envs };
-    return workerShellExec(command, options, logger);
+    const useWorker = inExperiment(DiscoveryUsingWorkers.experiment);
+    const service = await internalServiceContainer.get<IProcessServiceFactory>(IProcessServiceFactory).create();
+    options = { ...options, useWorker };
+    return service.shellExec(command, options);
 }
 
 export async function exec(
     file: string,
     args: string[],
     options: SpawnOptions = {},
-    useWorkerThreads = inExperiment(DiscoveryUsingWorkers.experiment),
+    useWorker = inExperiment(DiscoveryUsingWorkers.experiment),
 ): Promise<ExecutionResult<string>> {
-    if (!useWorkerThreads) {
-        const service = await internalServiceContainer.get<IProcessServiceFactory>(IProcessServiceFactory).create();
-        return service.exec(file, args, options);
-    }
-    const logger = internalServiceContainer.get<IProcessLogger>(IProcessLogger);
-    const envVarsService = internalServiceContainer.get<IEnvironmentVariablesProvider>(IEnvironmentVariablesProvider);
-    const envs = await envVarsService.getEnvironmentVariables();
-    options.env = { ...options.env, ...envs };
-    return workerPlainExec(file, args, options, logger);
+    const service = await internalServiceContainer.get<IProcessServiceFactory>(IProcessServiceFactory).create();
+    options = { ...options, useWorker };
+    return service.exec(file, args, options);
 }
 
 export function inExperiment(experimentName: string): boolean {

src/test/common/process/proc.exec.test.ts

@@ -34,6 +34,16 @@ suite('ProcessService Observable', () => {
         expect(result.stderr).to.equal(undefined, 'stderr not undefined');
     });
 
+    test('When using worker threads, exec should output print statements', async () => {
+        const procService = new ProcessService();
+        const printOutput = '1234';
+        const result = await procService.exec(pythonPath, ['-c', `print("${printOutput}")`], { useWorker: true });
+
+        expect(result).not.to.be.an('undefined', 'result is undefined');
+        expect(result.stdout.trim()).to.be.equal(printOutput, 'Invalid output');
+        expect(result.stderr).to.equal(undefined, 'stderr not undefined');
+    });
+
     test('exec should output print unicode characters', async function () {
         // This test has not been working for many months in Python 2.7 under
         // Windows. Tracked by #2546. (unicode under Py2.7 is tough!)
@@ -241,6 +251,18 @@ suite('ProcessService Observable', () => {
         expect(result.stderr).to.equal(undefined, 'stderr not empty');
         expect(result.stdout.trim()).to.be.equal(printOutput, 'Invalid output');
     });
+    test('When using worker threads, shellExec should be able to run python and filter output using conda related markers', async () => {
+        const procService = new ProcessService();
+        const printOutput = '1234';
+        const result = await procService.shellExec(
+            `"${pythonPath}" -c "print('>>>PYTHON-EXEC-OUTPUT');print('${printOutput}');print('<<<PYTHON-EXEC-OUTPUT')"`,
+            { useWorker: true },
+        );
+
+        expect(result).not.to.be.an('undefined', 'result is undefined');
+        expect(result.stderr).to.equal(undefined, 'stderr not empty');
+        expect(result.stdout.trim()).to.be.equal(printOutput, 'Invalid output');
+    });
     test('shellExec should fail on invalid command', async () => {
         const procService = new ProcessService();
         const result = procService.shellExec('invalid command');