fix(verify): discover related tests across languages

Extend related test discovery beyond Python using conservative conventions for Go, Rust, JavaScript/TypeScript, C, and C++ test files. Keep Python's existing scoped pytest behavior, but continue running project-level verification for non-Python backends so file paths are not misused as backend-specific test selectors.

Update post-verification logging to report related test hints separately from the actual project test command, and add regression coverage for multi-language discovery plus non-Python full-suite safety.

Author: QingtaoLi1

CoderMind/scripts/code_gen/post_verify.py

@@ -111,12 +111,18 @@ def _git_diff_test_files(prefix: str = "tests/") -> list:
         # fall back to all tests so no regression goes undetected.
         test_files = _git_diff_test_files("tests/test_")
 
+    regular_file = not (task.file_path.startswith("<") and task.file_path.endswith(">"))
+    backend_hint_files = test_files or ([task.file_path] if regular_file else None)
+    backend = resolve_test_backend(valid_files=backend_hint_files, repo_path=repo_path)
+    run_test_files = test_files if backend.name == "python" else None
+
     logger.info(
-        "Post-verification: running pytest on %s",
-        test_files if test_files else "all tests",
+        "Post-verification: related test files=%s; running %s project tests on %s",
+        test_files if test_files else "none",
+        backend.display_name,
+        run_test_files if run_test_files else "all tests",
     )
 
-    backend = resolve_test_backend(valid_files=test_files or None, repo_path=repo_path)
     if backend.name == "python":
         try:
             ensure_deps_installed(repo_path)
