cleanup

eleanorjboyd · eleanorjboyd · commit 29533cf16880 · 2026-02-03T13:38:10.000-08:00
diff --git a/.github/instructions/testing_feature_area.instructions.md b/.github/instructions/testing_feature_area.instructions.md
@@ -26,6 +26,10 @@ This document maps the testing support in the extension: discovery, execution (r
     -   `src/client/testing/serviceRegistry.ts` — DI/wiring for testing services.
 -   Workspace orchestration
     -   `src/client/testing/testController/workspaceTestAdapter.ts` — `WorkspaceTestAdapter` (provider-agnostic entry used by controller).
+-   **Project-based testing (multi-project workspaces)**
+    -   `src/client/testing/testController/common/testProjectRegistry.ts` — `TestProjectRegistry` (manages project lifecycle, discovery, and nested project handling).
+    -   `src/client/testing/testController/common/projectAdapter.ts` — `ProjectAdapter` interface (represents a single Python project with its own test infrastructure).
+    -   `src/client/testing/testController/common/projectUtils.ts` — utilities for project ID generation, display names, and shared adapter creation.
 -   Provider adapters
     -   Unittest
         -   `src/client/testing/testController/unittest/testDiscoveryAdapter.ts`
@@ -151,6 +155,51 @@ The adapters in the extension don't implement test discovery/run logic themselve
     -   Settings are consumed by `src/client/testing/common/testConfigurationManager.ts`, `src/client/testing/configurationFactory.ts`, and adapters under `src/client/testing/testController/*` which read settings to build CLI args and env for subprocesses.
     -   The setting definitions and descriptions are in `package.json` and localized strings in `package.nls.json`.
 
+## Project-based testing (multi-project workspaces)
+
+Project-based testing enables multi-project workspace support where each Python project gets its own test tree root with its own Python environment.
+
+> **⚠️ Note: unittest support for project-based testing is NOT yet implemented.** Project-based testing currently only works with pytest. unittest support will be added in a future PR.
+
+### Architecture
+
+-   **TestProjectRegistry** (`testProjectRegistry.ts`): Central registry that:
+
+    -   Discovers Python projects via the Python Environments API
+    -   Creates and manages `ProjectAdapter` instances per workspace
+    -   Computes nested project relationships and configures ignore lists
+    -   Falls back to "legacy" single-adapter mode when API unavailable
+
+-   **ProjectAdapter** (`projectAdapter.ts`): Interface representing a single project with:
+    -   Project identity (ID, name, URI from Python Environments API)
+    -   Python environment with execution details
+    -   Test framework adapters (discovery/execution)
+    -   Nested project ignore paths (for parent projects)
+
+### How it works
+
+1. **Activation**: When the extension activates, `PythonTestController` checks if the Python Environments API is available.
+2. **Project discovery**: `TestProjectRegistry.discoverAndRegisterProjects()` queries the API for all Python projects in each workspace.
+3. **Nested handling**: `configureNestedProjectIgnores()` identifies child projects and adds their paths to parent projects' ignore lists.
+4. **Test discovery**: For each project, the controller calls `project.discoveryAdapter.discoverTests()` with the project's URI. The adapter sets `PROJECT_ROOT_PATH` environment variable for the Python runner.
+5. **Python side**: `get_test_root_path()` in `vscode_pytest/__init__.py` returns `PROJECT_ROOT_PATH` (if set) or falls back to `cwd`.
+6. **Test tree**: Each project gets its own root node in the Test Explorer, with test IDs scoped by project ID using the `||` separator.
+
+### Logging prefix
+
+All project-based testing logs use the `[test-by-project]` prefix for easy filtering in the output channel.
+
+### Key files
+
+-   Python side: `python_files/vscode_pytest/__init__.py` — `get_test_root_path()` function and `PROJECT_ROOT_PATH` environment variable.
+-   TypeScript: `testProjectRegistry.ts`, `projectAdapter.ts`, `projectUtils.ts`, and the discovery adapters.
+
+### Tests
+
+-   `src/test/testing/testController/common/testProjectRegistry.unit.test.ts` — TestProjectRegistry tests
+-   `src/test/testing/testController/common/projectUtils.unit.test.ts` — Project utility function tests
+-   `python_files/tests/pytestadapter/test_get_test_root_path.py` — Python-side get_test_root_path() tests
+
 ## Coverage support (how it works)
 
 -   Coverage is supported by running the Python helper scripts with coverage enabled and then collecting a coverage payload from the runner.
diff --git a/src/client/testing/testController/common/projectUtils.ts b/src/client/testing/testController/common/projectUtils.ts
@@ -2,6 +2,15 @@
 // Licensed under the MIT License.
 
 import { Uri } from 'vscode';
+import { IConfigurationService } from '../../../common/types';
+import { IEnvironmentVariablesProvider } from '../../../common/variables/types';
+import { UNITTEST_PROVIDER } from '../../common/constants';
+import { TestProvider } from '../../types';
+import { ITestDiscoveryAdapter, ITestExecutionAdapter, ITestResultResolver } from './types';
+import { UnittestTestDiscoveryAdapter } from '../unittest/testDiscoveryAdapter';
+import { UnittestTestExecutionAdapter } from '../unittest/testExecutionAdapter';
+import { PytestTestDiscoveryAdapter } from '../pytest/pytestDiscoveryAdapter';
+import { PytestTestExecutionAdapter } from '../pytest/pytestExecutionAdapter';
 
 /**
  * Separator used to scope test IDs to a specific project.
@@ -52,3 +61,32 @@ export function createProjectDisplayName(projectName: string, pythonVersion: str
 
     return `${projectName} (Python ${shortVersion})`;
 }
+
+/**
+ * Creates test adapters (discovery and execution) for a given test provider.
+ * Centralizes adapter creation to avoid code duplication across Controller and TestProjectRegistry.
+ *
+ * @param testProvider The test framework provider ('pytest' | 'unittest')
+ * @param resultResolver The result resolver to use for test results
+ * @param configSettings The configuration service
+ * @param envVarsService The environment variables provider
+ * @returns An object containing the discovery and execution adapters
+ */
+export function createTestAdapters(
+    testProvider: TestProvider,
+    resultResolver: ITestResultResolver,
+    configSettings: IConfigurationService,
+    envVarsService: IEnvironmentVariablesProvider,
+): { discoveryAdapter: ITestDiscoveryAdapter; executionAdapter: ITestExecutionAdapter } {
+    if (testProvider === UNITTEST_PROVIDER) {
+        return {
+            discoveryAdapter: new UnittestTestDiscoveryAdapter(configSettings, resultResolver, envVarsService),
+            executionAdapter: new UnittestTestExecutionAdapter(configSettings, resultResolver, envVarsService),
+        };
+    }
+
+    return {
+        discoveryAdapter: new PytestTestDiscoveryAdapter(configSettings, resultResolver, envVarsService),
+        executionAdapter: new PytestTestExecutionAdapter(configSettings, resultResolver, envVarsService),
+    };
+}
diff --git a/src/client/testing/testController/common/testDiscoveryHandler.ts b/src/client/testing/testController/common/testDiscoveryHandler.ts
@@ -67,7 +67,7 @@ export class TestDiscoveryHandler {
                     runIdToTestItem: testItemIndex.runIdToTestItemMap,
                     runIdToVSid: testItemIndex.runIdToVSidMap,
                     vsIdToRunId: testItemIndex.vsIdToRunIdMap,
-                } as any,
+                },
                 token,
                 projectId,
             );
