py-wlcli 0.8.0__py3-none-any.whl

wl_cli/commands/testcommands/coverage_cache_manager.py

@@ -0,0 +1,183 @@
+"""Coverage cache management module (the coverage cache adapter).
+
+This is one of the three adapters over the single cache seam
+:class:`~wl_cli.utils.cache_ledger.CacheLedger` (#213, ADR-0011). It owns what
+this cache decides for itself -- the key inputs, the user-level location and the
+7-day TTL. Key spelling, storage, freshness and the error policy are the
+ledger's.
+
+The key stays on file **stat** metadata (``mtime_ns`` / ``ctime_ns`` / ``size``)
+rather than file content: ``ctime`` cannot be restored by the user, so a content
+change always moves the key, and the coverage pass does not have to re-read every
+source and test file just to build a key (the performance trade-off recorded in
+#15). What #213 changed is the failure path: when a file cannot be ``stat``-ed
+there is no truthful key, so **nothing is cached** for that run instead of
+silently keying on the path alone.
+"""
+
+from pathlib import Path
+from typing import Any, cast
+
+from ...utils.cache_ledger import CacheInputs, CacheLedger
+from ...utils.config import get_config
+
+_DEFAULT_CACHE_ROOT = Path.home() / ".cache" / "wl"
+
+#: Returned by :meth:`CoverageCacheManager.get_cache_key` when a file's
+#: ``stat`` failed, so no truthful key exists. ``KeyedStore`` refuses the empty
+#: string as a key, and the two cache operations below guard on it explicitly:
+#: a read is a miss and a write is a no-op. The call sites therefore need no
+#: special case -- an unkeyed run simply never caches.
+UNKEYED = ""
+
+
+def _default_coverage_cache_dir() -> Path:
+    """Resolve the default coverage cache directory.
+
+    Mirrors the test-cache root resolution (the ``test_cache.cache_dir`` config
+    key, falling back to ``~/.cache/wl``) and appends ``test-cache/coverage``.
+
+    Returns:
+        Path to the default coverage cache directory.
+    """
+    configured = get_config("test_cache.cache_dir", None)
+    root = (
+        Path(configured).expanduser()
+        if isinstance(configured, str) and configured
+        else _DEFAULT_CACHE_ROOT
+    )
+    return root / "test-cache" / "coverage"
+
+
+class CoverageCacheManager:
+    """Cache whole ``coverage.json`` payloads, keyed by the files they describe.
+
+    Responsibilities:
+    - Answer the key inputs: every source and test file's path plus its stat
+      metadata, in sorted path order
+    - Read and write coverage payloads through the ledger
+    - Own the location (user-level) and the TTL (7 days); the ledger owns the
+      mechanism
+    """
+
+    CACHE_EXPIRY_SECONDS = 7 * 86400  # 7 days
+    NAMESPACE = "coverage"
+
+    def __init__(self, cache_dir: Path | None = None) -> None:
+        """Initialize CoverageCacheManager.
+
+        Args:
+            cache_dir: Directory holding coverage cache entries. Defaults to
+                ``<test_cache.cache_dir>/test-cache/coverage``.
+        """
+        self._ledger = CacheLedger(
+            cache_dir if cache_dir is not None else _default_coverage_cache_dir(),
+            self.CACHE_EXPIRY_SECONDS,
+        )
+
+    def get_cache_key(self, source_files: list[Path], test_files: list[Path]) -> str:
+        """Build the coverage cache key from the files the coverage describes.
+
+        Args:
+            source_files: List of source code files
+            test_files: List of corresponding test files
+
+        Returns:
+            The ledger key (``coverage_`` plus the full SHA-256 digest), or
+            :data:`UNKEYED` when any file's ``stat`` failed. In that case the
+            caller gets a miss on read and a no-op on write: a key that ignored
+            a file's identity would serve one run's coverage to another run.
+        """
+        parts: list[str] = []
+        for file_path in (
+            *sorted(source_files, key=str),
+            *sorted(test_files, key=str),
+        ):
+            part = self._file_part(file_path)
+            if part is None:
+                return UNKEYED
+            parts.append(part)
+
+        return self._ledger.key(CacheInputs(self.NAMESPACE, tuple(parts)))
+
+    def get_cached_coverage(self, cache_key: str) -> dict[str, Any] | None:
+        """Get cached coverage data from the cache.
+
+        A read failure of any kind -- missing entry, unreadable file, corrupt
+        JSON, an expired entry -- is a miss, never an exception.
+
+        Args:
+            cache_key: The cache key to look up; :data:`UNKEYED` always misses.
+
+        Returns:
+            Cached coverage data as dictionary, or None if there is no usable
+            entry.
+        """
+        if not cache_key:
+            return None
+        entry = self._ledger.get(cache_key)
+        if entry is None:
+            return None
+
+        coverage_data = entry.get("coverage_data")
+        return cast("dict[str, Any] | None", coverage_data) if coverage_data else None
+
+    def save_cached_coverage(
+        self, cache_key: str, coverage_data: dict[str, Any]
+    ) -> bool:
+        """Save coverage data to the cache, atomically.
+
+        A failed write never breaks the coverage run: the ledger logs it and
+        returns ``False``.
+
+        Args:
+            cache_key: The cache key to use; :data:`UNKEYED` writes nothing.
+            coverage_data: Coverage data to cache.
+
+        Returns:
+            True if the entry was written; False when the key is
+            :data:`UNKEYED` or the write failed.
+        """
+        if not cache_key:
+            return False
+        return self._ledger.put(
+            cache_key,
+            {"coverage_data": coverage_data, "version": "2.0"},
+        )
+
+    @staticmethod
+    def _file_part(file_path: Path) -> str | None:
+        """One file's contribution to the key, or ``None`` when it is unknown.
+
+        The part is the normalized path plus the stat metadata the key has
+        always used (``mtime_ns`` / ``ctime_ns`` / ``size``). A ``stat``
+        failure returns ``None`` rather than a path-only part: the file's
+        identity is then unknown, and an entry keyed without it could be served
+        to a later run that is not this run (#213, replacing the old
+        ``except Exception: pass``).
+
+        Args:
+            file_path: The file to describe.
+
+        Returns:
+            The part, or ``None`` if ``stat`` failed.
+        """
+        try:
+            stat_result = file_path.stat()
+        except (OSError, ValueError):
+            # ``OSError``: the file vanished or cannot be inspected. ``ValueError``:
+            # the path itself is unusable (an embedded NUL), which can name no
+            # file and so can yield no truthful key either. Both mean the same
+            # thing here, and nothing else is expected from ``stat`` (#213
+            # review NIT-7).
+            return None
+
+        path_str = str(file_path).replace("\\", "/")
+        return "\0".join(
+            (
+                path_str,
+                str(stat_result.st_mtime_ns),
+                str(stat_result.st_ctime_ns),
+                str(stat_result.st_size),
+            )
+        )

