Files
breeze/tests/phone_check_gate_test.py
waozi ef0de86e02
Cloudflare Pages / Build and verify the site (push) Successful in 3m29s
Integrate Breeze desktop, Android, and app updates
Use the verified dependency lock across native hosts and bundled apps. Preserve saved styles, local app reactivation, and offline packages while integrating the latest practice, Habits, Lumi, and figure preview updates.
2026-11-20 02:24:34 -03:00

264 lines
13 KiB
Python

"""The release gate accepts only a passing phone check of the released app content."""
import copy
import hashlib
import importlib.util
import json
from pathlib import Path
import subprocess
import tempfile
import unittest
from unittest import mock
ROOT = Path(__file__).resolve().parents[1]
spec = importlib.util.spec_from_file_location("check_phone_check", ROOT / "scripts/check-phone-check.py")
gate = importlib.util.module_from_spec(spec)
spec.loader.exec_module(gate)
phone_check = gate.phone_check
RECEIPT = {
"schema": 2, "version": "3.0.0", "app_tree": "", "source_commit": "", "uncommitted": [],
"apk": {"sha256": "0" * 64, "package": "xyz.waozi.inbe.debug", "version_code": 300, "version_name": "3.0.0"},
"device": {"model": "moto e6 play", "android": "9"},
"practice": {"name": "Wim Hof", "seconds": 60.0, "frames": 3580, "refresh_hz": 60.0, "fps": 59.6,
"late_percent": 0.4, "p95_frame_ms": 16.9, "worst_frame_ms": 41.2,
"resume_layout_shift": 0.4},
"passed": True,
}
class PhoneCheckGateTest(unittest.TestCase):
def setUp(self):
temporary = tempfile.TemporaryDirectory(prefix="inbe-phone-gate-")
self.addCleanup(temporary.cleanup)
self.root = Path(temporary.name)
self.git("init", "-q")
# Commits otherwise start git maintenance in the background, which can
# still be writing to .git while the temporary directory is removed.
self.git("config", "maintenance.auto", "false")
self.git("config", "user.email", "[email protected]")
self.git("config", "user.name", "Test")
self.commit({"src/main.zi": "one\n", "src/core/version.zi": "VersionString :: \"2.9.9\"\n",
"scripts/build-apps.sh": "build\n", "scripts/check-version.py": "check\n",
"CHANGELOG.md": "## [3.0.0]\n"})
self.checked = self.git("rev-parse", "HEAD").strip()
self.checked_app = phone_check.app_tree(self.root, "HEAD")
def git(self, *argv):
return subprocess.run(["git", "-C", str(self.root), *argv], check=True, capture_output=True,
text=True).stdout
def write(self, files):
for name, text in files.items():
path = self.root / name
path.parent.mkdir(parents=True, exist_ok=True)
path.write_text(text)
def commit(self, files, message="change"):
self.write(files)
self.git("add", "-A")
self.git("commit", "-q", "-m", message)
def receipt(self, change=None):
receipt = copy.deepcopy(RECEIPT)
receipt["source_commit"] = self.checked
receipt["app_tree"] = self.checked_app
if change:
change(receipt)
return json.dumps(receipt)
def record(self, change=None):
self.commit({"releases/phone-checks/3.0.0.json": self.receipt(change)})
def test_passing_check_of_the_released_app(self):
self.record()
self.assertEqual(gate.validate(self.root, "3.0.0")["version"], "3.0.0")
def test_fixed_apk_provenance_is_independent_of_peer_source_edits(self):
apk = self.root / "candidate.apk"
apk.write_bytes(b"synthetic isolated APK")
path = self.root / "build.json"
path.write_text(json.dumps(dict(status="passed", app_tree=self.checked_app,
apk=dict(sha256=hashlib.sha256(apk.read_bytes()).hexdigest()))))
self.commit({"src/main.zi": "peer committed work\n"})
(self.root / "src/core/version.zi").write_text('VersionString :: "4.0.0"\n')
with mock.patch.object(phone_check, "ROOT", self.root):
phone_check.require_build_receipt(apk, path, self.checked)
self.assertEqual(phone_check.source_state(self.checked), (self.checked, [], [], "2.9.9"))
with self.assertRaisesRegex(ValueError, "does not match"):
phone_check.require_build_receipt(apk, path, "HEAD")
apk.write_bytes(b"different APK")
with self.assertRaisesRegex(ValueError, "does not match"):
phone_check.require_build_receipt(apk, path, self.checked)
def test_running_owner_app_rejects_before_install_or_input(self):
phone = mock.Mock()
phone.adb.return_value = b"device\n"
phone.pid.return_value = "1234"
with mock.patch.object(phone_check, "apk_identity", return_value={"package": "fixture.debug"}):
with self.assertRaisesRegex(ValueError, "already running"):
phone_check.check(phone, self.root / "candidate.apk", 60, self.root)
self.assertEqual(phone.adb.call_args_list, [mock.call("get-state")])
phone.shell.assert_not_called()
def test_practice_failure_still_closes_the_owned_app(self):
phone = mock.Mock()
phone.host = "local"
phone.adb.side_effect = [b"device\n", b"Success\n"]
phone.pid.side_effect = ["", "4321", ""]
phone.screenshot.side_effect = RuntimeError("fixture screenshot failed")
with mock.patch.object(phone_check, "apk_identity", return_value={"package": "fixture.debug"}), \
mock.patch.object(phone_check.time, "sleep"):
with self.assertRaisesRegex(RuntimeError, "fixture screenshot failed"):
phone_check.check(phone, self.root / "candidate.apk", 60, self.root)
self.assertEqual(phone.shell.call_args, mock.call("am", "force-stop", "fixture.debug"))
self.assertEqual(phone.pid.call_args, mock.call("fixture.debug"))
def test_missing_process_is_empty_but_adb_failure_is_not_ignored(self):
phone = phone_check.Phone("local", "Fixture")
with mock.patch.object(phone, "shell", side_effect=subprocess.CalledProcessError(
1, ["pidof"], output=b"")):
self.assertEqual(phone.pid("fixture.debug"), "")
with mock.patch.object(phone, "shell", side_effect=subprocess.CalledProcessError(
1, ["adb"], output=b"device offline")):
with self.assertRaises(subprocess.CalledProcessError):
phone.pid("fixture.debug")
with mock.patch.object(phone, "shell", side_effect=subprocess.CalledProcessError(
1, ["adb"], output=b"", stderr=b"device offline")):
with self.assertRaises(subprocess.CalledProcessError):
phone.pid("fixture.debug")
def test_default_launch_uses_the_selected_serial_and_launcher_intent(self):
phone = phone_check.Phone("local", "ZE2223BQZT")
with mock.patch.object(phone, "remote", return_value=b"Status: ok\n") as remote:
phone.start("fixture.debug")
remote.assert_called_once_with(
"adb", "-s", "ZE2223BQZT", "shell", "am", "start", "-W",
"-a", "android.intent.action.MAIN",
"-c", "android.intent.category.LAUNCHER",
"-n", "fixture.debug/xyz.waozi.inbe.MainActivity")
def test_docs_tests_and_tooling_may_change_after_the_check(self):
self.record()
later = {"docs/notes.md": "later documentation\n", "tests/extra.py": "\n",
"scripts/check-version.py": "stricter check\n", "scripts/web-smoke-test.mjs": "\n",
"scripts/release.py": "\n", ".github/workflows/ci.yml": "\n", "mk/tests-ui.mk": "\n",
"CHANGELOG.md": "## [3.0.0]\n- shorter store notes\n", "TODO.md": "\n"}
for name, text in later.items():
with self.subTest(path=name):
self.commit({name: text})
self.assertEqual(gate.validate(self.root, "3.0.0")["version"], "3.0.0")
def test_app_changed_after_the_check(self):
self.record()
for name in ("src/main.zi", "ziran.lock", "droid/app/build.gradle", "Makefile", "mk/sync.mk",
"scripts/build-apps.sh", "scripts/new-generator.py", "assets/app/icon.png",
"locales/pt.txt", "apps/diary/diary.zi", "design/tai-chi/text/en.txt"):
with self.subTest(path=name):
self.commit({name: "changed " + name + "\n"})
with self.assertRaisesRegex(ValueError, "changed after its phone check"):
gate.validate(self.root, "3.0.0")
def test_the_checked_content_counts_not_the_commit(self):
# One final release commit may replace an earlier unpushed one: the
# checked commit is then no longer an ancestor, but its app content is.
self.commit({"src/main.zi": "two\n"})
self.commit({"src/main.zi": "one\n"}, "revert to the checked content")
self.record(lambda value: value.update(source_commit="1" * 40))
self.assertEqual(gate.validate(self.root, "3.0.0")["version"], "3.0.0")
def test_uncommitted_version_files_check_the_commit_that_holds_them(self):
self.write({"src/core/version.zi": "VersionString :: \"3.0.0\"\n"})
on_disk = phone_check.app_tree(self.root)
self.assertNotEqual(on_disk, self.checked_app)
self.commit({"releases/phone-checks/3.0.0.json":
self.receipt(lambda value: value.update(app_tree=on_disk))})
self.assertEqual(phone_check.app_tree(self.root, "HEAD"), on_disk)
self.assertEqual(gate.validate(self.root, "3.0.0")["version"], "3.0.0")
def test_untracked_app_files_are_reported(self):
self.write({"src/apps/new.zi": "draft\n", "docs/draft.md": "draft\n"})
changed, untracked = phone_check.changed_app_files(self.root)
self.assertEqual((changed, untracked), ([], ["src/apps/new.zi"]))
def test_missing_check(self):
with self.assertRaisesRegex(ValueError, "no phone check"):
gate.validate(self.root, "3.0.0")
def test_explicit_owner_waiver_is_bound_to_the_version_and_app(self):
waiver = {"schema": 3, "status": "waived", "version": "3.0.0",
"app_tree": self.checked_app, "reason": "Owner explicitly waived the Moto check"}
target = "releases/phone-checks/3.0.0.json"
self.commit({target: json.dumps(waiver)})
self.assertEqual(gate.validate(self.root, "3.0.0")["status"], "waived")
for changes in ({"version": "3.0.1"}, {"app_tree": "0" * 64}, {"reason": " "},
{"passed": True}, {"practice": {"fps": 60}}):
with self.subTest(changes=changes):
self.commit({target: json.dumps(waiver | changes)})
with self.assertRaises(ValueError):
gate.validate(self.root, "3.0.0")
def test_failed_or_mismatched_checks(self):
cases = {
"slow": lambda value: value["practice"].update(fps=41.0),
"late frames": lambda value: value["practice"].update(late_percent=9.0),
"long stall": lambda value: value["practice"].update(worst_frame_ms=600.0),
"short run": lambda value: value["practice"].update(seconds=20.0),
"shifted after resume": lambda value: value["practice"].update(resume_layout_shift=11.4),
"resume not checked": lambda value: value["practice"].pop("resume_layout_shift"),
"marked failed": lambda value: value.update(passed=False),
"other version": lambda value: value.update(version="2.9.9"),
"other APK": lambda value: value["apk"].update(version_name="2.9.9"),
"old schema": lambda value: value.update(schema=1),
"no app content": lambda value: value.pop("app_tree"),
"other app content": lambda value: value.update(app_tree="1" * 64),
}
for name, change in cases.items():
with self.subTest(case=name):
self.record(change)
with self.assertRaises(ValueError):
gate.validate(self.root, "3.0.0")
class PresentedFrameTimingTest(unittest.TestCase):
def measure(self, observation_seconds=0):
clock = [0.0]
def sleep(seconds):
clock[0] += seconds
def shell(*args):
if "--list" in args:
return "Token{fixture}\nSurfaceView - fixture.debug/activity#0\n"
if "--latency-clear" in args:
return ""
self.assertIn("--latency", args)
# Four intervals: 16, 16, 16 and 48 ms. Duplicate polls, zeroes
# and an unfinished presentation must not alter the percentiles.
return "16666667\n0 0 0\n" + "\n".join(
f"1 {timestamp} 1" for timestamp in
(1000000000, 1016000000, 1032000000, 1048000000,
1096000000, phone_check.PENDING))
observer = mock.Mock(side_effect=lambda: sleep(observation_seconds))
phone = mock.Mock()
phone.shell.side_effect = shell
with mock.patch.object(phone_check.time, "monotonic", side_effect=lambda: clock[0]), \
mock.patch.object(phone_check.time, "sleep", side_effect=sleep):
timing = phone_check.frame_timing(phone, "fixture.debug", 5, observer)
self.assertTrue(observer.called)
return timing
def test_presented_frames_keep_the_slow_tail(self):
timing = self.measure()
self.assertEqual(timing["frames"], 5)
self.assertEqual(timing["median_frame_ms"], 16)
self.assertEqual(timing["p95_frame_ms"], 48)
self.assertFalse(timing["buffer_overrun_possible"])
def test_slow_observer_reports_possible_lost_frame_history(self):
self.assertTrue(self.measure(observation_seconds=3)["buffer_overrun_possible"])
if __name__ == "__main__":
unittest.main()