diff --git a/dep_freshness/_tables.py b/dep_freshness/_tables.py index fe0f57c..95e7baa 100644 --- a/dep_freshness/_tables.py +++ b/dep_freshness/_tables.py @@ -23,6 +23,10 @@ MAVEN: Final = "maven" # wait for, so the only reading of "current" it admits is "at HEAD". GITCOMMIT: Final = "gitcommit" TOOLCHAIN: Final = "toolchain" +# One package out of an Arch-style repo db (`.db`), pinned by a small +# `key=value` lock file. Versions are `epoch:pkgver-pkgrel` and compare with +# pacman's vercmp, never PEP 440 (see registries/pacman_repo.py). +PACMAN_REPO: Final = "pacman-repo" # The constraint a workflow parser writes for a version MATRIX. Standing # decision (kuhy, 2026-08-28): one toolchain version per repo, always newest, # so a matrix is a finding to delete rather than a range to satisfy. @@ -38,6 +42,7 @@ ECOSYSTEMS: Final = ( MAVEN, GITCOMMIT, TOOLCHAIN, + PACMAN_REPO, ) # --- Registry endpoints ----------------------------------------------------- @@ -134,6 +139,12 @@ MANIFEST_GLOBS: Final = ( "gradle-wrapper.properties", ) REQUIREMENTS_PATTERN: Final = r"^requirements.*\.txt$" +# A pacman-repo lock has no fixed filename (`proton-native.lock` is one), so +# it is recognised by content instead of a glob: a `*.lock` file whose first +# few KB hold a `repo=` line ending in `.db`. The read is bounded because +# `--all` sniffs every Cargo.lock and pubspec.lock too. +PACMAN_LOCK_SUFFIX: Final = ".lock" +PACMAN_LOCK_SNIFF_BYTES: Final = 4096 # `.utils` is where every CI workflow checks the shared gate out, INSIDE the # repo being checked. Without it `--all` walks utils' own manifests and fails diff --git a/dep_freshness/discover.py b/dep_freshness/discover.py index 0ce796b..ddedae4 100644 --- a/dep_freshness/discover.py +++ b/dep_freshness/discover.py @@ -19,6 +19,7 @@ from dep_freshness.parsers import ( golang, gradle, javascript, + pacman_lock, pubspec, python, rust, @@ -46,6 +47,7 @@ def is_manifest(path: Path) -> bool: or bool(_REQUIREMENTS.match(path.name)) or workflow.is_workflow(path) or gradle.is_catalog(path) + or pacman_lock.is_lock(path) ) @@ -60,6 +62,8 @@ def parse_manifest(path: Path) -> list[Dep]: return workflow.parse(path) if gradle.is_catalog(path): return gradle.parse_catalog(path) + if pacman_lock.is_lock(path): + return pacman_lock.parse(path) return [] diff --git a/dep_freshness/evaluate.py b/dep_freshness/evaluate.py index ad09a5b..1db0c47 100644 --- a/dep_freshness/evaluate.py +++ b/dep_freshness/evaluate.py @@ -15,9 +15,10 @@ purpose: from __future__ import annotations -from dep_freshness._tables import GITCOMMIT, MATRIX, TOOLCHAIN +from dep_freshness._tables import GITCOMMIT, MATRIX, PACMAN_REPO, TOOLCHAIN from dep_freshness.constraints import lower_bound, satisfies from dep_freshness.models import Dep, Finding, Severity +from dep_freshness.registries.pacman_repo import vercmp from dep_freshness.resolve import Answer from dep_freshness.versions import behind, google_api_key @@ -46,6 +47,29 @@ def _commit(dep: Dep, heads: str) -> Finding | None: ) +def _pacman(dep: Dep, answer: str) -> Finding | None: + """A repo db lists ONE version per package; any other pin is undownloadable. + + `answer` is `" "`. Compared with pacman's vercmp, so an + epoch outranks a bigger pkgver. The checksum goes into the detail so the + bump is a paste, and a right version with a wrong checksum is caught. + """ + version, _, sha = answer.partition(" ") + fix = f"version={version}" + (f" sha256={sha}" if sha else "") + if not dep.pinned: + return Finding(dep, Severity.UNPINNED, version, detail=f"pin {fix}") + if vercmp(dep.pinned, version) != 0: + return Finding(dep, Severity.STALE, version, detail=f"the repo serves {fix}") + if sha and dep.locked and dep.locked != sha.lower(): + return Finding( + dep, + Severity.LOCK_MISMATCH, + version, + detail=f"lock sha256 {dep.locked} != the repo's {sha}", + ) + return None + + def _generation(dep: Dep, pin, latest: str) -> Finding | None: """A Google API client is judged inside its own generation only.""" gen, rank = pin @@ -130,6 +154,8 @@ def judge(dep: Dep, answer: Answer) -> Finding | None: return _toolchain(dep, latest) if dep.ecosystem == GITCOMMIT: return _commit(dep, latest) + if dep.ecosystem == PACMAN_REPO: + return _pacman(dep, latest) pin = google_api_key(dep.pinned or "") if pin is not None: return _generation(dep, pin, latest) diff --git a/dep_freshness/parsers/pacman_lock.py b/dep_freshness/parsers/pacman_lock.py new file mode 100644 index 0000000..7d21527 --- /dev/null +++ b/dep_freshness/parsers/pacman_lock.py @@ -0,0 +1,81 @@ +"""A pacman-repo lock -> one package pinned out of an Arch-style repo db. + +The format is one `key=value` per line, `#` comments allowed: + + name=proton-cachyos-native + repo=https://mirror.cachyos.org/repo/x86_64/cachyos/cachyos.db + version=1:11.0.20261015-1 + sha256= + +There is no fixed filename, so `is_lock` recognises one by content: a +`*.lock` file whose first few KB hold a `repo=` line ending in `.db`. That +keeps Cargo.lock, pubspec.lock and friends out without a name list, and lets +pre-commit pass the file by name. `version` is kept verbatim: the epoch makes +it unreadable to `exact_pin`, and the judge compares it with pacman's vercmp. +`sha256` rides in `Dep.locked`, the field for "what the lock resolved to". +""" + +from __future__ import annotations + +import re +from pathlib import Path + +from dep_freshness._tables import ( + PACMAN_LOCK_SNIFF_BYTES, + PACMAN_LOCK_SUFFIX, + PACMAN_REPO, +) +from dep_freshness.models import Dep +from dep_freshness.registries.pacman_repo import qualified_name + +_REPO_DB = re.compile(r"^\s*repo\s*=\s*\S+\.db\s*$", re.MULTILINE) + + +def is_lock(path: Path) -> bool: + """True for a `*.lock` whose head names a repo `.db`.""" + if not path.name.endswith(PACMAN_LOCK_SUFFIX): + return False + try: + with path.open("rb") as handle: + head = handle.read(PACMAN_LOCK_SNIFF_BYTES) + except OSError: + return False + return bool(_REPO_DB.search(head.decode("utf-8", errors="replace"))) + + +def _fields(text: str) -> dict[str, tuple[str, int]]: + """`key -> (value, 1-based line)`; the first occurrence of a key wins.""" + fields: dict[str, tuple[str, int]] = {} + for number, line in enumerate(text.splitlines(), start=1): + stripped = line.strip() + if not stripped or stripped.startswith("#") or "=" not in stripped: + continue + key, _, value = stripped.partition("=") + fields.setdefault(key.strip(), (value.strip(), number)) + return fields + + +def parse(path: Path) -> list[Dep]: + if not is_lock(path): + return [] + try: + fields = _fields(path.read_text(encoding="utf-8", errors="replace")) + except OSError: + return [] + name, name_line = fields.get("name", ("", 0)) + repo, _ = fields.get("repo", ("", 0)) + if not name or not repo: + return [] + version, version_line = fields.get("version", ("", 0)) + sha, _ = fields.get("sha256", ("", 0)) + return [ + Dep( + ecosystem=PACMAN_REPO, + name=qualified_name(repo, name), + constraint=version, + path=path, + line=version_line or name_line, + pinned=version or None, + locked=sha.lower() or None, + ) + ] diff --git a/dep_freshness/registries/http.py b/dep_freshness/registries/http.py index 113a8d7..b24cee8 100644 --- a/dep_freshness/registries/http.py +++ b/dep_freshness/registries/http.py @@ -112,6 +112,20 @@ def get_text(url: str, accept: str | None = None) -> str | None: Same contract as `get_json`; Maven metadata is XML, not JSON. """ + body = get_bytes(url, accept) + if body is None: + return None + try: + return body.decode("utf-8") + except UnicodeDecodeError as exc: + raise Offline(f"{url}: {exc}") from exc + + +def get_bytes(url: str, accept: str | None = None) -> bytes | None: + """Fetch a raw body, or raise `Offline` / return None on 404. + + Same contract as `get_json`; a pacman repo `.db` is a compressed tar. + """ if not host_reachable(url): raise Offline(url) headers = {"User-Agent": USER_AGENT} @@ -125,7 +139,7 @@ def get_text(url: str, accept: str | None = None) -> str | None: attempt += 1 try: with urlopen(request, timeout=HTTP_TIMEOUT * attempt) as response: - return response.read().decode("utf-8") + return response.read() except HTTPError as exc: if exc.code == 404: return None diff --git a/dep_freshness/registries/pacman_repo.py b/dep_freshness/registries/pacman_repo.py new file mode 100644 index 0000000..9b3783e --- /dev/null +++ b/dep_freshness/registries/pacman_repo.py @@ -0,0 +1,179 @@ +"""Arch-style package repos: the one version a repo `.db` lists for a package. + +A repo db (`cachyos.db`, `extra.db`) is a tar, gzip- or zstd-compressed, with +one `-/desc` entry per package. The desc file holds `%NAME%`, +`%VERSION%` and `%SHA256SUM%` blocks. A repo keeps exactly ONE version of each +package, so "newest stable" is simply whatever the db lists. + +The repo URL travels inside the dep name as `#`, because +the resolver and the cache only ever see the name (the gittag lesson). Arch +package names cannot contain `#`, so `rpartition` splits it unambiguously. +That string is also the cache key and the allowlist label. + +The answer is `" "`, space-joined like gitcommit's heads: +the judge needs the version to compare and the checksum to check the lock's. + +Versions compare with pacman's `vercmp` (a port of libalpm's version.c), +never PEP 440: `1:11.0.20261015-1` is not a version `packaging` can read. +""" + +from __future__ import annotations + +import io +import tarfile + +from dep_freshness.registries.http import Offline, get_bytes + +try: # stdlib since Python 3.14; tarfile's "r:*" reads zstd through it + import compression.zstd # noqa: F401 + + _HAS_ZSTD = True +except ImportError: # pragma: no cover - this machine runs 3.15 + _HAS_ZSTD = False + +_ZSTD_MAGIC = b"\x28\xb5\x2f\xfd" +_SEPARATOR = "#" + + +def qualified_name(repo: str, package: str) -> str: + """The dep name for `package` out of the db at `repo`.""" + return f"{repo.strip()}{_SEPARATOR}{package.strip()}" + + +def split_name(name: str) -> tuple[str, str]: + """`(repo_url, package)` back out of a `qualified_name`.""" + repo, _, package = name.rpartition(_SEPARATOR) + return repo, package + + +def _fields(desc: str) -> dict[str, str]: + """`{"NAME": ..., "VERSION": ...}`: the first line under each `%KEY%`.""" + fields: dict[str, str] = {} + lines = desc.splitlines() + for number, line in enumerate(lines[:-1]): + if len(line) > 2 and line.startswith("%") and line.endswith("%"): + fields.setdefault(line.strip("%"), lines[number + 1].strip()) + return fields + + +def _open(url: str, body: bytes) -> tarfile.TarFile: + if body.startswith(_ZSTD_MAGIC) and not _HAS_ZSTD: + # `Offline`, not a bare error: `Resolver.latest` catches only that, so + # anything else would crash the gate instead of reporting UNKNOWN + # (exit 3 under --strict) with this message in the degraded banner. + raise Offline( + f"{url} is zstd-compressed; reading it needs Python 3.14+ " + "(compression.zstd)" + ) + try: + return tarfile.open(fileobj=io.BytesIO(body), mode="r:*") + except tarfile.TarError as exc: + # A captive portal's HTML is a broken network, not an answer. + raise Offline(f"{url}: not a repo db ({exc})") from exc + + +def latest(name: str) -> str | None: + """`" "` the repo lists for the package, or None. + + Matched on `%NAME%`, not the directory name: `foo-` also prefixes + `foo-git-1.0-1/`. The tar is untrusted, so it is read, never extracted. + """ + repo, package = split_name(name) + body = get_bytes(repo) + if body is None: + return None + with _open(repo, body) as tar: + for member in tar: + if not ( + member.isfile() + and member.name.startswith(f"{package}-") + and member.name.endswith("/desc") + ): + continue + handle = tar.extractfile(member) + if handle is None: + continue + fields = _fields(handle.read().decode("utf-8", errors="replace")) + if fields.get("NAME") == package and fields.get("VERSION"): + sha = fields.get("SHA256SUM", "") + return f"{fields['VERSION']} {sha}".strip() + return None + + +# --- vercmp ----------------------------------------------------------------- + + +def _alnum(char: str) -> bool: + return char.isascii() and char.isalnum() + + +def _rpmvercmp(a: str, b: str) -> int: + """libalpm's `rpmvercmp`: segment-wise compare of one EVR component.""" + if a == b: + return 0 + i = j = 0 + while i < len(a) and j < len(b): + sep_a, sep_b = i, j + while i < len(a) and not _alnum(a[i]): + i += 1 + while j < len(b) and not _alnum(b[j]): + j += 1 + if i >= len(a) or j >= len(b): + break + # A longer separator run sorts higher (`1.0..1` > `1.0.1`). + if i - sep_a != j - sep_b: + return -1 if i - sep_a < j - sep_b else 1 + start_a, start_b = i, j + numeric = a[i].isdigit() + same_kind = str.isdigit if numeric else (lambda c: c.isascii() and c.isalpha()) + while i < len(a) and same_kind(a[i]): + i += 1 + while j < len(b) and same_kind(b[j]): + j += 1 + seg_a, seg_b = a[start_a:i], b[start_b:j] + if not seg_b: + # Different segment kinds: a number beats letters. + return 1 if numeric else -1 + if numeric: + seg_a, seg_b = seg_a.lstrip("0"), seg_b.lstrip("0") + if len(seg_a) != len(seg_b): + return 1 if len(seg_a) > len(seg_b) else -1 + if seg_a != seg_b: + return 1 if seg_a > seg_b else -1 + if i >= len(a) and j >= len(b): + return 0 + # One side has more left: `1.0.a` > `1.0`, but `1.0a` < `1.0`. + if (i >= len(a) and not b[j].isalpha()) or (i < len(a) and a[i].isalpha()): + return -1 + return 1 + + +def _evr(text: str) -> tuple[str, str, str | None]: + """`(epoch, pkgver, pkgrel)`; epoch defaults to "0", pkgrel may be None.""" + digits = 0 + while digits < len(text) and text[digits].isdigit(): + digits += 1 + if digits < len(text) and text[digits] == ":": + epoch, rest = text[:digits] or "0", text[digits + 1 :] + else: + epoch, rest = "0", text + version, dash, release = rest.rpartition("-") + if not dash: + return epoch, rest, None + return epoch, version, release + + +def vercmp(left: str, right: str) -> int: + """-1, 0 or 1, exactly as pacman's `vercmp left right` prints. + + A missing pkgrel on either side compares equal on pkgrel, so `1.0` + matches `1.0-7`. + """ + if left == right: + return 0 + epoch_l, ver_l, rel_l = _evr(left) + epoch_r, ver_r, rel_r = _evr(right) + result = _rpmvercmp(epoch_l, epoch_r) or _rpmvercmp(ver_l, ver_r) + if result == 0 and rel_l is not None and rel_r is not None: + result = _rpmvercmp(rel_l, rel_r) + return result diff --git a/dep_freshness/resolve.py b/dep_freshness/resolve.py index 1a44580..4da4c17 100644 --- a/dep_freshness/resolve.py +++ b/dep_freshness/resolve.py @@ -18,6 +18,7 @@ from dep_freshness._tables import ( MAVEN, MAX_WORKERS, NPM, + PACMAN_REPO, PUB, PYPI, TOOLCHAIN, @@ -31,6 +32,7 @@ from dep_freshness.registries import ( gomod, maven, npmjs, + pacman_repo, pub, pypi, ) @@ -46,6 +48,7 @@ _LOOKUP = { GITTAG: gittag.latest, MAVEN: maven.latest, GITCOMMIT: gitcommit.latest, + PACMAN_REPO: pacman_repo.latest, } diff --git a/dep_freshness/tests/test_pacman_lock.py b/dep_freshness/tests/test_pacman_lock.py new file mode 100644 index 0000000..4780513 --- /dev/null +++ b/dep_freshness/tests/test_pacman_lock.py @@ -0,0 +1,135 @@ +"""A pacman-repo lock: parsed, discovered, and judged end to end. + +The consumer is steam-game-installer's `steam_installer/data/proton-native.lock`, +which pins one package out of the CachyOS repo. Pre-commit hands the gate the +file by name, so `is_manifest` must accept it on content, not on a glob. +""" + +from __future__ import annotations + +import json + +import pytest + +from dep_freshness import check, discover +from dep_freshness.models import Severity +from dep_freshness.parsers import pacman_lock +from dep_freshness.registries import pacman_repo +from dep_freshness.tests.conftest import write +from dep_freshness.tests.test_pacman_repo import SHA, build_db + +REPO = "https://mirror.cachyos.org/repo/x86_64/cachyos/cachyos.db" +LOCK = f"""\ +# pacman-repo lock: newest stable package from an Arch-style repo db +name=proton-cachyos-native +repo={REPO} +version=1:11.0.20261015-1 +sha256={SHA} +""" +LOCK_PATH = "steam_installer/data/proton-native.lock" + + +def test_the_lock_parses_to_one_pinned_dep(repo): + path = write(repo, LOCK_PATH, LOCK) + [dep] = pacman_lock.parse(path) + assert dep.ecosystem == "pacman-repo" + assert pacman_repo.split_name(dep.name) == (REPO, "proton-cachyos-native") + assert dep.pinned == "1:11.0.20261015-1" + assert dep.locked == SHA + assert dep.line == 4 # the version= line is what a bump edits + + +@pytest.mark.parametrize( + ("name", "body"), + [ + ("Cargo.lock", '[[package]]\nname = "serde"\nversion = "1.0.0"\n'), + ("other.lock", "name=x\nrepo=https://example.org/not-a-db.json\n"), + ("proton-native.txt", LOCK), + ], +) +def test_other_files_are_not_pacman_locks(repo, name, body): + path = write(repo, name, body) + assert not discover.is_manifest(path) + assert discover.parse_manifest(path) == [] + + +def test_the_lock_is_discovered_by_content(repo): + path = write(repo, LOCK_PATH, LOCK) + assert discover.is_manifest(path) + assert path in discover.find_manifests(repo) + + +def test_a_lock_without_a_version_is_unpinned(repo): + path = write(repo, "x.lock", LOCK.replace("version=1:11.0.20261015-1\n", "")) + [dep] = pacman_lock.parse(path) + assert dep.pinned is None + + +@pytest.fixture +def gate(repo, monkeypatch): + """Run the CLI on the lock, with the repo db answering `served`.""" + def invoke(lock_body, served, *flags): + name, version, sha = served + body = build_db({name: version}, sha=sha) + monkeypatch.setattr(pacman_repo, "get_bytes", lambda _url: body) + path = write(repo, LOCK_PATH, lock_body) + monkeypatch.chdir(repo) + return check.main([*flags, str(path)]) + return invoke + + +CURRENT = ("proton-cachyos-native", "1:11.0.20261015-1", SHA) + + +def test_a_current_lock_passes(gate): + assert gate(LOCK, CURRENT, "--strict") == 0 + + +def test_a_lock_behind_the_repo_fails(gate, capsys): + old = LOCK.replace("1:11.0.20261015-1", "1:10.0.20250101-1") + assert gate(old, CURRENT) == 1 + out = capsys.readouterr() + text = out.out + out.err + assert "proton-cachyos-native" in text + assert "1:11.0.20261015-1" in text + assert SHA in text # the bump is copy-pasteable + + +def test_an_epoch_beats_a_bigger_pkgver(gate): + # PEP 440 would read `11.0` > `1:2.0` (or nothing at all); pacman says the + # epoch wins, so a lock on 11.0 is behind a repo on 1:2.0. + old = LOCK.replace("1:11.0.20261015-1", "11.0-1") + assert gate(old, ("proton-cachyos-native", "1:2.0-1", SHA)) == 1 + + +def test_a_right_version_with_a_wrong_sha_is_a_mismatch(gate, capsys): + assert gate(LOCK, (*CURRENT[:2], "cd" * 32), "--json") == 1 + payload = json.loads(capsys.readouterr().out) + assert Severity.LOCK_MISMATCH.value in json.dumps(payload) + + +def test_a_package_the_repo_dropped_is_undeterminable(gate): + assert gate(LOCK, ("something-else", "1.0-1", SHA), "--strict") == 3 + + +def test_offline_with_a_cold_cache_is_undeterminable(repo, monkeypatch): + from dep_freshness.registries import http + + http.force_offline(True) + path = write(repo, LOCK_PATH, LOCK) + monkeypatch.chdir(repo) + assert check.main(["--strict", str(path)]) == 3 + assert check.main([str(path)]) == 0 # pre-commit degrades, never corners + + +def test_zstd_on_an_old_python_is_undeterminable_not_a_crash( + repo, monkeypatch, capsys +): + body = build_db({"proton-cachyos-native": "1:11.0.20261015-1"}, "zst") + monkeypatch.setattr(pacman_repo, "get_bytes", lambda _url: body) + monkeypatch.setattr(pacman_repo, "_HAS_ZSTD", False) + path = write(repo, LOCK_PATH, LOCK) + monkeypatch.chdir(repo) + assert check.main(["--strict", str(path)]) == 3 + out = capsys.readouterr() + assert "compression.zstd" in out.out + out.err diff --git a/dep_freshness/tests/test_pacman_repo.py b/dep_freshness/tests/test_pacman_repo.py new file mode 100644 index 0000000..8c3abfb --- /dev/null +++ b/dep_freshness/tests/test_pacman_repo.py @@ -0,0 +1,146 @@ +"""The pacman-repo adapter: pacman `vercmp` order and reading a repo `.db`. + +Versions here are `epoch:pkgver-pkgrel`, which PEP 440 cannot read at all: +`versions.behind` answers False for every pair, so a stale lock would read +as current. The ordering tests below come from the vercmp(8) man page, and +the differential test checks them against the real `/usr/bin/vercmp`. +""" + +from __future__ import annotations + +import io +import itertools +import shutil +import subprocess +import tarfile + +import pytest + +from dep_freshness.registries import pacman_repo +from dep_freshness.registries.http import Offline + +REPO = "https://mirror.example.org/repo/x86_64/extra/extra.db" +SHA = "ab" * 32 + +# vercmp(8): "1.0a < 1.0b < 1.0beta < 1.0p < 1.0pre < 1.0rc < 1.0 < 1.0.a < 1.0.1" +MAN_ORDER = ["1.0a", "1.0b", "1.0beta", "1.0p", "1.0pre", "1.0rc", "1.0", "1.0.a", + "1.0.1"] +PAIRS = [ + ("1:1.0", "2.0", 1), + ("0:2.0", "2.0", 0), + ("1:11.0.20261015-1", "1:10.0.20250101-1", 1), + ("1:11.0.20261015-1", "1:11.0.20261015-1", 0), + ("1.0-1", "1.0-2", -1), + ("1.0", "1.0-7", 0), # a missing pkgrel compares equal + ("1.0.0", "1.0", 1), + ("1.0_1", "1.0.1", 0), # any non-alphanumeric run is one separator + ("1.0", "1.0.0.0", -1), + ("2.0", "10.0", -1), + ("1.001", "1.1", 0), + ("r123", "r45", 1), +] + + +@pytest.mark.parametrize(("left", "right"), list(itertools.pairwise(MAN_ORDER))) +def test_vercmp_follows_the_man_page_order(left, right): + assert pacman_repo.vercmp(left, right) == -1 + assert pacman_repo.vercmp(right, left) == 1 + + +@pytest.mark.parametrize(("left", "right", "expected"), PAIRS) +def test_vercmp_epoch_and_pkgrel(left, right, expected): + assert pacman_repo.vercmp(left, right) == expected + + +@pytest.mark.skipif(not shutil.which("vercmp"), reason="pacman's vercmp absent") +@pytest.mark.parametrize( + ("left", "right"), + [*itertools.pairwise(MAN_ORDER), *((a, b) for a, b, _ in PAIRS)], +) +def test_vercmp_agrees_with_pacman(left, right): + real = subprocess.run( + ["vercmp", left, right], capture_output=True, text=True, check=True + ).stdout.strip() + assert pacman_repo.vercmp(left, right) == int(real) + + +def _desc(name: str, version: str, sha: str = SHA) -> bytes: + return ( + f"%FILENAME%\n{name}-{version}-x86_64.pkg.tar.zst\n\n%NAME%\n{name}\n\n" + f"%VERSION%\n{version}\n\n%SHA256SUM%\n{sha}\n\n" + ).encode() + + +def build_db( + packages: dict[str, str], compression: str = "gz", sha: str = SHA +) -> bytes: + """A repo db the way repo-add writes it: one `-/desc` per package.""" + raw = io.BytesIO() + with tarfile.open(fileobj=raw, mode=f"w:{compression}") as tar: + for name, version in packages.items(): + body = _desc(name, version, sha) + info = tarfile.TarInfo(f"{name}-{version}/desc") + info.size = len(body) + tar.addfile(info, io.BytesIO(body)) + return raw.getvalue() + + +@pytest.fixture +def serve(monkeypatch): + """Answer the next `get_bytes` with `body`, recording the URL asked for.""" + asked: list[str] = [] + + def install(body): + def fake(url): + asked.append(url) + return body + monkeypatch.setattr(pacman_repo, "get_bytes", fake) + return asked + return install + + +@pytest.mark.parametrize("compression", ["gz", "zst"]) +def test_latest_reads_version_and_sha_from_the_db(serve, compression): + asked = serve(build_db({"proton-native": "1:11.0-1", "zlib": "1.3-1"}, + compression)) + name = pacman_repo.qualified_name(REPO, "proton-native") + assert pacman_repo.latest(name) == f"1:11.0-1 {SHA}" + assert asked == [REPO] + + +def test_a_sibling_sharing_the_name_prefix_is_not_the_package(serve): + serve(build_db({"proton-native-v3": "9:9.0-1", "proton-native": "1:2.0-1"})) + name = pacman_repo.qualified_name(REPO, "proton-native") + assert pacman_repo.latest(name).split()[0] == "1:2.0-1" + + +def test_a_package_the_db_does_not_list_is_none(serve): + serve(build_db({"zlib": "1.3-1"})) + assert pacman_repo.latest(pacman_repo.qualified_name(REPO, "nope")) is None + + +def test_a_missing_db_is_none(serve): + serve(None) + assert pacman_repo.latest(pacman_repo.qualified_name(REPO, "x")) is None + + +def test_a_db_that_is_not_a_tar_is_offline(serve): + serve(b"captive portal") + with pytest.raises(Offline): + pacman_repo.latest(pacman_repo.qualified_name(REPO, "x")) + + +def test_zstd_without_compression_zstd_names_the_missing_module( + serve, monkeypatch +): + serve(build_db({"x": "1.0-1"}, "zst")) + monkeypatch.setattr(pacman_repo, "_HAS_ZSTD", False) + with pytest.raises(Offline, match="compression.zstd"): + pacman_repo.latest(pacman_repo.qualified_name(REPO, "x")) + + +def test_qualified_name_round_trips(): + assert pacman_repo.split_name(pacman_repo.qualified_name(REPO, "x")) == ( + REPO, + "x", + )