wl_cli/commands/testcommands/progress_manager.py

@@ -0,0 +1,79 @@
+"""Progress manager module for test commands."""
+
+import os
+from pathlib import Path
+
+
+class ProgressManager:
+    """Progress manager for displaying test progress."""
+
+    def _truncate_filename(self, filename):
+        """Truncate filename to fit in progress bar."""
+        max_len = 28
+        if len(filename) > max_len:
+            return filename[: max_len - 3] + "..."
+        return filename
+
+    def _update_test_progress(self, pbar, truncated_name, test_file, cache_hits):
+        """Update progress bar for test processing with cache details."""
+        # Check if this file used cached result
+        if test_file.name in cache_hits:
+            # Show cached status in progress bar
+            pbar.set_description(f"Testing {truncated_name:<28} [cached]")
+        else:
+            # Normal testing status
+            pbar.set_description(f"Testing {truncated_name:<28}")
+
+        pbar.update(1)
+
+    def _log_report_mode(self, report_mode: bool, concise: bool = False) -> None:
+        try:
+            from ...utils.logging import log_info_pair
+
+            if not concise:
+                log_info_pair(
+                    f"Report mode: {report_mode}",
+                    f"报告模式: {report_mode}",
+                )
+        except Exception:
+            pass
+
+    def _log_project_paths(
+        self, project_root: str, todo_dir: Path, concise: bool = False
+    ) -> None:
+        try:
+            from ...utils.logging import log_info_pair
+
+            if not concise:
+                log_info_pair(
+                    f"Project root: {project_root}",
+                    f"项目根目录: {project_root}",
+                )
+                log_info_pair(
+                    f"Todos dir: {todo_dir}",
+                    f"报告目录: {todo_dir}",
+                )
+        except Exception:
+            pass
+
+    def _build_env(self, project_root: str) -> dict:
+        env = os.environ.copy()
+        src_path = os.path.join(project_root, "src")
+        if "PYTHONPATH" in env:
+            env["PYTHONPATH"] = f"{src_path}{os.pathsep}{env['PYTHONPATH']}"
+        else:
+            env["PYTHONPATH"] = src_path
+        return env
+
+    def project_root(self) -> str:
+        """The project root the test run is anchored to, as a string.
+
+        A plain forwarder to the test subsystem's policy entry point
+        (:func:`~wl_cli.commands.testcommands.utils.project_root.project_root_for`),
+        which owns the ``tests/``/``src/`` pre-check and the CWD fallback
+        (ADR 0006: the fallback is the caller's policy, not the root module's).
+        It stays a method so callers keep a single, mockable seam.
+        """
+        from .utils.project_root import project_root_for
+
+        return project_root_for()

