release: prepare Web 2.0.1 automatic strategies and private updates

This commit is contained in:
AttilaNet
2026-11-11 12:52:08 +08:00
parent 5b1ef25048
commit 533280e007
30 changed files with 1177 additions and 107 deletions
@@ -14,7 +14,7 @@ from unittest.mock import patch
from urllib.parse import urlsplit
from ranch_assistant.model import Catalog
from ranch_web.policies import default_config
from ranch_web.policies import default_config, export_config
from ranch_web.views import build_view, schema
from . import test_workbench_browser as fixtures
@@ -68,6 +68,7 @@ class AutoReloginBrowserTests(unittest.TestCase):
fixtures.WorkbenchBrowserTests.setUp(self)
self.context.set_default_timeout(5000)
self.external_requests, self.unexpected_actions, self.writes, self.actions = [], [], [], []
self.action_handlers = {}
self.view_calls = 0
self.configs, self.summaries, self.login_data = {}, {}, {}
engine = SimpleNamespace(catalog=Catalog(), snapshot=None, demo=False)
@@ -112,6 +113,10 @@ class AutoReloginBrowserTests(unittest.TestCase):
if path.startswith(prefix + "/actions/"):
operation = path.rsplit("/", 1)[-1]
self.actions.append((identifier, operation, request.post_data_json))
handler = self.action_handlers.get((identifier, operation))
if handler:
self.fulfill(route, handler(request.post_data_json))
return
if operation != "logout":
self.unexpected_actions.append(operation)
route.abort()
@@ -132,7 +137,7 @@ class AutoReloginBrowserTests(unittest.TestCase):
def tearDown(self):
try:
self.assertEqual(self.external_requests, [])
self.assertEqual(self.unexpected_actions, [], "UI must never initiate game login or start strategies")
self.assertEqual(self.unexpected_actions, [], "UI must only submit explicitly requested fixture actions")
self.assertEqual(self.errors, [])
finally:
fixtures.WorkbenchBrowserTests.tearDown(self)
@@ -155,6 +160,11 @@ class AutoReloginBrowserTests(unittest.TestCase):
self.page.wait_for_function("() => document.querySelector('#save-status').textContent === '策略已自动保存'")
self.assertEqual(self.configs[identifier]["auto_relogin"], {"enabled": enabled, "delay_minutes": minutes})
def complete_login(self, operation, *, running=True):
self.summaries[self.first].update(connected=True, connection_state="online",
connection_message="游戏连接正常", error="", running=running)
return {"id": "mock-" + operation, "operation": operation, "status": "succeeded", "result": {}}
def test_defaults_visible_explanations_and_existing_layout(self):
self.open()
panel = self.go("login")
@@ -164,7 +174,7 @@ class AutoReloginBrowserTests(unittest.TestCase):
expect(delay).to_have_value("30")
for attribute, value in (("min", "1"), ("max", "10080"), ("step", "1")):
expect(delay).to_have_attribute(attribute, value)
for text in ("服务端", "记住账号和密码", "原区服", "角色", "恢复监控", "策略保持停止", "关闭页面", "服务重启"):
for text in ("服务端", "记住账号和密码", "原区服", "角色", "恢复监控", "自动执行已勾选功能", "顶部“停止”", "关闭页面", "服务重启"):
expect(panel).to_contain_text(text)
self.assertTrue(enabled.evaluate("node => Boolean(node.closest('.policy-form'))"))
self.assertTrue(enabled.evaluate("node => Boolean(node.compareDocumentPosition(document.querySelector('.login-layout')) & Node.DOCUMENT_POSITION_FOLLOWING)"))
@@ -176,6 +186,131 @@ class AutoReloginBrowserTests(unittest.TestCase):
self.assertEqual(self.writes, [])
self.assertEqual(self.actions, [])
def test_server_candidates_wait_for_role_then_run_only_selected_features_and_allow_stop(self):
self.configs[self.first]["daily_policy"].update(enabled=True, selected=["gift"])
original = copy.deepcopy(self.configs[self.first])
candidates = {"servers": [{"id": 7, "name": "离线测试区", "role_name": "离线角色"}]}
def login(payload):
self.login_data[self.first].update(candidates)
return {"id": "mock-login", "operation": "login", "status": "succeeded", "result": candidates}
def stop(payload):
self.summaries[self.first]["running"] = False
return {"id": "mock-stop", "operation": "stop", "status": "succeeded", "result": {"message": "策略已停止"}}
self.action_handlers.update({(self.first, "login"): login,
(self.first, "enter_server"): lambda payload: self.complete_login("enter_server"),
(self.first, "stop"): stop})
self.open()
panel = self.go("login")
panel.get_by_label("游戏账号", exact=True).fill("offline-role-test")
panel.get_by_label("游戏密码", exact=True).fill("synthetic-password")
panel.get_by_role("button", name="账号密码登录 / 获取区服", exact=True).click()
expect(panel.get_by_label("区服 / 角色", exact=True)).to_contain_text("离线测试区")
expect(self.page.locator("#connection")).to_have_text("游戏离线")
toggle = self.page.locator("#strategy-toggle")
expect(toggle).to_have_text("开启")
expect(toggle).to_be_disabled()
expect(self.page.locator("#notice")).to_be_hidden()
self.assertFalse(self.summaries[self.first]["running"])
panel.get_by_role("button", name="进入选中区服", exact=True).click()
expect(toggle).to_have_text("停止")
expect(toggle).to_have_attribute("aria-pressed", "true")
expect(self.page.locator("#notice")).to_contain_text("已自动开启策略")
expect(self.page.locator("#status-text")).to_contain_text("已配置且已勾选的功能")
expect(self.page.locator("#data-summary")).to_contain_text("顶部“停止”")
expect(self.page.locator("#page-tabs [role=tab]")).to_have_count(15)
self.assertEqual(self.configs[self.first], original, "Logging in must preserve every feature selection")
toggle.click()
expect(toggle).to_have_text("开启")
expect(self.page.locator("#data-summary")).to_contain_text("策略已停止")
self.assertEqual([operation for _, operation, _ in self.actions], ["login", "enter_server", "stop"])
self.assertEqual(self.actions[1][2], {"server_id": "7"})
self.assertEqual(self.configs[self.first], original)
self.assertEqual(self.writes, [])
def test_import_stays_stopped_and_next_restored_session_runs_imported_selection(self):
imported = copy.deepcopy(default_config())
imported["daily_policy"].update(enabled=True, selected=["gift"])
portable = export_config(imported)
imports = []
self.login_data[self.first]["saved_sessions"] = [{"id": "offline-session", "label": "离线区服 / 原角色"}]
self.action_handlers[(self.first, "restore_session")] = lambda payload: self.complete_login("restore_session")
def import_config(route):
imports.append(route.request.post_data_json)
self.configs[self.first] = copy.deepcopy(imported)
self.summaries[self.first]["running"] = False
self.summaries[self.first]["revision"] += 1
self.fulfill(route, {"id": "mock-import", "operation": "import_config", "status": "succeeded", "result": {}})
self.page.route(f"**/api/accounts/{self.first}/config/import", import_config)
self.open()
panel = self.go("login")
self.page.locator('.menu > summary').nth(2).click()
with self.page.expect_file_chooser() as chooser:
self.page.locator('[data-command="import-config"]').click()
chooser.value.set_files({"name": "offline-policy.json", "mimeType": "application/json",
"buffer": json.dumps(portable).encode("utf-8")})
expect(self.page.locator("#dialog-content")).to_contain_text("下次成功登录会自动执行已勾选功能")
self.page.locator("#dialog-confirm").click()
expect(self.page.locator("#notice")).to_contain_text("策略已导入,执行已停止")
expect(self.page.locator("#strategy-toggle")).to_be_disabled()
self.assertEqual(imports, [portable])
self.assertEqual(self.actions, [])
panel.get_by_role("button", name="恢复选中会话(无需重新输密码)", exact=True).click()
expect(self.page.locator("#strategy-toggle")).to_have_text("停止")
expect(self.page.locator("#notice")).to_contain_text("已自动开启策略")
self.assertEqual(self.actions, [(self.first, "restore_session", {"session_id": "offline-session"})])
self.assertEqual(self.configs[self.first], imported, "Restoring must preserve imported selections")
self.assertEqual(self.writes, [])
def test_failed_candidates_and_disconnected_success_jobs_never_report_login_success(self):
self.login_data[self.first].update(servers=[{"id": 7, "name": "候选区服"}],
saved_sessions=[{"id": "offline-session", "label": "候选角色"}])
for operation, label in (("enter_server", "进入选中区服"), ("restore_session", "恢复选中会话(无需重新输密码)")):
for job_status in ("failed", "succeeded"):
with self.subTest(operation=operation, job_status=job_status):
self.action_handlers[(self.first, operation)] = lambda payload, op=operation, status=job_status: {
"id": "mock-candidate", "operation": op, "status": status,
"error": "候选角色验证失败", "result": {"message": "候选声称登录成功"}}
self.open()
panel = self.go("login")
self.page.evaluate("""() => {
window.loginFeedback = [];
new MutationObserver(() => {
for (const id of ['status-text', 'notice']) {
const node = document.getElementById(id);
if (node && !node.hidden) window.loginFeedback.push(node.textContent);
}
}).observe(document.body, {subtree:true, childList:true, characterData:true,
attributes:true, attributeFilter:['hidden']});
}""")
panel.get_by_role("button", name=label, exact=True).click()
expect(self.page.locator("#notice.error")).to_be_visible()
expect(self.page.locator("#notice")).to_contain_text("候选角色验证失败" if job_status == "failed" else "尚未连接游戏")
expect(self.page.locator("#connection")).to_have_text("游戏离线")
expect(self.page.locator("#strategy-toggle")).to_be_disabled()
feedback = "\n".join(self.page.evaluate("window.loginFeedback"))
for false_success in ("已完成", "已读取角色", "已自动开启策略", "候选声称登录成功"):
self.assertNotIn(false_success, feedback)
self.assertNotIn("start", [operation for _, operation, _ in self.actions])
self.assertEqual(self.writes, [])
def test_stop_after_restore_is_shown_from_confirmed_server_status(self):
self.login_data[self.first]["saved_sessions"] = [{"id": "offline-session", "label": "离线角色"}]
self.action_handlers[(self.first, "restore_session")] = lambda payload: self.complete_login("restore_session", running=False)
self.open()
panel = self.go("login")
panel.get_by_role("button", name="恢复选中会话(无需重新输密码)", exact=True).click()
expect(self.page.locator("#connection")).to_have_text("已登录")
expect(self.page.locator("#notice")).to_contain_text("策略已停止")
expect(self.page.locator("#notice")).not_to_contain_text("已自动开启")
expect(self.page.locator("#data-summary")).to_contain_text("策略已停止")
expect(self.page.locator("#strategy-toggle")).to_have_text("开启")
self.assertEqual(self.actions, [(self.first, "restore_session", {"session_id": "offline-session"})])
def test_native_autosave_range_validation_refresh_and_focus(self):
self.open()
panel = self.go("login")
@@ -286,10 +421,14 @@ class AutoReloginBrowserTests(unittest.TestCase):
self.set_status(self.first, "failed", reason)
expect(status).to_contain_text(reason)
expect(status.locator("img")).to_have_count(0)
self.set_status(self.first, "monitoring", "重登成功,已恢复监控,策略保持停止")
self.summaries[self.first].update(connected=True, connection_state="online", connection_message="游戏连接正常", running=False)
expect(status).to_contain_text("已恢复监控,策略保持停止")
expect(self.page.locator("#strategy-toggle")).to_have_text("开启")
expect(self.page.locator("#strategy-toggle")).to_be_disabled()
original = copy.deepcopy(self.configs[self.first])
self.set_status(self.first, "monitoring", "重登成功,已恢复监控并自动执行已勾选功能,可在顶部停止")
self.summaries[self.first].update(connected=True, connection_state="online", connection_message="游戏连接正常", running=True)
expect(status).to_contain_text("已恢复监控并自动执行已勾选功能")
expect(self.page.locator("#strategy-toggle")).to_have_text("停止")
expect(self.page.locator("#data-summary")).to_contain_text("正在自动执行已配置且已勾选的功能")
self.assertEqual(self.configs[self.first], original)
self.assertEqual(self.actions, [])
def test_restart_wait_persists_across_reload_and_closing_page_has_no_actions(self):
@@ -297,12 +436,15 @@ class AutoReloginBrowserTests(unittest.TestCase):
self.open()
panel = self.go("login")
expect(panel.locator("[data-auto-relogin-status]")).to_contain_text("服务重启")
expect(self.page.locator("#strategy-toggle")).to_be_disabled()
before = len(self.writes)
self.page.reload(wait_until="networkidle")
panel = self.go("login")
expect(self.controls(panel)[0]).to_be_checked()
expect(self.controls(panel)[1]).to_have_value("30")
expect(panel.locator("[data-auto-relogin-countdown]")).to_contain_text("秒后自动重新登录")
expect(self.page.locator("#strategy-toggle")).to_have_text("开启")
expect(self.page.locator("#strategy-toggle")).to_be_disabled()
self.page.goto("about:blank")
self.page.close()
self.assertEqual(len(self.writes), before)
@@ -283,6 +283,8 @@ class WorkbenchBrowserTests(unittest.TestCase):
def test_fake_login_uses_servers_without_persisting_password(self):
payloads = []
summary = copy.deepcopy(self.manager.status(self.first))
summary.update(demo=False, connected=False, running=False, connection_state="offline", connection_message="尚未连接游戏")
login_result = {"servers": [{"id": 7, "name": "测试区", "role_name": "测试角色"}], "has_saved_password": True}
def route_login(route):
payloads.append(route.request.post_data_json)
@@ -294,12 +296,16 @@ class WorkbenchBrowserTests(unittest.TestCase):
self.fulfill(route, response)
self.page.route(f"**/api/accounts/{self.first}/actions/login", route_login)
self.page.route(f"**/api/accounts/{self.first}/views/login?*", route_login_view)
self.page.route("**/api/accounts", lambda route: self.fulfill(route, [summary, self.manager.status(self.second)]))
self.page.route(f"**/api/accounts/{self.first}/status", lambda route: self.fulfill(route, summary))
self.open()
panel = self.go("login")
panel.get_by_label("游戏账号", exact=True).fill("offline-test")
panel.get_by_label("游戏密码", exact=True).fill("test-password-never-persist")
panel.get_by_role("button", name="账号密码登录 / 获取区服", exact=True).click()
expect(panel.get_by_label('区服 / 角色',exact=True)).to_contain_text('测试区')
expect(self.page.locator('#connection')).to_have_text('游戏离线')
expect(self.page.locator('#strategy-toggle')).to_be_disabled()
self.assertEqual(payloads[0], {"account": "offline-test", "password": "test-password-never-persist", "remember": True})
self.assertEqual(panel.get_by_label("游戏密码", exact=True).input_value(), "")
self.assertEqual(self.page.evaluate("Object.keys(localStorage).length + Object.keys(sessionStorage).length"), 0)
+92 -2
View File
@@ -32,6 +32,7 @@ class AutoReloginTests(unittest.TestCase):
idle = fixtures.ServiceTests.idle
job = fixtures.ServiceTests.job
login = fixtures.ServiceTests.login
enable = fixtures.ServiceTests.enable
def connected(self, *, remember=True, server=2, account=None):
self.manager.login_factory = AutoLogin
@@ -79,6 +80,8 @@ class AutoReloginTests(unittest.TestCase):
def test_first_expiry_deadline_survives_idle_refresh_and_duplicate_ticks(self):
identifier, worker = self.connected()
self.enable(identifier)
selected = deepcopy(worker.config)
identity = worker.active_identity
self.disconnect(identifier, worker)
status = self.auto_status(identifier)
@@ -92,13 +95,17 @@ class AutoReloginTests(unittest.TestCase):
self.assertEqual(self.auto_status(identifier)["next_attempt_at"], status["next_attempt_at"])
self.assertEqual(len(AutoLogin.calls), before)
self.now += 1
self.tick(identifier, worker)
result = self.tick(identifier, worker)["result"]
self.assertEqual(len(AutoLogin.calls), before + 1)
self.assertEqual(worker.active_identity, identity)
self.assertEqual(worker.engine.client.session.server_id, 2)
self.assertEqual(worker.engine.client.session.role_id, 102)
self.assertTrue(self.manager.status(identifier)["connected"])
self.assertFalse(self.manager.status(identifier)["running"])
self.assertTrue(self.manager.status(identifier)["running"])
self.assertTrue(worker.engine.auto)
self.assertTrue(result["running"])
self.assertIn("已勾选", result["message"])
self.assertEqual(worker.config, selected)
self.assertTrue(worker.schedule.monitoring)
self.assertIsNone(self.auto_status(identifier)["next_attempt_at"])
for _ in range(3):
@@ -201,6 +208,8 @@ class AutoReloginTests(unittest.TestCase):
with patch.object(AutoLogin, "authenticate", wrong):
self.tick(identifier, worker)
self.assertFalse(self.manager.status(identifier)["connected"])
self.assertFalse(worker.running)
self.assertFalse(worker.engine.auto)
self.assertFalse(any(url.endswith("userServerService/enterGame")
for _, url, _ in fixtures.FakeClient.calls[before:]))
self.assertEqual(self.auto_status(identifier)["state"], "failed")
@@ -239,6 +248,8 @@ class AutoReloginTests(unittest.TestCase):
def test_portable_import_preserves_local_login_preference(self):
identifier, worker = self.connected()
self.enable(identifier)
self.job(identifier, self.manager.submit(identifier, "start"))
portable = export_config(default_config(), worker.engine.snapshot)
self.job(identifier, self.manager.submit(identifier, "import_config", {"config": portable}))
self.assertEqual(self.manager.get_config(identifier)["config"]["auto_relogin"],
@@ -246,6 +257,85 @@ class AutoReloginTests(unittest.TestCase):
public = json.dumps(self.manager.get_config(identifier)) + json.dumps(export_config(worker.config))
self.assertNotIn("synthetic-password", public)
self.assertNotIn("synthetic-center-token", public)
self.assertFalse(worker.running)
self.assertFalse(worker.engine.auto)
def test_restart_opt_in_activates_after_thirty_minutes_and_supersedes_old_stop(self):
identifier, worker = self.connected()
self.enable(identifier)
self.configure(identifier, delay=30)
self.manager.submit(identifier, "stop")
selected = deepcopy(worker.config)
self.manager.close()
before = len(AutoLogin.calls), len(fixtures.FakeClient.calls)
self.manager = WebManager(self.root, start_scheduler=False, login_factory=AutoLogin)
self.addCleanup(self.manager.close)
self.idle(identifier)
worker = self.manager._worker(identifier)
self.assertFalse(worker.running)
self.assertFalse(worker.engine.auto)
self.assertIsNone(worker.engine.client)
self.assertEqual((len(AutoLogin.calls), len(fixtures.FakeClient.calls)), before)
origin = worker.schedule.disconnected_at
worker.schedule.clock = lambda: self.now
self.now = origin + 1799
self.tick(identifier, worker)
self.assertFalse(worker.running)
self.assertEqual(len(AutoLogin.calls), before[0])
self.now = origin + 1800
result = self.tick(identifier, worker)["result"]
self.assertTrue(result["connected"])
self.assertTrue(result["running"])
self.assertTrue(worker.running)
self.assertTrue(worker.engine.auto)
self.assertEqual(worker.config, selected)
self.assertEqual(len(AutoLogin.calls), before[0] + 1)
def test_final_activation_revocation_never_starts_relogin_candidate(self):
for operation in ("stop", "logout", "forget_login", "policy", "disable", "delay"):
with self.subTest(operation=operation):
identifier, worker = self.connected()
self.enable(identifier)
self.disconnect(identifier, worker)
original_client = worker.engine.client
identity = worker.active_identity
entered, release = threading.Event(), threading.Event()
self.addCleanup(release.set)
original = worker.securestore.set_active
def held(active):
if active == identity and not release.is_set():
entered.set()
if not release.wait(5):
raise AssertionError("Relogin activation gate not released")
return original(active)
self.now += 60
before = self.manager.logs(identifier)["next"]
with patch.object(worker.securestore, "set_active", side_effect=held):
candidate = worker.enqueue("__tick")
self.assertTrue(entered.wait(2))
if operation in {"stop", "logout", "forget_login"}:
followup = self.manager.submit(identifier, operation)
else:
config = self.manager.get_config(identifier)["config"]
if operation == "policy":
config["daily_policy"]["enabled"] = False
else:
config["auto_relogin"].update(enabled=operation != "disable", delay_minutes=2)
followup = self.manager.set_config(identifier, config)["job"]
self.assertFalse(worker.running)
release.set()
self.job(identifier, candidate, status="cancelled")
self.job(identifier, followup)
self.assertFalse(worker.running)
self.assertFalse(worker.engine.auto)
if operation in {"logout", "forget_login"}:
self.assertIsNone(worker.engine.client)
else:
self.assertIs(worker.engine.client, original_client)
self.assertFalse(any("已自动开启" in row["message"]
for row in self.manager.logs(identifier, after=before)["entries"]))
def test_restart_opt_in_waits_and_logout_disarms_restart(self):
identifier, worker = self.connected()
+22 -1
View File
@@ -31,6 +31,8 @@ class ConnectionStateTests(unittest.TestCase):
if running:
self.enable(identifier)
self.job(identifier, self.manager.submit(identifier, "start"))
else:
self.manager.submit(identifier, "stop")
return identifier, worker
def tick(self, identifier, worker, *, status="succeeded"):
@@ -70,7 +72,26 @@ class ConnectionStateTests(unittest.TestCase):
self.assertIsNotNone(worker.securestore.load(worker.active_identity))
self.job(identifier, self.manager.submit(identifier, "restore_session", {"session_id": worker.active_identity}))
self.assertEqual(self.manager.status(identifier)["connection_state"], "online")
self.assertFalse(self.manager.status(identifier)["running"])
self.assertTrue(self.manager.status(identifier)["running"])
self.assertTrue(worker.engine.auto)
def test_explicit_stop_survives_heartbeat_local_refresh_and_monitor_until_login(self):
identifier, worker = self.connected(running=True)
self.manager.submit(identifier, "stop")
worker.engine.last_heartbeat = 0
result = self.tick(identifier, worker)["result"]
self.assertEqual(result["kind"], "heartbeat")
self.job(identifier, self.manager.submit(identifier, "refresh", {"page": "statistics"}))
self.job(identifier, self.manager.submit(identifier, "refresh"))
worker.schedule.next_poll = 0
self.tick(identifier, worker)
self.assertFalse(worker.running)
self.assertFalse(worker.engine.auto)
self.assertTrue(self.manager.status(identifier)["connected"])
result = self.job(identifier, self.manager.submit(identifier, "restore_session", {
"session_id": worker.active_identity}))["result"]
self.assertTrue(result["running"])
self.assertTrue(worker.engine.auto)
def test_timeout_retries_only_snapshot_and_keeps_uncertain_write_evidence(self):
identifier, worker = self.connected(running=True)
+195
View File
@@ -0,0 +1,195 @@
"""Private release transport checks using fake HTTP only, never user credentials."""
from contextlib import contextmanager
from email.message import Message
import io
import json
import os
from pathlib import Path
import tempfile
import traceback
import unittest
from unittest.mock import patch
from urllib.error import HTTPError, URLError
from urllib.request import HTTPSHandler, build_opener
from urllib.response import addinfourl
from ranch_web import updates
TOKEN = "github_pat_offline_test_secret"
RELEASES = [{"tag_name": "v2.0.1", "draft": False, "prerelease": False}]
class PrivateReleaseTests(unittest.TestCase):
def setUp(self):
temporary = tempfile.TemporaryDirectory(prefix="private-release-test-")
self.addCleanup(temporary.cleanup)
self.root = Path(temporary.name)
self.token_path = self.root / updates.TOKEN_FILE_NAME
environment = patch.dict(os.environ, {"RANCH_WEB_UPDATER_DIR": ""})
environment.start()
self.addCleanup(environment.stop)
os.environ.pop(updates.TOKEN_FILE_ENV, None)
network = patch("socket.socket.connect", side_effect=AssertionError("Live network forbidden"))
network.start()
self.addCleanup(network.stop)
def token(self, payload=None):
self.token_path.write_bytes(payload if payload is not None else (TOKEN + "\n").encode("ascii"))
self.token_path.chmod(0o600)
@contextmanager
def transport(self, body=None):
payload = body if body is not None else json.dumps(RELEASES).encode("ascii")
with patch.object(updates, "build_opener") as build:
build.return_value.open.side_effect = lambda *args, **kwargs: io.BytesIO(payload)
yield build
def test_missing_default_retains_public_and_no_argument_api(self):
with self.transport() as build:
self.assertEqual(updates.github_releases(), RELEASES)
self.assertEqual(updates.github_releases(self.root), RELEASES)
for call in build.return_value.open.call_args_list:
self.assertIsNone(call.args[0].get_header("Authorization"))
def test_shared_file_adds_auth_only_to_fixed_github_endpoint(self):
self.token()
with self.transport() as build:
self.assertEqual(updates.github_releases(self.root), RELEASES)
request = build.return_value.open.call_args.args[0]
self.assertEqual(request.full_url, updates.RELEASES_API + "?per_page=100&page=1")
self.assertEqual(request.get_header("Authorization"), "Bearer " + TOKEN)
self.assertIsInstance(build.call_args.args[0], updates._NoRedirect)
def test_absolute_override_is_a_file_and_takes_precedence(self):
self.token(b"ignored_default\n")
alternate = self.root / "alternate-token"
alternate.write_text(TOKEN, encoding="ascii")
alternate.chmod(0o600)
os.environ[updates.TOKEN_FILE_ENV] = str(alternate)
with self.transport() as build:
updates.github_releases(self.root)
self.assertEqual(build.return_value.open.call_args.args[0].get_header("Authorization"), "Bearer " + TOKEN)
def test_invalid_explicit_file_never_falls_back_or_exposes_path(self):
for value in ("", TOKEN, str(self.root / "missing-private-token")):
with self.subTest(value=value), self.transport() as build:
os.environ[updates.TOKEN_FILE_ENV] = value
with self.assertRaises(updates.GitHubReleaseError) as caught:
updates.github_releases(self.root)
self.assertEqual(caught.exception.code, "token_file_invalid")
self.assertNotIn(TOKEN, str(caught.exception))
self.assertNotIn(str(self.root), str(caught.exception))
build.assert_not_called()
def test_malformed_empty_large_and_header_injection_tokens_rejected(self):
for payload in (b"", b"bad token", b"token\r\nInjected: secret", b"\xff", b"a" * 4097):
with self.subTest(payload=payload[:20]), self.transport() as build:
self.token(payload)
with self.assertRaises(updates.GitHubReleaseError):
updates.github_releases(self.root)
build.assert_not_called()
def test_hard_link_token_rejected(self):
self.token()
os.link(self.token_path, self.root / "token-hardlink")
with self.transport() as build, self.assertRaises(updates.GitHubReleaseError):
updates.github_releases(self.root)
build.assert_not_called()
def test_symlink_even_to_missing_file_rejected(self):
try:
self.token_path.symlink_to(self.root / "missing-target")
except OSError:
self.skipTest("Symlinks unavailable for this test user")
with self.transport() as build, self.assertRaises(updates.GitHubReleaseError):
updates.github_releases(self.root)
build.assert_not_called()
@unittest.skipUnless(os.name == "posix", "POSIX permission check")
def test_readable_by_group_or_others_is_not_accepted(self):
self.token()
for mode in (0o644, 0o640, 0o400, 0o660):
self.token_path.chmod(mode)
with self.subTest(mode=mode), self.transport() as build, self.assertRaises(updates.GitHubReleaseError):
updates.github_releases(self.root)
build.assert_not_called()
def test_file_permission_errors_are_fixed_and_secret_free(self):
with patch.object(updates.os, "open", side_effect=PermissionError(TOKEN)), self.transport() as build:
with self.assertRaises(updates.GitHubReleaseError) as caught:
updates.github_releases(self.root)
self.assertNotIn(TOKEN, str(caught.exception))
build.assert_not_called()
def test_http_access_errors_with_and_without_token_are_not_no_release(self):
service = updates.UpdateService(self.root, "2.0.0")
for authenticated in (False, True):
if authenticated:
self.token()
for status in (401, 403, 404):
with self.subTest(authenticated=authenticated, status=status), self.transport() as build:
build.return_value.open.side_effect = HTTPError(updates.RELEASES_API, status, TOKEN, {}, io.BytesIO(TOKEN.encode()))
state = service.check()
self.assertEqual(state["status"], "check_failed")
self.assertIn("权限", state["message"])
self.assertFalse(state["available"])
self.assertFalse(state["can_apply"])
self.assertIsNone(state["latest_version"])
self.assertNotIn(TOKEN, json.dumps(state))
self.assertNotIn(TOKEN, (self.root / "update-check.json").read_text(encoding="utf-8"))
def test_untrusted_response_and_network_exception_are_sanitized(self):
self.token()
for body in (TOKEN.encode(), json.dumps({"error": TOKEN}).encode()):
with self.subTest(body=body), self.transport(body):
with self.assertRaises(updates.GitHubReleaseError) as caught:
updates.github_releases(self.root)
self.assertNotIn(TOKEN, "".join(traceback.format_exception(caught.exception)))
with self.transport() as build:
build.return_value.open.side_effect = URLError(TOKEN)
with self.assertRaises(updates.GitHubReleaseError) as caught:
updates.github_releases(self.root)
self.assertNotIn(TOKEN, "".join(traceback.format_exception(caught.exception)))
def test_redirect_responses_never_issue_a_second_request(self):
self.token()
requests = []
class RedirectTransport(HTTPSHandler):
def https_open(self, request):
requests.append(request)
headers = Message()
headers["Location"] = destination
response = addinfourl(io.BytesIO(b""), headers, request.full_url, status)
response.msg = "redirect"
return response
for destination in ("https://evil.invalid/" + TOKEN, updates.RELEASES_API + "/redirect"):
for status in (301, 302, 303, 307, 308):
requests.clear()
opener = build_opener(updates._NoRedirect(), RedirectTransport())
with self.subTest(destination=destination, status=status), patch.object(updates, "build_opener", return_value=opener):
with self.assertRaises(updates.GitHubReleaseError) as caught:
updates.github_releases(self.root)
self.assertEqual(len(requests), 1)
self.assertNotIn(TOKEN, str(caught.exception))
def test_untrusted_endpoint_is_rejected_before_loading_credentials(self):
for endpoint in ("https://evil.invalid/releases", "http://api.github.com/repos/attilanet/myrzx_bot/releases",
updates.RELEASES_API + "?redirect=bad", "https://api.github.com@evil.invalid/releases"):
with self.subTest(endpoint=endpoint), patch.object(updates, "RELEASES_API", endpoint), patch.object(updates, "_github_token") as read:
with self.assertRaises(updates.GitHubReleaseError):
updates.github_releases(self.root)
read.assert_not_called()
def test_cache_cannot_inject_freeform_failure_message(self):
for failure in (TOKEN, [TOKEN], {TOKEN: TOKEN}):
updates.atomic_json(self.root / "update-check.json", {"status": "check_failed", "failure": failure})
state = updates.UpdateService(self.root, "2.0.0").status()
self.assertEqual(state["status"], "check_failed")
self.assertNotIn(TOKEN, json.dumps(state))
if __name__ == "__main__":
unittest.main()
+126 -2
View File
@@ -143,7 +143,7 @@ class ServiceTests(unittest.TestCase):
status = self.manager.status(identifier)
self.assertTrue(status["connected"])
self.assertFalse(status["demo"])
self.assertFalse(status["running"])
self.assertTrue(status["running"])
worker = self.manager._worker(identifier)
identity = worker.active_identity
before = worker.securestore.load(identity).reqid
@@ -161,7 +161,131 @@ class ServiceTests(unittest.TestCase):
self.job(identifier, self.manager.submit(identifier, "restore_session", {"session_id": identity}))
restored = self.manager._worker(identifier).securestore.load(identity)
self.assertGreater(restored.reqid, before)
self.assertFalse(self.manager.status(identifier)["running"])
self.assertTrue(self.manager.status(identifier)["running"])
self.assertTrue(self.manager._worker(identifier).engine.auto)
def test_verified_login_starts_only_saved_selections_after_server_activation(self):
identifier = self.account(False)
self.login(identifier)
self.enable(identifier)
selected = deepcopy(self.manager.get_config(identifier)["config"])
self.job(identifier, self.manager.submit(identifier, "logout"))
before = len(FakeClient.calls)
self.job(identifier, self.manager.submit(identifier, "login", {
"account": "synthetic-owner", "password": "synthetic-password"}))
worker = self.manager._worker(identifier)
self.assertFalse(worker.running, "SDK server discovery activated strategies")
self.assertFalse(worker.engine.auto)
self.assertIsNone(worker.engine.client)
result = self.job(identifier, self.manager.submit(identifier, "enter_server", {"server_id": 1}))["result"]
self.assertTrue(result["connected"])
self.assertTrue(result["running"])
self.assertTrue(worker.engine.auto)
self.assertEqual(worker.config, selected, "Login changed the user's strategy selections")
self.assertIn("已勾选", result["message"])
self.assertEqual(self.manager.logs(identifier)["entries"][-1]["message"], result["message"])
self.assertEqual([url.rsplit("/", 2)[-2:] for _, url, _ in FakeClient.calls[before:]],
[["userServerService", "enterGame"], ["masterService", "masterQueryDetail"]])
def test_login_without_selected_rules_stays_enabled_and_later_selections_take_effect(self):
identifier = self.account(False)
self.job(identifier, self.manager.submit(identifier, "login", {
"account": "synthetic-owner", "password": "synthetic-password"}))
worker = self.manager._worker(identifier)
selected = deepcopy(worker.config)
result = self.job(identifier, self.manager.submit(identifier, "enter_server", {"server_id": 1}))["result"]
self.assertTrue(result["connected"])
self.assertTrue(result["running"])
self.assertTrue(worker.engine.auto)
self.assertEqual(worker.config, selected)
self.assertIn("已勾选", result["message"])
self.assertEqual(worker.engine.plans(), [])
before = len(FakeClient.calls)
worker.engine.last_heartbeat = worker.schedule.clock()
worker.schedule.next_poll = 0
self.job(identifier, worker.enqueue("__tick"))
self.assertTrue(worker.running)
self.assertTrue(worker.engine.auto)
self.assertTrue(all(url.endswith("masterService/masterQueryDetail")
for _, url, _ in FakeClient.calls[before:]))
self.enable(identifier)
self.assertTrue(worker.running)
self.assertTrue(worker.engine.auto)
self.assertTrue(worker.engine.daily_policy.enabled)
def test_restore_with_unknown_write_keeps_evidence_and_never_replays(self):
identifier = self.account(False)
self.login(identifier)
self.enable(identifier)
worker = self.manager._worker(identifier)
journal = worker.engine.battle_journal
pending = journal.begin(worker.engine.snapshot, {"kind": "battle", "description": "未确认战斗",
"path": "stageService/stageStart", "payload": {}, "stage_id": "0101", "difficulty": "1"})
journal.update(pending, "unknown", message="已有未确认请求,禁止重发")
evidence = journal.path.read_bytes()
before = len(FakeClient.calls)
result = self.job(identifier, self.manager.submit(identifier, "restore_session", {
"session_id": worker.active_identity}))["result"]
self.assertTrue(result["connected"])
self.assertFalse(result["running"])
self.assertFalse(worker.engine.auto)
self.assertIn("核对", result["message"])
self.assertEqual(journal.path.read_bytes(), evidence)
self.job(identifier, self.manager.submit(identifier, "start"), status="failed")
worker.engine.last_heartbeat = worker.schedule.clock()
self.job(identifier, worker.enqueue("__tick"))
self.assertEqual(worker.engine.battle_journal.pending(worker.engine.snapshot)["attempt_id"], pending["attempt_id"])
self.assertEqual(journal.path.read_bytes(), evidence)
self.assertTrue(all(url.endswith(("masterService/masterQueryDetail", "heartBeatService/keepAlive"))
for _, url, _ in FakeClient.calls[before:]))
def test_activation_persistence_can_be_revoked_before_final_commit(self):
for operation in ("enter_server", "restore_session"):
for revoke in ("stop", "logout", "forget_login", "config"):
with self.subTest(operation=operation, revoke=revoke):
identifier = self.account(False)
self.login(identifier, account="owner-" + identifier)
self.enable(identifier)
worker = self.manager._worker(identifier)
original_client = worker.engine.client
identity = worker.active_identity
if operation == "enter_server":
self.job(identifier, self.manager.submit(identifier, "login", {
"account": "owner-" + identifier, "password": "synthetic-password"}))
entered, release = threading.Event(), threading.Event()
self.addCleanup(release.set)
original = worker.securestore.set_active
def held(active):
if active == identity and not release.is_set():
entered.set()
if not release.wait(5):
raise AssertionError("Activation gate not released")
return original(active)
payload = {"server_id": 1} if operation == "enter_server" else {"session_id": identity}
before = self.manager.logs(identifier)["next"]
with patch.object(worker.securestore, "set_active", side_effect=held):
candidate = self.manager.submit(identifier, operation, payload)
self.assertTrue(entered.wait(2))
if revoke == "config":
config = self.manager.get_config(identifier)["config"]
config["daily_policy"]["enabled"] = False
followup = self.manager.set_config(identifier, config)["job"]
else:
followup = self.manager.submit(identifier, revoke)
self.assertFalse(worker.running)
release.set()
self.job(identifier, candidate, status="cancelled")
self.job(identifier, followup)
self.assertFalse(worker.running)
self.assertFalse(worker.engine.auto)
if revoke in {"stop", "config"}:
self.assertIs(worker.engine.client, original_client)
else:
self.assertIsNone(worker.engine.client)
self.assertFalse(any("已自动开启" in row["message"]
for row in self.manager.logs(identifier, after=before)["entries"]))
def test_role_workspaces_do_not_copy_targets_or_other_profiles_overrides(self):
first, other = self.account(False), self.account()
+1
View File
@@ -24,6 +24,7 @@ class UpdateTests(unittest.TestCase):
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)
+98 -1
View File
@@ -88,11 +88,12 @@ class HostUpdaterTests(unittest.TestCase):
self.addCleanup(self.github.stop)
# Linux CI runs unprivileged; real chown is a host deployment check.
self.chown = patch.object(updater.os, "chown", create=True)
self.chown.start()
self.mock_chown = self.chown.start()
self.addCleanup(self.chown.stop)
self.environment = patch.dict(os.environ, {"RANCH_WEB_UPDATER_DIR": str(self.config.control_dir)})
self.environment.start()
self.addCleanup(self.environment.stop)
os.environ.pop(updates.TOKEN_FILE_ENV, None)
def samples(self, directory=None):
with closing(sqlite3.connect((directory or self.config.data_dir) / "samples.sqlite3")) as connection:
@@ -282,6 +283,102 @@ class HostUpdaterTests(unittest.TestCase):
result = updater.HostUpdater(config, self.docker).run()
self.assertEqual(result["status"], "succeeded")
def test_private_web_check_request_and_host_apply_each_reread_shared_token(self):
self.enable()
self.github.stop()
path = self.config.data_dir / updates.TOKEN_FILE_NAME
tokens = ["github_pat_offline_check", "github_pat_offline_request", "github_pat_offline_host"]
path.write_text(tokens[0], encoding="ascii")
path.chmod(0o600)
payload = json.dumps([release("v2.0.1")]).encode("ascii")
service = updates.UpdateService(self.config.data_dir, "2.0.0")
with patch.object(updates, "build_opener") as build:
build.return_value.open.side_effect = lambda *args, **kwargs: io.BytesIO(payload)
self.assertTrue(service.check()["available"])
path.write_text(tokens[1], encoding="ascii")
self.assertEqual(service.request_update("v2.0.1")["status"], "pending")
path.write_text(tokens[2], encoding="ascii")
self.assertEqual(self.host.run()["status"], "succeeded")
authorizations = [call.args[0].get_header("Authorization") for call in build.return_value.open.call_args_list]
self.assertEqual(authorizations, ["Bearer " + token for token in tokens])
for document in [*self.config.data_dir.glob("*.json"), *self.config.control_dir.glob("*.json")]:
for token in tokens:
self.assertNotIn(token, document.read_text(encoding="utf-8"))
def test_private_access_failure_blocks_web_request_and_host_before_pull(self):
from urllib.error import HTTPError
self.enable()
self.github.stop()
service = updates.UpdateService(self.config.data_dir, "2.0.0")
for status in (401, 403, 404):
with self.subTest(status=status), patch.object(updates, "build_opener") as build:
build.return_value.open.side_effect = HTTPError(updates.RELEASES_API, status, "private-secret", {}, None)
with self.assertRaises(ValueError) as web_error:
service.request_update("v2.0.1")
with self.assertRaises(updater.UpdaterError) as host_error:
self.host.apply("v2.0.1")
for error in (web_error.exception, host_error.exception):
self.assertIn("权限", str(error))
self.assertNotIn("private-secret", str(error))
self.assertFalse((self.config.data_dir / "update-request.json").exists())
self.assertFalse(self.host.journal.exists())
self.assertFalse(self.config.backup_dir.exists())
self.assertEqual(self.docker.events, [])
def test_health_failure_restores_shared_token_permissions(self):
path = self.config.data_dir / updates.TOKEN_FILE_NAME
path.write_text("github_pat_offline_before", encoding="ascii")
path.chmod(0o600)
self.docker.fail_start = True
original_up = self.docker.up
def start(image):
if image != self.docker.old_image:
path.write_text("github_pat_offline_failed", encoding="ascii")
return original_up(image)
with patch.object(self.docker, "up", side_effect=start):
self.assertEqual(self.host.apply()["status"], "rolled_back")
self.assertEqual(path.read_text(encoding="ascii"), "github_pat_offline_before")
if os.name == "posix":
self.assertEqual(path.stat().st_mode & 0o777, 0o600)
def test_interactive_token_setup_is_local_hidden_and_sets_shared_ownership(self):
token = "github_pat_offline_interactive"
with patch.object(updater.getpass, "getpass", return_value=token), patch.object(updates, "build_opener") as network, patch.object(updater.Docker, "run") as docker:
result = updater.set_github_token(self.config)
path = self.config.data_dir / updates.TOKEN_FILE_NAME
self.assertEqual(path.read_text(encoding="ascii"), token + "\n")
self.assertEqual(self.mock_chown.call_args.args[1:], (10001, 10001))
if os.name == "posix":
self.assertEqual(path.stat().st_mode & 0o777, 0o600)
self.assertNotIn(token, json.dumps(result))
network.assert_not_called()
docker.assert_not_called()
def test_token_setup_rejects_echo_fallback_and_preserves_old_token_on_failure(self):
path = self.config.data_dir / updates.TOKEN_FILE_NAME
path.write_text("old-offline-token", encoding="ascii")
for failure in (EOFError("private-secret"), updater.getpass.GetPassWarning("private-secret")):
with self.subTest(failure=type(failure).__name__), patch.object(updater.getpass, "getpass", side_effect=failure):
with self.assertRaises(updater.UpdaterError) as caught:
updater.set_github_token(self.config)
self.assertNotIn("private-secret", str(caught.exception))
with patch.object(updater.getpass, "getpass", return_value="new-offline-token"), patch.object(updater.os, "replace", side_effect=OSError("private-secret")):
with self.assertRaises(updater.UpdaterError):
updater.set_github_token(self.config)
self.assertEqual(path.read_text(encoding="ascii"), "old-offline-token")
self.assertEqual(list(self.config.data_dir.glob(".update-token-*")), [])
def test_token_setup_dry_run_does_not_prompt_read_credentials_or_write(self):
source = Path(updater.__file__).with_name("updater.example.toml")
with patch.object(updater.getpass, "getpass") as prompt, patch.object(updates, "_github_token") as read, redirect_stdout(io.StringIO()) as output:
code = updater.main(["--config", str(source), "--set-github-token", "--dry-run"])
self.assertEqual(code, 0)
self.assertEqual(json.loads(output.getvalue())["mode"], "set-github-token")
prompt.assert_not_called()
read.assert_not_called()
def test_malformed_request_fails_without_network_or_docker(self):
self.enable()
updates.atomic_json(self.config.data_dir / "update-request.json", ["invalid"])
@@ -0,0 +1,72 @@
"""The release asset must run from outside the repo with only Python stdlib."""
import json
from pathlib import Path
import subprocess
import sys
import tempfile
import unittest
import zipfile
from ranch_web import __version__
ROOT = Path(__file__).resolve().parents[2]
OFFLINE_RUNNER = """
import os, runpy, socket, subprocess, sys
def forbidden(*args, **kwargs):
raise AssertionError('Network/Docker/prompt forbidden in package smoke test')
socket.socket.connect = forbidden
socket.create_connection = forbidden
subprocess.run = forbidden
import getpass
getpass.getpass = forbidden
os.environ['RANCH_WEB_UPDATE_GITHUB_TOKEN_FILE'] = '/nonexistent/private-token'
sys.argv = sys.argv[1:]
runpy.run_path(sys.argv[0], run_name='__main__')
"""
class UpdaterPackageTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.temporary = tempfile.TemporaryDirectory(prefix="standalone-updater-test-")
cls.addClassCleanup(cls.temporary.cleanup)
cls.folder = Path(cls.temporary.name)
cls.asset = cls.folder / "updater.pyz"
subprocess.run([sys.executable, "-I", "-S", "-B", str(ROOT / "tools/build_web_updater.py"),
"--output", str(cls.asset)], cwd=cls.folder, capture_output=True, check=True)
cls.config = cls.folder / "updater.toml"
cls.config.write_bytes((ROOT / "deploy/web/updater.example.toml").read_bytes())
def invoke(self, *arguments):
result = subprocess.run([sys.executable, "-I", "-S", "-B", "-X", "utf8", "-c", OFFLINE_RUNNER,
str(self.asset), *arguments], cwd=self.folder,
capture_output=True, text=True, encoding="utf-8", timeout=15)
self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
return result.stdout
def test_help_and_version_work_without_config_repo_or_dependencies(self):
self.assertIn("--set-github-token", self.invoke("--help"))
self.assertEqual(self.invoke("--version").strip(), f"ranch-web-updater {__version__}")
def test_dry_run_is_offline_does_not_load_token_or_write_files(self):
before = sorted(path.relative_to(self.folder) for path in self.folder.rglob("*"))
result = json.loads(self.invoke("--config", str(self.config), "--apply", "v2.0.1", "--dry-run"))
self.assertTrue(result["dry_run"])
self.assertEqual(result["image"], "ghcr.io/attilanet/myrzx_bot-web:v2.0.1")
self.assertFalse(result["auto_apply"])
self.assertFalse(result["accept_web_requests"])
self.assertEqual(before, sorted(path.relative_to(self.folder) for path in self.folder.rglob("*")))
def test_archive_is_minimal_and_reproducible(self):
second = self.folder / "second.pyz"
subprocess.run([sys.executable, "-I", "-S", "-B", str(ROOT / "tools/build_web_updater.py"),
"--output", str(second)], cwd=self.folder, capture_output=True, check=True)
self.assertEqual(self.asset.read_bytes(), second.read_bytes())
with zipfile.ZipFile(self.asset) as archive:
self.assertEqual(set(archive.namelist()), {"__main__.py", "updater.py", "ranch_web/__init__.py", "ranch_web/updates.py"})
self.assertEqual(archive.read("ranch_web/__init__.py"), (ROOT / "ranch_web/__init__.py").read_bytes())
if __name__ == "__main__":
unittest.main()