Overload methods testing rewrite

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

@@ -12,8 +12,8 @@ import {
     Uri,
     WorkspaceFolder,
 } from 'vscode';
-// ** import { IPythonExecutionFactory } from '../../../common/process/types';
 import { TestDiscoveryOptions } from '../../common/types';
+import { IPythonExecutionFactory } from '../../../common/process/types';
 
 export type TestRunInstanceOptions = TestRunOptions & {
     exclude?: readonly TestItem[];
@@ -179,21 +179,21 @@ export interface ITestServer {
 }
 
 export interface ITestDiscoveryAdapter {
-    // ** Uncomment second line and comment out first line to use the new discovery method.
+    // ** first line old method signature, second line new method signature
     discoverTests(uri: Uri): Promise<DiscoveredTestPayload>;
-    // discoverTests(uri: Uri, executionFactory: IPythonExecutionFactory): Promise<DiscoveredTestPayload>;
+    discoverTests(uri: Uri, executionFactory: IPythonExecutionFactory): Promise<DiscoveredTestPayload>;
 }
 
 // interface for execution/runner adapter
 export interface ITestExecutionAdapter {
-    // ** Uncomment second line and comment out first line to use the new execution method.
+    // ** first line old method signature, second line new method signature
     runTests(uri: Uri, testIds: string[], debugBool?: boolean): Promise<ExecutionTestPayload>;
-    // runTests(
-    //     uri: Uri,
-    //     testIds: string[],
-    //     debugBool?: boolean,
-    //     executionFactory?: IPythonExecutionFactory,
-    // ): Promise<ExecutionTestPayload>;
+    runTests(
+        uri: Uri,
+        testIds: string[],
+        debugBool?: boolean,
+        executionFactory?: IPythonExecutionFactory,
+    ): Promise<ExecutionTestPayload>;
 }
 
 // Same types as in pythonFiles/unittestadapter/utils.py

src/client/testing/testController/controller.ts

@@ -241,39 +241,46 @@ export class PythonTestController implements ITestController, IExtensionSingleAc
         if (uri) {
             const settings = this.configSettings.getSettings(uri);
             traceVerbose(`Testing: Refreshing test data for ${uri.fsPath}`);
+            const rewriteTestingEnabled = process.env.ENABLE_PYTHON_TESTING_REWRITE;
             if (settings.testing.pytestEnabled) {
                 // Ensure we send test telemetry if it gets disabled again
                 this.sendTestDisabledTelemetry = true;
-                // ** uncomment ~231 - 241 to NEW new test discovery mechanism
-                // const workspace = this.workspaceService.getWorkspaceFolder(uri);
-                // traceVerbose(`Discover tests for workspace name: ${workspace?.name} - uri: ${uri.fsPath}`);
-                // const testAdapter =
-                //     this.testAdapters.get(uri) || (this.testAdapters.values().next().value as WorkspaceTestAdapter);
-                // testAdapter.discoverTests(
-                //     this.testController,
-                //     this.refreshCancellation.token,
-                //     this.testAdapters.size > 1,
-                //     this.workspaceService.workspaceFile?.fsPath,
-                //     this.pythonExecFactory,
-                // );
-                // uncomment ~243 to use OLD test discovery mechanism
-                await this.pytest.refreshTestData(this.testController, uri, this.refreshCancellation.token);
+                if (rewriteTestingEnabled) {
+                    // ** rewriteTestingEnabled set to true to use NEW test discovery mechanism
+                    const workspace = this.workspaceService.getWorkspaceFolder(uri);
+                    traceVerbose(`Discover tests for workspace name: ${workspace?.name} - uri: ${uri.fsPath}`);
+                    const testAdapter =
+                        this.testAdapters.get(uri) || (this.testAdapters.values().next().value as WorkspaceTestAdapter);
+                    testAdapter.discoverTests(
+                        this.testController,
+                        this.refreshCancellation.token,
+                        this.testAdapters.size > 1,
+                        this.workspaceService.workspaceFile?.fsPath,
+                        this.pythonExecFactory,
+                    );
+                } else {
+                    // else use OLD test discovery mechanism
+                    await this.pytest.refreshTestData(this.testController, uri, this.refreshCancellation.token);
+                }
             } else if (settings.testing.unittestEnabled) {
                 // ** Ensure we send test telemetry if it gets disabled again
                 this.sendTestDisabledTelemetry = true;
-                // uncomment ~248 - 258 to NEW new test discovery mechanism
-                // const workspace = this.workspaceService.getWorkspaceFolder(uri);
-                // traceVerbose(`Discover tests for workspace name: ${workspace?.name} - uri: ${uri.fsPath}`);
-                // const testAdapter =
-                //     this.testAdapters.get(uri) || (this.testAdapters.values().next().value as WorkspaceTestAdapter);
-                // testAdapter.discoverTests(
-                //     this.testController,
-                //     this.refreshCancellation.token,
-                //     this.testAdapters.size > 1,
-                //     this.workspaceService.workspaceFile?.fsPath,
-                // );
-                // uncomment ~260 to use OLD test discovery mechanism
-                await this.unittest.refreshTestData(this.testController, uri, this.refreshCancellation.token);
+                if (rewriteTestingEnabled) {
+                    // ** rewriteTestingEnabled set to true to use NEW test discovery mechanism
+                    const workspace = this.workspaceService.getWorkspaceFolder(uri);
+                    traceVerbose(`Discover tests for workspace name: ${workspace?.name} - uri: ${uri.fsPath}`);
+                    const testAdapter =
+                        this.testAdapters.get(uri) || (this.testAdapters.values().next().value as WorkspaceTestAdapter);
+                    testAdapter.discoverTests(
+                        this.testController,
+                        this.refreshCancellation.token,
+                        this.testAdapters.size > 1,
+                        this.workspaceService.workspaceFile?.fsPath,
+                    );
+                } else {
+                    // else use OLD test discovery mechanism
+                    await this.unittest.refreshTestData(this.testController, uri, this.refreshCancellation.token);
+                }
             } else {
                 if (this.sendTestDisabledTelemetry) {
                     this.sendTestDisabledTelemetry = false;
@@ -384,25 +391,26 @@ export class PythonTestController implements ITestController, IExtensionSingleAc
 
                     const settings = this.configSettings.getSettings(workspace.uri);
                     if (testItems.length > 0) {
+                        const rewriteTestingEnabled = process.env.ENABLE_PYTHON_TESTING_REWRITE;
                         if (settings.testing.pytestEnabled) {
                             sendTelemetryEvent(EventName.UNITTEST_RUN, undefined, {
                                 tool: 'pytest',
                                 debugging: request.profile?.kind === TestRunProfileKind.Debug,
                             });
-                            // ** new execution runner/adapter
-                            // const testAdapter =
-                            //     this.testAdapters.get(workspace.uri) ||
-                            //     (this.testAdapters.values().next().value as WorkspaceTestAdapter);
-                            // return testAdapter.executeTests(
-                            //     this.testController,
-                            //     runInstance,
-                            //     testItems,
-                            //     token,
-                            //     request.profile?.kind === TestRunProfileKind.Debug,
-                            //     this.pythonExecFactory,
-                            // );
-
-                            // below is old way of running pytest execution
+                            // ** rewriteTestingEnabled set to true to use NEW test discovery mechanism
+                            if (rewriteTestingEnabled) {
+                                const testAdapter =
+                                    this.testAdapters.get(workspace.uri) ||
+                                    (this.testAdapters.values().next().value as WorkspaceTestAdapter);
+                                return testAdapter.executeTests(
+                                    this.testController,
+                                    runInstance,
+                                    testItems,
+                                    token,
+                                    request.profile?.kind === TestRunProfileKind.Debug,
+                                    this.pythonExecFactory,
+                                );
+                            }
                             return this.pytest.runTests(
                                 {
                                     includes: testItems,
@@ -415,23 +423,23 @@ export class PythonTestController implements ITestController, IExtensionSingleAc
                             );
                         }
                         if (settings.testing.unittestEnabled) {
-                            // potentially squeeze in the new execution way here?
                             sendTelemetryEvent(EventName.UNITTEST_RUN, undefined, {
                                 tool: 'unittest',
                                 debugging: request.profile?.kind === TestRunProfileKind.Debug,
                             });
-                            // new execution runner/adapter
-                            // const testAdapter =
-                            //     this.testAdapters.get(workspace.uri) ||
-                            //     (this.testAdapters.values().next().value as WorkspaceTestAdapter);
-                            // return testAdapter.executeTests(
-                            //     this.testController,
-                            //     runInstance,
-                            //     testItems,
-                            //     token,
-                            //     request.profile?.kind === TestRunProfileKind.Debug,
-                            // );
-
+                            // ** rewriteTestingEnabled set to true to use NEW test discovery mechanism
+                            if (rewriteTestingEnabled) {
+                                const testAdapter =
+                                    this.testAdapters.get(workspace.uri) ||
+                                    (this.testAdapters.values().next().value as WorkspaceTestAdapter);
+                                return testAdapter.executeTests(
+                                    this.testController,
+                                    runInstance,
+                                    testItems,
+                                    token,
+                                    request.profile?.kind === TestRunProfileKind.Debug,
+                                );
+                            }
                             // below is old way of running unittest execution
                             return this.unittest.runTests(
                                 {

src/client/testing/testController/pytest/pytestDiscoveryAdapter.ts

@@ -37,20 +37,19 @@ export class PytestTestDiscoveryAdapter implements ITestDiscoveryAdapter {
         }
     }
 
-    // ** Old version of discover tests.
-    discoverTests(uri: Uri): Promise<DiscoveredTestPayload> {
+    discoverTests(uri: Uri, executionFactory?: IPythonExecutionFactory): Promise<DiscoveredTestPayload> {
+        if (executionFactory !== undefined) {
+            // ** new version of discover tests.
+            const settings = this.configSettings.getSettings(uri);
+            const { pytestArgs } = settings.testing;
+            traceVerbose(pytestArgs);
+            return this.runPytestDiscovery(uri, executionFactory);
+        }
+        // if executionFactory is undefined, we are using the old method signature of discover tests.
         traceVerbose(uri);
         this.deferred = createDeferred<DiscoveredTestPayload>();
         return this.deferred.promise;
     }
-    // Uncomment this version of the function discoverTests to use the new discovery method.
-    // public async discoverTests(uri: Uri, executionFactory: IPythonExecutionFactory): Promise<DiscoveredTestPayload> {
-    //     const settings = this.configSettings.getSettings(uri);
-    //     const { pytestArgs } = settings.testing;
-    //     traceVerbose(pytestArgs);
-
-    //     return this.runPytestDiscovery(uri, executionFactory);
-    // }
 
     async runPytestDiscovery(uri: Uri, executionFactory: IPythonExecutionFactory): Promise<DiscoveredTestPayload> {
         const deferred = createDeferred<DiscoveredTestPayload>();

src/client/testing/testController/pytest/pytestExecutionAdapter.ts

@@ -2,10 +2,17 @@
 // Licensed under the MIT License.
 
 import { Uri } from 'vscode';
+import path from 'path';
 import { IConfigurationService, ITestOutputChannel } from '../../../common/types';
 import { createDeferred, Deferred } from '../../../common/utils/async';
 import { traceVerbose } from '../../../logging';
 import { DataReceivedEvent, ExecutionTestPayload, ITestExecutionAdapter, ITestServer } from '../common/types';
+import {
+    ExecutionFactoryCreateWithEnvironmentOptions,
+    IPythonExecutionFactory,
+    SpawnOptions,
+} from '../../../common/process/types';
+import { EXTENSION_ROOT_DIR } from '../../../constants';
 
 /**
  * Wrapper Class for pytest test execution. This is where we call `runTestCommand`?
@@ -32,70 +39,68 @@ export class PytestTestExecutionAdapter implements ITestExecutionAdapter {
         }
     }
 
-    // ** Old version of discover tests.
-    async runTests(uri: Uri, testIds: string[], debugBool?: boolean): Promise<ExecutionTestPayload> {
+    async runTests(
+        uri: Uri,
+        testIds: string[],
+        debugBool?: boolean,
+        executionFactory?: IPythonExecutionFactory,
+    ): Promise<ExecutionTestPayload> {
         traceVerbose(uri, testIds, debugBool);
-        // TODO:Remove this line after enabling runs
+        if (executionFactory !== undefined) {
+            // ** new version of run tests.
+            return this.runTestsNew(uri, testIds, debugBool, executionFactory);
+        }
+        // if executionFactory is undefined, we are using the old method signature of run tests.
         this.outputChannel.appendLine('Running tests.');
         this.deferred = createDeferred<ExecutionTestPayload>();
         return this.deferred.promise;
     }
-}
-
-//     public async runTests(
-//         uri: Uri,
-//         testIds: string[],
-//         debugBool?: boolean,
-//         executionFactory?: IPythonExecutionFactory,
-//     ): Promise<ExecutionTestPayload> {
-//         const deferred = createDeferred<ExecutionTestPayload>();
-//         const relativePathToPytest = 'pythonFiles';
-//         const fullPluginPath = path.join(EXTENSION_ROOT_DIR, relativePathToPytest);
-//         this.configSettings.isTestExecution();
-//         const uuid = this.testServer.createUUID(uri.fsPath);
-//         this.promiseMap.set(uuid, deferred);
-//         const settings = this.configSettings.getSettings(uri);
-//         const { pytestArgs } = settings.testing;
-
-//         const pythonPathParts: string[] = process.env.PYTHONPATH?.split(path.delimiter) ?? [];
-//         const pythonPathCommand = [fullPluginPath, ...pythonPathParts].join(path.delimiter);
 
-//         const spawnOptions: SpawnOptions = {
-//             cwd: uri.fsPath,
-//             throwOnStdErr: true,
-//             extraVariables: {
-//                 PYTHONPATH: pythonPathCommand,
-//                 TEST_UUID: uuid.toString(),
-//                 TEST_PORT: this.testServer.getPort().toString(),
-//             },
-//             outputChannel: this.outputChannel,
-//         };
+    private async runTestsNew(
+        uri: Uri,
+        testIds: string[],
+        debugBool?: boolean,
+        executionFactory?: IPythonExecutionFactory,
+    ): Promise<ExecutionTestPayload> {
+        const deferred = createDeferred<ExecutionTestPayload>();
+        const relativePathToPytest = 'pythonFiles';
+        const fullPluginPath = path.join(EXTENSION_ROOT_DIR, relativePathToPytest);
+        this.configSettings.isTestExecution();
+        const uuid = this.testServer.createUUID(uri.fsPath);
+        this.promiseMap.set(uuid, deferred);
+        const settings = this.configSettings.getSettings(uri);
+        const { pytestArgs } = settings.testing;
 
-//         // Create the Python environment in which to execute the command.
-//         const creationOptions: ExecutionFactoryCreateWithEnvironmentOptions = {
-//             allowEnvironmentFetchExceptions: false,
-//             resource: uri,
-//         };
-//         // need to check what will happen in the exec service is NOT defined and is null
-//         const execService = await executionFactory?.createActivatedEnvironment(creationOptions);
+        const pythonPathParts: string[] = process.env.PYTHONPATH?.split(path.delimiter) ?? [];
+        const pythonPathCommand = [fullPluginPath, ...pythonPathParts].join(path.delimiter);
 
-//         const testIdsString = testIds.join(' ');
-//         console.debug('what to do with debug bool?', debugBool);
-//         try {
-//             execService?.exec(['-m', 'pytest', '-p', 'vscode_pytest', testIdsString].concat(pytestArgs), spawnOptions);
-//         } catch (ex) {
-//             console.error(ex);
-//         }
+        const spawnOptions: SpawnOptions = {
+            cwd: uri.fsPath,
+            throwOnStdErr: true,
+            extraVariables: {
+                PYTHONPATH: pythonPathCommand,
+                TEST_UUID: uuid.toString(),
+                TEST_PORT: this.testServer.getPort().toString(),
+            },
+            outputChannel: this.outputChannel,
+        };
 
-//         return deferred.promise;
-//     }
-// }
+        // Create the Python environment in which to execute the command.
+        const creationOptions: ExecutionFactoryCreateWithEnvironmentOptions = {
+            allowEnvironmentFetchExceptions: false,
+            resource: uri,
+        };
+        // need to check what will happen in the exec service is NOT defined and is null
+        const execService = await executionFactory?.createActivatedEnvironment(creationOptions);
 
-// function buildExecutionCommand(args: string[]): TestExecutionCommand {
-//     const executionScript = path.join(EXTENSION_ROOT_DIR, 'pythonFiles', 'unittestadapter', 'execution.py');
+        const testIdsString = testIds.join(' ');
+        console.debug('what to do with debug bool?', debugBool);
+        try {
+            execService?.exec(['-m', 'pytest', '-p', 'vscode_pytest', testIdsString].concat(pytestArgs), spawnOptions);
+        } catch (ex) {
+            console.error(ex);
+        }
 
-//     return {
-//         script: executionScript,
-//         args: ['--udiscovery', ...args],
-//     };
-// }
+        return deferred.promise;
+    }
+}