mirror of
https://github.com/Abdess/retroarch_system.git
synced 2026-10-24 04:39:06 -05:00
391 lines
17 KiB
Python
391 lines
17 KiB
Python
"""Which platforms a release publishes a ZIP for, and how every surface says it.
|
|
|
|
The release carried a pack for every platform, 35 GB, while five of them
|
|
drew 83% of the downloads. `release_pack: true` in the registry is now the
|
|
list: the build, the pack checks, the release record and every download
|
|
table read it. The other platforms keep their install manifest, and each
|
|
page that would show a ZIP says there is none and gives the command.
|
|
|
|
Every release also deleted the previous tag, and with it each asset URL:
|
|
six of the eight links a community wiki had to our packs answered 404. Each
|
|
platform has a permanent page at get/<platform>/ instead.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import contextlib
|
|
import io
|
|
import json
|
|
import sys
|
|
import tempfile
|
|
import unittest
|
|
from pathlib import Path
|
|
from unittest import mock
|
|
|
|
import yaml
|
|
|
|
REPO_ROOT = Path(__file__).resolve().parent.parent
|
|
sys.path.insert(0, str(REPO_ROOT / "scripts"))
|
|
|
|
import common # noqa: E402
|
|
import release_record # noqa: E402
|
|
|
|
PLATFORMS = str(REPO_ROOT / "platforms")
|
|
TMP_ROOT = REPO_ROOT / "tmp"
|
|
SITE = "https://abdess.github.io/retrobios/"
|
|
# The owner's choice of 2026-10-23, from the download counts of v2026.10.10.
|
|
RELEASED = {"retroarch", "emudeck", "retrobat", "batocera", "romm", "misterfpga"}
|
|
|
|
|
|
def _write_registry(root: Path, platforms: dict) -> str:
|
|
platforms_dir = root / "platforms"
|
|
platforms_dir.mkdir()
|
|
for name in platforms:
|
|
(platforms_dir / f"{name}.yml").write_text(
|
|
yaml.dump({"platform": name.title(), "systems": {}}), encoding="utf-8"
|
|
)
|
|
registry = {name: {"config": f"{name}.yml", **entry} for name, entry in platforms.items()}
|
|
(platforms_dir / "_registry.yml").write_text(
|
|
yaml.dump({"platforms": registry}), encoding="utf-8"
|
|
)
|
|
return str(platforms_dir)
|
|
|
|
|
|
def _which_pack() -> str:
|
|
import generate_site
|
|
|
|
with contextlib.chdir(REPO_ROOT):
|
|
return generate_site.generate_which_pack()
|
|
|
|
|
|
class TheFieldIsTheList(unittest.TestCase):
|
|
def test_the_registry_marks_the_most_downloaded_setups(self):
|
|
self.assertEqual(
|
|
set(common.list_release_pack_platforms(PLATFORMS, include_archived=True)), RELEASED
|
|
)
|
|
|
|
def test_only_marked_platforms_are_listed_and_archived_ones_on_request(self):
|
|
with tempfile.TemporaryDirectory(dir=TMP_ROOT) as tmp:
|
|
platforms_dir = _write_registry(Path(tmp), {
|
|
"big": {"status": "active", "release_pack": True},
|
|
"small": {"status": "active"},
|
|
"off": {"status": "active", "release_pack": False},
|
|
"old": {"status": "archived", "release_pack": True},
|
|
})
|
|
self.assertEqual(common.list_release_pack_platforms(platforms_dir), ["big"])
|
|
self.assertEqual(
|
|
common.list_release_pack_platforms(platforms_dir, include_archived=True),
|
|
["big", "old"],
|
|
)
|
|
self.assertEqual(
|
|
common.list_registered_platforms(platforms_dir), ["big", "off", "small"]
|
|
)
|
|
|
|
def test_the_schema_holds_the_field(self):
|
|
try:
|
|
from jsonschema import Draft202012Validator
|
|
except ImportError:
|
|
self.skipTest("jsonschema is a tooling dependency")
|
|
|
|
schema = json.loads((REPO_ROOT / "schemas" / "registry.schema.json").read_text())
|
|
validator = Draft202012Validator(schema)
|
|
registry = yaml.safe_load((REPO_ROOT / "platforms" / "_registry.yml").read_text())
|
|
self.assertEqual([e.message for e in validator.iter_errors(registry)], [])
|
|
registry["platforms"]["knulli"]["release_pack"] = "yes"
|
|
self.assertTrue(list(validator.iter_errors(registry)))
|
|
|
|
|
|
class TheBuildReadsTheField(unittest.TestCase):
|
|
def _groups(self, *argv: str) -> list[str]:
|
|
import generate_pack
|
|
|
|
built: list[str] = []
|
|
|
|
def capture(args, groups, *rest, **kw):
|
|
built.extend(name for group, _rep in groups for name in group)
|
|
|
|
with tempfile.TemporaryDirectory(dir=TMP_ROOT) as out, \
|
|
contextlib.chdir(REPO_ROOT), \
|
|
mock.patch.object(generate_pack, "_run_platform_packs", capture), \
|
|
mock.patch.object(generate_pack, "_run_manifest_mode", capture), \
|
|
mock.patch.object(sys, "argv", ["generate_pack.py", *argv, "--output-dir", out]), \
|
|
contextlib.redirect_stdout(io.StringIO()):
|
|
generate_pack.main()
|
|
return built
|
|
|
|
def test_all_builds_the_release_packs_only(self):
|
|
self.assertEqual(set(self._groups("--all", "--offline")), RELEASED)
|
|
|
|
def test_archived_platforms_without_the_field_stay_out(self):
|
|
self.assertEqual(
|
|
set(self._groups("--all", "--include-archived", "--offline")), RELEASED
|
|
)
|
|
|
|
def test_manifests_cover_every_platform(self):
|
|
self.assertEqual(
|
|
set(self._groups("--all", "--manifest", "--offline")),
|
|
set(common.list_registered_platforms(PLATFORMS, include_archived=True)),
|
|
)
|
|
|
|
def test_the_release_owners_are_the_marked_platforms(self):
|
|
owners = release_record.release_owners(PLATFORMS)
|
|
served = {p for platforms in owners.values() for p in platforms}
|
|
self.assertEqual(served, RELEASED)
|
|
|
|
def test_the_list_marks_installer_only_platforms(self):
|
|
import subprocess
|
|
|
|
proc = subprocess.run(
|
|
[sys.executable, "scripts/generate_pack.py", "--list"],
|
|
capture_output=True, text=True, cwd=REPO_ROOT, check=True, timeout=120,
|
|
)
|
|
lines = proc.stdout.splitlines()
|
|
for name in RELEASED:
|
|
self.assertIn(name, lines)
|
|
self.assertIn("recalbox (installer only)", lines)
|
|
|
|
|
|
class APlatformWithoutAPackFailsNoCheck(unittest.TestCase):
|
|
VERIFY = (
|
|
"RetroArch: 10/10 OK [existence]\n"
|
|
"KNULLI: 5/5 OK [md5]\n"
|
|
)
|
|
PACK = (
|
|
"Generating pack for RetroArch...\n"
|
|
" dist/RetroArch_BIOS_Pack.zip: 10 files packed, 10/10 files OK [existence]\n"
|
|
)
|
|
|
|
def test_the_consistency_step_skips_a_setup_served_by_the_installer(self):
|
|
import pipeline
|
|
|
|
with contextlib.redirect_stdout(io.StringIO()) as out:
|
|
self.assertTrue(pipeline.check_consistency(
|
|
self.VERIFY, self.PACK, pipeline.release_pack_keys(PLATFORMS)))
|
|
self.assertIn("KNULLI: 5/5 (no release pack, served by the installer)", out.getvalue())
|
|
|
|
def test_a_released_platform_without_its_pack_still_fails(self):
|
|
import pipeline
|
|
|
|
verify = self.VERIFY + "Batocera: 3/3 OK [md5]\n"
|
|
with contextlib.redirect_stdout(io.StringIO()):
|
|
self.assertFalse(pipeline.check_consistency(
|
|
verify, self.PACK, pipeline.release_pack_keys(PLATFORMS)))
|
|
|
|
def test_the_pipeline_passes_the_release_platforms(self):
|
|
source = (REPO_ROOT / "scripts" / "pipeline.py").read_text(encoding="utf-8")
|
|
self.assertIn("release_pack_keys(include_archived=args.include_archived)", source)
|
|
|
|
def test_verify_packs_sweeps_the_release_packs_only(self):
|
|
import subprocess
|
|
|
|
with tempfile.TemporaryDirectory(dir=TMP_ROOT) as directory:
|
|
proc = subprocess.run(
|
|
[sys.executable, "scripts/generate_pack.py", "--all", "--verify-packs",
|
|
"--output-dir", directory],
|
|
capture_output=True, text=True, cwd=REPO_ROOT, timeout=600,
|
|
)
|
|
swept = {line.split(":")[0].strip() for line in proc.stdout.splitlines()
|
|
if "SKIP (no pack in" in line}
|
|
self.assertEqual(swept, RELEASED)
|
|
|
|
|
|
class TheReleaseCheckReadsTheField(unittest.TestCase):
|
|
RECORD = {"tag": "v1", "packs": {
|
|
"A_BIOS_Pack.zip": {"download_size": 1, "assets": ["A_BIOS_Pack.zip"],
|
|
"platforms": ["retroarch"]},
|
|
"K_BIOS_Pack.zip": {"download_size": 1, "assets": ["K_BIOS_Pack.zip"],
|
|
"platforms": ["knulli"]},
|
|
}}
|
|
|
|
def test_a_missing_and_an_unlisted_pack_are_reported(self):
|
|
from check_release import Asset, compare_release
|
|
|
|
sums = {"A_BIOS_Pack.zip": "a" * 64, "K_BIOS_Pack.zip": "b" * 64}
|
|
assets = {name: Asset(1, digest) for name, digest in sums.items()}
|
|
assets["SHA256SUMS.txt"] = Asset(1, None)
|
|
findings = compare_release(self.RECORD, sums, assets, "v1", None,
|
|
{"retroarch", "batocera"})
|
|
kinds = {(f.kind, f.name) for f in findings}
|
|
self.assertIn(("no-pack", "batocera"), kinds)
|
|
self.assertIn(("not-released", "K_BIOS_Pack.zip"), kinds)
|
|
self.assertNotIn(("no-pack", "retroarch"), kinds)
|
|
|
|
|
|
class TheTablesFollowTheField(unittest.TestCase):
|
|
def test_a_pack_of_a_platform_without_the_field_is_not_advertised(self):
|
|
record = {"tag": "v1", "packs": {
|
|
"RetroArch_Lakka_BIOS_Pack.zip": {"platforms": ["lakka", "retroarch"],
|
|
"assets": ["x.zip"]},
|
|
"Recalbox_BIOS_Pack.zip": {"platforms": ["recalbox"], "assets": ["y.zip"]},
|
|
}}
|
|
shown = release_record.advertised(record, PLATFORMS)
|
|
self.assertEqual(list(shown["packs"]), ["RetroArch_Lakka_BIOS_Pack.zip"])
|
|
self.assertEqual(shown["packs"]["RetroArch_Lakka_BIOS_Pack.zip"]["platforms"],
|
|
["retroarch"])
|
|
self.assertIsNone(release_record.pack_for("lakka", shown))
|
|
self.assertEqual(release_record.advertised({}, PLATFORMS), {})
|
|
|
|
|
|
class EverySurfaceSaysWhy(unittest.TestCase):
|
|
def test_a_setup_page_says_no_zip_with_the_command_beside_it(self):
|
|
import generate_site
|
|
|
|
line = generate_site.no_zip_line("KNULLI")
|
|
self.assertEqual(line, "No ZIP for KNULLI. The command installs every file and checks it.")
|
|
with contextlib.chdir(REPO_ROOT):
|
|
block = generate_site._pack_buttons("knulli")
|
|
guide = generate_site._guide_download(
|
|
"knulli", "KNULLI", generate_site.GUIDES["knulli"], None, "## Download")
|
|
self.assertIn(line, block)
|
|
self.assertIn(generate_site.NO_ZIP_FAQ, block)
|
|
self.assertIn(line, "\n".join(guide))
|
|
self.assertNotIn("yet", block)
|
|
|
|
def test_a_built_setup_page_has_the_line(self):
|
|
page = REPO_ROOT / "website" / "src" / "content" / "docs" / "platforms" / "knulli.md"
|
|
if not page.is_file():
|
|
self.skipTest("the site is not generated")
|
|
text = page.read_text(encoding="utf-8")
|
|
self.assertIn("No ZIP for KNULLI. The command installs every file and checks it.", text)
|
|
install = text.index("## Install")
|
|
self.assertLess(install, text.index("No ZIP for KNULLI"))
|
|
|
|
def test_get_your_files_explains_the_rows(self):
|
|
page = _which_pack()
|
|
self.assertIn("No ZIP. [Use the command](platforms/knulli.md#install).", page)
|
|
self.assertIn("ZIPs are made for the setups most people download.", page)
|
|
self.assertIn("wiki/faq.md#why-is-there-no-zip-for-my-setup", page)
|
|
|
|
def test_the_readme_rows_read_use_the_command(self):
|
|
readme = (REPO_ROOT / "README.md").read_text(encoding="utf-8")
|
|
row = next(line for line in readme.splitlines() if line.startswith("| KNULLI |"))
|
|
self.assertIn(f"[Use the command]({SITE}get/knulli/)", row)
|
|
self.assertIn("ZIPs are made for the setups most people download.", readme)
|
|
|
|
def test_the_faq_answers_why(self):
|
|
faq = (REPO_ROOT / "wiki" / "faq.md").read_text(encoding="utf-8")
|
|
section = faq.split("## Why is there no ZIP for my setup?", 1)[1].split("\n## ", 1)[0]
|
|
self.assertIn("most people download", section)
|
|
self.assertIn("checks each one", section)
|
|
self.assertIn("--dry-run", section)
|
|
|
|
def test_the_release_process_documents_the_field_and_the_counts(self):
|
|
page = (REPO_ROOT / "wiki" / "release-process.md").read_text(encoding="utf-8")
|
|
self.assertIn("release_pack: true", page)
|
|
self.assertIn("download_count", page)
|
|
self.assertIn("part1of", page)
|
|
|
|
|
|
class TheReleaseNotesNameTheSetupsWithoutAZip(unittest.TestCase):
|
|
RECORD = {"tag": "v2026.10.24", "packs": {
|
|
"RomM_5_BIOS_Pack.zip": {
|
|
"files": 1, "extracted_size": 1, "download_size": 1,
|
|
"assets": ["RomM_5_BIOS_Pack.zip"], "platforms": ["romm"]},
|
|
}}
|
|
|
|
def test_the_paragraph_names_them_and_points_to_the_command(self):
|
|
import release_notes
|
|
|
|
text = release_notes.render(self.RECORD, PLATFORMS, "### What changed\n\n- x\n")
|
|
paragraph = next(line for line in text.splitlines() if line.startswith("No ZIP for "))
|
|
for name in ("KNULLI", "Recalbox", "RetroPie", "Lakka"):
|
|
self.assertIn(name, paragraph)
|
|
for name in ("RetroArch", "Batocera", "RomM"):
|
|
self.assertNotIn(f" {name},", paragraph)
|
|
self.assertIn("The command above", paragraph)
|
|
self.assertIn("--dry-run", paragraph)
|
|
self.assertLess(text.index(paragraph), text.index("### What changed"))
|
|
|
|
def test_the_rows_link_get_pages(self):
|
|
import release_notes
|
|
|
|
text = release_notes.render(self.RECORD, PLATFORMS, "x")
|
|
self.assertIn(f"[Download]({SITE}get/romm/)", text)
|
|
self.assertNotIn("/releases/download/", text)
|
|
|
|
|
|
class EveryPlatformHasAPermanentPage(unittest.TestCase):
|
|
def test_a_page_for_every_registered_platform(self):
|
|
import generate_site
|
|
|
|
record = release_record.load_advertised()
|
|
with contextlib.chdir(REPO_ROOT):
|
|
for name in common.list_registered_platforms(PLATFORMS, include_archived=True):
|
|
page = generate_site.generate_get_page(name)
|
|
pack = release_record.pack_for(name, record)
|
|
with self.subTest(platform=name):
|
|
self.assertRegex(page, r"\n# (.+ )?BIOS (pack|files)( for .+)?\n")
|
|
if name in RELEASED and pack:
|
|
for asset in pack["assets"]:
|
|
self.assertIn(
|
|
f"/releases/download/{record['tag']}/{asset}", page)
|
|
elif name not in RELEASED:
|
|
self.assertNotIn("_BIOS_Pack", page)
|
|
self.assertIn(f"install.sh | sh -s -- --platform {name}", page)
|
|
self.assertIn("No ZIP for ", page)
|
|
|
|
def test_the_generator_writes_and_sweeps_them(self):
|
|
import generate_site
|
|
|
|
self.assertIn(release_record.GET_DIR, generate_site.GENERATED_DIRS)
|
|
source = Path(generate_site.__file__).read_text(encoding="utf-8")
|
|
self.assertIn('write_if_changed(str(get_dir / f"{name}.md"), generate_get_page(name))',
|
|
source)
|
|
|
|
def test_built_pages_exist(self):
|
|
docs = REPO_ROOT / "website" / "src" / "content" / "docs" / release_record.GET_DIR
|
|
if not docs.is_dir():
|
|
self.skipTest("the site is not generated")
|
|
for name in common.list_registered_platforms(PLATFORMS, include_archived=True):
|
|
with self.subTest(platform=name):
|
|
self.assertTrue(any(docs.glob(f"{name}.md*")))
|
|
|
|
|
|
class TheSiteCheckResolvesEveryGetPage(unittest.TestCase):
|
|
def _site(self, root: Path, pages: dict[str, str]) -> Path:
|
|
site = root / "dist"
|
|
for rel, body in pages.items():
|
|
path = site / rel
|
|
path.parent.mkdir(parents=True, exist_ok=True)
|
|
path.write_text(f"<!doctype html><html lang=en><body>{body}</body></html>",
|
|
encoding="utf-8")
|
|
return site
|
|
|
|
def test_missing_and_wrong_pages_are_reported(self):
|
|
import validate_site
|
|
|
|
record = {"tag": "v1", "packs": {"RomM_BIOS_Pack.zip": {
|
|
"platforms": ["romm"], "assets": ["RomM_BIOS_Pack.zip"],
|
|
"files": 1, "extracted_size": 1, "download_size": 1}}}
|
|
download = validate_site.RELEASE_DOWNLOAD
|
|
with tempfile.TemporaryDirectory(dir=TMP_ROOT) as tmp:
|
|
root = Path(tmp)
|
|
record_path = root / "release.json"
|
|
record_path.write_text(json.dumps(record), encoding="utf-8")
|
|
pages = {
|
|
f"get/{name}/index.html": "install.sh"
|
|
for name in common.list_registered_platforms(PLATFORMS, include_archived=True)
|
|
}
|
|
pages["get/romm/index.html"] = f'<a href="{download}v1/RomM_BIOS_Pack.zip">x</a>'
|
|
pages["get/knulli/index.html"] = f'<a href="{download}v1/K_BIOS_Pack.zip">x</a>'
|
|
del pages["get/lakka/index.html"]
|
|
site = self._site(root, pages)
|
|
parsed = {p.resolve(): validate_site._parse_page(p) for p in site.rglob("*.html")}
|
|
issues = validate_site._check_get_pages(parsed, site.resolve(), Path(PLATFORMS),
|
|
record_path)
|
|
joined = "\n".join(issues)
|
|
self.assertIn("get/lakka/index.html: no download page", joined)
|
|
self.assertIn("get/knulli/index.html: links a pack", joined)
|
|
self.assertIn("get/knulli/index.html: gives no install command", joined)
|
|
self.assertNotIn("get/romm/", joined)
|
|
self.assertNotIn("get/retroarch/", joined)
|
|
|
|
def test_the_cli_runs_the_check(self):
|
|
source = (REPO_ROOT / "scripts" / "validate_site.py").read_text(encoding="utf-8")
|
|
self.assertIn("validate_site(Path(args.site_dir), args.base, args.platforms_dir, args.record)",
|
|
source)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|