05ae530442
Install current verified harness releases inside Docker, preserve persistent accounts and settings, and provide separate interactive and pipeline model defaults with terminal onboarding and fuzzy pickers. Add Docker-aware authoring transport, Pi stage execution, bounded workflow controls, reliable final-result readback and usage settlement, and finite short-lived CLI pipe draining. Keep dated installation evidence and packaged authoring guidance consistent. Verified with a real Docker installation, both harness stages and interactive authors, the built-in plan/implement/review starter, independent host race/vet checks, installer tests, and packaged skill tests. Generated release receipts stay ignored in clean checkouts.
183 lines
8.7 KiB
Python
183 lines
8.7 KiB
Python
import importlib.util
|
|
import json
|
|
from pathlib import Path
|
|
import unittest
|
|
|
|
spec = importlib.util.spec_from_file_location("resolve_releases", Path(__file__).with_name("resolve-releases.py"))
|
|
resolve_releases = importlib.util.module_from_spec(spec)
|
|
spec.loader.exec_module(resolve_releases)
|
|
|
|
|
|
class FakeRegistry:
|
|
"""Deterministic loopback fixture; the resolver's fetch seam keeps tests offline.
|
|
|
|
A single complete matching-refs array is served; there is deliberately no
|
|
``tags/list`` handler, so any registry cross-check would return 404 and fail.
|
|
"""
|
|
|
|
def __init__(self, refs=None, pi=None, digest="sha256:" + "a" * 64,
|
|
digests=None, refs_response=None):
|
|
self.refs = refs if refs is not None else ["v1.18.35", "v2.0.25", "v2.0.26"]
|
|
self.pi = pi if pi is not None else {"version": "1.1.0", "engines": {"node": ">=22.19.0"}}
|
|
self.digest = digest
|
|
self.digests = digests or {}
|
|
self.refs_response = refs_response
|
|
self.calls = []
|
|
|
|
def __call__(self, url, headers=None):
|
|
self.calls.append(url)
|
|
if "/git/matching-refs/" in url:
|
|
if self.refs_response is not None:
|
|
return 200, {}, json.dumps(self.refs_response).encode()
|
|
body = [{"ref": "refs/tags/" + name} for name in self.refs]
|
|
return 200, {}, json.dumps(body).encode()
|
|
if "/token?" in url:
|
|
return 200, {}, json.dumps({"token": "fixture"}).encode()
|
|
if "/manifests/" in url:
|
|
tag = url.rsplit("/", 1)[-1]
|
|
if tag in self.digests:
|
|
value = self.digests[tag]
|
|
headers = {} if value is None else {"docker-content-digest": value}
|
|
return 200, headers, b""
|
|
return 200, {"docker-content-digest": self.digest}, b""
|
|
if "registry.npmjs.org" in url:
|
|
return 200, {}, json.dumps(self.pi).encode()
|
|
return 404, {}, b""
|
|
|
|
|
|
class ReleaseResolutionTests(unittest.TestCase):
|
|
def test_selects_highest_v2_from_one_complete_matching_refs_request(self):
|
|
registry = FakeRegistry()
|
|
result = resolve_releases.resolve_opencode(registry)
|
|
self.assertEqual(result["version"], "2.0.26")
|
|
self.assertEqual(result["digest"], "sha256:" + "a" * 64)
|
|
self.assertEqual(result["candidates"], ["2.0.25", "2.0.26"])
|
|
self.assertNotIn("pages", result)
|
|
calls = " ".join(registry.calls)
|
|
self.assertNotIn("releases/latest", calls)
|
|
self.assertNotIn("last=", calls)
|
|
self.assertNotIn("/tags/list", calls, "redundant registry cross-check must be gone")
|
|
self.assertIn("matching-refs", result["anchor"])
|
|
ref_urls = [url for url in registry.calls if "/git/matching-refs/" in url]
|
|
self.assertEqual(len(ref_urls), 1, "matching-refs must be a single bounded request")
|
|
self.assertNotIn("per_page", ref_urls[0])
|
|
self.assertNotIn("page=", ref_urls[0])
|
|
self.assertNotIn("?", ref_urls[0])
|
|
manifest_calls = [url for url in registry.calls if "/manifests/" in url]
|
|
self.assertEqual(len(manifest_calls), 1)
|
|
self.assertIn("2.0.26", manifest_calls[0])
|
|
|
|
def test_complete_100_plus_ref_array_resolves_in_one_request(self):
|
|
refs = [f"v2.0.{i}" for i in range(120)] + ["v2.1.0", "v2.0.26"]
|
|
registry = FakeRegistry(refs=refs)
|
|
result = resolve_releases.resolve_opencode(registry)
|
|
self.assertEqual(result["version"], "2.1.0")
|
|
ref_urls = [url for url in registry.calls if "/git/matching-refs/" in url]
|
|
self.assertEqual(len(ref_urls), 1)
|
|
self.assertFalse(any("/tags/list" in url for url in registry.calls))
|
|
|
|
def test_over_cap_ref_array_fails_closed(self):
|
|
registry = FakeRegistry(refs=[f"v2.0.{i}" for i in range(resolve_releases.MAX_REFS + 1)])
|
|
with self.assertRaisesRegex(resolve_releases.ReleaseError, "cap"):
|
|
resolve_releases.resolve_opencode(registry)
|
|
self.assertFalse(any("/manifests/" in url for url in registry.calls))
|
|
|
|
def test_oversized_response_body_is_rejected(self):
|
|
def fetch(url, headers=None):
|
|
if "/git/matching-refs/" in url:
|
|
return 200, {}, b"[" + b" " * (resolve_releases.MAX_BODY + 1)
|
|
return 404, {}, b""
|
|
|
|
with self.assertRaisesRegex(resolve_releases.ReleaseError, "exceeds"):
|
|
resolve_releases.resolve_opencode(fetch)
|
|
|
|
def test_newer_v1_tag_is_ignored(self):
|
|
registry = FakeRegistry(refs=["v2.0.25", "v2.0.26", "v1.19.0"])
|
|
result = resolve_releases.resolve_opencode(registry)
|
|
self.assertEqual(result["version"], "2.0.26")
|
|
self.assertNotIn("1.19.0", result["candidates"])
|
|
self.assertEqual(result["candidates"], ["2.0.25", "2.0.26"])
|
|
|
|
def test_stable_v2_beats_newer_prerelease_and_build_suffix(self):
|
|
registry = FakeRegistry(refs=["v2.0.26", "v2.0.27-rc.1", "v2.0.27+build.5"])
|
|
result = resolve_releases.resolve_opencode(registry)
|
|
self.assertEqual(result["version"], "2.0.26")
|
|
self.assertEqual(result["candidates"], ["2.0.26"])
|
|
|
|
def test_missing_newest_digest_fails_closed_without_older_fallback(self):
|
|
registry = FakeRegistry(refs=["v2.0.25", "v2.0.26"], digests={"2.0.26": None})
|
|
with self.assertRaisesRegex(resolve_releases.ReleaseError, "digest"):
|
|
resolve_releases.resolve_opencode(registry)
|
|
manifest_calls = [url for url in registry.calls if "/manifests/" in url]
|
|
self.assertEqual([url.rsplit("/", 1)[-1] for url in manifest_calls], ["2.0.26"])
|
|
self.assertFalse(any("/manifests/2.0.25" in url for url in registry.calls))
|
|
|
|
def test_no_supported_v2_in_official_metadata_fails_closed(self):
|
|
registry = FakeRegistry(refs=["v1.18.35", "v3.0.0"])
|
|
with self.assertRaisesRegex(resolve_releases.ReleaseError, "no supported OpenCode V2"):
|
|
resolve_releases.resolve_opencode(registry)
|
|
|
|
def test_malformed_github_metadata_is_rejected(self):
|
|
cases = [
|
|
[42],
|
|
[{"ref": "refs/heads/main"}],
|
|
[{"ref": "refs/tags/not-a-version"}],
|
|
[{"ref": 123}],
|
|
[{"noref": "refs/tags/v2.0.26"}],
|
|
]
|
|
for refs in cases:
|
|
registry = FakeRegistry(refs_response=refs)
|
|
with self.assertRaises(resolve_releases.ReleaseError):
|
|
resolve_releases.resolve_opencode(registry)
|
|
|
|
def test_non_list_github_payload_is_rejected(self):
|
|
def fetch(url, headers=None):
|
|
if "/git/matching-refs/" in url:
|
|
return 200, {}, json.dumps({"ref": "refs/tags/v2.0.26"}).encode()
|
|
return 404, {}, b""
|
|
|
|
with self.assertRaisesRegex(resolve_releases.ReleaseError, "not a list"):
|
|
resolve_releases.resolve_opencode(fetch)
|
|
|
|
def test_invalid_manifest_digest_is_rejected(self):
|
|
with self.assertRaisesRegex(resolve_releases.ReleaseError, "digest"):
|
|
resolve_releases.resolve_opencode(FakeRegistry(digest="not-a-digest"))
|
|
|
|
def test_non_registry_host_is_rejected(self):
|
|
with self.assertRaisesRegex(resolve_releases.ReleaseError, "non-registry host"):
|
|
resolve_releases._default_fetch("https://evil.example.com/tags/list")
|
|
|
|
def test_malformed_pi_metadata_is_rejected(self):
|
|
for pi in ({"version": "not-semver"}, {"version": "1.1.0", "engines": "node"}, 42):
|
|
with self.assertRaises(resolve_releases.ReleaseError):
|
|
resolve_releases.resolve_pi(FakeRegistry(pi=pi))
|
|
|
|
def test_unsupported_node_engine_range_fails_closed(self):
|
|
for engine in (">=22 <24", "^22.19.0", ">=22.0.0 || >=20"):
|
|
with self.assertRaisesRegex(resolve_releases.ReleaseError, "unsupported"):
|
|
resolve_releases.node_satisfies(engine, "22.19.0")
|
|
|
|
def test_resolve_pi_validates_node_engine(self):
|
|
registry = FakeRegistry()
|
|
result = resolve_releases.resolve_pi(registry, node_version="22.19.0")
|
|
self.assertEqual(result["version"], "1.1.0")
|
|
with self.assertRaisesRegex(resolve_releases.ReleaseError, "requires Node"):
|
|
resolve_releases.resolve_pi(FakeRegistry(), node_version="20.0.0")
|
|
|
|
def test_combined_resolution_shape(self):
|
|
result = resolve_releases.resolve(FakeRegistry(), node_version="22.19.0")
|
|
self.assertEqual(set(result), {"opencode", "pi"})
|
|
self.assertEqual(result["opencode"]["image"], resolve_releases.OPENCODE_IMAGE)
|
|
|
|
def test_load_fixture_rejects_incomplete_data(self):
|
|
import tempfile
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
path = Path(directory, "fixture.json")
|
|
path.write_text(json.dumps({"opencode": {}}))
|
|
with self.assertRaises(resolve_releases.ReleaseError):
|
|
resolve_releases.load_fixture(path)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|