Files
breeze/tests/version_test.py
T
waozi c9a0eae23c Bump versions only when a release is made
Between releases every change goes under one Unreleased section of
CHANGELOG.md and of each app's changelog; App packages already waits for
the next version. The version check accepts that leading section, and the
version test fixture copies the release notes script update_version.sh runs.
2026-10-29 12:56:34 -03:00

236 lines
12 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"
self.write(name, self.read(name).replace(
"# Changelog\n", "# Changelog\n\n## [Unreleased]\n\n- A change waiting for the next release.\n", 1))
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()