Factor out internal.scripts.testing_tools.run_adapter().

Author: ericsnowcurrently

src/client/common/process/internal.ts

@@ -306,4 +306,61 @@ export namespace scripts {
         // There is no output to parse, so we do not return a function.
         return [script, ...testArgs];
     }
+
+    //============================
+    // testing_tools/
+
+    export namespace testing_tools {
+        const _SCRIPTS_DIR = path.join(SCRIPTS_DIR, 'testing_tools');
+
+        type TestNode = {
+            id: string;
+            name: string;
+            parentid: string;
+        };
+        type TestParent = TestNode & {
+            kind: 'folder' | 'file' | 'suite' | 'function';
+        };
+        type TestFSNode = TestParent & {
+            kind: 'folder' | 'file';
+            relpath: string;
+        };
+
+        export type TestFolder = TestFSNode & {
+            kind: 'folder';
+        };
+        export type TestFile = TestFSNode & {
+            kind: 'file';
+        };
+        export type TestSuite = TestParent & {
+            kind: 'suite';
+        };
+        // function-as-a-container is for parameterized ("sub") tests.
+        export type TestFunction = TestParent & {
+            kind: 'function';
+        };
+        export type Test = TestNode & {
+            source: string;
+        };
+        export type DiscoveredTests = {
+            rootid: string;
+            root: string;
+            parents: TestParent[];
+            tests: Test[];
+        };
+
+        //============================
+        // run_adapter.py
+
+        export function run_adapter(adapterArgs: string[]): [string[], (out: string) => DiscoveredTests[]] {
+            const script = path.join(_SCRIPTS_DIR, 'run_adapter.py');
+            const args = [script, ...adapterArgs];
+
+            function parse(out: string): DiscoveredTests[] {
+                return JSON.parse(out);
+            }
+
+            return [args, parse];
+        }
+    }
 }

src/client/testing/common/services/discovery.ts

@@ -4,25 +4,21 @@
 'use strict';
 
 import { inject, injectable, named } from 'inversify';
-import * as path from 'path';
 import { OutputChannel } from 'vscode';
 import { traceError } from '../../../common/logger';
+import { scripts as internalScripts } from '../../../common/process/internal';
 import {
     ExecutionFactoryCreateWithEnvironmentOptions,
-    ExecutionResult,
     IPythonExecutionFactory,
     SpawnOptions
 } from '../../../common/process/types';
 import { IOutputChannel } from '../../../common/types';
-import { EXTENSION_ROOT_DIR } from '../../../constants';
 import { captureTelemetry } from '../../../telemetry';
 import { EventName } from '../../../telemetry/constants';
 import { TEST_OUTPUT_CHANNEL } from '../constants';
 import { ITestDiscoveryService, TestDiscoveryOptions, Tests } from '../types';
 import { DiscoveredTests, ITestDiscoveredTestParser } from './types';
 
-const DISCOVERY_FILE = path.join(EXTENSION_ROOT_DIR, 'pythonFiles', 'testing_tools', 'run_adapter.py');
-
 @injectable()
 export class TestsDiscoveryService implements ITestDiscoveryService {
     constructor(
@@ -32,20 +28,19 @@ export class TestsDiscoveryService implements ITestDiscoveryService {
     ) {}
     @captureTelemetry(EventName.UNITTEST_DISCOVER_WITH_PYCODE, undefined, true)
     public async discoverTests(options: TestDiscoveryOptions): Promise<Tests> {
-        let output: ExecutionResult<string> | undefined;
         try {
-            output = await this.exec(options);
-            const discoveredTests = JSON.parse(output.stdout) as DiscoveredTests[];
+            const discoveredTests = await this.exec(options);
             return this.parser.parse(options.workspaceFolder, discoveredTests);
         } catch (ex) {
-            if (output) {
-                traceError('Failed to parse discovered Test', new Error(output.stdout));
+            if (ex.stdout) {
+                traceError('Failed to parse discovered Test', new Error(ex.stdout));
             }
             traceError('Failed to parse discovered Test', ex);
             throw ex;
         }
     }
-    public async exec(options: TestDiscoveryOptions): Promise<ExecutionResult<string>> {
+    public async exec(options: TestDiscoveryOptions): Promise<DiscoveredTests[]> {
+        const [args, parse] = internalScripts.testing_tools.run_adapter(options.args);
         const creationOptions: ExecutionFactoryCreateWithEnvironmentOptions = {
             allowEnvironmentFetchExceptions: false,
             resource: options.workspaceFolder
@@ -56,8 +51,13 @@ export class TestsDiscoveryService implements ITestDiscoveryService {
             cwd: options.cwd,
             throwOnStdErr: true
         };
-        const argv = [DISCOVERY_FILE, ...options.args];
-        this.outChannel.appendLine(`python ${argv.join(' ')}`);
-        return execService.exec(argv, spawnOptions);
+        this.outChannel.appendLine(`python ${args.join(' ')}`);
+        const proc = await execService.exec(args, spawnOptions);
+        try {
+            return parse(proc.stdout);
+        } catch (ex) {
+            ex.stdout = proc.stdout;
+            throw ex; // re-throw
+        }
     }
 }

src/client/testing/common/services/types.ts

@@ -4,42 +4,15 @@
 'use strict';
 
 import { Uri } from 'vscode';
+import { scripts as internalScripts } from '../../../common/process/internal';
 import { Tests } from '../types';
 
-export type TestNode = {
-    id: string;
-    name: string;
-    parentid: string;
-};
-export type TestParent = TestNode & {
-    kind: 'folder' | 'file' | 'suite' | 'function';
-};
-export type TestFSNode = TestParent & {
-    kind: 'folder' | 'file';
-    relpath: string;
-};
-export type TestFolder = TestFSNode & {
-    kind: 'folder';
-};
-export type TestFile = TestFSNode & {
-    kind: 'file';
-};
-export type TestSuite = TestParent & {
-    kind: 'suite';
-};
-// function-as-a-container is for parameterized ("sub") tests.
-export type TestFunction = TestParent & {
-    kind: 'function';
-};
-export type Test = TestNode & {
-    source: string;
-};
-export type DiscoveredTests = {
-    rootid: string;
-    root: string;
-    parents: TestParent[];
-    tests: Test[];
-};
+export type DiscoveredTests = internalScripts.testing_tools.DiscoveredTests;
+export type Test = internalScripts.testing_tools.Test;
+export type TestFolder = internalScripts.testing_tools.TestFolder;
+export type TestFile = internalScripts.testing_tools.TestFile;
+export type TestSuite = internalScripts.testing_tools.TestSuite;
+export type TestFunction = internalScripts.testing_tools.TestFunction;
 
 export const ITestDiscoveredTestParser = Symbol('ITestDiscoveredTestParser');
 export interface ITestDiscoveredTestParser {

src/test/testing/common/services/discovery.unit.test.ts

@@ -46,8 +46,7 @@ suite('Unit Tests - Common Discovery', () => {
         };
         const discoveredTests: DiscoveredTests[] = [{ hello: 1 } as any];
         const parsedResult = ({ done: true } as any) as Tests;
-        const json = JSON.stringify(discoveredTests);
-        discovery.exec = () => Promise.resolve({ stdout: json });
+        discovery.exec = () => Promise.resolve(discoveredTests);
         when(parser.parse(options.workspaceFolder, deepEqual(discoveredTests))).thenResolve(parsedResult as any);
 
         const tests = await discovery.discoverTests(options);