py-wlcli 0.8.0__py3-none-any.whl

wl_cli/commands/testcommands/single_test_executor.py

@@ -0,0 +1,250 @@
+"""Single test file executor with caching integration."""
+
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+
+from .cache_manager import CacheManager
+from .speed_checker import check_test_speeds, format_timeout_message, load_speed_config
+from .test_utils import _probe_pytest_cov
+
+
+class SingleTestExecutor:
+    """Executes single test file with caching support."""
+
+    def __init__(self, cache_manager: CacheManager):
+        """Initialize with cache manager dependency."""
+        self.cache_manager = cache_manager
+        # 每个解释器的 pytest-cov 可达性只探一次：判定结果按解释器缓存，避免
+        # `wl test -s` 逐文件重复起探针进程。
+        self._pytest_cov_cache: dict[str, bool] = {}
+
+    def execute(
+        self,
+        python_executable: str,
+        test_file: Path,
+        project_root: str,
+        env: dict[str, str],
+        debug_mode: bool,
+        no_cache: bool,
+        step_by_step: bool = False,
+        concise: bool = False,
+        no_skip: bool = False,
+        extra_args: list[str] | None = None,
+    ) -> tuple[bool, str]:
+        """Execute a single test file with caching check.
+
+        Args:
+            extra_args: Already-filtered passthrough pytest args to append to
+                this one file's command (see
+                ``test_runner._attribution_args``). The attribution pass uses
+                it so a file is judged under the same selection the batch run
+                used; ``None`` keeps every existing caller's command unchanged.
+        """
+        # Check if we can use cached result
+        if not no_cache:
+            cache_hit, cache_reason, _, _ = self._check_cache_for_single_file(
+                test_file, step_by_step, concise, python_executable
+            )
+            if cache_hit:
+                return True, ""
+        else:
+            # Skip cache
+            cache_reason = "Cache skipped - --no-cache option used"
+            if not concise and not step_by_step:
+                print(f"[Cache] {cache_reason} for {test_file.name}")
+
+        # Build pytest command
+        cmd_args = self._build_test_command(
+            python_executable, test_file, debug_mode, step_by_step, env, extra_args
+        )
+
+        # Execute pytest
+        result = self._execute_test(cmd_args, project_root, env)
+
+        # Process result
+        test_success, error_message = self._process_test_result(result)
+
+        # 归因转发了用户选择（rv183 P1）：pytest 退出码 5 表示「本文件没有跑任何
+        # 用例」，在**带选择**的重跑里这只是「用户的 `-k`/`-m` 没命中」——它不是
+        # 该文件通过的证据。若照 rc==5 写成功缓存，之后的运行会拿着这份假绿命中
+        # 缓存、exit 0 报「using cache」，而测试依旧是坏的。故此时按「未归因」处理：
+        # 不写 pass，落到下面的失败分支把该文件的缓存剔掉，下一轮必须重跑。
+        if extra_args and result.returncode == 5:
+            test_success = False
+            error_message = (
+                "no tests matched the forwarded selection (pytest exit 5); "
+                "file left unattributed"
+            )
+
+        # Check for slow test cases in step-by-step mode
+        if step_by_step and test_success:
+            config = load_speed_config()
+            if config.enabled and result.stdout:
+                timeout_info = check_test_speeds(
+                    result.stdout, config.threshold, no_skip
+                )
+                if timeout_info and config.fail_on_timeout:
+                    error_message = format_timeout_message(timeout_info)
+                    test_success = False
+
+        # Save result to cache only if not in no-cache mode
+        # If test failed, delete the cache instead of saving failed result
+        if not no_cache:
+            if test_success:
+                self.cache_manager.record_passed_single(
+                    test_file, step_by_step, concise, python_executable
+                )
+            else:
+                # Delete cache for failed test
+                self.cache_manager.invalidate_file(
+                    test_file, step_by_step, concise, python_executable
+                )
+
+        return test_success, error_message
+
+    def _check_cache_for_single_file(
+        self,
+        test_file: Path,
+        step_by_step: bool = False,
+        concise: bool = False,
+        python_executable: str | None = None,
+    ) -> tuple[bool, str, bool, str | None]:
+        """Check cache for a single test file.
+
+        ``python_executable`` is the interpreter this file is about to run
+        under: the cache key fingerprints it, so a hit can only come from a
+        run under the same interpreter (#191).
+        """
+        return self.cache_manager.cached_result(
+            test_file, step_by_step, concise, python_executable
+        )
+
+    def _build_test_command(
+        self,
+        python_executable: str,
+        test_file: Path,
+        debug_mode: bool,
+        step_by_step: bool = False,
+        env: dict[str, str] | None = None,
+        extra_args: list[str] | None = None,
+    ) -> list[str]:
+        """Build pytest command for a single test file.
+
+        ``extra_args`` goes **before** the file path so a value-taking option
+        (``-k expr``) can never swallow the path as its value.
+        """
+        cmd_args = [python_executable, "-m", "pytest"]
+
+        if debug_mode:
+            cmd_args.extend(["-v", "--tb=short"])
+        else:
+            cmd_args.extend(["-q"])
+
+        # Disable coverage for single file tests —— 但**只在 pytest-cov 存在时**传。
+        # `--no-cov` 是 pytest-cov 提供的 flag；未装该插件时 pytest 会以
+        # "unrecognized arguments: --no-cov" 直接失败，而不是忽略它。
+        # 这正是 `wl test -s` 在缺 pytest-cov 的环境里跑不起来的原因。
+        if self._check_pytest_cov(python_executable, env):
+            cmd_args.extend(["--no-cov"])
+
+        # In step-by-step mode, enable duration reporting for all test cases
+        if step_by_step:
+            cmd_args.extend(["--durations", "0", "--durations-min", "0"])
+
+        if extra_args:
+            cmd_args.extend(extra_args)
+
+        cmd_args.append(str(test_file))
+        return cmd_args
+
+    def _check_pytest_cov(
+        self, python_executable: str, env: dict[str, str] | None = None
+    ) -> bool:
+        """pytest-cov 是否可被**子进程解释器**导入。
+
+        判定必须落在真正执行 pytest 的解释器上，而不是 wl 进程本身：两者可以
+        是两个解释器（例如 wl 由 uv tool 环境提供、测试却跑在项目 .venv 里）。
+        只看 wl 进程会让 `--no-cov` 误判 —— 漏判时子进程会转而吃 pyproject 的
+        `--cov=wl_cli`，于是 `wl test -s` 的并发子进程在同一份未隔离的 coverage
+        数据文件上初始化/写入，抛 DataError 并在项目根留下
+        `.coverage.<host>.<pid>.<rand>` 残片。
+
+        探针本体是 `test_utils._probe_pytest_cov`（#112 起三处入口共用同一实现，
+        不再各持一份）；此处只负责**按解释器缓存**。`env` 是执行该解释器时用的
+        环境，探针必须拿到同一份，否则探针与子进程看的环境不同，「同一判定」无从
+        谈起（子进程还多注入一个隔离用的 `COVERAGE_FILE`，那只决定 coverage 往哪
+        写，不影响 import 判定）。
+
+        缓存以解释器为键：一次运行里执行用 env 是固定的，故无需并入键。
+        """
+        cached = self._pytest_cov_cache.get(python_executable)
+        if cached is not None:
+            return cached
+        available = _probe_pytest_cov(python_executable, env)
+        self._pytest_cov_cache[python_executable] = available
+        return available
+
+    def _execute_test(
+        self,
+        cmd_args: list[str],
+        project_root: str,
+        env: dict[str, str],
+    ) -> subprocess.CompletedProcess:
+        """Execute pytest and return the result.
+
+        每个子进程都拿到**私有**的 coverage 数据命名空间：`COVERAGE_FILE` 指向
+        一次性的临时目录。pytest-cov 的 `Central` 控制器总是以 `data_suffix=True`
+        写 `.coverage.<host>.<pid>.<rand>`，收尾时再按 basename 通配 combine ——
+        `wl test -s` 会并发跑多个 pytest，共用同一 basename 时它们会彼此读到尚未
+        建表的半成品 SQLite 文件（`DataError: no such table: file`），并把残片留在
+        项目根。隔离后各进程互不可见，项目根也不再产生残片。
+
+        注意 `env` 由 16 路并发线程共享，绝不能就地修改，只能拷贝。
+        """
+        coverage_dir = tempfile.mkdtemp(prefix="wl-test-cov-")
+        child_env = dict(env)
+        child_env["COVERAGE_FILE"] = str(Path(coverage_dir) / ".coverage")
+        try:
+            try:
+                result = subprocess.run(
+                    cmd_args,
+                    cwd=project_root,
+                    check=False,
+                    env=child_env,
+                    capture_output=True,
+                    text=True,
+                    errors="replace",
+                    timeout=300,  # 5 minute timeout per test file
+                )
+            except subprocess.TimeoutExpired as e:
+                result = subprocess.CompletedProcess(
+                    args=cmd_args,
+                    returncode=-1,
+                    stdout=e.stdout if isinstance(e.stdout, str) else "",
+                    stderr=(e.stderr if isinstance(e.stderr, str) else "")
+                    + "\n[Timeout] Test execution exceeded 300 seconds",
+                )
+        finally:
+            shutil.rmtree(coverage_dir, ignore_errors=True)
+        return result
+
+    def _process_test_result(
+        self,
+        result: subprocess.CompletedProcess,
+    ) -> tuple[bool, str]:
+        """Process test result and return success status and error message."""
+        test_success = False
+        error_message = ""
+
+        if result.returncode == 0:
+            test_success = True
+        elif result.returncode == 5:
+            # No tests in this file, continue
+            test_success = True
+        else:
+            error_message = f"stdout:\n{result.stdout}\nstderr:\n{result.stderr}"
+            test_success = False
+
+        return test_success, error_message

