Files
pipelines/scripts/test_resolve_releases.py
T
alan a70e3aef4b Install Pipelines natively by default on macOS and Linux
Add scripts/setup-native.py and make ./install (and --native) build the server, the CLI
and ntfy from source into ~/.local/share/pipelines, detect an existing host OpenCode
and Pi instead of installing them, install the packaged authoring skill, migrate an
existing Docker database and ntfy auth store, save the host client default and start
both services. ./install --docker keeps the previous Docker server + ntfy
installation unchanged.

ntfy is compiled from its pinned Go module on every host because upstream publishes
no macOS server binary (its darwin asset is built with -tags noserver); its cgo
SQLite driver is why a C compiler is now required natively. The ntfy credential
bootstrap and the client default writer are shared by both installers,
installation.Load resolves symlinked prefixes, the Docker migration copies the
SQLite write-ahead log so the newest definitions and runs are not lost, and the
account subcommands read the generated configuration through NTFY_CONFIG_FILE.

Verified on macOS: 115 Python tests, go build/vet/test, and scratch installs that
migrate 9 pipelines and 31 runs, build ntfy v2.30.0 and start both services healthy
on spare ports before stopping them.
2026-10-13 17:20:14 +01:00

237 lines
11 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_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()