Files
breeze/tests/package_compat_test.py
T
waozi b868c162c9 Run only Habits and Practices packages that draw their own screens
This host no longer draws Habits' and Practices' screens, so a package of
theirs built for an older host interface would leave them blank. Each app
in apps/versions.json may now name the oldest host interface its packages
must be built for; Habits and Practices name 30. An older installed or
rolled-back package gives way to the bundled copy, and the compatibility
test skips the node's older releases of those two as this build does.
2026-10-25 00:25:23 -03:00

277 lines
13 KiB
Python

#!/usr/bin/env python3
"""Run app packages across Inner Breeze versions before they reach phones.
Forward: this build runs every package the Waozi node serves to an app with its
host interface. Phones still hold those packages when they install this app.
Reverse: the last released app runs each package built here that declares a
host interface the released app accepts, so a package update that claims to
support older apps cannot break them. Packages reach only apps that run their
format: an app released before the ZX format never asks the node for `.zx`
packages, so there is nothing to check against it.
Bundled packages are loaded with --bundle, which validates them and fails the
run when the host rejects them. The node's Arcade, and Chess while the node
still serves it on its own, are installed through More apps, played against
the computer and restarted to check the saved game.
"""
import argparse
import hashlib
import json
import os
from pathlib import Path
import stat
import subprocess
import sys
import tempfile
import time
import urllib.error
import urllib.parse
import urllib.request
from PIL import Image, ImageStat
ROOT = Path(__file__).resolve().parents[1]
REPOSITORY = "waozixyz/breeze"
# (ledger name, app ID, local bundle, --feature name)
PACKAGES = (
("inbe", "inbe", "build/inbe.zx", None),
("lists", "inbe.lists", "build/apps/lists.zx", "lists"),
("habits", "inbe.habits", "build/apps/habits.zx", "habits"),
("practices", "inbe.practices", "build/apps/practices.zx", "practices"),
("diary", "inbe.diary", "build/apps/diary.zx", "diary"),
("lumi", "inbe.lumi", "build/apps/lumi.zx", "lumi"),
("leaderboard", "inbe.leaderboard", "build/apps/leaderboard.zx", None),
)
SCRUBBED = ("DISPLAY", "WAYLAND_DISPLAY", "XAUTHORITY", "DBUS_SESSION_BUS_ADDRESS",
"SESSION_MANAGER", "GDK_DISPLAY")
def fetch(url, limit):
headers = {"User-Agent": "Inbe-Compatibility-Test/1.0"}
# Anonymous GitHub API calls share 60 an hour per address, which CI
# runners exhaust; Actions passes its token as GITHUB_TOKEN. Release
# downloads redirect to signed storage URLs that must not carry it.
token = os.environ.get("GITHUB_TOKEN") or os.environ.get("GH_TOKEN")
if token and urllib.parse.urlsplit(url).hostname == "api.github.com":
headers["Authorization"] = f"Bearer {token}"
headers["Accept"] = "application/vnd.github+json"
request = urllib.request.Request(url, headers=headers)
with urllib.request.urlopen(request, timeout=60) as response:
data = response.read(limit + 1)
if len(data) > limit:
raise ValueError(f"{url} exceeds {limit} bytes")
return data
def host_range(ledger):
"""Apps released before version ranges accept only their own interface."""
return ledger.get("oldest_host_api", ledger["host_api"]), ledger["host_api"]
def latest_release_tag():
"""GitHub's public latest link avoids shared anonymous API rate limits."""
request = urllib.request.Request(f"https://github.com/{REPOSITORY}/releases/latest",
headers={"User-Agent": "Inbe-Compatibility-Test/1.0"}, method="HEAD")
with urllib.request.urlopen(request, timeout=60) as response:
target = urllib.parse.urlsplit(response.geturl())
prefix = f"/{REPOSITORY}/releases/tag/"
if target.scheme != "https" or target.hostname != "github.com" or not target.path.startswith(prefix):
raise ValueError("GitHub's latest release link did not resolve to this repository's release")
tag = urllib.parse.unquote(target.path[len(prefix):])
if not tag or "/" in tag:
raise ValueError("GitHub's latest release link returned no release tag")
return tag
def declared_host(ledger, name):
return ledger["apps"][name].get("host_api", ledger["host_api"])
def run_app(binary, bundle, feature, output, label):
"""Open one package and render its app once on a private display."""
environment = {key: value for key, value in os.environ.items() if key not in SCRUBBED}
environment.update(YUE_DESKTOP_RECOVERY="0", SDL_AUDIODRIVER="dummy", APP_NO_TRAY="1")
image = output / (label + ".png")
log = output / (label + ".log")
image.unlink(missing_ok=True)
command = ["xvfb-run", "-a", "-n", "361", "-s", "-noreset -screen 0 1280x900x24", str(binary),
"--bundle", str(bundle), *(["--feature", feature] if feature else []),
"--screenshot", str(image), "--screenshot-width", "540", "--screenshot-height", "960"]
with tempfile.TemporaryDirectory(prefix=label + '-profile-', dir=output) as profile, log.open("w") as stream:
environment['APP_DATA_ROOT'] = profile
result = subprocess.run(command, env=environment, stdout=stream, stderr=subprocess.STDOUT,
timeout=180)
text = log.read_text(errors="replace")
if result.returncode != 0 or not image.exists():
raise AssertionError(f"{label}: the app rejected the package (exit {result.returncode})\n{text[-2000:]}")
if any(message in text for message in ("app launch rejected", "cell launch rejected")):
raise AssertionError(f"{label}: the package loaded but its app did not open\n{text[-2000:]}")
# A host call whose records do not fit fails inside the package and the
# screen silently loses that part, so any failed call fails the check.
failures = sorted({line for line in text.splitlines() if "portable execution failed" in line})
if failures:
raise AssertionError(f"{label}: package calls failed: " + "; ".join(failures))
with Image.open(image) as picture:
if max(ImageStat.Stat(picture.convert("RGB")).stddev) < 2:
raise AssertionError(f"{label}: the app rendered a blank screen")
def forward(binary, origin, ledger, output):
oldest, current = host_range(ledger)
checked = 0
for name, app_id, _, feature in PACKAGES:
route = f"{origin}/api/v2/packages/{app_id}"
try:
metadata = json.loads(fetch(f"{route}/latest?host_api={current}&module_api={ledger['module_api']}&format=zx", 65536))
except urllib.error.HTTPError as error:
if error.code == 404:
print(f"forward {app_id}: the node has no release this build can run")
continue
raise
floor = ledger["apps"][name].get("oldest_host_api", oldest)
if not floor <= metadata["host_api"] <= current or metadata["module_api"] != ledger["module_api"]:
print(f"forward {app_id}: skipped {metadata['version']}, built for host "
f"{metadata['host_api']} outside {floor}..{current}")
continue
artifact = metadata["artifacts"][0]
data = fetch(f"{route}/{artifact['sha256']}.zx", artifact["size"])
if len(data) != artifact["size"] or hashlib.sha256(data).hexdigest() != artifact["sha256"]:
raise AssertionError(f"forward {app_id}: the node served bytes that differ from its release")
bundle = output / f"published-{name}.zx"
bundle.write_bytes(data)
run_app(binary, bundle, feature, output, f"forward-{name}")
print(f"forward {app_id} {metadata['version']} (host {metadata['host_api']}): runs in this build")
checked += 1
return checked
def published_release(origin, ledger, app_id, output):
"""Download the node's release of app_id for this build, or None if it serves none."""
oldest, current = host_range(ledger)
route = f"{origin}/api/v2/packages/{app_id}"
try:
metadata = json.loads(fetch(
f"{route}/latest?host_api={current}&module_api={ledger['module_api']}&format=zx", 65536))
except urllib.error.HTTPError as error:
if error.code == 404:
return None
raise
if not oldest <= metadata["host_api"] <= current or metadata["module_api"] != ledger["module_api"]:
raise AssertionError(f"The published {app_id} package does not support this host")
artifact = metadata["artifacts"][0]
data = fetch(f"{route}/{artifact['sha256']}.zx", artifact["size"])
if len(data) != artifact["size"] or hashlib.sha256(data).hexdigest() != artifact["sha256"]:
raise AssertionError(f"The node's {app_id} bytes differ from its release")
directory = output / ("published-" + app_id.split(".")[-1])
directory.mkdir(parents=True, exist_ok=True)
bundle = directory / (app_id.split(".")[-1] + ".zx")
bundle.write_bytes(data)
(directory / "release.json").write_text(json.dumps(metadata, indent=2) + "\n")
return bundle, metadata
def published_release_retried(origin, ledger, app_id, output, attempts=6, delay=15):
"""The node restarts for a minute or so whenever it is deployed; ask
again for a while before deciding that it serves no release."""
for attempt in range(attempts):
try:
return published_release(origin, ledger, app_id, output)
except (OSError, ValueError) as error:
if attempt == attempts - 1:
raise
print(f"forward {app_id}: the node did not answer ({error}); asking again")
time.sleep(delay)
return None
def published_games(binary, origin, ledger, output):
"""Install and play the node's games, independently of Arcade's checkout.
Arcade carries Chess; Chess on its own is checked only while the node
still serves it. At least one of them must be served.
"""
environment = {key: value for key, value in os.environ.items() if key not in SCRUBBED}
environment["YUE_DESKTOP_RECOVERY"] = "0"
checked = 0
for app_id, test in (("inbe.arcade", "tests/arcade_ui_test.sh"), ("inbe.chess", "tests/chess_ui_test.sh")):
published = published_release_retried(origin, ledger, app_id, output)
if published is None:
print(f"forward {app_id}: the node serves no release")
continue
bundle, metadata = published
subprocess.run(["sh", str(ROOT / test), str(binary), str(bundle)],
env=environment, check=True, timeout=600)
print(f"forward {app_id} {metadata['version']}: install, play, board and saved restart passed")
checked += 1
if checked == 0:
raise AssertionError("The node serves neither Arcade nor Chess")
return checked
def released_app(tag, output):
"""Unpack the release's Linux AppImage without FUSE."""
image = output / "released.AppImage"
image.write_bytes(fetch(f"https://github.com/{REPOSITORY}/releases/download/{tag}/"
"inbe-linux-x86_64.AppImage", 256 * 1024 * 1024))
image.chmod(image.stat().st_mode | stat.S_IXUSR)
environment = {key: value for key, value in os.environ.items() if key not in SCRUBBED}
subprocess.run([str(image), "--appimage-extract"], cwd=output, env=environment, check=True,
stdout=subprocess.DEVNULL, timeout=300)
return output / "squashfs-root/AppRun"
def reverse(tag, ledger, output):
released = json.loads(fetch(f"https://raw.githubusercontent.com/{REPOSITORY}/{tag}/apps/versions.json", 65536))
if released.get("package_format", "zib") != ledger.get("package_format", "zib"):
print(f"reverse {tag}: the released app runs {released.get('package_format', 'zib')} packages and is "
f"never offered these {ledger.get('package_format', 'zib')} ones; nothing to check")
return 0
oldest, current = host_range(released)
candidates = [package for package in PACKAGES
if oldest <= declared_host(ledger, package[0]) <= current and
ledger["module_api"] == released["module_api"]]
if not candidates:
print(f"reverse {tag}: no package here declares host {oldest}..{current}; nothing to check")
return 0
binary = released_app(tag, output)
for name, app_id, path, feature in candidates:
bundle = ROOT / path
if not bundle.exists():
raise AssertionError(f"reverse {app_id}: {path} is missing; build the packages first")
run_app(binary, bundle, feature, output, f"reverse-{name}")
print(f"reverse {app_id} (declares host {declared_host(ledger, name)}): runs in {tag}")
return len(candidates)
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("binary", type=Path, nargs="?", help="this build's app; needed unless --skip-forward")
parser.add_argument("--origin", default="https://api.waozi.xyz")
parser.add_argument("--release", help="Release tag to check new packages against (default: the latest)")
parser.add_argument("--skip-forward", action="store_true")
parser.add_argument("--skip-reverse", action="store_true")
args = parser.parse_args()
ledger = json.loads((ROOT / "apps/versions.json").read_text())
output = ROOT / "build/package-compat-test"
output.mkdir(parents=True, exist_ok=True)
checked = 0
if not args.skip_forward:
if args.binary is None:
parser.error("the forward check needs this build's app binary")
binary = args.binary.resolve(strict=True)
origin = args.origin.rstrip("/")
checked += forward(binary, origin, ledger, output)
checked += published_games(binary, origin, ledger, output)
if not args.skip_reverse:
tag = args.release
if tag is None:
tag = latest_release_tag()
with tempfile.TemporaryDirectory(prefix="inbe-released-", dir=output) as directory:
checked += reverse(tag, ledger, Path(directory))
print(f"Package compatibility: {checked} package runs passed")
if __name__ == "__main__":
sys.exit(main())