wl_cli/commands/testcommands/speed_checker.py

@@ -0,0 +1,118 @@
+"""Test speed checking for step-by-step mode."""
+
+import re
+from dataclasses import dataclass
+
+from wl_cli.utils.config import get_config
+
+
+@dataclass
+class SpeedConfig:
+    """Speed check configuration."""
+
+    enabled: bool
+    threshold: float
+    fail_on_timeout: bool
+
+
+def load_speed_config() -> SpeedConfig:
+    """Load speed check configuration from global config."""
+    enabled = get_config("test_speed.enabled", True)
+    threshold = get_config("test_speed.threshold", 5.0)
+    fail_on_timeout = get_config("test_speed.fail_on_timeout", True)
+    return SpeedConfig(
+        enabled=enabled,
+        threshold=threshold,
+        fail_on_timeout=fail_on_timeout,
+    )
+
+
+@dataclass
+class TimeoutInfo:
+    """Information about a timed-out test case."""
+
+    test_name: str
+    duration: float
+    threshold: float
+
+
+# Regex pattern to match pytest --durations output
+# Example: "0.12s call     tests/file.py::test_func"
+# Example: "10.00s setup    tests/file.py::test_func"
+_DURATION_PATTERN = re.compile(r"^\s*([\d\.]+)s\s+\w+\s+(.+)$", re.MULTILINE)
+
+
+def check_test_speeds(
+    stdout: str,
+    threshold: float,
+    no_skip: bool = False,
+) -> TimeoutInfo | None:
+    """
+    Check pytest output for slow test cases.
+
+    Args:
+        stdout: pytest stdout output
+        threshold: timeout threshold in seconds
+
+    Returns:
+        TimeoutInfo if first slow test found, None otherwise
+    """
+    # Patterns to skip - these tests are intentionally slow
+    skip_patterns = [
+        "performance",
+        "benchmark",
+        "profile",
+        "expiration",
+        "expire",
+        "timeout",
+        "sleep",
+        "concurrency",
+        "format",
+        "lock",
+        "uv",
+        "docstring",
+        "style",
+        "build",
+        "workspace",
+        "integration",
+        "comprehensive",
+        "initializer",
+        "initialize",
+        "fetch",
+        "git",
+        "self",
+        "slow",
+        "collection",
+        "cache",
+        "publish",
+    ]
+
+    for match in _DURATION_PATTERN.finditer(stdout):
+        duration_str = match.group(1)
+        test_name = match.group(2).strip()
+        try:
+            duration = float(duration_str)
+            if duration > threshold:
+                # Skip intentionally slow tests by name pattern
+                lower_name = test_name.lower()
+                if not no_skip and any(
+                    pattern in lower_name for pattern in skip_patterns
+                ):
+                    continue
+                return TimeoutInfo(
+                    test_name=test_name,
+                    duration=duration,
+                    threshold=threshold,
+                )
+        except ValueError:
+            continue
+    return None
+
+
+def format_timeout_message(info: TimeoutInfo) -> str:
+    """Format timeout error message for display."""
+    return (
+        f"\n⏱️  测试用例耗时过长 ({info.duration:.2f}s > {info.threshold:.2f}s)\n"
+        f"   测试用例: {info.test_name}\n"
+        f"   测试用例速度过慢，请尝试优化测试逻辑。\n"
+    )

