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.
236 lines
12 KiB
Python
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()
|