diff --git a/src/client/testing/testController/common/testProjectRegistry.ts b/src/client/testing/testController/common/testProjectRegistry.ts
@@ -13,13 +13,8 @@ import { PythonProject, PythonEnvironment } from '../../../envExt/types';
 import { getEnvExtApi, useEnvExtension } from '../../../envExt/api.internal';
 import { isParentPath } from '../../../common/platform/fs-paths';
 import { ProjectAdapter } from './projectAdapter';
-import { getProjectId, createProjectDisplayName } from './projectUtils';
+import { getProjectId, createProjectDisplayName, createTestAdapters } from './projectUtils';
 import { PythonResultResolver } from './resultResolver';
-import { ITestDiscoveryAdapter, ITestExecutionAdapter } from './types';
-import { UnittestTestDiscoveryAdapter } from '../unittest/testDiscoveryAdapter';
-import { UnittestTestExecutionAdapter } from '../unittest/testExecutionAdapter';
-import { PytestTestDiscoveryAdapter } from '../pytest/pytestDiscoveryAdapter';
-import { PytestTestExecutionAdapter } from '../pytest/pytestExecutionAdapter';
 
 /**
  * Registry for Python test projects within workspaces.
@@ -83,7 +78,7 @@ export class TestProjectRegistry {
      * Returns the discovered projects for the caller to use.
      */
     public async discoverAndRegisterProjects(workspaceUri: Uri): Promise<ProjectAdapter[]> {
-        traceInfo(`[ProjectManager] Discovering projects for workspace: ${workspaceUri.fsPath}`);
+        traceInfo(`[test-by-project] Discovering projects for workspace: ${workspaceUri.fsPath}`);
 
         const projects = await this.discoverProjects(workspaceUri);
 
@@ -94,7 +89,7 @@ export class TestProjectRegistry {
         });
 
         this.workspaceProjects.set(workspaceUri, projectsMap);
