updates

Author: eleanorjboyd

src/client/testing/common/debugLauncher.ts

@@ -17,6 +17,7 @@ import { getWorkspaceFolder, getWorkspaceFolders } from '../../common/vscodeApis
 import { showErrorMessage } from '../../common/vscodeApis/windowApis';
 import { createDeferred } from '../../common/utils/async';
 import { addPathToPythonpath } from './helpers';
+import * as envExtApi from '../../envExt/api.internal';
 
 /**
  * Key used to mark debug configurations with a unique session identifier.
@@ -186,8 +187,8 @@ export class DebugLauncher implements ITestDebugLauncher {
         }
 
         // Use project name in debug session name if provided
-        if (options.debugSessionName) {
-            debugConfig.name = `Debug Tests: ${options.debugSessionName}`;
+        if (options.project) {
+            debugConfig.name = `Debug Tests: ${options.project.name}`;
         }
 
         if (!debugConfig.rules) {
@@ -339,11 +340,20 @@ export class DebugLauncher implements ITestDebugLauncher {
         // run via F5 style debugging.
         launchArgs.purpose = [];
 
-        // For project-based execution, use the explicit Python path if provided.
+        // For project-based execution, get the Python path from the project's environment.
         // This ensures debug sessions use the correct interpreter for each project.
-        if (options.pythonPath) {
-            launchArgs.python = options.pythonPath;
-            traceVerbose(`[test-by-project] Debug session using explicit Python path: ${options.pythonPath}`);
+        if (options.project && envExtApi.useEnvExtension()) {
+            try {
+                const pythonEnv = await envExtApi.getEnvironment(options.project.uri);
+                if (pythonEnv?.execInfo?.run?.executable) {
+                    launchArgs.python = pythonEnv.execInfo.run.executable;
+                    traceVerbose(
+                        `[test-by-project] Debug session using Python path from project: ${launchArgs.python}`,
+                    );
+                }
+            } catch (error) {
+                traceVerbose(`[test-by-project] Could not get environment for project, using default: ${error}`);
+            }
         }
 
         return launchArgs;

src/client/testing/common/types.ts

@@ -2,6 +2,7 @@ import { CancellationToken, DebugSessionOptions, OutputChannel, Uri } from 'vsco
 import { Product } from '../../common/types';
 import { TestSettingsPropertyNames } from '../configuration/types';
 import { TestProvider } from '../types';
+import { PythonProject } from '../../envExt/types';
 
 export type UnitTestProduct = Product.pytest | Product.unittest;
 
@@ -27,15 +28,12 @@ export type LaunchOptions = {
     pytestUUID?: string;
     runTestIdsPort?: string;
     /**
-     * Optional explicit Python path for project-based execution.
-     * When provided, debug sessions should use this interpreter instead of the workspace default.
+     * Optional Python project for project-based execution.
+     * When provided, the debug launcher will:
+     * - Use the project's associated Python environment
+     * - Name the debug session after the project
      */
