"""Offline update protocol checks; no game API, Docker, or live GitHub.""" from datetime import timedelta import json import os from pathlib import Path import tempfile import unittest from unittest.mock import patch from ranch_web import updates def release(tag, **extra): return {"tag_name": tag, "draft": False, "prerelease": False, **extra} class UpdateTests(unittest.TestCase): def setUp(self): self.temporary = tempfile.TemporaryDirectory(prefix="ranch-updates-") self.addCleanup(self.temporary.cleanup) self.folder = Path(self.temporary.name) self.root = self.folder / "data" self.control = self.folder / "host-control" self.environment = patch.dict(os.environ, {"RANCH_WEB_UPDATER_DIR": ""}) self.environment.start() self.addCleanup(self.environment.stop) os.environ.pop(updates.TOKEN_FILE_ENV, None) self.github = patch.object(updates, "github_releases", return_value=[]) self.releases = self.github.start() self.addCleanup(self.github.stop) self.service = updates.UpdateService(self.root, "2.0.0.dev1") def enable(self, **overrides): now = updates.utc_now() value = {"protocol": 1, "executor_id": "a" * 32, "enabled": True, "auto_apply": False, "heartbeat_at": updates.timestamp(now), "expires_at": updates.timestamp(now + timedelta(minutes=15)), **overrides} updates.atomic_json(self.control / "capability.json", value) os.environ["RANCH_WEB_UPDATER_DIR"] = str(self.control) def test_status_does_not_create_data_or_use_network(self): result = self.service.status() self.assertEqual(result["status"], "unchecked") self.assertFalse(self.root.exists()) self.releases.assert_not_called() def test_release_gate_accepts_official_repository_case_and_exact_source_version(self): for repository in ("AttilaNet/myrzx_bot", "attilanet/myrzx_bot", "ATTILANET/MYRZX_BOT"): with self.subTest(repository=repository): self.assertEqual(updates.validate_image_release(repository, "v2.0.0", "2.0.0"), "v2.0.0") def test_release_gate_rejects_forks_dev_source_and_unstable_tags(self): variants = [("someone/myrzx_bot", "v2.0.0", "2.0.0"), ("AttilaNet/myrzx_bot", "v2.0.0", "2.0.0.dev1"), ("AttilaNet/myrzx_bot", "v2.0.1", "2.0.0"), ("AttilaNet/myrzx_bot", "v3.0.0", "3.0.0"), ("AttilaNet/myrzx_bot", "v2.0.0-rc1", "2.0.0-rc1")] for values in variants: with self.subTest(values=values), self.assertRaises(ValueError): updates.validate_image_release(*values) def test_only_desktop_or_no_releases_means_no_web_update(self): self.releases.return_value = [release("v1.2.0"), release("v3.0.0")] result = self.service.check() self.assertEqual(result["status"], "no_release") self.assertIsNone(result["latest_version"]) self.assertFalse(result["available"]) self.assertIn("桌面", result["message"]) def test_dev_can_upgrade_to_same_number_stable(self): self.releases.return_value = [release("v2.0.0")] self.assertTrue(self.service.check()["available"]) def test_same_stable_and_downgrade_are_not_updates(self): self.releases.return_value = [release("v2.0.0")] for current in ("2.0.0", "2.1.0", "v2.0.0"): with self.subTest(current=current): state = updates.UpdateService(self.root, current).check() self.assertEqual(state["status"], "up_to_date") self.assertFalse(state["available"]) def test_numeric_order_and_untrusted_release_url(self): self.releases.return_value = [release("v2.9.9"), release("v2.10.0", html_url="https://evil.invalid")] result = self.service.check() self.assertEqual(result["latest_version"], "v2.10.0") self.assertEqual(result["release_url"], "https://github.com/attilanet/myrzx_bot/releases/tag/v2.10.0") def test_draft_prerelease_and_noncanonical_tags_skipped(self): tags = ["v2.01.0", "v2.1.00", "2.1.0", "v2.1.0-rc1", "v2.1.0+build", "v2.1.0.dev1", "v2.1.0\n", "v2.1.0;id", "v2.1.0", "v1.99.99", "v3.0.0"] self.releases.return_value = [release(tag) for tag in tags] + [release("v2.1.0", draft=True), release("v2.2.0", prerelease=True)] self.assertEqual(self.service.check()["status"], "no_release") def test_network_failure_has_no_exception_or_secret_text(self): self.releases.side_effect = RuntimeError("token=secret C:/private/account") state = self.service.check() encoded = json.dumps(state) self.assertEqual(state["status"], "check_failed") self.assertFalse(state["available"]) self.assertNotIn("secret", encoded) self.assertNotIn("private", encoded) def test_unconfigured_windows_can_only_check(self): self.releases.return_value = [release("v2.0.0")] self.service.check() state = self.service.request_update() self.assertEqual(state["status"], "unavailable") self.assertFalse(state["can_apply"]) self.assertFalse((self.root / "update-request.json").exists()) def test_data_cannot_self_enable_host_executor(self): updates.atomic_json(self.root / "capability.json", {"protocol": 1, "enabled": True}) self.assertFalse(self.service.status()["executor"]["enabled"]) def test_disabled_expired_future_and_malformed_proof_refuse_apply(self): now = updates.utc_now() variants = [dict(enabled=False), dict(expires_at=updates.timestamp(now - timedelta(seconds=1))), dict(heartbeat_at=updates.timestamp(now + timedelta(hours=1))), dict(expires_at=updates.timestamp(now + timedelta(hours=1))), dict(executor_id="bad"), dict(protocol=2)] for variant in variants: with self.subTest(variant=variant): self.enable(**variant) self.assertEqual(self.service.request_update()["status"], "unavailable") self.assertFalse((self.root / "update-request.json").exists()) def test_apply_creates_only_strict_pending_request(self): self.enable() self.releases.return_value = [release("v2.0.0")] state = self.service.request_update() self.assertEqual(state["status"], "pending") self.assertFalse(state["can_apply"]) value = updates.read_json(self.root / "update-request.json") self.assertEqual(set(value), {"protocol", "request_id", "executor_id", "version", "requested_at"}) self.assertEqual(value["version"], "v2.0.0") self.assertEqual(value["executor_id"], "a" * 32) self.assertTrue(updates.valid_id(value["request_id"])) self.assertIsNone(state["host_status"]) def test_duplicate_request_is_idempotent(self): self.enable() self.releases.return_value = [release("v2.0.0")] first = self.service.request_update() second = self.service.request_update() self.assertEqual(first["request"], second["request"]) self.assertEqual(self.releases.call_count, 1) def test_tampered_cached_release_is_not_enough_for_apply(self): self.enable() updates.atomic_json(self.root / "update-check.json", {"status": "available", "latest_version": "v2.9.9"}) with self.assertRaises(ValueError): self.service.request_update("v2.9.9") self.assertFalse((self.root / "update-request.json").exists()) def test_apply_rejects_unsafe_tag_before_network(self): self.enable() for tag in ("v1.2.0", "v3.0.0", "v2.1.0;rm", "v2.1.0\n", "latest", "v2.1.0-rc1"): with self.subTest(tag=tag), self.assertRaises(ValueError): self.service.request_update(tag) self.releases.assert_not_called() def test_request_rejects_equal_or_older_official_version(self): self.enable() self.releases.return_value = [release("v2.0.0")] for current in ("2.0.0", "2.1.0"): with self.subTest(current=current), self.assertRaises(ValueError): updates.UpdateService(self.root, current).request_update("v2.0.0") def test_public_host_state_uses_allowlist_and_fixed_error(self): self.enable() self.releases.return_value = [release("v2.0.0")] request = self.service.request_update()["request"] updates.atomic_json(self.root / "updater-status.json", { "protocol": 1, "request_id": request["request_id"], "version": "v2.0.0", "status": "rolled_back", "updated_at": updates.timestamp(), "error": "private token", "path": "C:/account", "password": "do-not-send", }) state = self.service.status() self.assertEqual(state["status"], "rolled_back") self.assertEqual(state["request"]["status"], "rolled_back") encoded = json.dumps(state) for value in ("private token", "C:/account", "do-not-send", "executor_id"): self.assertNotIn(value, encoded) def test_corrupt_large_or_wrong_type_control_files_are_ignored(self): self.root.mkdir() for content in ("not json", "[]", '"wrong type"', "x" * 65537): with self.subTest(content=content[:20]): (self.root / "update-check.json").write_text(content, encoding="utf-8") (self.root / "update-request.json").write_text(content, encoding="utf-8") (self.root / "updater-status.json").write_text(content, encoding="utf-8") self.assertEqual(self.service.status()["status"], "unchecked") def test_official_fetch_uses_fixed_url_bounded_body_no_redirects(self): class Reply: def __enter__(self): return self def __exit__(self, *args): pass def read(self, size): self_size.append(size) return b'[{"tag_name":"v1.2.0","draft":false,"prerelease":false}]' self_size = [] self.github.stop() with patch.object(updates, "build_opener") as build: build.return_value.open.return_value = Reply() result = updates.github_releases() self.assertEqual(result[0]["tag_name"], "v1.2.0") request = build.return_value.open.call_args.args[0] self.assertEqual(request.full_url, updates.RELEASES_API + "?per_page=100&page=1") self.assertIsInstance(build.call_args.args[0], updates._NoRedirect) self.assertEqual(self_size, [2 * 1024 * 1024 + 1]) if __name__ == "__main__": unittest.main()