wl_cli/commands/testcommands/test_command_builder.py

@@ -0,0 +1,165 @@
+"""
+Test command builder utilities for test command.
+"""
+
+from pathlib import Path
+
+from .coverage_analyzer import coverage_targets
+from .test_utils import _probe_pytest_cov
+
+
+class TestCommandBuilder:
+    """Build pytest command arguments based on configuration."""
+
+    def __init__(self, python_detector):
+        """Initialize test command builder.
+
+        Args:
+            python_detector: Instance of PythonEnvDetector to get Python executable
+        """
+        self.python_detector = python_detector
+
+    def build_command_args(
+        self,
+        report_mode: bool,
+        args: list[str],
+        debug_mode: bool = False,
+        verbose: bool = False,
+        python_executable: str | None = None,
+        env: dict[str, str] | None = None,
+        *,
+        project_root: Path,
+    ) -> list[str]:
+        """Build the command arguments for pytest.
+
+        Args:
+            report_mode: Whether to generate detailed reports
+            args: Additional pytest arguments
+            debug_mode: Whether to run in debug mode
+            verbose: Whether to show verbose output
+            python_executable: Interpreter that will actually execute pytest.
+                Defaults to the detector's current answer. Callers that already
+                resolved a specific interpreter must pass it here, so the
+                pytest-cov probe below judges the very interpreter that runs.
+            env: Environment the interpreter will be exec'd with. The probe is
+                given the same env, so judge and executor see one environment.
+            project_root: Project root whose package ``--cov`` should measure.
+                Required: the caller resolved this root once already (the
+                same value it hands pytest as its cwd), so ``--cov`` names the
+                package of the project that actually runs (rv192 MINOR-3).
+                Resolving it again here could name a different project than
+                the run itself (rv192b NIT).
+
+        Returns:
+            List of command arguments
+        """
+        if python_executable is None:
+            python_executable = self.python_detector.get_python_executable()
+        cmd_args: list[str] = [python_executable, "-m", "pytest"]
+
+        # Configure warning behavior based on mode
+        if report_mode or debug_mode or verbose:
+            # In report/debug/verbose mode, show all warning details
+            cmd_args.append("-W")
+            cmd_args.append("always")
+            cmd_args.append("-v")
+            if report_mode:
+                cmd_args.append("--tb=short")  # Show shorter tracebacks for failures
+            else:
+                cmd_args.append("--tb=long")  # Show full tracebacks in debug mode
+        else:
+            # In default concise mode, keep quiet and concise
+            # Use --tb=short to only show short tracebacks and final short test summary info
+            cmd_args.append(
+                "--tb=short"
+            )  # Only show short tracebacks + short test summary info
+            cmd_args.append("-q")  # Quiet mode - suppress progress characters
+            cmd_args.append("--no-header")  # Don't show pytest header
+            # In concise mode, only show warning categories that should fail the test
+            cmd_args.append("-W")
+            cmd_args.append("error::DeprecationWarning")
+            cmd_args.append("-W")
+            cmd_args.append("ignore::UserWarning")
+            cmd_args.append("-W")
+            cmd_args.append("ignore::RuntimeWarning")
+
+        # Add debug markers if in debug mode
+        if debug_mode and "-xvs" not in args:
+            cmd_args.extend(
+                ["-xvs"]
+            )  # Stop at first failure, verbose, show print output
+
+        has_user_cov = any(arg.startswith("--cov") for arg in args)
+
+        # Add coverage-related arguments
+        # By default: do NOT check coverage - only enable coverage in report mode
+        has_pytest_cov = self._check_pytest_cov(python_executable, env)
+        if has_pytest_cov and not has_user_cov:
+            if report_mode:
+                # Only enable coverage collection in report mode. The target is
+                # the project's own package (rv192 MINOR-3): `--cov=wl_cli`
+                # measured nothing for any other project.
+                cmd_args.extend(
+                    [
+                        *[
+                            f"--cov={target}"
+                            for target in coverage_targets(project_root)
+                        ],
+                        "--cov-branch",
+                        "--cov-context=test",
+                    ]
+                )
+                # Control coverage report output based on verbosity
+                if verbose or report_mode:
+                    cmd_args.append("--cov-report=term-missing:skip-covered")
+                else:
+                    # In concise mode, disable terminal coverage report completely
+                    cmd_args.append("--cov-report=")
+                    cmd_args.append("--no-cov-on-fail")
+            else:
+                # Default mode: disable coverage completely
+                cmd_args.append("--no-cov")
+
+        if report_mode:
+            # In report mode, generate additional coverage outputs
+            # Create todos directory in current working directory
+            todo_dir = Path("todos")
+            todo_dir.mkdir(exist_ok=True)
+            cov_json = str(todo_dir / "coverage.json")
+            junit_xml = str(todo_dir / "junit.xml")
+            # `--cov-report` 由 pytest-cov 提供：缺失时必须**省略**，否则 pytest 以
+            # "unrecognized arguments" 失败（`wl test --report` 曾恒传它）。
+            # `--junitxml` 是 pytest 核心 flag，始终可传。
+            if has_pytest_cov:
+                cmd_args.append(f"--cov-report=json:{cov_json}")
+            cmd_args.append(f"--junitxml={junit_xml}")
+
+        # Add any additional user arguments
+        if args:
+            # Check if any argument looks like a test file/directory path (doesn't start with --)
+            has_path_arg = any(not arg.startswith("--") for arg in args)
+            cmd_args.extend(args)
+
+            # Add default test path if no path arguments provided (regardless of mode)
+            if not has_path_arg:
+                cmd_args.append("tests/")
+        else:
+            # If no args provided, add default test path
+            cmd_args.append("tests/")
+
+        return cmd_args
+
+    def _check_pytest_cov(
+        self, python_executable: str, env: dict[str, str] | None = None
+    ) -> bool:
+        """pytest-cov 是否可被**执行 pytest 的那个解释器**导入。
+
+        判定必须落在真正执行 pytest 的解释器上，而不是 wl 进程本身：`wl test`
+        全量路径由 `test_runner._run_all_tests` 用调用方解析出的 `python_executable`
+        执行 pytest，可能是与 wl 进程不同的解释器。只在 wl 进程内 `__import__`
+        会让 `--no-cov` 误判：漏判 ⇒ 子进程转而吃 pyproject 的 `--cov=wl_cli`；
+        多判 ⇒ 子进程收到 pytest 认不出的 `--no-cov` 直接失败。
+
+        探针本体是 `test_utils._probe_pytest_cov`（#112 起三处入口共用）。
+        """
+        return _probe_pytest_cov(python_executable, env)