Unlucky-Launcher/packaging/tests/gpu_shot_ci_probe.py

#!/usr/bin/env python3
"""`gpu-evidence.yml` 的**功能断言**部分（M253 / r1+r2 复审返工）：把 workflow 里的 `run:` 原文抽出来真跑。

为什么单独一份：判据脚本自己守 ≤400 行硬线，而这里全是「把 `run:` 落盘、用桩 env 起 bash、读
`$GITHUB_OUTPUT` / `$GITHUB_STEP_SUMMARY` / 退出码」的**执行脚手架**，与「哪条判据该红」的判断无关
（同 `gpu_shot_selftest.py` 与 `check_gpu_shot.py` 的分工）。

两组功能断言，各自对应一类「绿而没判」：

**A. `detect` 步（`probe_problems`）—— 跳过要留痕、红线不许退化成跳过。**
字符串存在性检查被 r1 复审证伪过：旧版只要求「同一步的 run 里同时出现 4 个字符串」，于是把
`available` 写成恒 `false`（门禁永久关闭、每次运行都绿）它照样绿 —— **文案都在，执行路径却没走到**。

| # | 输入 | 必须发生什么 |
|---|------|-------------|
| S1 | 无产物（CI 常态） | `available=false` + summary 写「跳过 / 未验证」+ stdout 有 `::warning::` |
| S2 | 约定产物成对 | `available=true` |
| S3 | 约定产物半套（只有日志） | `available=false`（半套不算可用） |
| S4 | dispatch 成对 | `available=true` |
| S5 | dispatch 点名不存在 | `exit≠0`，且**不写** `available`（写了就等于退化成跳过） |
| S6 | dispatch 正例缺 PNG | `exit≠0`，同上 |
| S7 | dispatch 负例只给日志 | `available=true`（`--expect-refuse` 允许省略 PNG） |

**B. `judge` 步（`judge_problems`）—— 判据步必须真的把红判成红。**
r2 复审实测：判据命令后面加 `|| echo "先忽略"`、`; :`、去掉 pipefail 再 `| cat`、`if ! python3 …`、
`true  # python3 …`（保留子串锚点），五种写法的判据步**全 exit 0**（绿而没判），而标记表判据一条都没抓住。
所以这里跑两次：正例成对必须 `exit 0`，CPU 档日志（`renderer=tiny-skia`）必须 `exit≠0`。第 2 条一红就
同时封掉「吞码」整类，不依赖任何标记表。

**跑的是原文，只改一个令牌**：`run` 原文里 `python3` 换成本进程的解释器（Windows 上没有 `python3`；
控制流、运算符、参数一字不改）。夹具用 `gpu_shot_selftest.synth_log/synth_png`，不另造第二套。
判据步的 `cwd` 是仓库根（它要 `packaging/check_gpu_shot.py` 的相对路径）。

不降级：找不到能跑的 `bash` 就**判红**（「认不出/跑不了」≠「没问题」）。
"""

from __future__ import annotations

import os
import re
import shutil
import subprocess
import sys
import tempfile
from pathlib import Path

PACKAGING = Path(__file__).resolve().parent.parent
REPO = PACKAGING.parent
sys.path[:0] = [str(PACKAGING), str(Path(__file__).resolve().parent)]
from gpu_shot_selftest import SELFTEST_SIZE, synth_log, synth_png  # noqa: E402

_CACHE: dict[str, list[str]] = {}
PYTHON_TOKEN = re.compile(r"\bpython3\b")


def _find_bash() -> str | None:
    """挑一个**真能跑**的 bash。Windows 上 `bash.exe` 可能是 WSL 的 relay（没有 `/bin/bash`），要验一次。"""
    candidates = [os.environ.get("BASH"), shutil.which("bash")]
    if os.name == "nt":
        candidates += [r"C:\Program Files\Git\bin\bash.exe", r"C:\Program Files\Git\usr\bin\bash.exe"]
    candidates.append("bash")
    for candidate in candidates:
        if not candidate:
            continue
        try:
            done = subprocess.run([candidate, "-c", "echo ok"], capture_output=True, text=True, timeout=60)
        except (OSError, subprocess.SubprocessError):
            continue
        if done.returncode == 0 and "ok" in (done.stdout or ""):
            return candidate
    return None


