checkpoint- project test nodes

eleanorjboyd · eleanorjboyd · commit b2a3a8e50021 · 2026-01-08T16:01:00.000-08:00
diff --git a/python_files/vscode_pytest/__init__.py b/python_files/vscode_pytest/__init__.py
@@ -77,6 +77,9 @@ def __init__(self, message):
 map_id_to_path = {}
 collected_tests_so_far = set()
 TEST_RUN_PIPE = os.getenv("TEST_RUN_PIPE")
+PROJECT_ROOT_PATH = os.getenv(
+    "PROJECT_ROOT_PATH"
+)  # Path to project root for multi-project workspaces
 SYMLINK_PATH = None
 INCLUDE_BRANCHES = False
 
@@ -86,6 +89,20 @@ def __init__(self, message):
 _CACHED_CWD: pathlib.Path | None = None
 
 
+def get_test_root_path() -> pathlib.Path:
+    """Get the root path for the test tree.
+
+    For project-based testing, this returns PROJECT_ROOT_PATH (the project root).
+    For legacy mode, this returns the current working directory.
+
+    Returns:
+        pathlib.Path: The root path to use for the test tree.
+    """
+    if PROJECT_ROOT_PATH:
+        return pathlib.Path(PROJECT_ROOT_PATH)
+    return pathlib.Path.cwd()
+
+
 def pytest_load_initial_conftests(early_config, parser, args):  # noqa: ARG001
     has_pytest_cov = early_config.pluginmanager.hasplugin(
         "pytest_cov"
@@ -409,41 +426,43 @@ def pytest_sessionfinish(session, exitstatus):
     Exit code 4: pytest command line usage error
     Exit code 5: No tests were collected
     """
-    cwd = pathlib.Path.cwd()
+    # Get the root path for the test tree structure (not the CWD for test execution)
+    # This is PROJECT_ROOT_PATH in project-based mode, or cwd in legacy mode
+    test_root_path = get_test_root_path()
     if SYMLINK_PATH:
-        print("Plugin warning[vscode-pytest]: SYMLINK set, adjusting cwd.")
-        cwd = pathlib.Path(SYMLINK_PATH)
+        print("Plugin warning[vscode-pytest]: SYMLINK set, adjusting test root path.")
+        test_root_path = pathlib.Path(SYMLINK_PATH)
 
     if IS_DISCOVERY:
         if not (exitstatus == 0 or exitstatus == 1 or exitstatus == 5):
             error_node: TestNode = {
                 "name": "",
-                "path": cwd,
+                "path": test_root_path,
                 "type_": "error",
                 "children": [],
                 "id_": "",
             }
-            send_discovery_message(os.fsdecode(cwd), error_node)
+            send_discovery_message(os.fsdecode(test_root_path), error_node)
         try:
             session_node: TestNode | None = build_test_tree(session)
             if not session_node:
                 raise VSCodePytestError(
                     "Something went wrong following pytest finish, \
                         no session node was created"
                 )
-            send_discovery_message(os.fsdecode(cwd), session_node)
+            send_discovery_message(os.fsdecode(test_root_path), session_node)
         except Exception as e:
             ERRORS.append(
                 f"Error Occurred, traceback: {(traceback.format_exc() if e.__traceback__ else '')}"
             )
             error_node: TestNode = {
                 "name": "",
-                "path": cwd,
+                "path": test_root_path,
                 "type_": "error",
                 "children": [],
                 "id_": "",
             }
-            send_discovery_message(os.fsdecode(cwd), error_node)
+            send_discovery_message(os.fsdecode(test_root_path), error_node)
     else:
         if exitstatus == 0 or exitstatus == 1:
             exitstatus_bool = "success"
@@ -454,7 +473,7 @@ def pytest_sessionfinish(session, exitstatus):
             exitstatus_bool = "error"
 
             send_execution_message(
-                os.fsdecode(cwd),
+                os.fsdecode(test_root_path),
                 exitstatus_bool,
                 None,
             )
@@ -540,7 +559,7 @@ def pytest_sessionfinish(session, exitstatus):
 
         payload: CoveragePayloadDict = CoveragePayloadDict(
             coverage=True,
-            cwd=os.fspath(cwd),
+            cwd=os.fspath(test_root_path),
             result=file_coverage_map,
             error=None,
         )
@@ -832,7 +851,11 @@ def create_session_node(session: pytest.Session) -> TestNode:
     Keyword arguments:
     session -- the pytest session.
     """
-    node_path = get_node_path(session)
+    # Use PROJECT_ROOT_PATH if set (project-based testing), otherwise use session path (legacy)
+    if PROJECT_ROOT_PATH:
+        node_path = pathlib.Path(PROJECT_ROOT_PATH)
+    else:
+        node_path = get_node_path(session)
     return {
         "name": node_path.name,
         "path": node_path,
diff --git a/src/client/testing/testController/common/types.ts b/src/client/testing/testController/common/types.ts
@@ -16,6 +16,7 @@ import {
 import { ITestDebugLauncher } from '../../common/types';
 import { IPythonExecutionFactory } from '../../../common/process/types';
 import { PythonEnvironment } from '../../../pythonEnvironments/info';
+import { ProjectAdapter } from './projectAdapter';
 
 export enum TestDataKinds {
     Workspace,
@@ -160,6 +161,7 @@ export interface ITestDiscoveryAdapter {
         executionFactory: IPythonExecutionFactory,
         token?: CancellationToken,
         interpreter?: PythonEnvironment,
+        project?: ProjectAdapter,
     ): Promise<void>;
 }
 
diff --git a/src/client/testing/testController/controller.ts b/src/client/testing/testController/controller.ts
@@ -53,7 +53,7 @@ import { ITestDebugLauncher } from '../common/types';
 import { PythonResultResolver } from './common/resultResolver';
 import { onDidSaveTextDocument } from '../../common/vscodeApis/workspaceApis';
 import { IEnvironmentVariablesProvider } from '../../common/variables/types';
-import { ProjectAdapter } from './common/projectAdapter';
+import { ProjectAdapter, WorkspaceDiscoveryState } from './common/projectAdapter';
 import { getProjectId, createProjectDisplayName } from './common/projectUtils';
 import { PythonProject, PythonEnvironment } from '../../envExt/types';
 import { getEnvExtApi, useEnvExtension } from '../../envExt/api.internal';
@@ -73,7 +73,7 @@ export class PythonTestController implements ITestController, IExtensionSingleAc
      * Set to true to enable multi-project testing support (Phases 2-4 must be complete).
      * Default: false (use legacy single-workspace mode)
      */
-    private readonly useProjectBasedTesting = false;
+    private readonly useProjectBasedTesting = true;
 
     // Legacy: Single workspace test adapter per workspace (backward compatibility)
     private readonly testAdapters: Map<Uri, WorkspaceTestAdapter> = new Map();
@@ -83,11 +83,13 @@ export class PythonTestController implements ITestController, IExtensionSingleAc
     // Note: Project URI strings match Python Environments extension's Map<string, PythonProject> keys
     private readonly workspaceProjects: Map<Uri, Map<string, ProjectAdapter>> = new Map();
 
-    // TODO: Phase 3-4 - Add these maps when implementing discovery and execution:
+    // Temporary state for tracking overlaps during discovery (created/destroyed per refresh)
+    private readonly workspaceDiscoveryState: Map<Uri, WorkspaceDiscoveryState> = new Map();
+
+    // TODO: Phase 3-4 - Add these maps when implementing execution:
     // - vsIdToProject: Map<string, ProjectAdapter> - Fast lookup for test execution
     // - fileUriToProject: Map<string, ProjectAdapter> - File watching and change detection
     // - projectToVsIds: Map<string, Set<string>> - Project cleanup and refresh
-    // - workspaceDiscoveryState: Map<Uri, WorkspaceDiscoveryState> - Temporary overlap detection
 
     private readonly triggerTypes: TriggerType[] = [];
 
@@ -551,6 +553,13 @@ export class PythonTestController implements ITestController, IExtensionSingleAc
         // Ensure we send test telemetry if it gets disabled again
         this.sendTestDisabledTelemetry = true;
 
+        // Branch: Use project-based discovery if feature flag enabled and projects exist
+        if (this.useProjectBasedTesting && this.workspaceProjects.has(workspace.uri)) {
+            await this.refreshWorkspaceProjects(workspace.uri);
+            return;
+        }
+
+        // Legacy mode: Single workspace adapter
         if (settings.testing.pytestEnabled) {
             await this.discoverTestsForProvider(workspace.uri, 'pytest');
         } else if (settings.testing.unittestEnabled) {
@@ -560,6 +569,137 @@ export class PythonTestController implements ITestController, IExtensionSingleAc
         }
     }
 
+    /**
+     * Phase 2: Discovers tests for all projects within a workspace (project-based testing).
+     * Runs discovery in parallel for all projects and tracks file overlaps for Phase 3.
+     * Each project populates its TestItems independently using the existing discovery flow.
+     */
+    private async refreshWorkspaceProjects(workspaceUri: Uri): Promise<void> {
+        const projectsMap = this.workspaceProjects.get(workspaceUri);
+        if (!projectsMap || projectsMap.size === 0) {
+            traceError(`[test-by-project] No projects found for workspace: ${workspaceUri.fsPath}`);
+            return;
+        }
+
+        const projects = Array.from(projectsMap.values());
+        traceInfo(`[test-by-project] Starting discovery for ${projects.length} project(s) in workspace`);
+
+        // Initialize discovery state for overlap tracking
+        const discoveryState: WorkspaceDiscoveryState = {
+            workspaceUri,
+            fileToProjects: new Map(),
+            fileOwnership: new Map(),
+            projectsCompleted: new Set(),
+            totalProjects: projects.length,
+            isComplete: false,
+        };
+        this.workspaceDiscoveryState.set(workspaceUri, discoveryState);
+
+        try {
+            // Run discovery for all projects in parallel
+            // Each project will populate TestItems independently via existing flow
+            await Promise.all(projects.map((project) => this.discoverProject(project, discoveryState)));
+
+            // Mark discovery complete
+            discoveryState.isComplete = true;
+            traceInfo(
+                `[test-by-project] Discovery complete: ${discoveryState.projectsCompleted.size}/${projects.length} projects succeeded`,
+            );
+
+            // Log overlap information for debugging
+            const overlappingFiles = Array.from(discoveryState.fileToProjects.entries()).filter(
+                ([, projects]) => projects.size > 1,
+            );
+            if (overlappingFiles.length > 0) {
+                traceInfo(`[test-by-project] Found ${overlappingFiles.length} file(s) discovered by multiple projects`);
+            }
+
+            // TODO: Phase 3 - Resolve overlaps and rebuild test tree with proper ownership
+            // await this.resolveOverlapsAndAssignTests(workspaceUri);
+        } finally {
+            // Clean up temporary discovery state
+            this.workspaceDiscoveryState.delete(workspaceUri);
+        }
+    }
+
+    /**
+     * Phase 2: Runs test discovery for a single project.
+     * Uses the existing discovery flow which populates TestItems automatically.
+     * Tracks which files were discovered for overlap detection in Phase 3.
+     */
+    private async discoverProject(project: ProjectAdapter, discoveryState: WorkspaceDiscoveryState): Promise<void> {
+        try {
+            traceInfo(`[test-by-project] Discovering tests for project: ${project.projectName}`);
+            project.isDiscovering = true;
+
+            // Run discovery using project's adapter with project's interpreter
+            // This will call the existing discovery flow which populates TestItems via result resolver
+            // Note: The adapter expects the legacy PythonEnvironment type, but for now we can pass
+            // the environment from the API. The adapters internally use execInfo which both types have.
+            //
+            // Pass the ProjectAdapter so discovery adapters can extract project.projectUri.fsPath
+            // and set PROJECT_ROOT_PATH environment variable. This tells Python subprocess where to
+            // trim the test tree, keeping test paths relative to project root instead of workspace root,
+            // while preserving CWD for user's test configurations.
+            //
+            // TODO: Symlink consideration - If project.projectUri.fsPath contains symlinks,
+            // Python's path resolution may differ from Node.js. Discovery adapters should consider
+            // using fs.promises.realpath() to resolve symlinks before passing PROJECT_ROOT_PATH to Python,
+            // similar to handleSymlinkAndRootDir() in pytest. This ensures PROJECT_ROOT_PATH matches
+            // the resolved path Python will use.
+            await project.discoveryAdapter.discoverTests(
+                project.projectUri,
+                this.pythonExecFactory,
+                this.refreshCancellation.token,
+                project.pythonEnvironment as any, // Type cast needed - API type vs legacy type
+                project, // Pass project for access to projectUri and other project-specific data
+            );
+
+            // Track which files this project discovered by inspecting created TestItems
+            // This data will be used in Phase 3 for overlap resolution
+            this.trackProjectDiscoveredFiles(project, discoveryState);
+
+            // Mark project as completed
+            discoveryState.projectsCompleted.add(project.projectId);
+            traceInfo(`[test-by-project] Project ${project.projectName} discovery completed`);
+        } catch (error) {
+            traceError(`[test-by-project] Discovery failed for project ${project.projectName}:`, error);
+            // Individual project failures don't block others
+            discoveryState.projectsCompleted.add(project.projectId); // Still mark as completed
+        } finally {
+            project.isDiscovering = false;
+        }
+    }
+
+    /**
+     * Tracks which files a project discovered by inspecting its TestItems.
+     * Populates the fileToProjects map for overlap detection in Phase 3.
+     */
+    private trackProjectDiscoveredFiles(project: ProjectAdapter, discoveryState: WorkspaceDiscoveryState): void {
+        // Get all test items for this project from its result resolver
+        const testItems = project.resultResolver.runIdToTestItem;
+
+        // Extract unique file paths from test items
+        const filePaths = new Set<string>();
+        testItems.forEach((testItem) => {
+            if (testItem.uri) {
+                filePaths.add(testItem.uri.fsPath);
+            }
+        });
+
+        // Track which projects discovered each file
+        filePaths.forEach((filePath) => {
+            if (!discoveryState.fileToProjects.has(filePath)) {
+                discoveryState.fileToProjects.set(filePath, new Set());
+            }
+            discoveryState.fileToProjects.get(filePath)!.add(project);
+        });
+
+        traceVerbose(
+            `[test-by-project] Project ${project.projectName} discovered ${filePaths.size} file(s) with ${testItems.size} test(s)`,
+        );
+    }
+
     /**
      * Discovers tests for all workspaces in the workspace folders.
      */
diff --git a/src/client/testing/testController/pytest/pytestDiscoveryAdapter.ts b/src/client/testing/testController/pytest/pytestDiscoveryAdapter.ts
@@ -19,6 +19,7 @@ import { PythonEnvironment } from '../../../pythonEnvironments/info';
 import { useEnvExtension, getEnvironment, runInBackground } from '../../../envExt/api.internal';
 import { buildPytestEnv as configureSubprocessEnv, handleSymlinkAndRootDir } from './pytestHelpers';
 import { cleanupOnCancellation, createProcessHandlers, setupDiscoveryPipe } from '../common/discoveryHelpers';
+import { ProjectAdapter } from '../common/projectAdapter';
 
 /**
  * Configures the subprocess environment for pytest discovery.
@@ -53,6 +54,7 @@ export class PytestTestDiscoveryAdapter implements ITestDiscoveryAdapter {
         executionFactory: IPythonExecutionFactory,
         token?: CancellationToken,
         interpreter?: PythonEnvironment,
+        project?: ProjectAdapter,
     ): Promise<void> {
         // Setup discovery pipe and cancellation
         const {
@@ -84,6 +86,17 @@ export class PytestTestDiscoveryAdapter implements ITestDiscoveryAdapter {
             // Configure subprocess environment
             const mutableEnv = await configureDiscoveryEnv(this.envVarsService, uri, discoveryPipeName);
 
+            // Set PROJECT_ROOT_PATH for project-based testing
+            // This tells Python where to trim the test tree, keeping test paths relative to project root
+            // instead of workspace root, while preserving CWD for user's test configurations.
+            // Using fsPath for cross-platform compatibility (handles Windows vs Unix paths).
+            // TODO: Symlink consideration - PROJECT_ROOT_PATH may contain symlinks. If handleSymlinkAndRootDir()
+            // resolves the CWD to a different path, PROJECT_ROOT_PATH might not match. Consider resolving
+            // PROJECT_ROOT_PATH symlinks before passing, or adjust Python-side logic to handle both paths.
+            if (project) {
+                mutableEnv.PROJECT_ROOT_PATH = project.projectUri.fsPath;
+            }
+
             // Setup process handlers (shared by both execution paths)
             const handlers = createProcessHandlers('pytest', uri, cwd, this.resultResolver, deferredTillExecClose, [5]);
 
diff --git a/src/client/testing/testController/unittest/testDiscoveryAdapter.ts b/src/client/testing/testController/unittest/testDiscoveryAdapter.ts
@@ -18,6 +18,7 @@ import { PythonEnvironment } from '../../../pythonEnvironments/info';
 import { createTestingDeferred } from '../common/utils';
 import { buildDiscoveryCommand, buildUnittestEnv as configureSubprocessEnv } from './unittestHelpers';
 import { cleanupOnCancellation, createProcessHandlers, setupDiscoveryPipe } from '../common/discoveryHelpers';
+import { ProjectAdapter } from '../common/projectAdapter';
 
 /**
  * Configures the subprocess environment for unittest discovery.
@@ -51,6 +52,7 @@ export class UnittestTestDiscoveryAdapter implements ITestDiscoveryAdapter {
         executionFactory: IPythonExecutionFactory,
         token?: CancellationToken,
         interpreter?: PythonEnvironment,
+        project?: ProjectAdapter,
     ): Promise<void> {
         // Setup discovery pipe and cancellation
         const {
@@ -78,6 +80,17 @@ export class UnittestTestDiscoveryAdapter implements ITestDiscoveryAdapter {
             // Configure subprocess environment
             const mutableEnv = await configureDiscoveryEnv(this.envVarsService, uri, discoveryPipeName);
 
+            // Set PROJECT_ROOT_PATH for project-based testing
+            // This tells Python where to trim the test tree, keeping test paths relative to project root
+            // instead of workspace root, while preserving CWD for user's test configurations.
+            // Using fsPath for cross-platform compatibility (handles Windows vs Unix paths).
+            // TODO: Symlink consideration - If CWD or PROJECT_ROOT_PATH contain symlinks, path matching
+            // in Python may fail. Consider resolving symlinks before comparison, or using os.path.realpath()
+            // on the Python side to normalize paths before building test tree.
+            if (project) {
+                mutableEnv.PROJECT_ROOT_PATH = project.projectUri.fsPath;
+            }
+
             // Setup process handlers (shared by both execution paths)
             const handlers = createProcessHandlers('unittest', uri, cwd, this.resultResolver, deferredTillExecClose);
 
