#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""tests/test_release_clients.py —— 05-03/05-05:PyPI/TestPyPI + GitCode 适配层 scripted API 测试。

05-03 Task 1 覆盖面(按 PLAN behavior 逐条落地,D-06/D-07/D-10,REL-01/PUB-03):
- 占用语义:版本 JSON 端点 200 即占用——urls 为空也 occupied(空 urls 不能反证版本不存在)。
- Twine 上传:argv 精确为 upload --non-interactive --repository-url <realm legacy URL> + 唯一
  归档 wheel;无 skip-existing、无 verbose、无 dist glob、token 绝不进 argv(env-only);
  凭据缺失/用户名非 __token__/归档缺失都在 subprocess 之前失败。
- verify 有界轮询:404 → 200 空 urls → 200 正确 metadata 的传播序列最终绿;info.version、
  唯一 bdist_wheel、精确 filename、digests.sha256、yanked=false 全部匹配才绿。
- 边界 fail:错误 hash / 两个 wheel / sdist / yanked / 文件名不符 / 类型不符 → 冲突立即失败;
  429+合法 Retry-After / 500 在总预算内有界重试;超时 → ReleasePollTimeout(结果未知方向,
  绝不判成功);invalid JSON / 302 redirect 立即失败且不跟随。
- reconcile_pypi:单次 GET 对账返回明确 missing/matching/conflict/pending,不凭退出码猜。
- canary:虚构凭据经上传/验证分支后不出现在 argv 记录、异常文本或返回证据中。

05-05 Task 1 覆盖面(D-11/A7 GitCode 官方链 + V12/DoS 有界传输,T-5-12/13/15/28):
- GitCodeClientTest:create→upload_url→raw PUT→传播轮询→下载字节 SHA256 的脚本序列;create body
  恰五个官方键且 release_status=latest、target_commitish=HEAD;PUT 是归档原始字节(非 multipart);
  upload_info 只在内存(client 属性零残留);assets 全集按实际 type=attach/source 分类——上传全集
  (attach)必须恰一个且名字精确等于归档 wheel,额外 wheel/任何 Python sdist/其他附件均失败,
  type=source 平台自动归档豁免且不被删除,未知/缺失 type fail-closed;digest 缺失可过、错误失败;
  release_status=none 可过、pre/prerelease=true/任何返回 draft=true 失败;tag/target/body 逐字比对;
  429/500 预算内重试、invalid JSON/302 立即失败不跟随、超时 ReleasePollTimeout;canary 零泄漏。
- BoundedResponseTest:JSON=4MiB、HTML=8MiB、raw=本地 size+1、其他默认 JSON 上限;Content-Length
  声明超限在读取前失败、无声明但实际超限在分块读取中失败、边界内恰好 size 成功;wheel 以
  expected_size+1 为天花板流式 hash——多一字节即失败且单响应读取总量不超过 expected_size+1;
  timeout 在 JSON 解析/HTML 解码/内容比对前失败。

