217 lines
11 KiB
Python
217 lines
11 KiB
Python
"""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()
|