-        traceInfo(`[ProjectManager] Registered ${projects.length} project(s) for ${workspaceUri.fsPath}`);
+        traceInfo(`[test-by-project] Registered ${projects.length} project(s) for ${workspaceUri.fsPath}`);
 
         return projects;
     }
@@ -111,7 +106,7 @@ export class TestProjectRegistry {
             const ignorePaths = projectIgnores.get(project.projectId);
             if (ignorePaths && ignorePaths.length > 0) {
                 project.nestedProjectPathsToIgnore = ignorePaths;
-                traceInfo(`[ProjectManager] ${project.projectName} will ignore nested: ${ignorePaths.join(', ')}`);
+                traceInfo(`[test-by-project] ${project.projectName} will ignore nested: ${ignorePaths.join(', ')}`);
             }
         }
     }
@@ -132,22 +127,22 @@ export class TestProjectRegistry {
     private async discoverProjects(workspaceUri: Uri): Promise<ProjectAdapter[]> {
         try {
             if (!useEnvExtension()) {
-                traceInfo('[ProjectManager] Python Environments API not available, using default project');
+                traceInfo('[test-by-project] Python Environments API not available, using default project');
                 return [await this.createDefaultProject(workspaceUri)];
             }
 
             const envExtApi = await getEnvExtApi();
             const allProjects = envExtApi.getPythonProjects();
-            traceInfo(`[ProjectManager] Found ${allProjects.length} total Python projects from API`);
+            traceInfo(`[test-by-project] Found ${allProjects.length} total Python projects from API`);
 
             // Filter to projects within this workspace
             const workspaceProjects = allProjects.filter((project) =>
                 isParentPath(project.uri.fsPath, workspaceUri.fsPath),
             );
-            traceInfo(`[ProjectManager] Filtered to ${workspaceProjects.length} projects in workspace`);
+            traceInfo(`[test-by-project] Filtered to ${workspaceProjects.length} projects in workspace`);
 
             if (workspaceProjects.length === 0) {
-                traceInfo('[ProjectManager] No projects found, creating default project');
+                traceInfo('[test-by-project] No projects found, creating default project');
                 return [await this.createDefaultProject(workspaceUri)];
             }
 
@@ -158,18 +153,18 @@ export class TestProjectRegistry {
                     const adapter = await this.createProjectAdapter(pythonProject, workspaceUri);
                     adapters.push(adapter);
                 } catch (error) {
-                    traceError(`[ProjectManager] Failed to create adapter for ${pythonProject.uri.fsPath}:`, error);
+                    traceError(`[test-by-project] Failed to create adapter for ${pythonProject.uri.fsPath}:`, error);
                 }
             }
 
             if (adapters.length === 0) {
-                traceInfo('[ProjectManager] All adapters failed, falling back to default project');
+                traceInfo('[test-by-project] All adapters failed, falling back to default project');
                 return [await this.createDefaultProject(workspaceUri)];
             }
 
             return adapters;
         } catch (error) {
-            traceError('[ProjectManager] Discovery failed, using default project:', error);
+            traceError('[test-by-project] Discovery failed, using default project:', error);
             return [await this.createDefaultProject(workspaceUri)];
         }
     }