def _run(bash: str, script: Path, workdir: Path, env_extra: dict, cwd: str | None = None, flags: tuple[str, ...] = ("-e",)):
    """跑一份 `run:` 原文，返回 `(CompletedProcess, GITHUB_OUTPUT 字典, GITHUB_STEP_SUMMARY 文本)`。

    `flags` 默认 `-e`（GitHub 的 `bash -e {0}`）；判据步还会用**裸 bash**（不带 `-e`）再跑一遍 ——
    `... ; :` 这种写法只有在不靠 `-e` 兜底时才会把红吞掉（实测：`bash -e` 仍 exit 1，裸 bash exit 0）。
    """
    out_path, sum_path = workdir / "gh_output", workdir / "gh_summary"
    env = os.environ.copy()
    env.update({"GITHUB_OUTPUT": out_path.as_posix(), "GITHUB_STEP_SUMMARY": sum_path.as_posix()})
    env.update({key: ("" if value is None else str(value)) for key, value in env_extra.items()})
    done = subprocess.run([bash, *flags, str(script)], cwd=cwd or str(workdir), env=env, capture_output=True, text=True, encoding="utf-8", errors="replace")
    outputs: dict[str, str] = {}
    if out_path.exists():
        for line in out_path.read_text(encoding="utf-8", errors="replace").splitlines():
            key, sep, value = line.partition("=")
            if sep:
                outputs[key.strip()] = value
    summary = sum_path.read_text(encoding="utf-8", errors="replace") if sum_path.exists() else ""
    return done, outputs, summary


def _case(label: str, done, outputs: dict, summary: str, *, available: str, contains: tuple[str, ...] = (), warning: bool = False) -> list[str]:
    problems: list[str] = []
    if done.returncode != 0:
        problems.append(f"{label}：退出码 {done.returncode}，应为 0（stderr: {(done.stderr or '').strip()[:200]}）")
    if outputs.get("available") != available:
        problems.append(f"{label}：`available={outputs.get('available')!r}`，应为 {available!r} —— 探测结论被改坏了，门就永久开或永久关")
    for needle in contains:
        if needle not in summary:
            problems.append(f"{label}：job summary 里缺 `{needle}` —— 跳过不再留痕")
    if warning and "::warning::" not in (done.stdout or ""):
        problems.append(f"{label}：stdout 里没有 `::warning::` —— 跳过变成了静默 pass")
    return problems


def _probe_scenarios(bash: str, script_text: str) -> list[str]:
    problems: list[str] = []
    with tempfile.TemporaryDirectory(prefix="ull-gpu-ci-", ignore_cleanup_errors=True) as tmp:
        root = Path(tmp)
        fixtures = root / "fixtures"
        fixtures.mkdir()
        log = fixtures / "a1-gpu.stderr.log"
        log.write_text("[shot] 200x120\n", encoding="utf-8")
        png = fixtures / "a1-gpu.png"
        png.write_bytes(b"\x89PNG\r\n\x1a\n")

        def case(slug: str, tree: tuple[tuple[str, bytes], ...] = ()):
            workdir = root / slug
            workdir.mkdir()
            for rel, payload in tree:
                path = workdir / rel
                path.parent.mkdir(parents=True, exist_ok=True)
                path.write_bytes(payload)
            script = workdir / "probe.sh"
            script.write_text(script_text, encoding="utf-8")
            return script, workdir

        base = {"EVENT": "push", "SHOT_LOG": "", "SHOT_PNG": "", "EXPECT_REFUSE": None}
        convention = "DevDocs/artifacts/gpu-probe/gpu-shot"
        script, workdir = case("s1-none")
        problems += _case("S1 无产物（CI 常态）", *_run(bash, script, workdir, base), available="false", contains=("跳过", "未验证"), warning=True)
        script, workdir = case("s2-convention-pair", ((f"{convention}.stderr.log", b"x"), (f"{convention}.png", b"x")))
        problems += _case("S2 约定产物成对", *_run(bash, script, workdir, base), available="true")
        script, workdir = case("s3-convention-half", ((f"{convention}.stderr.log", b"x"),))
        problems += _case("S3 约定产物半套（只有日志）", *_run(bash, script, workdir, base), available="false", contains=("跳过",))
        script, workdir = case("s4-dispatch-pair")
        problems += _case("S4 dispatch 成对", *_run(bash, script, workdir, dict(base, SHOT_LOG=str(log), SHOT_PNG=str(png))), available="true")
        for slug, label, extra in (
            ("s5-dispatch-missing", "S5 dispatch 点名不存在", {"SHOT_LOG": str(root / "nope.log"), "SHOT_PNG": str(png)}),
            ("s6-dispatch-no-png", "S6 dispatch 正例缺 PNG", {"SHOT_LOG": str(log), "SHOT_PNG": ""}),
        ):
            script, workdir = case(slug)
            done, outputs, _summary = _run(bash, script, workdir, dict(base, **extra))
            if done.returncode == 0:
                problems.append(f"{label}：退出码 0 —— 「明确说要判、东西不在」退化成了跳过（假绿）")
            if outputs:
                problems.append(f"{label}：该红却写了 `$GITHUB_OUTPUT`（{outputs}）")
        script, workdir = case("s7-dispatch-refuse")
        problems += _case("S7 dispatch 负例只给日志", *_run(bash, script, workdir, dict(base, SHOT_LOG=str(log), SHOT_PNG="", EXPECT_REFUSE="true")), available="true")
    return problems