测试纪律:全部走 FakeTransport/FakeRunner/FakeClock/FakePoster/FakeOpener(零真实网络、零真实
上传、零真实 token);fake green 只证状态机,不关闭 PUB-03(真实名称注册属 05-08/05-10 manual-only)。
用法:python -m unittest tests.test_release_clients -v
"""
import hashlib
import json
import sys
import tempfile
import unittest
import urllib.error
import zipfile
from pathlib import Path

ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / "ohos_devloop" / "scripts"))  # 扁平脚本直 import(test_release 先例)

try:
    import release  # noqa: E402
except ImportError:  # release 本体未落地(上游先例:跳过而非报错)
    release = None

# 适配面就绪标志:RED 阶段(符号未落地)行为用例按 05-01/05-02 先例 skip,由 surface 用例承载红信号
_ADAPTER_READY = (
    release is not None
    and all(hasattr(release, s) for s in ("PollPolicy", "PYPI_REALMS", "ReleasePollTimeout",
                                          "reconcile_pypi"))
    and all(hasattr(getattr(release, "PyPIClient", object()), m) for m in ("upload", "verify"))
)

# 05-05 Task 1 就绪标志:有界传输 + GitCode 写链符号面(RED 阶段行为用例按先例 skip,surface 用例承载红信号)
_BOUNDED_READY = (
    release is not None
    and all(hasattr(release, s) for s in ("BoundedTransport", "BoundedResponse",
                                          "read_bounded", "stream_expected_sha256",
                                          "HTTP_TIMEOUT_S", "JSON_MAX_BYTES", "HTML_MAX_BYTES"))
)
_GITCODE_READY = (
    _BOUNDED_READY
    and all(hasattr(getattr(release, "GitCodeClient", object()), m)
            for m in ("create", "upload_url", "put_wheel", "verify"))
)

TESTPYPI_JSON = "https://test.pypi.org"
TESTPYPI_LEGACY = "https://test.pypi.org/legacy/"
PYPI_JSON = "https://pypi.org"
PYPI_LEGACY = "https://upload.pypi.org/legacy/"
WHEEL_NAME = "ohos_devloop-0.1.2-py3-none-any.whl"
GOOD_SHA = "ab" * 32
CANARY = "glcp-canary-clients-4f8b2c90d17e"


# ---------------------------------------------------------------------------
# 内存替身:transport(GET)/ runner(twine 子进程)/ clock(零真实等待)
# ---------------------------------------------------------------------------

class FakeTransport:
    """scripted 只读 transport:按序消费 (status, headers, body) 脚本;记录完整 URL(仅测试内存)。"""

    def __init__(self, script=None, route=None):
        self.script = list(script or [])
        self.route = route  # 可选 f(url) -> (status, headers, body)(优先于脚本)
        self.calls: list[str] = []

    def __call__(self, url, timeout=30):
        self.calls.append(url)
        if self.route is not None:
            return self.route(url)
        if self.script:
            status, headers, body = self.script.pop(0)
            return status, dict(headers or {}), body
        raise AssertionError(f"FakeTransport 脚本耗尽,仍被请求: {url}")


class FakeRunner:
    """twine 子进程替身:记录 argv(含 env 键名审计所需的完整 argv),可注入 rc。"""

    def __init__(self, rc=0):
        self.rc = rc
        self.calls: list[list[str]] = []

    def __call__(self, argv, timeout=None, cwd=None, env=None):
        self.calls.append([str(a) for a in argv])
        return self.rc, "", ""


class FakeClock:
    """假时钟:sleep 推进计数器(轮询零真实等待),记录每次 sleep 秒数。"""

    def __init__(self):
        self.now = 1000.0
        self.sleeps: list[float] = []

    def clock(self):
        return self.now

    def sleep(self, sec):
        self.sleeps.append(sec)
        self.now += sec


class FakePoster:
    """GitCode 写链替身(POST create / 预签名 PUT):按序消费脚本,记录 method/url/data/headers。"""

    def __init__(self, script=None):
        self.script = list(script or [])
        self.calls: list[tuple[str, str, bytes, dict]] = []

    def __call__(self, method, url, data, headers):
        self.calls.append((method, url, bytes(data or b""), dict(headers or {})))
        if self.script:
            status, hdrs, body = self.script.pop(0)
            return status, dict(hdrs or {}), body
        raise AssertionError(f"FakePoster 脚本耗尽,仍被调用: {method} {url.split('?')[0]}")


class FakeDownloader:
    """附件下载替身:记录 (url, expected_size),返回注入的 (sha256, size)。"""

    def __init__(self, sha: str, size: int):
        self.sha, self.size = sha, size
        self.calls: list[tuple[str, int]] = []

    def __call__(self, url, expected_size):
        self.calls.append((url, expected_size))
        return self.sha, self.size


class FakeResponse:
    """分块响应替身:headers 可带 Content-Length;read(n) 按序供数据并记录每次请求尺寸。

    url=None 时模拟无 final-url 属性的响应(transport 回退 request.full_url)。
    """

    def __init__(self, data: bytes = b"", headers: dict | None = None, status: int = 200,
                 url: str | None = None):
        self.data = bytes(data)
        self.headers = dict(headers or {})
        self.status = status
        self.read_sizes: list[int] = []
        self.read_calls = 0
        self.url = url

    def read(self, n: int = -1) -> bytes:
        self.read_calls += 1
        self.read_sizes.append(int(n))
        if n is None or n < 0:
            chunk, self.data = self.data, b""
        else:
            chunk, self.data = self.data[:n], self.data[n:]
        return chunk

    def __enter__(self):
        return self

    def __exit__(self, *exc):
        return False

    def close(self):
        pass


class FakeOpener:
    """opener 替身:open(request, timeout) 返回注入 FakeResponse / 抛注入异常;记录 request/timeout。"""

    def __init__(self, response=None, exc: Exception | None = None):
        self.response = response
        self.exc = exc
        self.calls: list[tuple[object, object]] = []

    def open(self, request, timeout=None):
        self.calls.append((request, timeout))
        if self.exc is not None:
            raise self.exc
        return self.response


def make_fake_wheel(outdir: Path, version: str = "0.1.2") -> Path:
    outdir.mkdir(parents=True, exist_ok=True)
    name = f"ohos_devloop-{version}-py3-none-any.whl"
    meta = (f"Metadata-Version: 2.4\nName: ohos-devloop\nVersion: {version}\n"
            f"Project-URL: Homepage, https://gitcode.com/ohos-devloop/devloop_core\n")
    with zipfile.ZipFile(outdir / name, "w") as z:
        z.writestr(f"ohos_devloop-{version}.dist-info/METADATA", meta)
    return outdir / name


def sha256_file(p: Path) -> str:
    h = hashlib.sha256()
    with p.open("rb") as f:
        for chunk in iter(lambda: f.read(1 << 16), b""):
            h.update(chunk)
    return h.hexdigest()


def make_state(tmp: Path, version: str = "0.1.2", with_archive: bool = True):
    """构造绑归档字节的 ReleaseState(run_dir/artifact/wheel 为上传唯一正本)。"""
    run_dir = tmp / "runs" / f"release-{version}"
    wheel = make_fake_wheel(run_dir / "artifact", version) if with_archive else None
    sha = sha256_file(wheel) if wheel else GOOD_SHA
    state = release.ReleaseState(
        version=version, tag=f"v{version}", head="a" * 40,
        wheel_name=wheel.name if wheel else WHEEL_NAME,
        wheel_size=wheel.stat().st_size if wheel else 1024,
        wheel_sha256=sha, run_dir=run_dir)
    return state, wheel


def version_body(urls: list[dict], version: str = "0.1.2") -> bytes:
    return json.dumps({"info": {"version": version}, "urls": urls}).encode("utf-8")


def good_entry(sha: str = GOOD_SHA, filename: str = WHEEL_NAME,
               host: str = "test.pypi.org") -> dict:
    return {"filename": filename, "packagetype": "bdist_wheel", "yanked": False,
            "url": f"https://{host}/packages/{filename}",
            "upload_time_iso_8601": "2026-11-18T00:00:00+00:00",
            "digests": {"sha256": sha}}


def client_for(tmp: Path, transport, runner=None, **kw) -> "release.PyPIClient":
    clock = kw.pop("clock", None) or FakeClock()
    c = release.PyPIClient(
        index_url=kw.pop("index_url", TESTPYPI_JSON), transport=transport,
        runner=runner or FakeRunner(), clock=clock.clock, sleeper=clock.sleep, **kw)
    c._test_clock = clock  # 挂给断言用(不影响生产行为)
    return c


@unittest.skipUnless(release is not None, "release 模块未落地")
class PyPIClientTest(unittest.TestCase):

    def setUp(self):
        self._tmp = tempfile.TemporaryDirectory(prefix="pypi-client-")
        self.tmp = Path(self._tmp.name).resolve()

    def tearDown(self):
        self._tmp.cleanup()

    # -- 适配面存在性(RED 信号承载) ----------------------------------------

    def test_adapter_surface_exists(self):
        """Task 1 符号面:PollPolicy/PYPI_REALMS/ReleasePollTimeout/reconcile_pypi + upload/verify。"""
        for sym in ("PollPolicy", "PYPI_REALMS", "ReleasePollTimeout", "reconcile_pypi"):
            self.assertTrue(hasattr(release, sym), f"release 缺 {sym}(Task 1 GREEN 前预期红)")
        for meth in ("upload", "verify"):
            self.assertTrue(hasattr(release.PyPIClient, meth),
                            f"PyPIClient 缺 {meth}(Task 1 GREEN 前预期红)")

    @unittest.skipUnless(_ADAPTER_READY, "PyPI 上传适配层未落地(Task 1 GREEN 前跳过)")
    def test_poll_policy_defaults(self):
        """PollPolicy 缺省 = 180s 总预算 / 2s 起步 / 10s 封顶(A4 操作默认值,非官方 SLA)。"""
        p = release.PollPolicy()
        self.assertEqual((p.timeout_s, p.initial_interval_s, p.max_interval_s), (180, 2, 10))

    @unittest.skipUnless(_ADAPTER_READY, "PyPI 上传适配层未落地(Task 1 GREEN 前跳过)")
    def test_realm_urls_are_explicit(self):
        """realm → 显式 legacy 上传 URL(不读 .pypirc、不靠 twine 默认仓配置漂移)。"""
        realms = release.PYPI_REALMS
        self.assertEqual(realms["testpypi"]["legacy"], TESTPYPI_LEGACY)
        self.assertEqual(realms["pypi"]["legacy"], PYPI_LEGACY)
        self.assertEqual(realms["testpypi"]["json"], TESTPYPI_JSON)
        self.assertEqual(realms["pypi"]["json"], PYPI_JSON)

    # -- 占用语义(D-06/D-07) ----------------------------------------------

    @unittest.skipUnless(_ADAPTER_READY, "PyPI 上传适配层未落地(Task 1 GREEN 前跳过)")
    def test_version_200_occupied_even_with_empty_urls(self):
        """版本端点 200 即占用:文件列表为空不能反证版本不存在(D-07)。"""
        t = FakeTransport(route=lambda u: (200, {}, version_body([])))
        c = client_for(self.tmp, t)
        occupied, detail = c.version_occupied("ohos-devloop", "0.1.2")
        self.assertTrue(occupied, detail)
        self.assertIn("占用", detail)

    @unittest.skipUnless(_ADAPTER_READY, "PyPI 上传适配层未落地(Task 1 GREEN 前跳过)")
    def test_version_404_not_occupied(self):
        t = FakeTransport(route=lambda u: (404, {}, b"{}"))
        c = client_for(self.tmp, t)
        occupied, _detail = c.version_occupied("ohos-devloop", "0.1.2")
        self.assertFalse(occupied)

    # -- Twine 上传 argv / 凭据前门(D-10) ----------------------------------

    @unittest.skipUnless(_ADAPTER_READY, "PyPI 上传适配层未落地(Task 1 GREEN 前跳过)")
    def test_upload_requires_credentials_before_subprocess(self):
        """凭据缺失 / 用户名非 __token__ / 归档缺失:subprocess 之前失败(runner 零调用)。"""
        state, _wheel = make_state(self.tmp)
        for env in ({"TWINE_USERNAME": "__token__"},                     # 缺 PASSWORD
                    {"TWINE_USERNAME": "__token__", "TWINE_PASSWORD": "  "},  # 空白密码
                    {"TWINE_USERNAME": "lesli", "TWINE_PASSWORD": CANARY},    # 非 token 用户
                    {}):                                                # 全缺
            runner = FakeRunner()
            c = client_for(self.tmp, FakeTransport(), runner=runner)
            with self.subTest(env_keys=sorted(env)):
                with self.assertRaises(release.ReleaseError) as cm:
                    c.upload(state, "testpypi", env=env)
                self.assertIn("TWINE", str(cm.exception))
                self.assertEqual(runner.calls, [], "凭据缺失必须在 subprocess 前失败")
        # 归档缺失同样在 subprocess 前失败
        state2, _ = make_state(self.tmp / "noarch", with_archive=False)
        runner2 = FakeRunner()
        c2 = client_for(self.tmp, FakeTransport(), runner=runner2)
        with self.assertRaises(release.ReleaseError) as cm2:
            c2.upload(state2, "testpypi",
                      env={"TWINE_USERNAME": "__token__", "TWINE_PASSWORD": CANARY})
        self.assertEqual(runner2.calls, [], "归档缺失必须在 subprocess 前失败")

    @unittest.skipUnless(_ADAPTER_READY, "PyPI 上传适配层未落地(Task 1 GREEN 前跳过)")
    def test_upload_argv_exact_single_archived_wheel(self):
        """argv 精确:upload --non-interactive --repository-url <realm> + 唯一归档 wheel。

        无 skip-existing、无 verbose、无 dist glob、token 绝不进 argv(凭据只走 env 继承)。
        """
        state, wheel = make_state(self.tmp)
        for realm, legacy in (("testpypi", TESTPYPI_LEGACY), ("pypi", PYPI_LEGACY)):
            runner = FakeRunner()
            c = client_for(self.tmp, FakeTransport(), runner=runner)
            with self.subTest(realm=realm):
                c.upload(state, realm,
                         env={"TWINE_USERNAME": "__token__", "TWINE_PASSWORD": CANARY})
                self.assertEqual(len(runner.calls), 1)
                argv = runner.calls[0]
                self.assertEqual(argv, [sys.executable, "-m", "twine", "upload",
                                        "--non-interactive", "--repository-url", legacy,
                                        str(wheel)])
                lows = [a.lower() for a in argv]
                for banned in ("--skip-existing", "skip_existing", "--verbose", "-v",
                               "--config-file", ".pypirc"):
                    self.assertNotIn(banned, lows, f"上传 argv 禁止项 {banned}: {argv}")
                self.assertEqual([a for a in argv if a.endswith(".whl")], [str(wheel)],
                                 "上传只接受唯一归档 wheel(禁止 dist glob)")
                self.assertNotIn(CANARY, " ".join(argv), "token 不得进 argv")

    @unittest.skipUnless(_ADAPTER_READY, "PyPI 上传适配层未落地(Task 1 GREEN 前跳过)")
    def test_upload_nonzero_rc_raises_sanitized(self):
        """twine rc!=0 → ReleaseError(结果未知方向,绝不判成功;消息不含原始输出/env 值)。"""
        state, _wheel = make_state(self.tmp)
        runner = FakeRunner(rc=9)
        c = client_for(self.tmp, FakeTransport(), runner=runner)
        with self.assertRaises(release.ReleaseError) as cm:
            c.upload(state, "testpypi",
                     env={"TWINE_USERNAME": "__token__", "TWINE_PASSWORD": CANARY})
        self.assertNotIn(CANARY, str(cm.exception))
        self.assertIn("testpypi", str(cm.exception))

    # -- verify 有界轮询(D-07) ---------------------------------------------

    @unittest.skipUnless(_ADAPTER_READY, "PyPI 上传适配层未落地(Task 1 GREEN 前跳过)")
    def test_verify_polls_through_404_and_empty_urls_to_success(self):
        """传播序列 404 → 200 空 urls → 200 正确 metadata:有界轮询最终绿,零真实等待。"""
        state, _wheel = make_state(self.tmp)
        t = FakeTransport(script=[
            (404, {}, b"{}"),
            (200, {}, version_body([])),
            (200, {}, version_body([good_entry(sha=state.wheel_sha256)])),
        ])
        c = client_for(self.tmp, t)
        ev = c.verify("ohos-devloop", "0.1.2", state.wheel_name, state.wheel_sha256)
        self.assertEqual(ev["api_url"], f"{TESTPYPI_JSON}/pypi/ohos-devloop/0.1.2/json")
        self.assertEqual(ev["file_url"], f"https://test.pypi.org/packages/{WHEEL_NAME}")
        self.assertEqual(ev["sha256"], state.wheel_sha256)
        self.assertEqual(ev["upload_time"], "2026-11-18T00:00:00+00:00")
        self.assertTrue(ev["verified_at"])
        self.assertEqual(len(t.calls), 3)
        self.assertEqual(c._test_clock.sleeps, [2, 4], "退避应 2s 起步指数增长")

    @unittest.skipUnless(_ADAPTER_READY, "PyPI 上传适配层未落地(Task 1 GREEN 前跳过)")
    def test_verify_conflicts_fail_immediately(self):
        """错误 hash / 两个 wheel / sdist / yanked / 文件名不符 / 类型不符:冲突立即失败。"""
        state, _wheel = make_state(self.tmp)
        sha = state.wheel_sha256
        cases = {
            "wrong-hash": [good_entry(sha="cd" * 32)],
            "two-wheels": [good_entry(sha=sha), good_entry(sha=sha)],
            "sdist": [good_entry(sha=sha),
                      {"filename": "ohos_devloop-0.1.2.tar.gz", "packagetype": "sdist",
                       "yanked": False, "url": "https://test.pypi.org/x.tar.gz",
                       "digests": {"sha256": "00" * 32}}],
            "yanked": [{**good_entry(sha=sha), "yanked": True}],
            "wrong-filename": [good_entry(sha=sha, filename="ohos_devloop-9.9.9-py3-none-any.whl")],
            "wrong-packagetype": [{**good_entry(sha=sha), "packagetype": "bdist_egg"}],
        }
        for label, urls in cases.items():
            t = FakeTransport(route=lambda u, urls=urls: (200, {}, version_body(urls)))
            c = client_for(self.tmp, t)
            with self.subTest(case=label):
                with self.assertRaises(release.ReleaseError) as cm:
                    c.verify("ohos-devloop", "0.1.2", state.wheel_name, state.wheel_sha256)
                self.assertNotIsInstance(cm.exception, release.ReleasePollTimeout)
                self.assertTrue("冲突" in str(cm.exception) or "不符" in str(cm.exception),
                                f"冲突消息缺失: {cm.exception}")
                self.assertEqual(len(t.calls), 1, "冲突必须立即失败,不继续轮询")

    @unittest.skipUnless(_ADAPTER_READY, "PyPI 上传适配层未落地(Task 1 GREEN 前跳过)")
    def test_verify_429_retry_after_and_500_retry_within_budget(self):
        """429+合法 Retry-After: 1 → 按其等待;500 → 退避重试;预算内最终 200 绿。"""
        state, _wheel = make_state(self.tmp)
        t = FakeTransport(script=[
            (429, {"Retry-After": "1"}, b"{}"),
            (500, {}, b"{}"),
            (200, {}, version_body([good_entry(sha=state.wheel_sha256)])),
        ])
        c = client_for(self.tmp, t)
        ev = c.verify("ohos-devloop", "0.1.2", state.wheel_name, state.wheel_sha256)
        self.assertEqual(ev["sha256"], state.wheel_sha256)
        self.assertEqual(c._test_clock.sleeps[0], 1, "合法 Retry-After=1 必须被尊重")

    @unittest.skipUnless(_ADAPTER_READY, "PyPI 上传适配层未落地(Task 1 GREEN 前跳过)")
    def test_verify_timeout_is_unknown_not_success(self):
        """预算耗尽 → ReleasePollTimeout(failed/uploaded_unverified 方向,绝不判成功)。"""
        state, _wheel = make_state(self.tmp)
        t = FakeTransport(route=lambda u: (404, {}, b"{}"))
        c = client_for(self.tmp, t)
        with self.assertRaises(release.ReleasePollTimeout) as cm:
            c.verify("ohos-devloop", "0.1.2", state.wheel_name, state.wheel_sha256,
                     policy=release.PollPolicy(timeout_s=30, initial_interval_s=2,
                                               max_interval_s=10))
        self.assertGreaterEqual(c._test_clock.now - 1000.0, 30, "必须等满预算才放弃")
        self.assertIn("未知", str(cm.exception))

    @unittest.skipUnless(_ADAPTER_READY, "PyPI 上传适配层未落地(Task 1 GREEN 前跳过)")
    def test_verify_invalid_json_fails_closed(self):
        """200 非 JSON body → 立即 fail-closed(不绿、不当 pending 轮到超时)。"""
        state, _wheel = make_state(self.tmp)
        t = FakeTransport(route=lambda u: (200, {}, b"<html>gateway error</html>"))
        c = client_for(self.tmp, t)
        with self.assertRaises(release.ReleaseError) as cm:
            c.verify("ohos-devloop", "0.1.2", state.wheel_name, state.wheel_sha256)
        self.assertNotIsInstance(cm.exception, release.ReleasePollTimeout)
        self.assertIn("JSON", str(cm.exception))

    @unittest.skipUnless(_ADAPTER_READY, "PyPI 上传适配层未落地(Task 1 GREEN 前跳过)")
    def test_verify_redirect_not_followed(self):
        """302 → 立即失败且不跟随重定向(禁自动 redirect;Location 不是证据)。"""
        state, _wheel = make_state(self.tmp)
        t = FakeTransport(route=lambda u: (302, {"Location": "https://evil.example/x"}, b""))
        c = client_for(self.tmp, t)
        with self.assertRaises(release.ReleaseError) as cm:
            c.verify("ohos-devloop", "0.1.2", state.wheel_name, state.wheel_sha256)
        self.assertEqual(len(t.calls), 1, "不得跟随重定向发起第二次请求")
        self.assertNotIn("evil.example", str(cm.exception), "异常不得携带重定向目标 URL")

    # -- reconcile_pypi(远端对账,不凭退出码猜) ------------------------------

    @unittest.skipUnless(_ADAPTER_READY, "PyPI 上传适配层未落地(Task 1 GREEN 前跳过)")
    def test_reconcile_categories(self):
        """单次 GET 对账:missing(404) / matching(全匹配) / conflict(内容不符) / pending(空 urls)。"""
        state, _wheel = make_state(self.tmp)
        meta = {"name": "ohos-devloop"}
        cases = {
            "missing": (FakeTransport(route=lambda u: (404, {}, b"{}")), "missing"),
            "matching": (FakeTransport(route=lambda u: (200, {}, version_body(
                [good_entry(sha=state.wheel_sha256)]))), "matching"),
            "conflict": (FakeTransport(route=lambda u: (200, {}, version_body(
                [good_entry(sha="ee" * 32)]))), "conflict"),
            "pending": (FakeTransport(route=lambda u: (200, {}, version_body([]))), "pending"),
        }
        for label, (t, expected) in cases.items():
            with self.subTest(case=label):
                category, detail = release.reconcile_pypi(
                    state, "testpypi", meta, client=client_for(self.tmp, t))
                self.assertEqual(category, expected, detail)

    # -- canary(D-10:凭据零泄漏) -------------------------------------------

    @unittest.skipUnless(_ADAPTER_READY, "PyPI 上传适配层未落地(Task 1 GREEN 前跳过)")
    def test_canary_never_in_argv_messages_or_evidence(self):
        """虚构 token 经上传成功/失败与验证异常后:argv 记录、异常文本、证据全无 canary。"""
        state, _wheel = make_state(self.tmp)
        blobs: list[str] = []
        # 上传成功(argv 含 env 继承的 canary 吗?——不得含)
        runner = FakeRunner()
        c = client_for(self.tmp, FakeTransport(), runner=runner)
        c.upload(state, "testpypi", env={"TWINE_USERNAME": "__token__",
                                         "TWINE_PASSWORD": CANARY})
        blobs.extend(" ".join(a) for a in runner.calls)
        # 上传失败 + 网络层异常(异常文本含完整 URL/query——必须脱敏重写)
        def leaky(url, timeout=30):
            raise OSError(f"connect failed: {url}?token={CANARY}")
        c2 = client_for(self.tmp, leaky, runner=FakeRunner(rc=3))
        with self.assertRaises(release.ReleaseError) as cm:
            c2.upload(state, "testpypi",
                      env={"TWINE_USERNAME": "__token__", "TWINE_PASSWORD": CANARY})
        blobs.append(str(cm.exception))
        c3 = client_for(self.tmp, leaky)
        with self.assertRaises(release.ReleaseError) as cm2:
            c3.verify("ohos-devloop", "0.1.2", state.wheel_name, state.wheel_sha256)
        blobs.append(str(cm2.exception))
        for i, blob in enumerate(blobs):
            for pat in (CANARY, "Authorization", "access_token=", "Bearer "):
                self.assertNotIn(pat, blob, f"分块 #{i}: 敏感模式 {pat!r} 泄漏")


# ---------------------------------------------------------------------------
# 05-05 Task 1:GitCode 适配层(D-11/A7)+ 有界外部传输(V12/DoS,T-5-28)
# ---------------------------------------------------------------------------

GC_API = "https://api.gitcode.com/api/v5"
GC_RELEASE_URL = "https://gitcode.com/ohos-devloop/devloop_core/releases/v0.1.2"
GC_ASSET_URL = "https://gitcode.com/ohos-devloop/devloop_core/releases/download/v0.1.2/" + WHEEL_NAME
PRESIGNED = "glcp-presigned-canary-77a2e6b40d19"  # 预签名/签名头专用哨兵(区别于 token canary)
NOTES = "## [0.1.2] - 2026-11-18\n\n### Added\n- 测试条目。"


def gc_asset(name: str, *, type_: str = "attach", digest: str | None = None,
             url: str | None = None) -> dict:
    entry = {"type": type_, "name": name,
             "browser_download_url": url or f"https://gitcode.com/ohos-devloop/devloop_core/releases/download/v0.1.2/{name}"}
    if digest is not None:
        entry["digest"] = digest
    return entry


def gc_release(state, notes: str, *, assets=None, prerelease=False, release_status="latest",
               draft=None, target=None, body=None, tag=None) -> bytes:
    rel = {"tag_name": tag if tag is not None else state.tag,
           "name": state.tag,
           "body": notes if body is None else body,
           "target_commitish": target if target is not None else state.head,
           "prerelease": prerelease, "release_status": release_status,
           "assets": list(assets or []), "created_at": "2026-11-19T08:00:00+08:00"}
    if draft is not None:
        rel["draft"] = draft
    return json.dumps(rel).encode("utf-8")


def gc_client(state, transport, poster=None, downloader=None, **kw):
    """构造带全注入件(零真实网络)的 GitCodeClient(state 供默认下载替身对账 hash)。"""
    clock = kw.pop("clock", None) or FakeClock()
    c = release.GitCodeClient(
        "ohos-devloop", "devloop_core", CANARY, transport=transport,
        poster=poster if poster is not None else FakePoster(),
        downloader=downloader if downloader is not None else FakeDownloader(state.wheel_sha256,
                                                                           state.wheel_size),
        clock=clock.clock, sleeper=clock.sleep, **kw)
    c._test_clock = clock
    return c


@unittest.skipUnless(release is not None, "release 模块未落地")
class GitCodeClientTest(unittest.TestCase):
    """GitCode 官方链:create(五键)→ upload_url(内存)→ raw PUT → 有界轮询 → 下载 SHA256。"""

    def setUp(self):
        self._tmp = tempfile.TemporaryDirectory(prefix="gitcode-client-")
        self.tmp = Path(self._tmp.name).resolve()

    def tearDown(self):
        self._tmp.cleanup()

    def _state(self):
        return make_state(self.tmp)

    # -- 适配面存在性(RED 信号承载) ----------------------------------------

    def test_gitcode_surface_exists(self):
        """Task 1 符号面:BoundedTransport/read_bounded/stream_expected_sha256 + GitCode 写链。"""
        for sym in ("BoundedTransport", "BoundedResponse", "read_bounded",
                    "stream_expected_sha256", "HTTP_TIMEOUT_S", "JSON_MAX_BYTES",
                    "HTML_MAX_BYTES"):
            self.assertTrue(hasattr(release, sym), f"release 缺 {sym}(Task 1 GREEN 前预期红)")
        for meth in ("create", "upload_url", "put_wheel", "verify"):
            self.assertTrue(hasattr(release.GitCodeClient, meth),
                            f"GitCodeClient 缺 {meth}(Task 1 GREEN 前预期红)")

    # -- create(D-11:官方五键,无猜测 draft 参数) --------------------------

    @unittest.skipUnless(_GITCODE_READY, "GitCode 写链未落地(Task 1 GREEN 前跳过)")
    def test_create_body_exactly_five_official_keys(self):
        """create 只发 tag_name/name/body/target_commitish/release_status=latest。"""
        state, _wheel = self._state()
        poster = FakePoster(script=[(201, {}, gc_release(state, NOTES))])
        c = gc_client(state, FakeTransport(), poster=poster)
        rel = c.create(state, NOTES)
        self.assertEqual(len(poster.calls), 1)
        method, url, data, headers = poster.calls[0]
        self.assertEqual(method, "POST")
        self.assertIn(f"{GC_API}/repos/ohos-devloop/devloop_core/releases", url)
        self.assertIn("access_token=", url, "GitCode token 经 query(官方口径,内存组 URL)")
        sent = json.loads(data.decode("utf-8"))
        self.assertEqual(set(sent), {"tag_name", "name", "body", "target_commitish",
                                     "release_status"},
                         "create body 必须恰五个官方键(不发送猜测的 draft 参数)")
        self.assertEqual(sent["tag_name"], state.tag)
        self.assertEqual(sent["name"], state.tag)
        self.assertEqual(sent["body"], NOTES)
        self.assertEqual(sent["target_commitish"], state.head)
        self.assertEqual(sent["release_status"], "latest")
        self.assertEqual(rel["tag_name"], state.tag)

    @unittest.skipUnless(_GITCODE_READY, "GitCode 写链未落地(Task 1 GREEN 前跳过)")
    def test_create_failure_sanitized_no_token(self):
        """create 401/403/500:ReleaseError 脱敏(status + host),无 token/预签名 URL。"""
        state, _wheel = self._state()
        for status in (401, 403, 500):
            poster = FakePoster(script=[(status, {}, b"oops")])
            c = gc_client(state, FakeTransport(), poster=poster)
            with self.subTest(status=status):
                with self.assertRaises(release.ReleaseError) as cm:
                    c.create(state, NOTES)
                self.assertNotIn(CANARY, str(cm.exception))
                self.assertIn(str(status), str(cm.exception))

    # -- upload_url(短期内存对象,绝不进状态/receipt/日志) ------------------

    @unittest.skipUnless(_GITCODE_READY, "GitCode 写链未落地(Task 1 GREEN 前跳过)")
    def test_upload_url_exact_wheel_name_and_memory_only(self):
        """upload_url 查询 file_name=精确 wheel 名;返回的 url/headers 只留在返回值(client 零残留)。"""
        state, _wheel = self._state()
        presigned = f"https://obs.example.test/put?X-Expires=60&sig={PRESIGNED}"
        t = FakeTransport(route=lambda u: (200, {}, json.dumps(
            {"url": presigned, "headers": {"x-obs-callback": PRESIGNED}}).encode("utf-8")))
        c = gc_client(state, t)
        info = c.upload_url(state)
        self.assertIn(f"/repos/ohos-devloop/devloop_core/releases/{state.tag}/upload_url", t.calls[0])
        self.assertIn(f"file_name={state.wheel_name}", t.calls[0])
        self.assertEqual(info["url"], presigned)
        self.assertEqual(info["headers"], {"x-obs-callback": PRESIGNED})
        # 短期内存对象:client 实例属性中不得残留预签名 URL/签名头(token 本身是合法内存持有)
        for attr, val in vars(c).items():
            if attr == "token":
                continue
            blob = json.dumps(val, default=str, ensure_ascii=False) if not isinstance(val, str) else val
            self.assertNotIn(PRESIGNED, blob, f"client.{attr} 残留签名信息")

    @unittest.skipUnless(_GITCODE_READY, "GitCode 写链未落地(Task 1 GREEN 前跳过)")
    def test_upload_url_failure_sanitized(self):
        """upload_url 非 200 / 缺键:fail-closed,异常不含 token。"""
        state, _wheel = self._state()
        t = FakeTransport(route=lambda u: (500, {}, b"boom"))
        c = gc_client(state, t)
        with self.assertRaises(release.ReleaseError) as cm:
            c.upload_url(state)
        self.assertNotIn(CANARY, str(cm.exception))
        t2 = FakeTransport(route=lambda u: (200, {}, b'{"url": "https://x"}'))  # 缺 headers
        c2 = gc_client(state, t2)
        with self.assertRaises(release.ReleaseError):
            c2.upload_url(state)

    # -- put_wheel(归档原始字节,非 multipart) ------------------------------

    @unittest.skipUnless(_GITCODE_READY, "GitCode 写链未落地(Task 1 GREEN 前跳过)")
    def test_put_wheel_raw_bytes_not_multipart(self):
        """PUT body 是归档 wheel 原始字节 + 返回 headers 原样;无 multipart 边界/表单。"""
        state, wheel = self._state()
        poster = FakePoster(script=[(200, {}, b"{}")])
        presigned = f"https://obs.example.test/put?sig=abc"
        info = {"url": presigned, "headers": {"x-obs-acl": "public-read"}}
        c = gc_client(state, FakeTransport(), poster=poster)
        c.put_wheel(info, wheel)
        method, url, data, headers = poster.calls[0]
        self.assertEqual(method, "PUT")
        self.assertEqual(url, presigned)
        self.assertEqual(data, wheel.read_bytes(), "PUT body 必须是归档 wheel 的原始字节")
        self.assertEqual(headers, {"x-obs-acl": "public-read"}, "headers 原样使用返回值")
        marker = data[:200]
        self.assertNotIn(b"multipart/form-data", marker)
        self.assertNotIn(b"boundary=", marker)

    @unittest.skipUnless(_GITCODE_READY, "GitCode 写链未落地(Task 1 GREEN 前跳过)")
    def test_put_wheel_failure_sanitized(self):
        """PUT 非 2xx:ReleaseError 脱敏(不含预签名 URL/query)。"""
        state, wheel = self._state()
        poster = FakePoster(script=[(403, {}, b"denied")])
        info = {"url": f"https://obs.example.test/put?sig={CANARY}", "headers": {}}
        c = gc_client(state, FakeTransport(), poster=poster)
        with self.assertRaises(release.ReleaseError) as cm:
            c.put_wheel(info, wheel)
        self.assertNotIn(CANARY, str(cm.exception))
        self.assertNotIn("obs.example.test", str(cm.exception))

    # -- verify 有界轮询(PollPolicy 300s;A7 非 draft/non-prerelease 判据) --

    @unittest.skipUnless(_GITCODE_READY, "GitCode 写链未落地(Task 1 GREEN 前跳过)")
    def test_verify_script_through_propagation_to_verified(self):
        """create→无 attach→单 wheel→下载字节正确的脚本序列:传播轮询后 verified。"""
        state, _wheel = self._state()
        dl = FakeDownloader(state.wheel_sha256, state.wheel_size)
        t = FakeTransport(script=[
            (200, {}, gc_release(state, NOTES, assets=[gc_asset("ohos_devloop-0.1.2.src.zip",
                                                                type_="source")])),
            (200, {}, gc_release(state, NOTES, assets=[
                gc_asset("ohos_devloop-0.1.2.src.zip", type_="source"),
                gc_asset(WHEEL_NAME, digest=None)])),  # digest 缺失可过
        ])
        c = gc_client(state, t, downloader=dl)
        ev = c.verify(state, NOTES)
        self.assertEqual(ev["sha256"], state.wheel_sha256)
        self.assertEqual(ev["release_url"], GC_RELEASE_URL)
        self.assertEqual(ev["asset_url"], GC_ASSET_URL)
        self.assertEqual(ev["target_commitish"], state.head)
        self.assertFalse(ev["prerelease"])
        self.assertEqual(ev["release_status"], "latest")
        self.assertTrue(ev["verified_at"])
        self.assertEqual(len(t.calls), 2, "传播中(仅 source 归档)必须继续轮询而非判绿/判死")
        self.assertEqual(dl.calls, [(GC_ASSET_URL, state.wheel_size)],
                         "下载经稳定附件 URL 且以归档 size 为期望")

    @unittest.skipUnless(_GITCODE_READY, "GitCode 写链未落地(Task 1 GREEN 前跳过)")
    def test_verify_digest_optional_cross_check(self):
        """digest 缺失可过;digest 存在且 == 本地 SHA256 过;digest 存在但不同 → 失败。"""
        state, _wheel = self._state()
        sha = state.wheel_sha256
        cases = {
            "missing-digest": [gc_asset(WHEEL_NAME)],
            "matching-digest": [gc_asset(WHEEL_NAME, digest=sha)],
            # 2026-11-19 真实首发实测:GitCode API 现以 OCI 风格 'sha256:<hex>' 返回
            # digest——前缀等价裸 hex(05-10 首发在裸串比对上误判冲突的回归锚点)
            "matching-digest-sha256-prefixed": [gc_asset(WHEEL_NAME, digest=f"sha256:{sha}")],
        }
        for label, assets in cases.items():
            t = FakeTransport(route=lambda u: (200, {}, gc_release(state, NOTES, assets=assets)))
            c = gc_client(state, t, downloader=FakeDownloader(sha, state.wheel_size))
            with self.subTest(case=label):
                ev = c.verify(state, NOTES)
                self.assertEqual(ev["sha256"], sha)
        for label, bad in {
            "prefixed-different-hex": f"sha256:{'ee' * 32}",
            "different-scheme-same-hex": f"sha512:{sha}",
            "bare-different-hex": "ee" * 32,
        }.items():
            t = FakeTransport(route=lambda u: (200, {}, gc_release(state, NOTES, assets=[
                gc_asset(WHEEL_NAME, digest=bad)])))
            c = gc_client(state, t, downloader=FakeDownloader(sha, state.wheel_size))
            with self.subTest(case=label):
                with self.assertRaises(release.ReleaseError) as cm:
                    c.verify(state, NOTES)
                self.assertIn("digest", str(cm.exception))

    @unittest.skipUnless(_GITCODE_READY, "GitCode 写链未落地(Task 1 GREEN 前跳过)")
    def test_reconcile_prefixed_digest_matching(self):
        """resume 对账路径同样认 OCI 'sha256:<hex>' digest:matching 只验证不重传;
        前缀后 hex 不同仍是 conflict(05-10 首发恢复路径的回归锚点)。"""
        state, _wheel = self._state()
        sha = state.wheel_sha256
        t = FakeTransport(route=lambda u: (200, {}, gc_release(state, NOTES, assets=[
            gc_asset(WHEEL_NAME, digest=f"sha256:{sha}")])))
        c = gc_client(state, t, downloader=FakeDownloader(sha, state.wheel_size))
        category, detail = release.reconcile_gitcode(state, NOTES, c)
        self.assertEqual(category, "matching", detail)
        t2 = FakeTransport(route=lambda u: (200, {}, gc_release(state, NOTES, assets=[
            gc_asset(WHEEL_NAME, digest=f"sha256:{'ee' * 32}")])))
        c2 = gc_client(state, t2, downloader=FakeDownloader(sha, state.wheel_size))
        category2, detail2 = release.reconcile_gitcode(state, NOTES, c2)
        self.assertEqual(category2, "conflict", detail2)

    @unittest.skipUnless(_GITCODE_READY, "GitCode 写链未落地(Task 1 GREEN 前跳过)")
    def test_verify_download_hash_mismatch_conflicts(self):
        """下载字节 SHA256 与归档不符:立即冲突失败(下载字节是地面真值)。"""
        state, _wheel = self._state()
        t = FakeTransport(route=lambda u: (200, {}, gc_release(state, NOTES,
                                                               assets=[gc_asset(WHEEL_NAME)])))
        c = gc_client(state, t,
                      downloader=FakeDownloader("ee" * 32, state.wheel_size))
        with self.assertRaises(release.ReleaseError) as cm:
            c.verify(state, NOTES)
        self.assertTrue("冲突" in str(cm.exception) or "不符" in str(cm.exception))

    @unittest.skipUnless(_GITCODE_READY, "GitCode 写链未落地(Task 1 GREEN 前跳过)")
    def test_verify_formal_state_matrix(self):
        """release_status=none 可过;pre / prerelease=true / 任何返回 draft=true 失败;draft 缺省可过。"""
        state, _wheel = self._state()
        wheel_asset = [gc_asset(WHEEL_NAME)]
        ok = {
            "status-none": dict(release_status="none", assets=wheel_asset),
            "draft-absent": dict(assets=wheel_asset),
            "draft-false": dict(draft=False, assets=wheel_asset),
        }
        for label, kw in ok.items():
            t = FakeTransport(route=lambda u, kw=kw: (200, {}, gc_release(state, NOTES, **kw)))
            c = gc_client(state, t, downloader=FakeDownloader(state.wheel_sha256,
                                                              state.wheel_size))
            with self.subTest(case=label):
                c.verify(state, NOTES)  # 不抛即过
        bad = {
            "status-pre": dict(release_status="pre"),
            "prerelease-true": dict(prerelease=True),
            "draft-true": dict(draft=True),
            "wrong-target": dict(target="f" * 40),
            "wrong-body": dict(body="## [0.1.2] - 其他内容"),
            "wrong-tag": dict(tag="v9.9.9"),
        }
        for label, kw in bad.items():
            t = FakeTransport(route=lambda u: (200, {}, gc_release(state, NOTES, **kw)))
            c = gc_client(state, t, downloader=FakeDownloader(state.wheel_sha256,
                                                                 state.wheel_size))
            with self.subTest(case=label):
                with self.assertRaises(release.ReleaseError):
                    c.verify(state, NOTES)

    @unittest.skipUnless(_GITCODE_READY, "GitCode 写链未落地(Task 1 GREEN 前跳过)")
    def test_verify_assets_classification_fail_closed(self):
        """attach 全集恰一个且名精确等于归档 wheel;source 豁免;未知/缺失 type、额外制品失败。"""
        state, _wheel = self._state()
        sha = state.wheel_sha256
        size = state.wheel_size
        cases = {
            "extra-other-whl": [gc_asset(WHEEL_NAME), gc_asset("other-1.0-py3-none-any.whl")],
            "sdist-attach": [gc_asset(WHEEL_NAME),
                             gc_asset("ohos_devloop-0.1.2.tar.gz")],
            "two-wheels": [gc_asset(WHEEL_NAME), gc_asset(WHEEL_NAME, url=GC_ASSET_URL + ".2")],
            "wrong-wheel-name": [gc_asset("ohos_devloop-9.9.9-py3-none-any.whl")],
            "unknown-type": [gc_asset(WHEEL_NAME), gc_asset("mystery.bin", type_="other")],
            "missing-type": [dict(name=WHEEL_NAME, browser_download_url=GC_ASSET_URL)],
            "zip-not-wheel-attach": [gc_asset("notes.zip")],
        }
        for label, assets in cases.items():
            t = FakeTransport(route=lambda u: (200, {}, gc_release(state, NOTES, assets=assets)))
            c = gc_client(state, t, downloader=FakeDownloader(sha, size))
            with self.subTest(case=label):
                with self.assertRaises(release.ReleaseError) as cm:
                    c.verify(state, NOTES)
                self.assertNotIsInstance(cm.exception, release.ReleasePollTimeout,
                                         "内容冲突必须立即失败,不轮询到超时")
        # type=source 平台自动归档单独豁免且不删除:只有 source + 正确 wheel 时不触发任何写
        poster = FakePoster()
        t = FakeTransport(route=lambda u: (200, {}, gc_release(state, NOTES, assets=[
            gc_asset("ohos_devloop-0.1.2.src.zip", type_="source"),
            gc_asset(WHEEL_NAME)])))
        c = gc_client(state, t, poster=poster, downloader=FakeDownloader(sha, size))
        c.verify(state, NOTES)
        self.assertEqual(poster.calls, [], "verify 不得删除/修改平台自动源码归档(零写调用)")

    @unittest.skipUnless(_GITCODE_READY, "GitCode 写链未落地(Task 1 GREEN 前跳过)")
    def test_verify_poll_edges(self):
        """404/429/500 预算内重试;assets 空为传播中继续轮询;超时 → ReleasePollTimeout;
        invalid JSON / 302 redirect 立即失败且不跟随。"""
        state, _wheel = self._state()
        sha, size = state.wheel_sha256, state.wheel_size
        ok_assets = [gc_asset(WHEEL_NAME)]
        # 429 → 500 → 200 空 assets → 404 → 200 全匹配
        t = FakeTransport(script=[
            (429, {"Retry-After": "1"}, b"{}"),
            (500, {}, b"{}"),
            (200, {}, gc_release(state, NOTES, assets=[])),
            (404, {}, b"{}"),
            (200, {}, gc_release(state, NOTES, assets=ok_assets)),
        ])
        c = gc_client(state, t, downloader=FakeDownloader(sha, size))
        ev = c.verify(state, NOTES)
        self.assertEqual(ev["sha256"], sha)
        self.assertEqual(c._test_clock.sleeps[0], 1, "合法 Retry-After=1 必须被尊重")
        # 超时:一直 404 → ReleasePollTimeout(结果未知方向)
        t2 = FakeTransport(route=lambda u: (404, {}, b"{}"))
        c2 = gc_client(state, t2, downloader=FakeDownloader(sha, size))
        with self.assertRaises(release.ReleasePollTimeout):
            c2.verify(state, NOTES, policy=release.PollPolicy(timeout_s=30))
        # invalid JSON:立即 fail-closed
        t3 = FakeTransport(route=lambda u: (200, {}, b"<html>gateway</html>"))
        c3 = gc_client(state, t3, downloader=FakeDownloader(sha, size))
        with self.assertRaises(release.ReleaseError) as cm3:
            c3.verify(state, NOTES)
        self.assertIn("JSON", str(cm3.exception))
        # 302:立即失败且不跟随(第二个请求不得发出)
        t4 = FakeTransport(route=lambda u: (302, {"Location": "https://evil.example/x"}, b""))
        c4 = gc_client(state, t4, downloader=FakeDownloader(sha, size))
        with self.assertRaises(release.ReleaseError) as cm4:
            c4.verify(state, NOTES)
        self.assertEqual(len(t4.calls), 1)
        self.assertNotIn("evil.example", str(cm4.exception))

    @unittest.skipUnless(_GITCODE_READY, "GitCode 写链未落地(Task 1 GREEN 前跳过)")
    def test_verify_missing_release_status_fails_closed(self):
        """release_status 键缺失:fail-closed(无法证明非 pre,不得默认放行)。"""
        state, _wheel = self._state()
        rel = json.loads(gc_release(state, NOTES, assets=[gc_asset(WHEEL_NAME)]))
        rel.pop("release_status")
        t = FakeTransport(route=lambda u: (200, {}, json.dumps(rel).encode("utf-8")))
        c = gc_client(state, t, downloader=FakeDownloader(state.wheel_sha256, state.wheel_size))
        with self.assertRaises(release.ReleaseError) as cm:
            c.verify(state, NOTES)
        self.assertIn("release_status", str(cm.exception))

    # -- canary(T-5-13:token/预签名 URL 零泄漏) ----------------------------

    @unittest.skipUnless(_GITCODE_READY, "GitCode 写链未落地(Task 1 GREEN 前跳过)")
    def test_canary_never_in_messages_or_client_state(self):
        """网络层异常(含完整带 token/签名 URL)被重写为脱敏 ReleaseError;client 零残留。"""
        state, wheel = self._state()

        def leaky(url, timeout=30):
            raise OSError(f"connect failed: {url}?token={CANARY}")

        c = gc_client(state, leaky)
        blobs = []
        with self.assertRaises(release.ReleaseError) as cm1:
            c.verify(state, NOTES)
        blobs.append(str(cm1.exception))

        def leaky_post(method, url, data, headers):
            raise OSError(f"put failed: {url}&sig={CANARY}")
        c2 = gc_client(state, FakeTransport(), poster=leaky_post)
        with self.assertRaises(release.ReleaseError) as cm2:
            c2.create(state, NOTES)
        blobs.append(str(cm2.exception))

        def leaky_dl(url, expected_size):
            raise OSError(f"download failed: {url}?sig={CANARY}")
        t = FakeTransport(route=lambda u: (200, {}, gc_release(
            state, NOTES, assets=[gc_asset(WHEEL_NAME)])))
        c3 = gc_client(state, t, downloader=leaky_dl)
        with self.assertRaises(release.ReleaseError) as cm3:
            c3.verify(state, NOTES)
        blobs.append(str(cm3.exception))
        for i, blob in enumerate(blobs):
            for pat in (CANARY, "Authorization", "access_token=", "x-obs-", "Bearer "):
                self.assertNotIn(pat, blob, f"分块 #{i}: 敏感模式 {pat!r} 泄漏")
        for client in (c, c2, c3):
            for attr, val in vars(client).items():
                if attr == "token":
                    continue  # token 本身是合法内存持有(内存组 URL 的正本)
                blob = val if isinstance(val, str) else json.dumps(val, default=str,
                                                                   ensure_ascii=False)
                self.assertNotIn(CANARY, blob, f"client.{attr} 残留 canary")


@unittest.skipUnless(release is not None, "release 模块未落地")
class BoundedResponseTest(unittest.TestCase):
    """有界外部读取(V12/DoS,T-5-28):分类上限、声明/实际超限、timeout、wheel 流式 hash。"""

    def setUp(self):
        self._tmp = tempfile.TemporaryDirectory(prefix="bounded-")
        self.tmp = Path(self._tmp.name).resolve()

    def tearDown(self):
        self._tmp.cleanup()

    # -- 分类上限常量 --------------------------------------------------------

    def test_limit_constants(self):
        """HTTP_TIMEOUT_S=30;JSON_MAX_BYTES=4MiB;HTML_MAX_BYTES=8MiB(接口契约)。"""
        self.assertEqual(release.HTTP_TIMEOUT_S, 30)
        self.assertEqual(release.JSON_MAX_BYTES, 4 * 1024 * 1024)
        self.assertEqual(release.HTML_MAX_BYTES, 8 * 1024 * 1024)

    # -- read_bounded:声明超限 / 实际超限 / 恰好边界 ------------------------

    @unittest.skipUnless(_BOUNDED_READY, "有界传输未落地(Task 1 GREEN 前跳过)")
    def test_declared_content_length_over_limit_fails_before_read(self):
        """声明 Content-Length 超限:读取前失败(response.read 零调用)。"""
        limit = 1024
        resp = FakeResponse(b"x" * 8, headers={"Content-Length": str(limit + 1)})
        with self.assertRaises(release.ReleaseError) as cm:
            release.read_bounded(resp, limit)
        self.assertIn("Content-Length", str(cm.exception))
        self.assertEqual(resp.read_calls, 0, "声明超限必须在任何读取前失败")

    @unittest.skipUnless(_BOUNDED_READY, "有界传输未落地(Task 1 GREEN 前跳过)")
    def test_actual_bytes_over_limit_fails_without_declaration(self):
        """无 Content-Length 但实际字节超限:分块读取中超限立即失败。"""
        limit = 1000
        resp = FakeResponse(b"x" * (limit + 1))
        with self.assertRaises(release.ReleaseError):
            release.read_bounded(resp, limit)
        self.assertLessEqual(sum(resp.read_sizes), limit + 1,
                             "至多多探 1 字节判定超限")

    @unittest.skipUnless(_BOUNDED_READY, "有界传输未落地(Task 1 GREEN 前跳过)")
    def test_exact_limit_succeeds(self):
        """边界内恰好 size 成功:字节完整返回(含分块供给形态)。"""
        limit = 1000
        for declared in (None, str(limit)):
            with self.subTest(declared=declared):
                headers = {"Content-Length": declared} if declared else {}
                resp = FakeResponse(b"y" * limit, headers=headers)
                body = release.read_bounded(resp, limit)
                self.assertEqual(body, b"y" * limit)

    @unittest.skipUnless(_BOUNDED_READY, "有界传输未落地(Task 1 GREEN 前跳过)")
    def test_chunked_reads_capped_at_64kib(self):
        """按 ≤64KiB 分块读取(不一次性整读);raw=本地 size+1 形态同样适用。"""
        chunk = 64 * 1024
        data = b"z" * (chunk * 2 + 100)
        resp = FakeResponse(data)
        body = release.read_bounded(resp, len(data) + 1)  # raw:本地 size+1
        self.assertEqual(body, data)
        self.assertTrue(all(s <= chunk for s in resp.read_sizes),
                        f"分块尺寸超过 64KiB: {max(resp.read_sizes)}")
        self.assertGreaterEqual(len(resp.read_sizes), 3, "大响应必须分块读取")

    @unittest.skipUnless(_BOUNDED_READY, "有界传输未落地(Task 1 GREEN 前跳过)")
    def test_raw_local_size_plus_one_boundary(self):
        """raw 上限 = 本地资产 size+1:恰 size 过;超上限(size+2)失败。

        size+1 恰在上限内(多探 1 字节语义);wheel 的「多一字节即失败」由
        stream_expected_sha256 的精确相等判据承担(见 wheel 流式用例)。
        """
        data = b"k" * 500
        ok = FakeResponse(data)
        self.assertEqual(release.read_bounded(ok, len(data) + 1), data)
        self.assertEqual(release.read_bounded(FakeResponse(data + b"!"), len(data) + 1),
                         data + b"!")
        with self.assertRaises(release.ReleaseError):
            release.read_bounded(FakeResponse(data + b"!!"), len(data) + 1)

    # -- BoundedTransport:timeout 在解析前失败 / 默认 JSON 上限 -------------

    @unittest.skipUnless(_BOUNDED_READY, "有界传输未落地(Task 1 GREEN 前跳过)")
    def test_transport_timeout_fails_before_any_parsing(self):
        """opener 超时异常:在任何读取/解析前以 ReleaseError 失败(不退回无界整读)。"""
        opener = FakeOpener(exc=TimeoutError("timed out"))
        transport = release.BoundedTransport()
        transport.opener = opener  # 注入 seam(生产默认 no-redirect opener)
        req = urllib_request_get("https://example.test/json")
        with self.assertRaises(release.ReleaseError) as cm:
            transport(req)
        self.assertNotIn("/json", str(cm.exception), "超时异常不得携带 URL 路径/query")

    @unittest.skipUnless(_BOUNDED_READY, "有界传输未落地(Task 1 GREEN 前跳过)")
    def test_transport_default_limit_is_json(self):
        """未显式分类(默认 JSON 上限):4MiB<body<8MiB 失败;显式 HTML 上限则通过。"""
        body = b"a" * (release.JSON_MAX_BYTES + 1024)
        transport = release.BoundedTransport()
        transport.opener = FakeOpener(response=FakeResponse(
            body, headers={"Content-Type": "application/json"}))
        req = urllib_request_get("https://example.test/json")
        with self.assertRaises(release.ReleaseError):
            transport(req)  # 默认 max_bytes=JSON_MAX_BYTES
        transport2 = release.BoundedTransport()
        transport2.opener = FakeOpener(response=FakeResponse(
            body, headers={"Content-Type": "text/html"}))
        resp = transport2(req, max_bytes=release.HTML_MAX_BYTES)
        self.assertEqual(resp.status, 200)
        self.assertEqual(len(resp.body), len(body))

    @unittest.skipUnless(_BOUNDED_READY, "有界传输未落地(Task 1 GREEN 前跳过)")
    def test_transport_response_and_http_error_shapes(self):
        """2xx → BoundedResponse(status, final_url, body);4xx/5xx 同形返回(不抛 HTTPError)。"""
        transport = release.BoundedTransport()
        transport.opener = FakeOpener(response=FakeResponse(b'{"ok": 1}'))
        req = urllib_request_get("https://example.test/json")
        resp = transport(req)
        self.assertEqual(resp.status, 200)
        self.assertEqual(resp.body, b'{"ok": 1}')
        self.assertEqual(resp.final_url, req.full_url)
        err_fp = FakeResponse(b'{"message": "nope"}')
        http_err = urllib.error.HTTPError(req.full_url, 404, "Not Found",
                                          {"Content-Type": "application/json"}, err_fp)
        transport2 = release.BoundedTransport()
        transport2.opener = FakeOpener(exc=http_err)
        resp2 = transport2(req)
        self.assertEqual(resp2.status, 404)
        self.assertEqual(resp2.body, b'{"message": "nope"}')

    # -- stream_expected_sha256:expected_size+1 天花板流式 hash --------------

    @unittest.skipUnless(_BOUNDED_READY, "有界传输未落地(Task 1 GREEN 前跳过)")
    def test_stream_wheel_exact_size_ok(self):
        """恰 expected_size 字节:流式 hash 正确(与 hashlib 全量一致)。"""
        data = os_urandom_bytes(100_000)
        opener = FakeOpener(response=FakeResponse(data))
        sha, size = release.stream_expected_sha256(
            urllib_request_get("https://example.test/w.whl"), len(data), opener=opener)
        self.assertEqual(sha, hashlib.sha256(data).hexdigest())
        self.assertEqual(size, len(data))

    @unittest.skipUnless(_BOUNDED_READY, "有界传输未落地(Task 1 GREEN 前跳过)")
    def test_stream_wheel_one_byte_over_fails(self):
        """expected_size+1 字节:失败,且单响应读取总量不超过 expected_size+1。"""
        data = os_urandom_bytes(10_001)
        expected = len(data) - 1
        resp = FakeResponse(data)
        opener = FakeOpener(response=resp)
        with self.assertRaises(release.ReleaseError):
            release.stream_expected_sha256(
                urllib_request_get("https://example.test/w.whl"), expected, opener=opener)
        self.assertLessEqual(sum(resp.read_sizes), expected + 1)

    @unittest.skipUnless(_BOUNDED_READY, "有界传输未落地(Task 1 GREEN 前跳过)")
    def test_stream_wheel_far_over_fails_at_ceiling(self):
        """远超过限(expected+100KiB):在 expected_size+1 天花板处失败,不无界整读。"""
        data = os_urandom_bytes(64 * 1024 * 3)
        expected = 1000
        resp = FakeResponse(data)
        opener = FakeOpener(response=resp)
        with self.assertRaises(release.ReleaseError):
            release.stream_expected_sha256(
                urllib_request_get("https://example.test/w.whl"), expected, opener=opener)
        self.assertLessEqual(sum(resp.read_sizes), expected + 1,
                             "读取天花板必须是 expected_size+1,不得退回无界整读")

    @unittest.skipUnless(_BOUNDED_READY, "有界传输未落地(Task 1 GREEN 前跳过)")
    def test_stream_wheel_short_and_declared_over_fail(self):
        """少于 expected(EOF 提前)失败;声明 Content-Length>expected 在读取前失败。"""
        data = b"q" * 100
        opener = FakeOpener(response=FakeResponse(data))
        with self.assertRaises(release.ReleaseError):
            release.stream_expected_sha256(
                urllib_request_get("https://example.test/w.whl"), 200, opener=opener)
        resp = FakeResponse(b"q" * 10, headers={"Content-Length": "999999"})
        opener2 = FakeOpener(response=resp)
        with self.assertRaises(release.ReleaseError) as cm:
            release.stream_expected_sha256(
                urllib_request_get("https://example.test/w.whl"), 100, opener=opener2)
        self.assertEqual(resp.read_calls, 0, "声明超限必须读取前失败")
        self.assertIn("Content-Length", str(cm.exception))

    @unittest.skipUnless(_BOUNDED_READY, "有界传输未落地(Task 1 GREEN 前跳过)")
    def test_stream_wheel_timeout_fails(self):
        """下载超时:ReleaseError(fail-closed),不退回无界整读。"""
        opener = FakeOpener(exc=TimeoutError("read timed out"))
        with self.assertRaises(release.ReleaseError):
            release.stream_expected_sha256(
                urllib_request_get("https://example.test/w.whl"), 1024, opener=opener)

    @unittest.skipUnless(_BOUNDED_READY, "有界传输未落地(Task 1 GREEN 前跳过)")
    def test_stream_wheel_uses_30s_timeout(self):
        """opener.open 以 timeout=HTTP_TIMEOUT_S(30s)打开(单请求超时是固定属性)。"""
        data = b"r" * 50
        opener = FakeOpener(response=FakeResponse(data))
        release.stream_expected_sha256(
            urllib_request_get("https://example.test/w.whl"), 50, opener=opener)
        self.assertEqual(opener.calls[0][1], 30)


def urllib_request_get(url: str):
    import urllib.request
    return urllib.request.Request(url, method="GET")


def os_urandom_bytes(n: int) -> bytes:
    import os as _os
    return _os.urandom(n)


if __name__ == "__main__":
    unittest.main()