@@ -179,7 +174,7 @@ export class TestProjectRegistry {
      */
     private async createProjectAdapter(pythonProject: PythonProject, workspaceUri: Uri): Promise<ProjectAdapter> {
         const projectId = pythonProject.uri.fsPath;
-        traceInfo(`[ProjectManager] Creating adapter for: ${pythonProject.name} at ${projectId}`);
+        traceInfo(`[test-by-project] Creating adapter for: ${pythonProject.name} at ${projectId}`);
 
         // Resolve Python environment
         const envExtApi = await getEnvExtApi();
@@ -191,7 +186,12 @@ export class TestProjectRegistry {
         // Create test infrastructure
         const testProvider = this.getTestProvider(workspaceUri);
         const resultResolver = new PythonResultResolver(this.testController, testProvider, workspaceUri, projectId);
-        const { discoveryAdapter, executionAdapter } = this.createAdapters(testProvider, resultResolver);
+        const { discoveryAdapter, executionAdapter } = createTestAdapters(
+            testProvider,
+            resultResolver,
+            this.configSettings,
+            this.envVarsService,
+        );
 
         const projectName = createProjectDisplayName(pythonProject.name, pythonEnvironment.version);
 
@@ -215,11 +215,16 @@ export class TestProjectRegistry {
      * Creates a default project for legacy/fallback mode.
      */
     private async createDefaultProject(workspaceUri: Uri): Promise<ProjectAdapter> {
-        traceInfo(`[ProjectManager] Creating default project for: ${workspaceUri.fsPath}`);
+        traceInfo(`[test-by-project] Creating default project for: ${workspaceUri.fsPath}`);
 
         const testProvider = this.getTestProvider(workspaceUri);
         const resultResolver = new PythonResultResolver(this.testController, testProvider, workspaceUri);
-        const { discoveryAdapter, executionAdapter } = this.createAdapters(testProvider, resultResolver);
+        const { discoveryAdapter, executionAdapter } = createTestAdapters(
+            testProvider,
+            resultResolver,
+            this.configSettings,
+            this.envVarsService,
+        );
 
         const interpreter = await this.interpreterService.getActiveInterpreter(workspaceUri);
 
@@ -276,7 +281,7 @@ export class TestProjectRegistry {
 
                 if (childPath.startsWith(parentPath + path.sep)) {
                     nestedPaths.push(childPath);
-                    traceVerbose(`[ProjectManager] Nested: ${child.projectName} under ${parent.projectName}`);
+                    traceVerbose(`[test-by-project] Nested: ${child.projectName} under ${parent.projectName}`);
                 }
             }
 
@@ -295,32 +300,4 @@ export class TestProjectRegistry {
         const settings = this.configSettings.getSettings(workspaceUri);
         return settings.testing.unittestEnabled ? UNITTEST_PROVIDER : 'pytest';
     }
-
-    /**
-     * Creates discovery and execution adapters for a test provider.
-     */
-    private createAdapters(
-        testProvider: TestProvider,
-        resultResolver: PythonResultResolver,
-    ): { discoveryAdapter: ITestDiscoveryAdapter; executionAdapter: ITestExecutionAdapter } {
-        if (testProvider === UNITTEST_PROVIDER) {
-            return {
-                discoveryAdapter: new UnittestTestDiscoveryAdapter(
-                    this.configSettings,
-                    resultResolver,
-                    this.envVarsService,
-                ),
-                executionAdapter: new UnittestTestExecutionAdapter(
-                    this.configSettings,
-                    resultResolver,
-                    this.envVarsService,
-                ),
-            };
-        }
-
-        return {
-            discoveryAdapter: new PytestTestDiscoveryAdapter(this.configSettings, resultResolver, this.envVarsService),
-            executionAdapter: new PytestTestExecutionAdapter(this.configSettings, resultResolver, this.envVarsService),
-        };
-    }
 }
diff --git a/src/client/testing/testController/common/types.ts b/src/client/testing/testController/common/types.ts
@@ -143,10 +143,18 @@ export type TestCommandOptions = {
 //     triggerRunDataReceivedEvent(data: DataReceivedEvent): void;
 //     triggerDiscoveryDataReceivedEvent(data: DataReceivedEvent): void;
 // }
-export interface ITestResultResolver {
+
+/**
+ * Test item mapping interface used by populateTestTree.
+ * Contains only the maps needed for building the test tree.
+ */
+export interface ITestItemMappings {
     runIdToVSid: Map<string, string>;
     runIdToTestItem: Map<string, TestItem>;
     vsIdToRunId: Map<string, string>;
+}
+
+export interface ITestResultResolver extends ITestItemMappings {
     detailedCoverageMap: Map<string, FileCoverageDetail[]>;
 
     resolveDiscovery(payload: DiscoveredTestPayload, token?: CancellationToken): void;
diff --git a/src/client/testing/testController/common/utils.ts b/src/client/testing/testController/common/utils.ts
@@ -13,7 +13,7 @@ import {
     DiscoveredTestNode,
     DiscoveredTestPayload,
     ExecutionTestPayload,
-    ITestResultResolver,
+    ITestItemMappings,
 } from './types';
 import { Deferred, createDeferred } from '../../../common/utils/async';
 import { createReaderPipe, generateRandomPipeName } from '../../../common/pipes/namedPipes';
@@ -210,7 +210,7 @@ export function populateTestTree(
     testController: TestController,
     testTreeData: DiscoveredTestNode,
     testRoot: TestItem | undefined,
-    resultResolver: ITestResultResolver,
+    testItemMappings: ITestItemMappings,
     token?: CancellationToken,
     projectId?: string,
 ): void {
@@ -252,9 +252,9 @@ export function populateTestTree(
 
                 testRoot!.children.add(testItem);
                 // add to our map - use runID as key, vsId as value
-                resultResolver.runIdToTestItem.set(child.runID, testItem);
-                resultResolver.runIdToVSid.set(child.runID, vsId);
-                resultResolver.vsIdToRunId.set(vsId, child.runID);
+                testItemMappings.runIdToTestItem.set(child.runID, testItem);
+                testItemMappings.runIdToVSid.set(child.runID, vsId);
+                testItemMappings.vsIdToRunId.set(vsId, child.runID);
             } else {
                 let node = testController.items.get(child.path);
 
@@ -282,7 +282,7 @@ export function populateTestTree(
 
                     testRoot!.children.add(node);
                 }
-                populateTestTree(testController, child, node, resultResolver, token, projectId);
+                populateTestTree(testController, child, node, testItemMappings, token, projectId);
             }
         }
     });
diff --git a/src/client/testing/testController/controller.ts b/src/client/testing/testController/controller.ts
diff --git a/src/test/testing/testController/common/testProjectRegistry.unit.test.ts b/src/test/testing/testController/common/testProjectRegistry.unit.test.ts
