124 lines
6.6 KiB
Python
Executable File
124 lines
6.6 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
import hashlib
|
|
import json
|
|
import plistlib
|
|
import subprocess
|
|
import tempfile
|
|
import unittest
|
|
import zipfile
|
|
from pathlib import Path
|
|
from unittest import mock
|
|
|
|
import sys
|
|
|
|
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "scripts"))
|
|
import mobile_bundle as bundle
|
|
|
|
|
|
def manifest(commit: str, apk: Path, ipa: Path) -> dict:
|
|
return {
|
|
"schema_version": 1,
|
|
"release": "ci-test",
|
|
"commit": commit,
|
|
"artifacts": {
|
|
"android": {"url": str(apk), "sha256": hashlib.sha256(apk.read_bytes()).hexdigest(), "package": "page.writes"},
|
|
"ios": {"url": str(ipa), "sha256": hashlib.sha256(ipa.read_bytes()).hexdigest(), "bundle_id": "page.writes"},
|
|
},
|
|
}
|
|
|
|
|
|
class MobileBundleTests(unittest.TestCase):
|
|
def test_manifest_contract(self):
|
|
with tempfile.TemporaryDirectory() as temp:
|
|
root = Path(temp)
|
|
apk, ipa = root / "a.apk", root / "a.ipa"
|
|
apk.write_bytes(b"apk")
|
|
ipa.write_bytes(b"ipa")
|
|
bundle.validate_manifest(manifest("a" * 40, apk, ipa), "ci-test")
|
|
with self.assertRaises(bundle.ManifestFailure):
|
|
bundle.validate_manifest(manifest("a" * 40, apk, ipa), "wrong")
|
|
|
|
def test_exact_worktree_repairs_stale_commit(self):
|
|
with tempfile.TemporaryDirectory() as temp:
|
|
repo, worktrees = Path(temp) / "repo", Path(temp) / "worktrees"
|
|
repo.mkdir()
|
|
run = lambda args: subprocess.run(args, check=True, stdout=subprocess.DEVNULL)
|
|
run(["git", "init", "-q", str(repo)])
|
|
run(["git", "-C", str(repo), "config", "user.email", "tester@example.invalid"])
|
|
run(["git", "-C", str(repo), "config", "user.name", "Tester"])
|
|
(repo / "file").write_text("one")
|
|
run(["git", "-C", str(repo), "add", "file"])
|
|
run(["git", "-C", str(repo), "commit", "-qm", "one"])
|
|
first = subprocess.check_output(["git", "-C", str(repo), "rev-parse", "HEAD"], text=True).strip()
|
|
(repo / "file").write_text("two")
|
|
run(["git", "-C", str(repo), "commit", "-qam", "two"])
|
|
second = subprocess.check_output(["git", "-C", str(repo), "rev-parse", "HEAD"], text=True).strip()
|
|
path = worktrees / second[:12]
|
|
run(["git", "-C", str(repo), "worktree", "add", "--detach", str(path), first])
|
|
actual, commit = bundle.ensure_worktree(second, bundle.RuntimeContext(repo), worktrees)
|
|
self.assertEqual(actual, path.resolve())
|
|
self.assertEqual(commit, second)
|
|
|
|
def test_ipa_identity_and_install(self):
|
|
with tempfile.TemporaryDirectory() as temp:
|
|
root = Path(temp)
|
|
ipa = root / "app.ipa"
|
|
with zipfile.ZipFile(ipa, "w") as archive:
|
|
archive.writestr("Payload/Writes.app/Info.plist", plistlib.dumps({"CFBundleIdentifier": "page.writes"}))
|
|
self.assertEqual(bundle.ios_identity(ipa), "page.writes")
|
|
context = bundle.RuntimeContext(root)
|
|
calls = []
|
|
def fake(args, **kwargs):
|
|
calls.append(args)
|
|
return bundle.CommandResult(0, "/container" if "get_app_container" in args else "")
|
|
with mock.patch.object(bundle, "run_command", side_effect=fake):
|
|
result = bundle.install_ios({"xcrun": "xcrun", "udid": "UDID", "name": "Test"}, ipa, "page.writes", context)
|
|
self.assertTrue(result["verified"])
|
|
self.assertTrue(any("install" in call for call in calls))
|
|
|
|
def test_android_missing_device_is_environment_failure(self):
|
|
context = bundle.RuntimeContext(Path("."))
|
|
with mock.patch.object(bundle.shutil, "which", return_value="/sdk/adb"), mock.patch.object(
|
|
bundle, "run_command", side_effect=[bundle.CommandResult(0, ""), bundle.CommandResult(0, "List of devices attached")]
|
|
):
|
|
with self.assertRaises(bundle.EnvironmentFailure):
|
|
bundle.android_preflight(context)
|
|
|
|
def test_network_failure_is_actionable(self):
|
|
context = bundle.RuntimeContext(Path("."))
|
|
with mock.patch.object(bundle.urllib.request, "urlopen", side_effect=OSError("offline")), mock.patch.object(bundle.time, "sleep"):
|
|
with mock.patch.dict(bundle.os.environ, {"HOST": "test.invalid"}, clear=False):
|
|
with self.assertRaisesRegex(bundle.EnvironmentFailure, "VPN"):
|
|
bundle.check_network(context)
|
|
|
|
def test_retry_recovers(self):
|
|
context = bundle.RuntimeContext(Path("."))
|
|
responses = [bundle.CommandResult(1, "busy"), bundle.CommandResult(0, "ok")]
|
|
with mock.patch.object(bundle, "run_command", side_effect=responses), mock.patch.object(bundle.time, "sleep"):
|
|
self.assertEqual(bundle.retry_command(["fake"], context=context, action="install").code, 0)
|
|
|
|
def test_full_gate_blocks_install_when_ios_fails(self):
|
|
with tempfile.TemporaryDirectory() as temp:
|
|
root = Path(temp) / "repo"
|
|
root.mkdir()
|
|
subprocess.run(["git", "init", "-q", str(root)], check=True)
|
|
subprocess.run(["git", "-C", str(root), "config", "user.email", "tester@example.invalid"], check=True)
|
|
subprocess.run(["git", "-C", str(root), "config", "user.name", "Tester"], check=True)
|
|
(root / "marker").write_text("x")
|
|
subprocess.run(["git", "-C", str(root), "add", "marker"], check=True)
|
|
subprocess.run(["git", "-C", str(root), "commit", "-qm", "bundle"], check=True)
|
|
commit = subprocess.check_output(["git", "-C", str(root), "rev-parse", "HEAD"], text=True).strip()
|
|
apk, ipa = Path(temp) / "a.apk", Path(temp) / "a.ipa"
|
|
apk.write_bytes(b"apk")
|
|
ipa.write_bytes(b"ipa")
|
|
manifest_path = Path(temp) / "manifest.json"
|
|
manifest_path.write_text(json.dumps(manifest(commit, apk, ipa)))
|
|
args = bundle.parser().parse_args(["run", "--release", str(manifest_path), "--root", str(root), "--worktree-root", str(Path(temp) / "wt")])
|
|
with mock.patch.object(bundle, "android_identity", return_value="page.writes"), mock.patch.object(bundle, "ios_identity", return_value="page.writes"), mock.patch.object(bundle, "android_preflight", return_value={"adb": "adb", "serial": "device"}), mock.patch.object(bundle, "ios_preflight", side_effect=bundle.EnvironmentFailure("Mac unavailable")), mock.patch.object(bundle, "check_network"), mock.patch.object(bundle, "install_android") as install:
|
|
self.assertEqual(bundle.execute(args), 1)
|
|
install.assert_not_called()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|