"""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"))
try:
import release
except ImportError:
release = None
_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"))
)
_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"
class FakeTransport:
"""scripted 只读 transport:按序消费 (status, headers, body) 脚本;记录完整 URL(仅测试内存)。"""
def __init__(self, script=None, route=None):
self.script = list(script or [])
self.route = route
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()
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)
@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)
@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__"},
{"TWINE_USERNAME": "__token__", "TWINE_PASSWORD": " "},
{"TWINE_USERNAME": "lesli", "TWINE_PASSWORD": CANARY},
{}):
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 前失败")
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))
@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")
@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)
@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] = []
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)
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} 泄漏")
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"
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)
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 前预期红)")
@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))
@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})
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"}'))
c2 = gc_client(state, t2)
with self.assertRaises(release.ReleaseError):
c2.upload_url(state)
@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))
@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)])),
])
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)],
"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,
"内容冲突必须立即失败,不轮询到超时")
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)]
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 必须被尊重")
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))
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))
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))
@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
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)
@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)
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)
@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
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)
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"}')
@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()