wl_cli/commands/testcommands/python_env_detector.py

@@ -0,0 +1,207 @@
+"""
+Python environment detection utilities for test command.
+"""
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+from ...utils.logging import log_debug
+from ...utils.platform_adapter import PlatformAdapter
+from ...utils.workspace_detector import WorkspaceDetector
+from .utils.project_root import project_root_for
+
+
+class PythonEnvDetector:
+    """Detect Python executable in different environments.
+
+    ``root`` is the directory the detection is anchored to; ``None`` -- the
+    default -- keeps the historical behaviour of resolving against the process
+    working directory, which is what ``wl test`` relies on (it is invoked *in*
+    the directory it is asked about). A caller whose subject runs somewhere else
+    must say so explicitly: ``wl gate``'s pytest leg is ``wl test`` launched in
+    the chain's anchor root, so its preflight has to ask about *that* root
+    rather than wherever the user happened to stand (issue #110).
+    """
+
+    def __init__(self, root: Path | None = None):
+        """Initialize Python environment detector.
+
+        Args:
+            root: Directory to anchor every lookup to. ``None`` means "the
+                process working directory", resolved lazily on each use so a
+                caller that never passes a root behaves exactly as before.
+        """
+        self.detector = WorkspaceDetector()
+        self._root = root
+
+    @property
+    def root(self) -> Path:
+        """The directory this detector resolves against."""
+        return Path.cwd() if self._root is None else self._root
+
+    def get_python_executable(self) -> str:
+        """
+        Get the Python executable path, using the same logic as wl build dist.
+
+        Returns:
+            str: Path to the Python executable
+        """
+        try:
+            python_exe, _ = self._resolve_python()
+            return python_exe or sys.executable
+        except Exception:
+            # 如果出现问题，回退到系统Python
+            return sys.executable
+
+    def _resolve_python(self) -> tuple[str | None, bool]:
+        """
+        Resolve Python executable path, with enhanced virtual environment detection.
+
+        Returns:
+            tuple: (python_path, is_virtual_env)
+        """
+        # 1. 检查是否在uv工作区环境中
+        is_workspace = self.detector.detect(self.root)
+        log_debug(f"uv workspace detected: {is_workspace}")
+
+        # 如果不在工作区，使用当前运行的Python解释器
+        if not is_workspace:
+            return sys.executable, False
+
+        # 2. 尝试通过不同方式查找虚拟环境中的Python
+        python_path = self._find_python_in_uv_workspace()
+        if python_path:
+            return python_path, True
+
+        python_path = self._find_python_in_custom_venv()
+        if python_path:
+            return python_path, True
+
+        python_path = self._find_python_in_environment_venv()
+        if python_path:
+            return python_path, True
+
+        # 3. 最后回退到系统Python
+        log_debug(f"Falling back to system Python: {sys.executable}")
+        return sys.executable, False
+
+    def _find_python_in_uv_workspace(self) -> str | None:
+        """查找uv工作区中的Python可执行文件。"""
+        venv_root = self.detector.get_venv_path(self.root)
+        if not venv_root:
+            return None
+
+        log_debug(f"get_venv_path result: {venv_root}")
+
+        # 尝试标准Python路径
+        python_exe = self._get_python_path_from_venv(venv_root)
+        if self._is_valid_python_executable(python_exe):
+            return python_exe
+
+        # 尝试python3路径
+        if not PlatformAdapter.is_windows():
+            python_exe_alt = str((venv_root / "bin" / "python3").absolute())
+            if self._is_valid_python_executable(python_exe_alt):
+                return python_exe_alt
+
+        # 尝试使用uv run
+        return self._get_python_using_uv_run()
+
+    def _find_python_in_custom_venv(self) -> str | None:
+        """使用_find_venv方法查找Python。"""
+        venv_path = self._find_venv()
+        if not venv_path:
+            return None
+
+        venv_root = Path(venv_path)
+        print(f"Debug: Found venv using _find_venv: {venv_root}")
+
+        python_exe = self._get_python_path_from_venv(venv_root)
+        if self._is_valid_python_executable(python_exe):
+            return python_exe
+
+        return None
+
+    def _find_python_in_environment_venv(self) -> str | None:
+        """通过VIRTUAL_ENV环境变量查找Python。"""
+        virtual_env = os.environ.get("VIRTUAL_ENV")
+        if not virtual_env:
+            return None
+
+        venv_root = Path(virtual_env)
+        print(f"Debug: Using VIRTUAL_ENV: {venv_root}")
+
+        python_exe = self._get_python_path_from_venv(venv_root)
+        if self._is_valid_python_executable(python_exe):
+            return python_exe
+
+        return None
+
+    def _get_python_path_from_venv(self, venv_root: Path) -> str:
+        """从虚拟环境根目录构造Python可执行文件路径。"""
+        if PlatformAdapter.is_windows():
+            return str((venv_root / "Scripts" / "python.exe").absolute())
+        else:
+            return str((venv_root / "bin" / "python").absolute())
+
+    def _is_valid_python_executable(self, python_path: str) -> bool:
+        """检查Python可执行文件是否存在。"""
+        log_debug(f"Checking Python executable at: {python_path}")
+        if Path(python_path).exists():
+            log_debug(f"Successfully found Python executable: {python_path}")
+            return True
+        log_debug(f"Python executable does not exist at: {python_path}")
+        return False
+
+    def _get_python_using_uv_run(self) -> str | None:
+        """使用uv run获取Python可执行文件路径。
+
+        ``cwd`` 与其它查找同源：``uv run`` 解析的是**运行目录**所属的项目，
+        所以锚定 root 的调用必须在这里也用它，否则会问到另一个项目（#110）。
+        ``None`` 仍然是「继承进程工作目录」，与改动前逐字节相同。
+        """
+        try:
+            result = subprocess.run(
+                [
+                    "uv",
+                    "run",
+                    "python",
+                    "-c",
+                    "import sys; print(sys.executable)",
+                ],
+                cwd=self._root,
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+            uv_python = result.stdout.strip()
+            log_debug(f"Using uv run python result: {uv_python}")
+            if Path(uv_python).exists():
+                return uv_python
+        except Exception as e:
+            log_debug(f"uv run python failed: {e}")
+        return None
+
+    def _find_venv(self) -> str | None:
+        """
+        Find virtual environment path if it exists.
+
+        Returns:
+            str | None: Path to virtual environment or None if not found
+        """
+
+        project_root = project_root_for(self._root)
+
+        # Check common virtual environment locations
+        possible_venv_paths = [
+            os.path.join(project_root, ".venv"),
+            os.path.join(project_root, "venv"),
+        ]
+
+        for venv_path in possible_venv_paths:
+            if os.path.exists(os.path.join(venv_path, "pyvenv.cfg")):
+                return venv_path
+
+        return None

wl_cli/commands/testcommands/report_generator.py

@@ -0,0 +1,101 @@
+"""Report generator for test results."""
+
+import time
+from pathlib import Path
+
+from ...utils.logging import log_info_pair
+from .test_reporter import generate_reports
+
+
+class ReportGenerator:
+    """Generates test reports after test completion."""
+
+    def generate(
+        self,
+        todo_dir: Path,
+        project_root: str,
+        verbose: bool = False,
+    ) -> None:
+        """Generate coverage and error reports."""
+        try:
+            cov_json = str(todo_dir / "coverage.json")
+            junit_xml = str(todo_dir / "junit.xml")
+            cov_md = str(todo_dir / "coverage.md")
+            err_md = str(todo_dir / "error.md")
+
+            self._log_report_paths(cov_json, junit_xml, verbose)
+
+            summary = generate_reports(
+                coverage_json_path=cov_json,
+                junit_xml_path=junit_xml,
+                out_cov=cov_md,
+                out_err=err_md,
+                project_root=project_root,
+            )
+
+            self._log_output_paths(cov_md, err_md, verbose)
+
+            if summary and verbose:
+                print(summary)
+
+            # Ensure files are fully written
+            time.sleep(0.5)
+            self._cleanup_temp_files(cov_json, junit_xml)
+        except Exception as e:
+            print(f"Failed to generate markdown reports: {e}")
+
+    def _log_report_paths(
+        self,
+        cov_json: str,
+        junit_xml: str,
+        verbose: bool = False,
+    ) -> None:
+        """Log report file paths."""
+        try:
+            if verbose:
+                log_info_pair(
+                    f"Coverage JSON path: {cov_json}",
+                    f"Coverage JSON路径: {cov_json}",
+                )
+                log_info_pair(
+                    f"JUnit XML path: {junit_xml}",
+                    f"JUnit XML路径: {junit_xml}",
+                )
+                log_info_pair(
+                    f"Coverage JSON exists: {Path(cov_json).exists()}",
+                    f"覆盖率JSON存在: {Path(cov_json).exists()}",
+                )
+                log_info_pair(
+                    f"JUnit XML exists: {Path(junit_xml).exists()}",
+                    f"JUnit XML存在: {Path(junit_xml).exists()}",
+                )
+        except Exception:
+            pass
+
+    def _log_output_paths(
+        self,
+        cov_md: str,
+        err_md: str,
+        verbose: bool = False,
+    ) -> None:
+        """Log output report paths."""
+        try:
+            if verbose:
+                log_info_pair(
+                    f"Coverage MD path: {cov_md}",
+                    f"Coverage MD存在: {Path(cov_md).exists()}",
+                )
+                log_info_pair(
+                    f"Error MD path: {err_md}",
+                    f"错误MD存在: {Path(err_md).exists()}",
+                )
+        except Exception:
+            pass
+
+    def _cleanup_temp_files(self, cov_json: str, junit_xml: str) -> None:
+        """Clean up temporary files after report generation."""
+        try:
+            Path(cov_json).unlink(missing_ok=True)
+            Path(junit_xml).unlink(missing_ok=True)
+        except Exception:
+            pass