def probe_problems(script_text: str) -> list[str]:
    """判据 A：`id: detect` 那一步的 `run` 原文实跑 7 种输入（带缓存，同文本只跑一次）。"""
    if not script_text.strip():
        return ["`id: detect` 那一步没有 `run:` —— 跳过路径无从执行"]
    if script_text not in _CACHE:
        bash = _find_bash()
        _CACHE[script_text] = (
            ["找不到能跑的 `bash`：跳过路径的功能断言无法执行，本判据不降级（认不出就红）"]
            if not bash
            else _probe_scenarios(bash, script_text)
        )
    return _CACHE[script_text]


def _judge_scenarios(bash: str, script_text: str) -> list[str]:
    problems: list[str] = []
    with tempfile.TemporaryDirectory(prefix="ull-gpu-judge-", ignore_cleanup_errors=True) as tmp:
        root = Path(tmp)
        passing = root / "pass.stderr.log"
        passing.write_text(synth_log(size=SELFTEST_SIZE), encoding="utf-8")
        cpu = root / "cpu.stderr.log"
        cpu.write_text(synth_log(renderer="tiny-skia", size=SELFTEST_SIZE), encoding="utf-8")
        png = root / "pass.png"
        png.write_bytes(synth_png("content", SELFTEST_SIZE))
        script = root / "judge.sh"
        script.write_text(PYTHON_TOKEN.sub(lambda _match: f'"{Path(sys.executable).as_posix()}"', script_text), encoding="utf-8")
        common = {"PNG": png.as_posix(), "EXPECT_REFUSE": "false"}
        # 两种模式都跑：`-e` = GitHub 的默认 shell；裸 bash = 不靠 `-e` 兜底（`; :` 只在后者现形）。
        for mode, flags in (("bash -e", ("-e",)), ("裸 bash", ())):
            for label, log_path, want_zero in (
                ("正例（六条判据全过）", passing, True),
                ("CPU 档日志（`renderer=tiny-skia`，必须判红）", cpu, False),
            ):
                done, _outputs, _summary = _run(bash, script, root, dict(common, LOG=log_path.as_posix()), cwd=str(REPO), flags=flags)
                if want_zero and done.returncode != 0:
                    problems.append(
                        f"[{mode}] 判据步对**正例**退出码 {done.returncode}，应为 0 —— 「判据全过」这条路走不通了"
                        f"（stderr: {(done.stderr or '').strip()[:200]}）"
                    )
                if not want_zero and done.returncode == 0:
                    problems.append(
                        f"[{mode}] 判据步对**必须判红**的输入退出码 0 —— 「绿而没判」：`|| echo` / `; :` / 管道 / `if !` / "
                        "`true  # 原行` / 裸 `exit 0` 都属于这一类"
                    )
    return problems


def judge_problems(script_text: str) -> list[str]:
    """判据 B：`id: judge` 那一步的 `run` 原文实跑两次（正例必须 0、CPU 档必须非 0）。"""
    if not script_text.strip():
        return ["`id: judge` 那一步没有 `run:` —— 判据步无从执行"]
    key = "judge:" + script_text
    if key not in _CACHE:
        bash = _find_bash()
        _CACHE[key] = (
            ["找不到能跑的 `bash`：判据步的功能断言无法执行，本判据不降级（认不出就红）"]
            if not bash
            else _judge_scenarios(bash, script_text)
        )
    return _CACHE[key]