@@ -125,7 +131,7 @@ def _git_diff_test_files(prefix: str = "tests/") -> list:
 
     result = run_project_tests(
         repo_path,
-        test_files=test_files or None,
+        test_files=run_test_files,
         timeout=timeout,
         extra_args=[f"--timeout={DEFAULT_TEST_TIMEOUT}", "--timeout-method=thread"],
         backend=backend,

CoderMind/scripts/code_gen/test_runner.py

@@ -116,35 +116,22 @@ def find_test_files_in_directory(
     return sorted(test_files)
 
 
-def find_related_test_files(
-    source_file: str,
-    repo_root: Path
-) -> List[str]:
-    """Find test files related to a source file using path-signature matching.
-
-    Builds a canonical signature from the source path by stripping common
-    prefixes (``src/``, ``lib/``) and the project-package directory, then
-    joining remaining directory parts + stem with ``_``.
-
-    Example::
-
-        src/flask_blog/auth/views.py  → signature "auth_views"
-        tests/test_auth_views.py      → match ✓
-
-    If no signature match is found, falls back to simple stem matching
-    (the legacy behavior).
-
-    Args:
-        source_file: Path to the source file (relative to repo root)
-        repo_root: Repository root path
+def _existing_relative_paths(repo_root: Path, candidates: List[Path]) -> List[str]:
+    """Return existing candidate paths relative to ``repo_root`` without duplicates."""
+    seen: Set[str] = set()
+    found: List[str] = []
+    for candidate in candidates:
+        if not candidate.exists() or not candidate.is_file():
+            continue
+        rel = str(candidate.relative_to(repo_root))
+        if rel not in seen:
+            seen.add(rel)
+            found.append(rel)
+    return found
 
-    Returns:
-        List of related test file paths (relative to repo root)
-    """
-    source_path = Path(source_file)
-    if source_path.suffix != '.py':
-        return []
 
+def _find_related_python_tests(source_path: Path, repo_root: Path) -> List[str]:
+    """Find Python tests related to ``source_path`` using legacy heuristics."""
     # --- Build canonical signature from source path ---
     # Strip known prefixes: "src", "lib"
     skip_prefixes = {'src', 'lib'}
@@ -197,6 +184,78 @@ def find_related_test_files(
     return related_tests
 
 
+def _find_related_non_python_tests(source_path: Path, repo_root: Path) -> List[str]:
+    """Find likely related non-Python test files using common naming conventions.
+
+    These are discovery hints only.  Non-Python post-verification still runs the
+    backend's project-level test command unless a backend-specific selector layer
+    explicitly supports scoped execution.
+    """
+    suffix = source_path.suffix.lower()
+    stem = source_path.stem
+    parent = repo_root / source_path.parent
+    tests_dir = repo_root / "tests"
+
+    if suffix == ".go":
+        return _existing_relative_paths(repo_root, [parent / f"{stem}_test.go"])
+
+    if suffix == ".rs":
+        return _existing_relative_paths(repo_root, [
+            parent / f"{stem}_test.rs",
+            tests_dir / f"{stem}.rs",
+            tests_dir / f"{stem}_test.rs",
+        ])
+
+    if suffix in {".ts", ".tsx", ".js", ".jsx"}:
+        variants = [
+            f"{stem}.test{suffix}",
+            f"{stem}.spec{suffix}",
+        ]
+        return _existing_relative_paths(repo_root, [
+            *(parent / name for name in variants),
+            *(parent / "__tests__" / name for name in variants),
+            *(tests_dir / name for name in variants),
+            *(tests_dir / source_path.parent.name / name for name in variants),
+        ])
+
+    c_suffixes = {".c": [".c"], ".cpp": [".cpp", ".cc", ".cxx"], ".cc": [".cc", ".cpp", ".cxx"], ".cxx": [".cxx", ".cpp", ".cc"]}
+    if suffix in c_suffixes:
+        names = []
+        for ext in c_suffixes[suffix]:
+            names.extend([f"test_{stem}{ext}", f"{stem}_test{ext}"])
+        return _existing_relative_paths(repo_root, [
+            *(parent / name for name in names),
+            *(tests_dir / name for name in names),
+        ])
+
+    return []
+
+
+def find_related_test_files(
+    source_file: str,
+    repo_root: Path
+) -> List[str]:
+    """Find test files likely related to a source file.
+
+    Python keeps the legacy path-signature matching. Other languages use
+    conservative file-name conventions (Go ``*_test.go``, JS/TS
+    ``*.test.*``/``*.spec.*``, C/C++ ``test_*``/``*_test`` and Rust common
+    integration-test names). These results are discovery hints; backend-specific
+    test execution decides whether scoped execution is safe.
+
+    Args:
+        source_file: Path to the source file (relative to repo root)
+        repo_root: Repository root path
+
+    Returns:
+        List of related test file paths (relative to repo root)
+    """
+    source_path = Path(source_file)
+    if source_path.suffix == '.py':
+        return _find_related_python_tests(source_path, repo_root)
+    return _find_related_non_python_tests(source_path, repo_root)
+
+
 def extract_files_from_diff(diff_content: str) -> Tuple[List[str], List[str]]:
     """Extract file paths from a git diff.
     

CoderMind/tests/test_post_verify.py

@@ -0,0 +1,55 @@
+import os
+import sys
+from dataclasses import dataclass
+
+# Ensure scripts/ is importable when tests run from the project root.
+_project_root = os.path.join(os.path.dirname(__file__), "..")
+sys.path.insert(0, os.path.join(_project_root, "scripts"))
+
+from code_gen import post_verify as post_verify_module
+from code_gen.test_runner import TestResult as RunnerTestResult
+from common.task_batch import PlannedTask
+
+
+@dataclass
+class _Backend:
+    name: str = "go"
+    display_name: str = "Go"
+
+
+def test_post_verify_keeps_non_python_project_tests_unscoped(monkeypatch, tmp_path):
+    source = tmp_path / "internal" / "store" / "store.go"
+    test = tmp_path / "internal" / "store" / "store_test.go"
+    source.parent.mkdir(parents=True)
+    source.write_text("package store\n", encoding="utf-8")
+    test.write_text("package store\n", encoding="utf-8")
+
+    task = PlannedTask(
+        task="Implement store",
+        file_path="internal/store/store.go",
+        units_key=["Store"],
+        unit_to_code={"Store": ""},
+        unit_to_features={"Store": []},
+    )
+
+    calls = {}
+
+    def fake_resolve_test_backend(valid_files=None, repo_path=None):
+        calls["valid_files"] = valid_files
+        return _Backend()
+
+    def fake_run_project_tests(repo_root, test_files=None, timeout=300, extra_args=None, env=None, backend=None):
+        calls["run_test_files"] = test_files
+        calls["backend"] = backend
+        return RunnerTestResult(success=True, return_code=0, output="ok", test_files=test_files or [])
+
+    monkeypatch.setattr(post_verify_module, "resolve_test_backend", fake_resolve_test_backend)
+    monkeypatch.setattr(post_verify_module, "run_project_tests", fake_run_project_tests)
+
+    passed, summary = post_verify_module.post_verify(tmp_path, task)
+
+    assert passed is True
+    assert "passed=0" in summary
+    assert calls["valid_files"] == ["internal/store/store_test.go"]
+    assert calls["run_test_files"] is None
+    assert calls["backend"].name == "go"

CoderMind/tests/test_related_test_discovery.py

@@ -0,0 +1,58 @@
+import os
+import sys
+
+# Ensure scripts/ is importable when tests run from the project root.
+_project_root = os.path.join(os.path.dirname(__file__), "..")
+sys.path.insert(0, os.path.join(_project_root, "scripts"))
+
+from code_gen.test_runner import find_related_test_files
+
+
+def _write(path, text=""):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(text, encoding="utf-8")
+
+
+def test_find_related_go_test_file(tmp_path):
+    _write(tmp_path / "internal" / "store" / "store.go")
+    _write(tmp_path / "internal" / "store" / "store_test.go")
+
+    assert find_related_test_files("internal/store/store.go", tmp_path) == [
+        "internal/store/store_test.go"
+    ]
+
+
+def test_find_related_typescript_test_file(tmp_path):
+    _write(tmp_path / "src" / "client.ts")
+    _write(tmp_path / "src" / "client.test.ts")
+
+    assert find_related_test_files("src/client.ts", tmp_path) == [
+        "src/client.test.ts"
+    ]
+
+
+def test_find_related_c_test_file(tmp_path):
+    _write(tmp_path / "src" / "task.c")
+    _write(tmp_path / "tests" / "test_task.c")
+
+    assert find_related_test_files("src/task.c", tmp_path) == [
+        "tests/test_task.c"
+    ]
+
+
+def test_find_related_cpp_test_file(tmp_path):
+    _write(tmp_path / "src" / "task.cpp")
+    _write(tmp_path / "tests" / "task_test.cpp")
+
+    assert find_related_test_files("src/task.cpp", tmp_path) == [
+        "tests/task_test.cpp"
+    ]
+
+
+def test_find_related_rust_test_file(tmp_path):
+    _write(tmp_path / "src" / "lib.rs")
+    _write(tmp_path / "tests" / "lib_test.rs")
+
+    assert find_related_test_files("src/lib.rs", tmp_path) == [
+        "tests/lib_test.rs"
+    ]