second checkpoint- ignore implemented

Author: eleanorjboyd

python_files/unittestadapter/pvsc_utils.py

@@ -166,6 +166,44 @@ def get_child_node(name: str, path: str, type_: TestNodeTypeEnum, root: TestNode
     return result  # type:ignore
 
 
+# TODO: Unittest nested project exclusion - commented out for now, focusing on pytest first
+# def should_exclude_file(test_path: str) -> bool:
+#     """Check if a test file should be excluded due to nested project ownership.
+#
+#     Reads NESTED_PROJECTS_TO_IGNORE environment variable (JSON array of paths)
+#     and checks if test_path is under any of those nested project directories.
+#
+#     Args:
+#         test_path: Absolute path to the test file
+#
+#     Returns:
+#         True if the file should be excluded, False otherwise
+#     """
+#     nested_projects_json = os.getenv("NESTED_PROJECTS_TO_IGNORE")
+#     if not nested_projects_json:
+#         return False
+#
+#     try:
+#         nested_paths = json.loads(nested_projects_json)
+#         test_path_obj = pathlib.Path(test_path).resolve()
+#
+#         # Check if test file is under any nested project path
+#         for nested_path in nested_paths:
+#             nested_path_obj = pathlib.Path(nested_path).resolve()
+#             try:
+#                 test_path_obj.relative_to(nested_path_obj)
+#                 # If relative_to succeeds, test_path is under nested_path
+#                 return True
+#             except ValueError:
+#                 # test_path is not under nested_path
+#                 continue
+#
+#         return False
+#     except Exception:
+#         # On any error, don't exclude (safer to show tests than hide them)
+#         return False
+
+
 def build_test_tree(
     suite: unittest.TestSuite, top_level_directory: str
 ) -> Tuple[Union[TestNode, None], List[str]]:
@@ -251,6 +289,13 @@ def build_test_tree(
             # Find/build file node.
             path_components = [top_level_directory, *folders, py_filename]
             file_path = os.fsdecode(pathlib.PurePath("/".join(path_components)))
+
+            # PHASE 4: Check if file should be excluded (nested project ownership)
+            # TODO: Commented out for now - focusing on pytest implementation first
+            # if should_exclude_file(file_path):
+            #     # Skip this test - it belongs to a nested project
+            #     continue
+
             current_node = get_child_node(
                 py_filename, file_path, TestNodeTypeEnum.file, current_node
             )

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

@@ -85,6 +85,13 @@ export interface ProjectAdapter {
      */
     ownedTests?: DiscoveredTestNode;
 
+    /**
+     * Absolute paths of nested projects to ignore during discovery.
+     * Used to pass --ignore flags to pytest or exclusion filters to unittest.
+     * Only populated for parent projects that contain nested child projects.
+     */
+    nestedProjectPathsToIgnore?: string[];
+
     // === LIFECYCLE ===
     /**
      * Whether discovery is currently running for this project.

src/client/testing/testController/controller.ts

@@ -569,6 +569,62 @@ export class PythonTestController implements ITestController, IExtensionSingleAc
         }
     }
 
+    /**
+     * Phase 3: Identifies which projects are nested within other projects in the same workspace.
+     * Returns a map of parent project ID -> array of nested child project paths to ignore.
+     *
+     * Example: If ProjectB (alice/bob/) is nested in ProjectA (alice/),
+     * returns: { "projectA-id": ["alice/bob"] }
+     *
+     * Uses simple path prefix matching - a project is nested if its path starts with
+     * another project's path followed by a path separator.
+     */
+    private computeNestedProjectIgnores(workspaceUri: Uri): Map<string, string[]> {
+        const projectIgnores = new Map<string, string[]>();
+        const projects = this.workspaceProjects.get(workspaceUri);
+
+        if (!projects || projects.size === 0) {
+            return projectIgnores;
+        }
+
+        const projectArray = Array.from(projects.values());
+
+        // For each project, find all other projects nested within it
+        for (const parentProject of projectArray) {
+            const nestedPaths: string[] = [];
+
+            for (const potentialChild of projectArray) {
+                if (parentProject.projectId === potentialChild.projectId) {
+                    continue; // Skip self
+                }
+
+                // Check if child is nested under parent
+                const parentPath = parentProject.projectUri.fsPath;
+                const childPath = potentialChild.projectUri.fsPath;
+
+                // Use path.sep for cross-platform compatibility (/ on Unix, \\ on Windows)
+                if (childPath.startsWith(parentPath + path.sep)) {
+                    // Child is nested - add its path for ignoring
+                    nestedPaths.push(childPath);
+                    traceVerbose(
+                        `[test-by-project] Detected nested project: ${potentialChild.projectName} ` +
+                            `(${childPath}) under ${parentProject.projectName} (${parentPath})`,
+                    );
+                }
+            }
+
+            if (nestedPaths.length > 0) {
+                projectIgnores.set(parentProject.projectId, nestedPaths);
+                traceInfo(
+                    `[test-by-project] Project ${parentProject.projectName} will ignore ` +
+                        `${nestedPaths.length} nested project(s)`,
+                );
+            }
+        }
+
+        return projectIgnores;
+    }
+
     /**
      * 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.
@@ -596,7 +652,24 @@ export class PythonTestController implements ITestController, IExtensionSingleAc
         this.workspaceDiscoveryState.set(workspaceUri, discoveryState);
 
         try {
-            // Run discovery for all projects in parallel
+            // PHASE 3: Compute nested project relationships BEFORE discovery
+            const projectIgnores = this.computeNestedProjectIgnores(workspaceUri);
+
+            // Populate each project's ignore list by iterating through projects array directly
+            for (const project of projects) {
+                const ignorePaths = projectIgnores.get(project.projectId);
+                if (ignorePaths && ignorePaths.length > 0) {
+                    project.nestedProjectPathsToIgnore = ignorePaths;
+                    traceInfo(
+                        `[test-by-project] Project ${project.projectName} configured to ignore ${ignorePaths.length} nested project(s): ` +
+                            `${ignorePaths.join(', ')}`,
+                    );
+                } else {
+                    traceVerbose(`[test-by-project] Project ${project.projectName} has no nested projects to ignore`);
+                }
+            }
+
+            // Run discovery for all projects in parallel (now with ignore lists populated)
             // Each project will populate TestItems independently via existing flow
             await Promise.all(projects.map((project) => this.discoverProject(project, discoveryState)));
 

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

@@ -78,6 +78,25 @@ export class PytestTestDiscoveryAdapter implements ITestDiscoveryAdapter {
             let { pytestArgs } = settings.testing;
             const cwd = settings.testing.cwd && settings.testing.cwd.length > 0 ? settings.testing.cwd : uri.fsPath;
             pytestArgs = await handleSymlinkAndRootDir(cwd, pytestArgs);
+
+            // PHASE 4: Add --ignore flags for nested projects
+            traceVerbose(
+                `[test-by-project] Checking for nested projects to ignore. Project: ${project?.projectName}, ` +
+                    `nestedProjectPathsToIgnore length: ${project?.nestedProjectPathsToIgnore?.length ?? 0}`,
+            );
+            if (project?.nestedProjectPathsToIgnore?.length) {
+                const ignoreArgs = project.nestedProjectPathsToIgnore.map((nestedPath) => `--ignore=${nestedPath}`);
+                pytestArgs = [...pytestArgs, ...ignoreArgs];
+                traceInfo(
+                    `[test-by-project] Project ${project.projectName} ignoring ${ignoreArgs.length} ` +
+                        `nested project(s): ${ignoreArgs.join(' ')}`,
+                );
+            } else {
+                traceVerbose(
+                    `[test-by-project] No nested projects to ignore for project: ${project?.projectName ?? 'unknown'}`,
+                );
+            }
+
             const commandArgs = ['-m', 'pytest', '-p', 'vscode_pytest', '--collect-only'].concat(pytestArgs);
             traceVerbose(
                 `Running pytest discovery with command: ${commandArgs.join(' ')} for workspace ${uri.fsPath}.`,

src/client/testing/testController/unittest/testDiscoveryAdapter.ts

@@ -91,6 +91,18 @@ export class UnittestTestDiscoveryAdapter implements ITestDiscoveryAdapter {
                 mutableEnv.PROJECT_ROOT_PATH = project.projectUri.fsPath;
             }
 
+            // PHASE 4: Pass exclusion list via environment variable for unittest
+            // TODO: unittest doesn't have a built-in --ignore flag like pytest, so we'll need to pass the
+            // nested project paths via environment and handle filtering in Python-side discovery.py
+            // Commenting out for now - focusing on pytest implementation first
+            // if (project?.nestedProjectPathsToIgnore?.length) {
+            //     mutableEnv.NESTED_PROJECTS_TO_IGNORE = JSON.stringify(project.nestedProjectPathsToIgnore);
+            //     traceInfo(
+            //         `[test-by-project] Project ${project.projectName} will exclude ${project.nestedProjectPathsToIgnore.length} ` +
+            //         `nested project(s) in Python-side unittest discovery`
+            //     );
+            // }
+
             // Setup process handlers (shared by both execution paths)
             const handlers = createProcessHandlers('unittest', uri, cwd, this.resultResolver, deferredTillExecClose);