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_shared_allowlist_guard_requires_https_allowlisted_host(self): self.assertTrue(resolve_releases.is_allowlisted("https://api.github.com/x")) self.assertTrue(resolve_releases.is_allowlisted("https://ghcr.io/x")) self.assertTrue(resolve_releases.is_allowlisted("https://registry.npmjs.org/x")) self.assertFalse(resolve_releases.is_allowlisted("http://api.github.com/x")) self.assertFalse(resolve_releases.is_allowlisted("https://evil.example.com/x")) self.assertFalse(resolve_releases.is_allowlisted("https://api.github.com.evil.example/x")) 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) class FakeNtfy: """Deterministic ntfy tag fixture served through the same fetch seam.""" VERSION = "2.11.0" def __init__(self, tags=None, tags_response=None): self.tags = tags if tags is not None else ["v" + self.VERSION] self.tags_response = tags_response self.calls = [] def __call__(self, url, headers=None): self.calls.append(url) if "/git/matching-refs/" in url: if self.tags_response is not None: return 200, {}, json.dumps(self.tags_response).encode() return 200, {}, json.dumps([{"ref": "refs/tags/" + tag} for tag in self.tags]).encode() return 404, {}, b"" class NtfyResolutionTests(unittest.TestCase): def test_resolves_exact_version_from_official_tags_only(self): registry = FakeNtfy(tags=["v2.10.0", "v2.11.0"]) result = resolve_releases.resolve_ntfy(registry) self.assertEqual(result["version"], "2.11.0") self.assertEqual(result["tag"], "v2.11.0") self.assertEqual(result["module"], resolve_releases.NTFY_MODULE) self.assertEqual(result["repository"], resolve_releases.NTFY_REPOSITORY) # No release assets or checksums are fetched: the native installer builds # the server from the pinned module instead. self.assertNotIn("assets", result) self.assertEqual(len(registry.calls), 1) self.assertTrue(registry.calls[0].startswith( "https://api.github.com/repos/binwiederhier/ntfy/git/matching-refs/")) self.assertFalse(any("releases/latest" in url for url in registry.calls)) def test_malformed_tag_metadata_is_rejected(self): for tags in ([42], [{"ref": "refs/heads/main"}], [{"ref": "refs/tags/not-a-version"}], [{"noref": "refs/tags/v2.11.0"}]): with self.assertRaises(resolve_releases.ReleaseError): resolve_releases.resolve_ntfy(FakeNtfy(tags_response=tags)) def test_no_stable_release_fails_closed(self): with self.assertRaisesRegex(resolve_releases.ReleaseError, "no stable ntfy release"): resolve_releases.resolve_ntfy(FakeNtfy(tags=[])) if __name__ == "__main__": unittest.main()