adding tests for helpers

Author: eleanorjboyd

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

@@ -4,23 +4,48 @@
 import * as crypto from 'crypto';
 import { PythonProject } from '../../../envExt/types';
 
+/**
+ * Separator used to scope test IDs to a specific project.
+ * Format: {projectId}{SEPARATOR}{testPath}
+ * Example: "project-abc123def456::test_file.py::test_name"
+ */
+export const PROJECT_ID_SEPARATOR = '::';
+
 /**
  * Generates a unique project ID by hashing the PythonProject object.
  * This ensures consistent IDs across extension reloads for the same project.
+ * Uses 16 characters of the hash to reduce collision probability.
  *
  * @param pythonProject The PythonProject object from the environment API
  * @returns A unique string identifier for the project
  */
 export function generateProjectId(pythonProject: PythonProject): string {
     // Create a stable string representation of the project
+    // Use URI as the primary identifier (stable across renames)
     const projectString = JSON.stringify({
-        name: pythonProject.name,
         uri: pythonProject.uri.toString(),
+        name: pythonProject.name,
     });
 
     // Generate a hash to create a shorter, unique ID
+    // Using 16 chars (64 bits) instead of 12 (48 bits) for better collision resistance
     const hash = crypto.createHash('sha256').update(projectString).digest('hex');
-    return `project-${hash.substring(0, 12)}`;
+    return `project-${hash.substring(0, 16)}`;
+}
+
+/**
+ * Parses a project-scoped vsId back into its components.
+ *
+ * @param vsId The VS Code test item ID to parse
+ * @returns A tuple of [projectId, runId]. If the ID is not project-scoped,
+ *          returns [undefined, vsId] (legacy format)
+ */
+export function parseVsId(vsId: string): [string | undefined, string] {
+    const separatorIndex = vsId.indexOf(PROJECT_ID_SEPARATOR);
+    if (separatorIndex === -1) {
+        return [undefined, vsId]; // Legacy ID without project scope
+    }
+    return [vsId.substring(0, separatorIndex), vsId.substring(separatorIndex + PROJECT_ID_SEPARATOR.length)];
 }
 
 /**

src/client/testing/testController/controller.ts

@@ -52,7 +52,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, WorkspaceDiscoveryState } from './common/projectAdapter';
+import { ProjectAdapter } from './common/projectAdapter';
 import { generateProjectId, createProjectDisplayName } from './common/projectUtils';
 import { PythonProject, PythonEnvironment } from '../../envExt/types';
 import { getEnvExtApi, useEnvExtension } from '../../envExt/api.internal';
@@ -73,17 +73,11 @@ export class PythonTestController implements ITestController, IExtensionSingleAc
     // Map of workspace URI -> Map of project ID -> ProjectAdapter
     private readonly workspaceProjects: Map<Uri, Map<string, ProjectAdapter>> = new Map();
 
-    // Fast lookup maps for execution
-    // @ts-expect-error - used when useProjectBasedTesting=true
-    private readonly vsIdToProject: Map<string, ProjectAdapter> = new Map();
-    // @ts-expect-error - used when useProjectBasedTesting=true
-    private readonly fileUriToProject: Map<string, ProjectAdapter> = new Map();
-    // @ts-expect-error - used when useProjectBasedTesting=true
-    private readonly projectToVsIds: Map<string, Set<string>> = new Map();
-
-    // Temporary discovery state (created during discovery, cleared after)
-    // @ts-expect-error - used when useProjectBasedTesting=true
-    private readonly workspaceDiscoveryState: Map<Uri, WorkspaceDiscoveryState> = new Map();
+    // TODO: Phase 3-4 - Add these maps when implementing discovery and 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[] = [];
 
@@ -236,51 +230,49 @@ export class PythonTestController implements ITestController, IExtensionSingleAc
         // Try to use project-based testing if environment extension is enabled
         if (useEnvExtension()) {
             traceInfo('[test-by-project] Activating project-based testing mode');
-            try {
-                await Promise.all(
-                    Array.from(workspaces).map(async (workspace) => {
-                        traceInfo(`[test-by-project] Processing workspace: ${workspace.uri.fsPath}`);
-                        try {
-                            // Discover projects in this workspace
-                            const projects = await this.discoverWorkspaceProjects(workspace.uri);
-
-                            // Create map for this workspace
-                            const projectsMap = new Map<string, ProjectAdapter>();
-                            projects.forEach((project) => {
-                                projectsMap.set(project.projectId, project);
-                            });
-
-                            this.workspaceProjects.set(workspace.uri, projectsMap);
-
-                            traceInfo(
-                                `[test-by-project] Discovered ${projects.length} project(s) for workspace ${workspace.uri.fsPath}`,
-                            );
-
-                            // Set up file watchers if auto-discovery is enabled
-                            const settings = this.configSettings.getSettings(workspace.uri);
-                            if (settings.testing.autoTestDiscoverOnSaveEnabled) {
-                                traceVerbose(`Testing: Setting up watcher for ${workspace.uri.fsPath}`);
-                                this.watchForSettingsChanges(workspace);
-                                this.watchForTestContentChangeOnSave();
-                            }
-                        } catch (error) {
-                            traceError(
-                                `[test-by-project] Failed to activate project-based testing for ${workspace.uri.fsPath}:`,
-                                error,
-                            );
-                            traceInfo('[test-by-project] Falling back to legacy mode for this workspace');
-                            // Fall back to legacy mode for this workspace
-                            await this.activateLegacyWorkspace(workspace);
-                        }
-                    }),
-                );
-                return;
-            } catch (error) {
-                traceError(
-                    '[test-by-project] Failed to activate project-based testing, falling back to legacy mode:',
-                    error,
-                );
-            }
+
+            // Use Promise.allSettled to allow partial success in multi-root workspaces
+            const results = await Promise.allSettled(
+                Array.from(workspaces).map(async (workspace) => {
+                    traceInfo(`[test-by-project] Processing workspace: ${workspace.uri.fsPath}`);
+
+                    // Discover projects in this workspace
+                    const projects = await this.discoverWorkspaceProjects(workspace.uri);
+
+                    // Create map for this workspace
+                    const projectsMap = new Map<string, ProjectAdapter>();
+                    projects.forEach((project) => {
+                        projectsMap.set(project.projectId, project);
+                    });
+
+                    traceInfo(
+                        `[test-by-project] Discovered ${projects.length} project(s) for workspace ${workspace.uri.fsPath}`,
+                    );
+
+                    return { workspace, projectsMap };
+                }),
+            );
+
+            // Handle results individually - allows partial success
+            results.forEach((result, index) => {
+                const workspace = workspaces[index];
+                if (result.status === 'fulfilled') {
+                    this.workspaceProjects.set(workspace.uri, result.value.projectsMap);
+                    traceInfo(
+                        `[test-by-project] Successfully activated ${result.value.projectsMap.size} project(s) for ${workspace.uri.fsPath}`,
+                    );
+                    this.setupFileWatchers(workspace);
+                } else {
+                    traceError(
+                        `[test-by-project] Failed to activate project-based testing for ${workspace.uri.fsPath}:`,
+                        result.reason,
+                    );
+                    traceInfo('[test-by-project] Falling back to legacy mode for this workspace');
+                    // Fall back to legacy mode for this workspace only
+                    this.activateLegacyWorkspace(workspace);
+                }
+            });
+            return;
         }
 
         // Legacy activation (backward compatibility)