Files
breeze/tests/version_test.py
T
waozi 6ae3f5853d Shrink the APK with Ziran's compact saved IR and single copies
Ziran c8c6c96c writes saved IR format 59: each string once, compact
integers and relative source positions. The root package drops from
34.0 MB to 18.5 MB and the debug APK from 46.3 MB to 29.5 MB.

A host reads only its own program format, so host_api, oldest_host_api
and every package's host_api move to 41 (released hosts are 40). The
Apps controller is rebuilt with Apps ffebcc7 (e41f568f…, 592 KB instead
of 1.94 MB); controllers from before format 59 cannot run here, so their
trust entries go and collections publish again with this one.

The root package no longer carries a second copy of the Apps controller,
which the host reads from its own apps.zx asset, and the profile picker
draws Entity's flowers picture instead of an identical 1.85 MB copy.
2026-10-29 13:05:36 -03:00

239 lines
13 KiB
Python

#!/usr/bin/env python3
"""Exercise the release guard and updater in disposable release fixtures."""
from pathlib import Path
import json
import re
import shutil
import subprocess
import sys
import tempfile
import unittest
REPO = Path(__file__).resolve().parents[1]
class VersionTest(unittest.TestCase):
def setUp(self):
self.temporary = tempfile.TemporaryDirectory(prefix="inbe-version-")
self.addCleanup(self.temporary.cleanup)
self.root = Path(self.temporary.name)
paths = (
"CHANGELOG.md", "Makefile", "update_version.sh",
"apps/versions.json", "apps/inbe/CHANGELOG.md", "apps/lists/CHANGELOG.md",
"apps/habits/CHANGELOG.md", "apps/practice/CHANGELOG.md", "apps/diary/CHANGELOG.md",
"apps/lumi/CHANGELOG.md", "apps/leaderboard/CHANGELOG.md",
"src/apps/versions.zi",
"scripts/update-package-version.py", "scripts/generate-package-versions.py",
"scripts/release_notes.py",
"src/core/version.h", "src/core/version.zi",
"src/storage/sync_result.zi",
"droid/app/build.gradle", "windows/inbe.rc",
"packaging/click/manifest.json", "packaging/click/control",
"packaging/click/inbe.metainfo.xml",
"packaging/linux/appimage/inbe.appdata.xml",
"packaging/snap/snap/gui/inbe.metainfo.xml",
"packaging/snap/snap/snapcraft.yaml",
"packaging/firefox-addons/manifest.json",
"scripts/check-version.py", "scripts/list-expected-release-assets.sh",
"scripts/check-site-release-assets.sh", "scripts/publish-openstore.sh",
".github/workflows/release.yml", "site/build.sh",
)
# The Makefile reads its rules from the files in mk/.
makefiles = tuple(path.relative_to(REPO).as_posix()
for path in sorted((REPO / "mk").glob("*.mk")))
for name in paths + makefiles:
destination = self.root / name
destination.parent.mkdir(parents=True, exist_ok=True)
shutil.copy2(REPO / name, destination)
shutil.copytree(REPO / "fastlane", self.root / "fastlane")
self.version = re.search(r'^#define APP_VERSION_STRING "([^"]+)"',
self.read("src/core/version.h"), re.MULTILINE)[1]
def test_module_release_retains_wrapper_version(self):
wrapper = self.read("src/core/version.zi")
android = self.read("droid/app/build.gradle")
ledger = json.loads(self.read("apps/versions.json"))
component = ledger["apps"]["practices"]
previous = component.copy()
major, minor, patch = map(int, previous["version"].split("."))
latest = f"{major}.{minor}.{patch + 1}"
(self.root / "apps/practice/CHANGELOG.md").write_text(f"## [{latest}] - 2026-10-06\nUpdated practices.\n")
for attempt in range(2):
result = subprocess.run(["bash", str(self.root / "update_version.sh"), "--module", "practices"],
capture_output=True, text=True)
self.assertEqual(result.returncode, 0, result.stderr)
changed = json.loads(self.read("apps/versions.json"))
self.assertEqual(changed["apps"]["practices"]["version"], latest)
self.assertEqual(changed["apps"]["practices"]["sequence"], previous["sequence"] + 1)
for name in ("inbe", "habits", "lists", "diary"):
self.assertEqual(changed["apps"][name], ledger["apps"][name])
self.assertEqual(self.read("src/core/version.zi"), wrapper)
self.assertEqual(self.read("droid/app/build.gradle"), android)
def read(self, name):
return (self.root / name).read_text()
def write(self, name, content):
(self.root / name).write_text(content)
def check(self, *arguments, success=True):
result = subprocess.run(
[sys.executable, str(self.root / "scripts/check-version.py"), *arguments],
text=True, capture_output=True, check=False,
)
self.assertEqual(result.returncode == 0, success, result.stdout + result.stderr)
return result
def snapshot(self):
return {str(path.relative_to(self.root)): path.read_bytes()
for path in self.root.rglob("*") if path.is_file()}
def test_valid_metadata_is_read_only(self):
before = self.snapshot()
self.assertEqual(self.check("--print-version").stdout, self.version + "\n")
self.assertEqual(before, self.snapshot())
def test_build_gate_rejects_mismatch_after_success(self):
(self.root / "vendor").mkdir()
(self.root / "build/packages").mkdir(parents=True)
# The package links below are already in place; the manifest and a
# newer packages.mk keep Make from fetching them again.
for name in ("ziran.toml", "ziran.lock", "scripts/packages.sh"):
(self.root / name).parent.mkdir(parents=True, exist_ok=True)
shutil.copy2(REPO / name, self.root / name)
(self.root / "build/packages.mk").write_text("PACKAGES_READY := 1\n")
(self.root / "build/packages/kryon").symlink_to(REPO / "build/packages/kryon", target_is_directory=True)
def build():
return subprocess.run(["make", "version-check"], cwd=self.root,
capture_output=True, text=True, check=False)
valid = build()
self.assertEqual(valid.returncode, 0, valid.stdout + valid.stderr)
name = "droid/app/build.gradle"
self.write(name, self.read(name).replace(self.version, "9.8.7"))
invalid = build()
self.assertNotEqual(invalid.returncode, 0)
self.assertIn("expected", invalid.stdout + invalid.stderr)
def test_each_package_mismatch_is_rejected(self):
for name in ("droid/app/build.gradle", "packaging/click/manifest.json",
"packaging/click/control", "packaging/firefox-addons/manifest.json",
"packaging/click/inbe.metainfo.xml",
"packaging/linux/appimage/inbe.appdata.xml",
"packaging/snap/snap/gui/inbe.metainfo.xml",
"packaging/snap/snap/snapcraft.yaml", "windows/inbe.rc"):
with self.subTest(path=name):
original = self.read(name)
self.assertIn(self.version, original)
self.write(name, original.replace(self.version, "9.8.7"))
self.check(success=False)
self.write(name, original)
def test_header_missing_duplicate_malformed_and_inconsistent(self):
original = self.read("src/core/version.h")
line = f'#define APP_VERSION_STRING "{self.version}"'
for modified in (original.replace(line, ""), original + "\n" + line + "\n",
original + "\n#define APP_VERSION_STRING\n",
original + '\n# define APP_VERSION_STRING "9.8.7"\n',
original.replace(line, '#define APP_VERSION_STRING "Unreleased"'),
re.sub(r"APP_VERSION_MAJOR \d+", "APP_VERSION_MAJOR 99", original)):
with self.subTest(header=modified):
self.write("src/core/version.h", modified)
self.check(success=False)
self.write("src/core/version.h", original)
def test_obsolete_reader_is_rejected(self):
name = ".github/workflows/release.yml"
self.write(name, self.read(name) + "\n# Read INBE_VERSION_STRING\n")
self.assertIn("INBE_VERSION_STRING", self.check(success=False).stderr)
def test_ziran_version_missing_or_stale_is_rejected(self):
name = "src/core/version.zi"
original = self.read(name)
self.write(name, original.replace(f'VersionString :: "{self.version}"',
'VersionString :: "9.8.7"'))
self.assertIn(name, self.check(success=False).stderr)
(self.root / name).unlink()
self.assertIn("missing", self.check(success=False).stderr)
def test_missing_package_blocks_updater_before_any_write(self):
(self.root / "windows/inbe.rc").unlink()
before = self.snapshot()
result = subprocess.run(["bash", str(self.root / "update_version.sh")],
capture_output=True, text=True, check=False)
self.assertNotEqual(result.returncode, 0)
self.assertEqual(before, self.snapshot())
def test_release_asset_reader(self):
script = self.root / "scripts/list-expected-release-assets.sh"
result = subprocess.run(["sh", str(script)], capture_output=True, text=True, check=True)
self.assertIn(f"inbe-{self.version}.apk", result.stdout.splitlines())
# F-Droid's metadata compares its build with this signed APK.
self.assertIn(f"inbe-{self.version}-fdroid.apk", result.stdout.splitlines())
for invalid in ("", "Unreleased", "2.0", "2.0.0\n3.0.0", "02.0.0"):
with self.subTest(version=invalid):
result = subprocess.run(["sh", str(script), invalid], capture_output=True, check=False)
self.assertNotEqual(result.returncode, 0)
def test_unreleased_changes_keep_the_released_version(self):
code = re.search(r"versionCode (\d+)", self.read("droid/app/build.gradle"))[1]
name = "CHANGELOG.md"
changelog = self.read(name)
if "## [Unreleased]" not in changelog:
changelog = changelog.replace(
"# Changelog\n", "# Changelog\n\n## [Unreleased]\n\n- A change waiting for the next release.\n", 1)
self.write(name, changelog)
self.assertEqual(self.check("--print-version").stdout, f"{self.version}\n")
subprocess.run(["bash", str(self.root / "update_version.sh")], capture_output=True, text=True, check=True)
self.assertEqual(self.check("--print-version").stdout, f"{self.version}\n")
self.assertIn(f"versionCode {code}", self.read("droid/app/build.gradle"))
def test_updater_bumps_once_and_is_idempotent(self):
initial_code = int(re.search(r"versionCode (\d+)", self.read("droid/app/build.gradle"))[1])
name = "CHANGELOG.md"
self.write(name, self.read(name).replace(f"## [{self.version}]", "## [9.8.7]", 1))
self.check(success=False)
script = self.root / "update_version.sh"
subprocess.run(["bash", str(script)], capture_output=True, text=True, check=True)
self.assertEqual(self.check("--print-version").stdout, "9.8.7\n")
self.assertIn(f"versionCode {initial_code + 1}", self.read("droid/app/build.gradle"))
before = self.snapshot()
subprocess.run(["bash", str(script)], capture_output=True, text=True, check=True)
self.assertEqual(before, self.snapshot())
def test_release_versions_every_package_once(self):
ledger = json.loads(self.read("apps/versions.json"))
self.write("CHANGELOG.md", self.read("CHANGELOG.md").replace(f"## [{self.version}]", "## [9.8.7]", 1))
# Lumi's notes for this release are already written; the rest get
# maintenance entries, and the root brings the new versions.
major, minor, _ = map(int, ledger["apps"]["lumi"]["version"].split("."))
lumi = f"{major}.{minor + 1}.0"
self.write("apps/lumi/CHANGELOG.md", self.read("apps/lumi/CHANGELOG.md").replace(
"# Changelog\n", f"# Changelog\n\n## [{lumi}] - 2026-10-17\n\n- Lumi learns a new trick.\n", 1))
script = self.root / "update_version.sh"
subprocess.run(["bash", str(script)], capture_output=True, text=True, check=True)
changed = json.loads(self.read("apps/versions.json"))
for name, previous in ledger["apps"].items():
with self.subTest(app=name):
current = changed["apps"][name]
self.assertEqual((current["sequence"], current["release"]), (previous["sequence"] + 1, "9.8.7"))
self.assertEqual(changed["apps"]["lumi"]["version"], lumi)
major, minor, patch = map(int, ledger["apps"]["habits"]["version"].split("."))
habits = f"{major}.{minor}.{patch + 1}"
self.assertEqual(changed["apps"]["habits"]["version"], habits)
self.assertIn(f"## [{habits}] - ", self.read("apps/habits/CHANGELOG.md"))
self.assertIn("- Maintenance release for Inner Breeze 9.8.7.", self.read("apps/habits/CHANGELOG.md"))
self.assertIn(f"Lumi {lumi}, Habits {habits}, ", self.read("apps/inbe/CHANGELOG.md"))
self.assertIn(f'"{habits}"', self.read("src/apps/versions.zi"))
# Running it again for the same release changes nothing.
before = self.snapshot()
subprocess.run(["bash", str(script)], capture_output=True, text=True, check=True)
self.assertEqual(before, self.snapshot())
if __name__ == "__main__":
unittest.main()