release: prepare Web 2.0.1 automatic strategies and private updates
This commit is contained in:
@@ -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)
|
||||
|
||||
@@ -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()
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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()
|
||||
Reference in New Issue
Block a user