py-wlcli 0.8.0__py3-none-any.whl

wl_cli/commands/testcommands/test_utils.py

@@ -0,0 +1,197 @@
+"""Utility module for test commands."""
+
+import os
+from typing import Any
+
+
+def _probe_pytest_cov(
+    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`（于是
+    写 coverage 数据文件、可能撞上 fail_under）；多判时子进程收到 pytest 认不出
+    的 `--no-cov`，直接以 "unrecognized arguments" 失败。
+
+    `env` 必须与 exec 该解释器时拿到的环境一致，探针与子进程才看同一份
+    PATH/site-packages。#108 起所有调用点都传执行用 env。
+
+    解释器起不来（不存在 / 无法执行）时判 False：宁可少传 `--no-cov`，也不能传
+    一个 pytest 认不出的 flag。
+    """
+    import subprocess
+
+    try:
+        probe = subprocess.run(
+            [python_executable, "-c", "import pytest_cov"],
+            capture_output=True,
+            check=False,
+            timeout=30,
+            env=env,
+        )
+        return probe.returncode == 0
+    except (OSError, subprocess.SubprocessError):
+        return False
+
+
+def _ensure_pytest_available(python_executable: str) -> str:
+    """Ensure pytest is available, install if not."""
+    import subprocess
+
+    # 检查是否在测试环境中运行
+    is_testing = "PYTEST_CURRENT_TEST" in os.environ
+
+    # 只在非测试环境中检查和安装pytest
+    if not is_testing:
+        try:
+            subprocess.run(
+                [python_executable, "-m", "pytest", "--version"],
+                capture_output=True,
+                check=True,
+                text=True,
+                errors="replace",
+            )
+        except subprocess.CalledProcessError:
+            python_executable = _install_pytest(python_executable)
+        except FileNotFoundError:
+            # 如果Python环境不存在，抛出FileNotFoundError以便测试捕获
+            raise
+
+    return python_executable
+
+
+def _install_pytest(python_executable: str) -> str:
+    """Install pytest into the selected environment, or exit with an install hint.
+
+    uv-managed venvs (``uv venv``) ship no pip module, so ``uv pip install`` is
+    tried first (with ``--python`` pinning the exact interpreter ``wl test``
+    selected); classic pip venvs fall back to ``python -m pip install``.
+    """
+    import shutil
+    import subprocess
+    import sys
+
+    print(
+        f"Error: pytest not found in the selected Python environment: {python_executable}"
+    )
+    print("Installing pytest...")
+
+    commands: list[list[str]] = []
+    uv_path = shutil.which("uv")
+    if uv_path:
+        commands.append(
+            [uv_path, "pip", "install", "--python", python_executable, "pytest"]
+        )
+    commands.append([python_executable, "-m", "pip", "install", "pytest"])
+
+    install_errors: list[str] = []
+    for command in commands:
+        try:
+            subprocess.run(
+                command,
+                check=True,
+                capture_output=True,
+                text=True,
+                errors="replace",
+                timeout=120,
+            )
+        except (
+            subprocess.CalledProcessError,
+            FileNotFoundError,
+            PermissionError,
+            subprocess.TimeoutExpired,
+        ) as exc:
+            install_errors.append(_install_failure_summary(command[0], exc))
+            continue
+        # Verify the install actually made pytest importable: uv --python can
+        # target an environment other than the one tests will invoke.
+        try:
+            subprocess.run(
+                [python_executable, "-m", "pytest", "--version"],
+                capture_output=True,
+                check=True,
+                text=True,
+                timeout=30,
+            )
+        except (
+            subprocess.CalledProcessError,
+            FileNotFoundError,
+            PermissionError,
+            subprocess.TimeoutExpired,
+        ):
+            continue
+        print("pytest installed successfully.")
+        return python_executable
+
+    print("Error: could not install pytest automatically.")
+    print("pytest is a test-only dependency of wl_cli (the `test` extra).")
+    print(
+        'Install it with:  uv pip install -e ".[test]"   (or: pip install -e ".[test]")'
+    )
+    if install_errors:
+        print(f"Installer diagnostics: {' | '.join(install_errors)}")
+    sys.exit(1)
+
+
+def _install_failure_summary(tool: str, exc: BaseException) -> str:
+    """One-line summary of a failed installer attempt, for the exit hint."""
+    import subprocess
+
+    if isinstance(exc, subprocess.TimeoutExpired):
+        return f"{tool}: timed out after 120s"
+    if isinstance(exc, subprocess.CalledProcessError):
+        tail = (exc.stderr or exc.stdout or "").strip().splitlines()[-2:]
+        if tail:
+            return f"{tool}: {'; '.join(tail)}"
+        return f"{tool}: exit {exc.returncode}"
+    return f"{tool}: {exc}"
+
+
+def _process_command_args(
+    self, kwargs: dict[str, Any]
+) -> tuple[bool, bool, bool, bool, bool, bool, bool, bool, list[str]]:
+    """Process command line arguments."""
+    report_mode = kwargs.get("report", False)
+    debug_mode = kwargs.get("debug", False)
+    step_by_step = kwargs.get("step_by_step", False)
+    use_cache_arg = kwargs.get("use_cache", False)
+    no_cache_arg = kwargs.get("no_cache", False)
+    # wl test: default no cache
+    # wl test -s: default use cache
+    if no_cache_arg:
+        no_cache = True
+    elif use_cache_arg:
+        no_cache = False
+    else:
+        no_cache = not step_by_step  # wl test: no cache, wl test -s: use cache
+    clean_cache = kwargs.get("clean_cache", False)
+    cache_info = kwargs.get("cache_info", False)
+    quiet = kwargs.get("quiet", False)
+    verbose = kwargs.get("verbose", False)
+    passed_args = kwargs.get("unknown_args", kwargs.get("args", []))
+
+    # 处理特殊情况：如果args中有'debug'，将其移除并设置debug_mode为True
+    if "debug" in passed_args:
+        passed_args.remove("debug")
+        debug_mode = True
+
+    # 只在非测试环境中打印和记录信息
+    is_testing = "PYTEST_CURRENT_TEST" in os.environ
+    if not is_testing:
+        print(f"Debug mode: {debug_mode}")
+        # 传递concise参数，默认为False
+        self.progress_manager._log_report_mode(report_mode, False)
+
+    return (
+        report_mode,
+        debug_mode,
+        step_by_step,
+        no_cache,
+        clean_cache,
+        cache_info,
+        quiet,
+        verbose,
+        passed_args,
+    )

wl_cli/commands/testcommands/utils/__init__.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from .coverage_parser import coverage_totals, file_entries, read_json
+from .env_info import get_env_info
+from .junit_parser import parse_junit, read_xml
+from .markdown_utils import fmt_pct, write_md
+
+__all__ = [
+    "coverage_totals",
+    "file_entries",
+    "fmt_pct",
+    "get_env_info",
+    "parse_junit",
+    "read_json",
+    "read_xml",
+    "write_md",
+]

wl_cli/commands/testcommands/utils/coverage_parser.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, cast
+
+
+def read_json(path: str) -> dict[str, Any]:
+    """读取JSON文件并返回其内容。"""
+    p = Path(path)
+    if not p.exists():
+        return {}
+    try:
+        return cast("dict[str, Any]", json.loads(p.read_text(encoding="utf-8")))
+    except Exception:
+        return {}
+
+
+def coverage_totals(
+    data: dict[str, Any],
+) -> tuple[float | None, float | None, int, int, int]:
+    """计算覆盖率统计信息。"""
+    files = data.get("files", {})
+    num_files = len(files) if isinstance(files, dict) else 0
+    covered_lines = 0
+    total_lines = 0
+    covered_branches = 0
+    total_branches = 0
+    if isinstance(files, dict):
+        for info in files.values():
+            s = info.get("summary", {})
+            try:
+                covered_lines += int(s.get("covered_lines", 0))
+                total_lines += int(s.get("num_statements", s.get("num_lines", 0)))
+                covered_branches += int(s.get("covered_branches", 0))
+                total_branches += int(s.get("num_branches", 0))
+            except Exception:
+                pass
+    line_pct = (covered_lines / total_lines * 100.0) if total_lines else None
+    branch_pct = (covered_branches / total_branches * 100.0) if total_branches else None
+    return (
+        line_pct,
+        branch_pct,
+        total_lines,
+        total_branches,
+        num_files,
+    )
+
+
+def file_entries(
+    data: dict[str, Any], project_root: str
+) -> list[tuple[str, float | None, float | None]]:
+    """获取文件覆盖率条目列表。"""
+    files = data.get("files", {})
+    res: list[tuple[str, float | None, float | None]] = []
+    if isinstance(files, dict):
+        for path, info in files.items():
+            rel = path
+            try:
+                rel = str(
+                    Path(path).resolve().relative_to(Path(project_root).resolve())
+                )
+            except Exception:
+                pass
+            s = info.get("summary", {})
+
+            # Get line coverage percentage
+            lp = s.get("percent_covered")
+            if lp is None:
+                lp = info.get("percent_covered")
+            # If still None, calculate from covered_lines and num_statements
+            if lp is None:
+                covered_lines = s.get("covered_lines", 0)
+                num_statements = s.get("num_statements", s.get("num_lines", 0))
+                if num_statements > 0:
+                    lp = (covered_lines / num_statements) * 100
+
+            # Get branch coverage percentage
+            bp = s.get("percent_branches")
+            if bp is None:
+                bp = info.get("percent_branches")
+            # If still None, calculate from covered_branches and num_branches
+            if bp is None:
+                covered_branches = s.get("covered_branches", 0)
+                num_branches = s.get("num_branches", 0)
+                if num_branches > 0:
+                    bp = (covered_branches / num_branches) * 100
+
+            try:
+                lp_f = float(lp) if lp is not None else None
+            except Exception:
+                lp_f = None
+            try:
+                bp_f = float(bp) if bp is not None else None
+            except Exception:
+                bp_f = None
+            res.append((rel, lp_f, bp_f))
+    return res

wl_cli/commands/testcommands/utils/env_info.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+import platform
+import sys
+from datetime import datetime
+from typing import Any
+
+# Try to import pytest for version information
+_pytest: Any | None
+
+try:
+    import pytest
+
+    _pytest = pytest
+except ImportError:
+    _pytest = None
+
+
+def get_env_info() -> list[str]:
+    """获取测试环境信息。"""
+    now = datetime.now().isoformat(timespec="seconds")
+    py_ver = sys.version.replace("\n", " ")
+    os_info = f"{platform.system()} {platform.release()} ({platform.machine()})"
+
+    # Get pytest version if available
+    if _pytest is not None:
+        pytest_ver = getattr(_pytest, "__version__", "unknown")
+    else:
+        pytest_ver = "unknown"
+
+    return [
+        f"时间: {now}",
+        f"Python: {py_ver}",
+        f"OS: {os_info}",
+        f"pytest: {pytest_ver}",
+    ]

wl_cli/commands/testcommands/utils/junit_parser.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+import xml.etree.ElementTree
+from pathlib import Path
+
+
+def read_xml(path: str) -> xml.etree.ElementTree.Element | None:
+    """读取XML文件并返回其根元素。"""
+    p = Path(path)
+    if not p.exists():
+        return None
+    try:
+        tree = xml.etree.ElementTree.parse(str(p))
+        return tree.getroot()
+    except Exception:
+        return None
+
+
+def parse_junit(
+    root: xml.etree.ElementTree.Element | None,
+) -> tuple[int, int, int, int, int, float, list[dict[str, str]]]:
+    """解析JUnit XML数据并返回测试统计信息。"""
+    if root is None:
+        return (0, 0, 0, 0, 0, 0.0, [])
+    suites = [root] if root.tag == "testsuite" else list(root.findall("testsuite"))
+    tests = failures = errors = skipped = warnings = 0
+    time = 0.0
+    cases: list[dict[str, str]] = []
+    for ts in suites:
+        tests += int(ts.attrib.get("tests", 0))
+        failures += int(ts.attrib.get("failures", 0))
+        errors += int(ts.attrib.get("errors", 0))
+        skipped += int(ts.attrib.get("skipped", 0))
+        # 增加warnings计数
+        warnings += int(ts.attrib.get("warnings", 0))
+        try:
+            time += float(ts.attrib.get("time", 0.0))
+        except Exception:
+            pass
+        for tc in ts.findall("testcase"):
+            name = tc.attrib.get("name", "")
+            classname = tc.attrib.get("classname", "")
+            file_attr = tc.attrib.get("file", "")
+            text = ""
+            kind = ""
+            fail = tc.find("failure")
+            err = tc.find("error")
+            # 增加warning元素的查找
+            warn = tc.find("warning")
+            if fail is not None:
+                kind = "failure"
+                text = (
+                    fail.attrib.get("message", "") + "\n" + (fail.text or "")
+                ).strip()
+            elif err is not None:
+                kind = "error"
+                text = (err.attrib.get("message", "") + "\n" + (err.text or "")).strip()
+            elif warn is not None:
+                kind = "warning"
+                text = (
+                    warn.attrib.get("message", "") + "\n" + (warn.text or "")
+                ).strip()
+            if kind:
+                if len(text) > 1200:
+                    text = text[:1200] + "\n..."
+                cases.append(
+                    {
+                        "name": name,
+                        "classname": classname,
+                        "file": file_attr,
+                        "kind": kind,
+                        "text": text,
+                    }
+                )
+    return (tests, failures, errors, skipped, warnings, time, cases)

wl_cli/commands/testcommands/utils/markdown_utils.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+
+def fmt_pct(x: Any) -> str:
+    """格式化百分比值。"""
+    try:
+        v = float(x)
+        return f"{v:.2f}%"
+    except Exception:
+        return "N/A"
+
+
+def write_md(path: str, lines: list[str]) -> None:
+    """将文本行写入Markdown文件。"""
+    p = Path(path)
+    p.parent.mkdir(parents=True, exist_ok=True)
+    p.write_text("\n".join(lines) + "\n", encoding="utf-8")

wl_cli/commands/testcommands/utils/project_root.py

@@ -0,0 +1,61 @@
+"""The test commands subsystem's project-root **policy** entry point.
+
+This is not a root resolver: the root module (:mod:`wl_cli.utils.root`) owns
+*locating* a root. What lives here is the test subsystem's own answer to "where
+does this subsystem's ``src/`` and ``tests/`` tree live", which is pytest's
+rootdir question rather than a definition of the project root.
+
+Two rules make it up, and both stay in the subsystem on purpose (issue #120's
+ruling on #116's note_13750):
+
+- the ``tests/``/``src/`` pre-check -- a directory that already has one of those
+  *is* the root, with no marker lookup at all. The root module's ``PROJECT`` kind
+  is marker-based instead, so the two rules genuinely differ and the pre-check
+  cannot be folded into it;
+- the caller-side fallback -- when no marker exists the subsystem answers the
+  starting directory rather than "not found" (ADR 0006: the fallback is the
+  caller's policy, never ``resolve``'s).
+
+Issue #110 introduced this policy twice: an un-anchored spelling that read the
+process working directory and a mirrored anchored spelling, so a detector
+anchored outside the CWD would not leak the CWD back in. The hard cut (#123)
+merges them into this single ``start``-parameterised form; ``start=None`` means
+the working directory, which is exactly what the un-anchored spelling
+hard-coded, and every other behaviour is unchanged.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from ....utils.root import RootKind
+from ....utils.root_fallback import resolve_root_or_start
+
+
+def project_root_for(start: Path | None = None) -> str:
+    """The test subsystem's project root for *start*, as a string.
+
+    ``start=None`` asks about the process working directory. The answer is
+    *start* itself when it already looks like a project (it has ``tests/`` or
+    ``src/``); otherwise the root module's ``PROJECT`` root; and when neither
+    exists, *start*. Never returns ``None``.
+
+    The last step is the shared CLI-top-level fallback policy, not a private
+    copy of it: :func:`~wl_cli.utils.root_fallback.resolve_root_or_start` (#126).
+    Its answer is taken as ``str`` (this subsystem's contract is a string) and
+    ``start`` is passed verbatim (this helper never canonicalised it), keeping
+    the answer byte-for-byte what the spelling it replaces returned.
+    """
+    if start is None:
+        try:
+            start = Path.cwd()
+        except Exception:
+            return os.getcwd()
+    try:
+        if (start / "tests").exists() or (start / "src").exists():
+            return str(start)
+        # ADR 0006: 回退是调用方策略；唯一实现在 utils/root_fallback.py（#126）
+        return str(resolve_root_or_start(start, RootKind.PROJECT).path)
+    except Exception:
+        return str(start)

wl_cli/commands/update/__init__.py

@@ -0,0 +1,9 @@
+"""
+Update command module for wl_cli.
+
+This module provides the 'wl update' command family.
+"""
+
+from .update_command import update_command
+
+__all__ = ["update_command"]

wl_cli/commands/update/services/__init__.py

@@ -0,0 +1,21 @@
+"""
+Services for update command.
+"""
+
+from wl_cli.commands.update.services.backup_manager import BackupManager
+from wl_cli.commands.update.services.component_manager import ComponentManager
+from wl_cli.commands.update.services.conflict_resolver import (
+    ConflictResolution,
+    ConflictResolver,
+)
+from wl_cli.commands.update.services.vendors_updater import VendorsUpdater
+from wl_cli.commands.update.services.version_tracker import VersionTracker
+
+__all__ = [
+    "ComponentManager",
+    "VersionTracker",
+    "VendorsUpdater",
+    "BackupManager",
+    "ConflictResolver",
+    "ConflictResolution",
+]