Add Web 2 workspace and controlled deployment updates

This commit is contained in:
AttilaNet
2026-11-10 16:33:14 +08:00
parent 7fe4c0ffdf
commit dbb31707ea
58 changed files with 11283 additions and 0 deletions
+216
View File
@@ -0,0 +1,216 @@
"""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)
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()