-    pythonPath?: string;
-    /**
-     * Optional name for the debug session (e.g., project name).
-     * Used to identify debug sessions in the VS Code debug panel.
-     */
-    debugSessionName?: string;
+    project?: PythonProject;
 };
 
 export enum TestFilter {

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

@@ -10,6 +10,7 @@ import { ITestDebugLauncher } from '../../common/types';
 import { ProjectAdapter } from './projectAdapter';
 import { TestProjectRegistry } from './testProjectRegistry';
 import { getProjectId } from './projectUtils';
+import { getEnvExtApi, useEnvExtension } from '../../../envExt/api.internal';
 
 /**
  * Dependencies required for project-based test execution.
@@ -50,7 +51,7 @@ export async function executeTestsForProjects(
     }
 
     // Group test items by project
-    const testsByProject = groupTestItemsByProject(testItems, projects);
+    const testsByProject = await groupTestItemsByProject(testItems, projects);
 
     const isDebugMode = request.profile?.kind === TestRunProfileKind.Debug;
     traceInfo(`[test-by-project] Executing tests across ${testsByProject.size} project(s), debug=${isDebugMode}`);
@@ -99,23 +100,49 @@ export async function executeTestsForProjects(
 }
 
 /**
- * Groups test items by their owning project based on file path matching.
- * Each test item's URI is matched against project root paths.
+ * Lookup context for project resolution during a single test run.
+ * Maps file paths to their resolved ProjectAdapter to avoid
+ * repeated API calls and linear searches.
+ * Created fresh per run and discarded after grouping completes.
  */
-export function groupTestItemsByProject(
+interface ProjectLookupContext {
+    /** Maps file URI fsPath → resolved ProjectAdapter (or undefined if no match) */
+    uriToAdapter: Map<string, ProjectAdapter | undefined>;
+    /** Maps project URI fsPath → ProjectAdapter for O(1) adapter lookup */
+    projectPathToAdapter: Map<string, ProjectAdapter>;
+}
+
+/**
+ * Groups test items by their owning project using the Python Environment API.
+ * Each test item's URI is matched to a project via the API's getPythonProject method.
+ * Falls back to path-based matching when the extension API is not available.
+ *
+ * Uses a per-run cache to avoid redundant API calls for test items sharing the same file.
+ *
+ * Time complexity: O(n + p) amortized, where n = test items, p = projects
+ * - Building adapter lookup map: O(p)
+ * - Each test item: O(1) amortized (cached after first lookup per unique file)
+ */
+export async function groupTestItemsByProject(
     testItems: TestItem[],
     projects: ProjectAdapter[],
-): Map<string, { project: ProjectAdapter; items: TestItem[] }> {
+): Promise<Map<string, { project: ProjectAdapter; items: TestItem[] }>> {
     const result = new Map<string, { project: ProjectAdapter; items: TestItem[] }>();
 
     // Initialize entries for all projects
     for (const project of projects) {
         result.set(getProjectId(project.projectUri), { project, items: [] });
     }
 
+    // Build lookup context for this run - O(p) setup, enables O(1) lookups
+    const lookupContext: ProjectLookupContext = {
+        uriToAdapter: new Map(),
+        projectPathToAdapter: new Map(projects.map((p) => [p.projectUri.fsPath, p])),
+    };
+
     // Assign each test item to its project
     for (const item of testItems) {
-        const project = findProjectForTestItem(item, projects);
+        const project = await findProjectForTestItem(item, projects, lookupContext);
         if (project) {
             const entry = result.get(getProjectId(project.projectUri));
             if (entry) {
@@ -139,9 +166,64 @@ export function groupTestItemsByProject(
 
 /**
  * Finds the project that owns a test item based on the test item's URI.
+ * Uses the Python Environment extension API when available, falling back
+ * to path-based matching (longest matching path prefix).
+ *
+ * Results are stored in the lookup context to avoid redundant API calls for items in the same file.
+ * Time complexity: O(1) amortized with context, O(p) worst case on context miss.
+ */
+export async function findProjectForTestItem(
+    item: TestItem,
+    projects: ProjectAdapter[],
+    lookupContext?: ProjectLookupContext,
+): Promise<ProjectAdapter | undefined> {
+    if (!item.uri) return undefined;
+
+    const uriPath = item.uri.fsPath;
+
+    // Check lookup context first - O(1)
+    if (lookupContext?.uriToAdapter.has(uriPath)) {
+        return lookupContext.uriToAdapter.get(uriPath);
+    }
+
+    let result: ProjectAdapter | undefined;
+
+    // Try using the Python Environment extension API first
+    if (useEnvExtension()) {
+        try {
+            const envExtApi = await getEnvExtApi();
+            const pythonProject = envExtApi.getPythonProject(item.uri);
+            if (pythonProject) {
+                // Use lookup context for O(1) adapter lookup instead of O(p) linear search
+                result = lookupContext?.projectPathToAdapter.get(pythonProject.uri.fsPath);
+                if (!result) {
+                    // Fallback to linear search if lookup context not available
+                    result = projects.find((p) => p.projectUri.fsPath === pythonProject.uri.fsPath);
+                }
+            }
+        } catch (error) {
+            traceVerbose(`[test-by-project] Failed to use env extension API, falling back to path matching: ${error}`);
+        }
+    }
+
+    // Fallback: path-based matching (most specific/longest path wins)
+    if (!result) {
+        result = findProjectByPath(item, projects);
+    }
+
+    // Store result for future lookups of same file within this run - O(1)
+    if (lookupContext) {
+        lookupContext.uriToAdapter.set(uriPath, result);
+    }
+
+    return result;
+}
+
+/**
+ * Finds the project that owns a test item using path-based matching.
  * Returns the most specific (longest path) matching project.
  */
-export function findProjectForTestItem(item: TestItem, projects: ProjectAdapter[]): ProjectAdapter | undefined {
+function findProjectByPath(item: TestItem, projects: ProjectAdapter[]): ProjectAdapter | undefined {
     if (!item.uri) return undefined;
 
     const itemPath = item.uri.fsPath;

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

@@ -176,10 +176,8 @@ export class PytestTestExecutionAdapter implements ITestExecutionAdapter {
                     testProvider: PYTEST_PROVIDER,
                     runTestIdsPort: testIdsFileName,
                     pytestPort: resultNamedPipeName,
-                    // Pass explicit Python path for project-based debugging
-                    pythonPath: project?.pythonEnvironment.execInfo?.run?.executable,
-                    // Pass project name for debug session identification
-                    debugSessionName: project?.projectName,
+                    // Pass project for project-based debugging (Python path and session name derived from this)
+                    project: project?.pythonProject,
                 };
                 const sessionOptions: DebugSessionOptions = {
                     testRun: runInstance,