"""Per-page logs use synthetic records, disposable demos and loopback HTTP only.
Run: python -B -m unittest ranch_web.tests.browser.test_task_logs_browser -v
"""
from __future__ import annotations
import json
from pathlib import Path
import unittest
from unittest.mock import patch
from urllib.parse import parse_qs, urlsplit
from . import test_workbench_browser as fixtures
if fixtures.AVAILABLE:
from playwright.sync_api import expect
@unittest.skipUnless(fixtures.AVAILABLE, "Python Playwright and a system Chromium browser are required")
class TaskLogsBrowserTests(unittest.TestCase):
setUpClass = classmethod(fixtures.WorkbenchBrowserTests.setUpClass.__func__)
tearDownClass = classmethod(fixtures.WorkbenchBrowserTests.tearDownClass.__func__)
await_job = fixtures.WorkbenchBrowserTests.await_job
open = fixtures.WorkbenchBrowserTests.open
go = fixtures.WorkbenchBrowserTests.go
fulfill = staticmethod(fixtures.WorkbenchBrowserTests.fulfill)
def setUp(self):
guard = patch("requests.sessions.Session.request", side_effect=AssertionError("Live HTTP is forbidden"))
guard.start()
self.addCleanup(guard.stop)
fixtures.WorkbenchBrowserTests.setUp(self)
self.escapes = []
self.requests = []
self.records = {self.first: [], self.second: []}
self.log_calls = []
self.page.add_init_script("""(() => {
const original = window.setInterval;
window.setInterval = (callback, delay, ...args) => {
if (callback.name === 'tick') {window.__pollLogs = callback;return -1;}
return original(callback, delay, ...args);
};
})();""")
def local_only(route):
if route.request.url.startswith(self.base + "/"):
route.continue_()
else:
self.escapes.append(route.request.url)
route.abort()
self.context.route("**/*", local_only)
self.page.on("request", lambda request: self.requests.append(request))
def logs(route):
url = urlsplit(route.request.url)
account = url.path.split("/")[-2]
query = parse_qs(url.query)
after = int(query["after"][0])
debug = query["debug"] == ["true"]
self.log_calls.append((account, after, debug, query))
records = self.records[account]
self.fulfill(route, {"entries": [dict(entry, details_available=debug and entry.get("details_available", False))
for entry in records if entry["seq"] > after and (debug or not entry.get("debug"))],
"next": records[-1]["seq"] if records else 0})
self.page.route("**/api/accounts/*/logs?*", logs)
def tearDown(self):
try:
self.assertEqual(self.escapes, [], "Browser requests must stay on the disposable local server")
self.assertEqual(self.errors, [], "No browser console or JavaScript errors")
finally:
fixtures.WorkbenchBrowserTests.tearDown(self)
def add(self, category, message, *, account=None, level="info", **extra):
records = self.records[account or self.first]
seq = records[-1]["seq"] + 1 if records else 1
entry = {"id": seq, "seq": seq, "time": "2026-11-11T00:12:34Z", "message": message, "level": level, **extra}
if category is not None:
entry["category"] = category
records.append(entry)
return seq
def poll(self):
before = len(self.log_calls)
with self.page.expect_response(lambda response: "/logs?" in response.url):
self.page.evaluate("async () => {await window.__pollLogs();}")
self.assertEqual(len(self.log_calls), before + 1, "One shared log request per poll, independent of mounted pages")
def task(self, key):
return self.go(key).locator(f'.task-log-panel[data-task-log="{key}"]')
def download(self, button):
with self.page.expect_download() as pending:
button.click()
return Path(pending.value.path()).read_text(encoding="utf-8")
def test_categories_legacy_safety_and_all_fifteen_tabs(self):
categories = "hatching mainline gifts commissions exploration maps ranch daily login general".split()
for key in categories:
self.add(key, f"only-{key}")
self.add(None, "legacy-general")
self.add("future-category", "unknown-general")
unsafe = '
& '
self.add("hatching", unsafe)
self.open()
expect(self.page.locator(".page-tab")).to_have_count(15)
expect(self.page.locator("#log-heading")).to_have_text("总日志")
expect(self.page.locator("#log-lines .log-entry")).to_have_count(13)
for key in categories[:9]:
panel = self.task(key)
body = panel.locator(".task-log-lines")
expect(body).to_contain_text(f"only-{key}")
expect(body).to_have_attribute("aria-live", "off")
self.assertEqual(panel.evaluate("node => node.closest('.page-panel').dataset.page"), key)
if key == "login":
expect(body).to_contain_text("only-general")
expect(body).to_contain_text("legacy-general")
expect(body).to_contain_text("unknown-general")
else:
expect(body).not_to_contain_text("legacy-general")
expect(body).not_to_contain_text("unknown-general")
self.assertEqual(body.locator(".log-entry").count(), 2 if key == "hatching" else 1)
if key == "hatching":
expect(body).to_contain_text(unsafe)
expect(body.locator("img,script")).to_have_count(0)
self.assertIsNone(self.page.evaluate("window.__unsafeLog"))
expect(self.go("bag").locator(".task-log-panel")).to_have_count(0)
for _, _, _, query in self.log_calls:
self.assertEqual(set(query), {"after", "debug"})
def test_clear_and_download_are_scoped_in_both_directions_and_survive_debug_replay(self):
self.add("hatching", "hatch-before")
self.add("gifts", "gift-before")
self.add("hatching", "debug-before", level="debug", debug=True)
self.add("hatching", "second-account", account=self.second)
self.open()
hatch = self.task("hatching")
hatch.get_by_role("button", name="清空当前账号孵蛋日志显示", exact=True).click()
expect(hatch.locator(".log-entry")).to_have_count(0)
expect(self.page.locator("#log-lines")).to_contain_text("hatch-before")
self.assertIn("gift-before", self.download(self.page.locator("#download-log")))
self.assertEqual(self.download(hatch.get_by_role("button", name="下载当前账号孵蛋日志", exact=True)), "")
expect(self.task("gifts").locator(".task-log-lines")).to_contain_text("gift-before")
self.page.locator("#clear-log").click()
expect(self.page.locator("#log-lines .log-entry")).to_have_count(0)
expect(self.task("gifts").locator(".task-log-lines")).to_contain_text("gift-before")
self.page.locator(f'.account-tab[data-account="{self.second}"]').click()
expect(self.task("hatching").locator(".task-log-lines")).to_contain_text("second-account")
self.page.locator(f'.account-tab[data-account="{self.first}"]').click()
hatch = self.task("hatching")
expect(hatch.locator(".log-entry")).to_have_count(0)
with self.page.expect_response(lambda response: "/logs?after=0&debug=true" in response.url):
self.page.locator("#debug-toggle").click()
expect(hatch.locator(".log-entry")).to_have_count(0)
expect(self.page.locator("#log-lines .log-entry")).to_have_count(0)
self.add("hatching", "hatch-after")
self.add("gifts", "gift-after")
self.poll()
expect(hatch.locator(".task-log-lines")).to_contain_text("hatch-after")
downloaded = self.download(hatch.get_by_role("button", name="下载当前账号孵蛋日志", exact=True))
self.assertIn("hatch-after", downloaded)
for hidden in ("hatch-before", "debug-before", "gift-", "second-account"):
self.assertNotIn(hidden, downloaded)
total = self.download(self.page.locator("#download-log"))
self.assertIn("hatch-after", total)
self.assertIn("gift-after", total)
self.assertNotIn("before", total)
self.page.locator("#clear-log").click()
expect(hatch.locator(".task-log-lines")).to_contain_text("hatch-after")
self.assertTrue(all(request.method == "GET" for request in self.requests if "/logs" in request.url))
def test_switches_preserve_filters_inputs_focus_and_only_active_panel_updates(self):
self.add("hatching", "keep-first", level="warning")
self.add("gifts", "gift-initial")
self.add("hatching", "second-keep", account=self.second)
self.open()
hatch = self.task("hatching")
self.page.locator(".page-panel:not([hidden]) .subtab").last.click()
query = hatch.get_by_role("searchbox", name="孵蛋日志搜索", exact=True)
query.fill("keep")
hatch.get_by_role("combobox", name="孵蛋日志级别", exact=True).select_option("warning")
page_panel = self.page.locator('.page-panel[data-page="hatching"]:not([hidden])')
field = page_panel.locator('input[type="checkbox"]').first
self.assertGreater(field.count(), 0)
checked = not field.is_checked()
field.set_checked(checked)
field.evaluate("node => {window.__preservedInput=node;}")
query.focus()
query.evaluate("node => {node.setSelectionRange(1,3);window.__preservedSearch=node;}")
self.add("hatching", "keep-new", level="warning")
self.add("hatching", "excluded-info")
self.poll()
expect(query).to_be_focused()
self.assertEqual(query.evaluate("node => [node.selectionStart,node.selectionEnd]"), [1, 3])
self.assertTrue(query.evaluate("node => node===window.__preservedSearch"))
expect(hatch.locator(".log-entry")).to_have_count(2)
expect(hatch.locator(".task-log-lines")).not_to_contain_text("excluded-info")
hidden_hatch = self.page.locator('.page-panel[data-page="hatching"] .task-log-panel')
gifts = self.task("gifts")
self.add("hatching", "keep-hidden", level="warning")
self.add("gifts", "gift-new")
self.poll()
expect(gifts.locator(".task-log-lines")).to_contain_text("gift-new")
expect(hidden_hatch.locator(".log-entry")).to_have_count(2)
hatch = self.task("hatching")
expect(hatch.locator(".log-entry")).to_have_count(3)
expect(query).to_have_value("keep")
expect(hatch.get_by_role("combobox", name="孵蛋日志级别", exact=True)).to_have_value("warning")
self.assertEqual(field.is_checked(), checked)
self.assertTrue(field.evaluate("node => node===window.__preservedInput"))
self.page.locator(f'.account-tab[data-account="{self.second}"]').click()
second = self.task("hatching")
expect(second.get_by_role("searchbox", name="孵蛋日志搜索", exact=True)).to_have_value("")
expect(second.locator(".task-log-lines")).to_contain_text("second-keep")
expect(second.locator(".task-log-lines")).not_to_contain_text("keep-first")
self.page.locator(f'.account-tab[data-account="{self.first}"]').click()
hatch = self.task("hatching")
expect(hatch.get_by_role("searchbox", name="孵蛋日志搜索", exact=True)).to_have_value("keep")
expect(self.page.locator('.page-panel[data-page="hatching"]:not([hidden]) .subtab[aria-selected="true"]')).to_have_text("喂养策略")
def test_reading_pause_collapse_and_bounded_append_preserve_scroll_and_nodes(self):
for i in range(650):
self.add("maps", f"map-record-{i:04}")
self.open()
task = self.task("maps")
lines = task.locator(".task-log-lines")
expect(lines.locator(".log-entry")).to_have_count(600)
expect(task.get_by_role("button", name="扫荡日志:暂停自动滚动", exact=True)).to_have_attribute("aria-pressed", "true")
lines.evaluate("node => {node.scrollTop=node.scrollHeight/2;node.dispatchEvent(new Event('scroll'));}")
follow = task.get_by_role("button", name="扫荡日志:跟随最新日志", exact=True)
expect(follow).to_have_attribute("aria-pressed", "false")
position = lines.evaluate("node => {const row=[...node.children].find(row=>row.getBoundingClientRect().top>=node.getBoundingClientRect().top);window.__readingRow=row;return {seq:row.dataset.sequence,offset:row.getBoundingClientRect().top-node.getBoundingClientRect().top,parent:node.closest('.page-panel').scrollTop};}")
self.add("maps", "map-new")
self.poll()
expect(task.locator(".task-log-status")).to_contain_text("新增 1 条")
self.assertTrue(lines.evaluate("node => node.contains(window.__readingRow)"))
updated = lines.evaluate("node => ({offset:window.__readingRow.getBoundingClientRect().top-node.getBoundingClientRect().top,parent:node.closest('.page-panel').scrollTop})")
self.assertAlmostEqual(position["offset"], updated["offset"], delta=1)
self.assertEqual(position["parent"], updated["parent"])
hide = task.get_by_role("button", name="隐藏扫荡日志", exact=True)
hide.focus()
hide.press("Enter")
expect(task.locator(".task-log-heading button")).to_have_attribute("aria-expanded", "false")
rows_before = lines.text_content()
self.add("maps", "map-while-collapsed")
self.poll()
self.assertEqual(lines.text_content(), rows_before)
task.get_by_role("button", name="显示扫荡日志", exact=True).press("Enter")
expect(lines).to_contain_text("map-while-collapsed")
expect(task.get_by_role("button", name="扫荡日志:跟随最新日志", exact=True)).to_be_visible()
task.get_by_role("button", name="扫荡日志:跟随最新日志", exact=True).click()
self.assertLessEqual(lines.evaluate("node => node.scrollHeight-node.scrollTop-node.clientHeight"), 1)
# Unchanged ticks preserve nodes, filters and both scroll containers.
lines.locator(".log-entry").last.evaluate("node => {window.__lastLogNode=node;}")
self.poll()
self.assertTrue(lines.locator(".log-entry").last.evaluate("node => node===window.__lastLogNode"))
for i in range(900):
self.add("maps", f"bounded-{i:04}")
self.poll()
expect(lines.locator(".log-entry")).to_have_count(600)
text = self.download(task.get_by_role("button", name="下载当前账号扫荡日志", exact=True))
self.assertEqual(len(text.splitlines()), 1200, "Downloads use the same bounded shared buffer")
self.assertNotIn("map-record-0000", text)
with self.page.expect_response(lambda response: "/logs?after=0&debug=true" in response.url):
self.page.locator("#debug-toggle").click()
self.assertEqual(self.download(task.get_by_role("button", name="下载当前账号扫荡日志", exact=True)), text,
"Rewinding the shared cursor must not replay evicted records")
def test_total_and_task_reading_positions_and_follow_states_are_independent_per_account(self):
for i in range(85):
self.add("hatching", f"first-{i:03}")
self.add("hatching", f"second-{i:03}", account=self.second)
self.open()
hatch = self.task("hatching")
hatch.get_by_role("button", name="孵蛋日志:暂停自动滚动", exact=True).click()
total = self.page.locator("#log-lines")
total.evaluate("node => {node.scrollTop=140;node.dispatchEvent(new Event('scroll'));}")
expect(self.page.locator("#log-follow")).not_to_be_checked()
position = total.evaluate("node => node.scrollTop")
self.add("hatching", "first-new")
self.poll()
self.assertEqual(total.evaluate("node => node.scrollTop"), position)
expect(hatch.locator(".task-log-status")).to_contain_text("已暂停跟随,新增 1 条")
self.page.locator(f'.account-tab[data-account="{self.second}"]').click()
expect(self.page.locator("#log-follow")).to_be_checked()
expect(self.task("hatching").get_by_role("button", name="孵蛋日志:暂停自动滚动", exact=True)).to_be_visible()
self.page.locator(f'.account-tab[data-account="{self.first}"]').click()
expect(self.page.locator("#log-follow")).not_to_be_checked()
self.assertEqual(total.evaluate("node => node.scrollTop"), position)
expect(self.task("hatching").get_by_role("button", name="孵蛋日志:跟随最新日志", exact=True)).to_be_visible()
def test_hidden_total_switches_preserve_each_accounts_follow_and_scroll(self):
for i in range(85):
self.add("hatching", f"first-hidden-{i:03}")
self.add("hatching", f"second-hidden-{i:03}", account=self.second)
self.open()
total = self.page.locator("#log-lines")
follow = self.page.locator("#log-follow")
def switch(account):
self.page.locator(f'.account-tab[data-account="{account}"]').click()
expect(self.page.locator(f'.account-tab[data-account="{account}"]')).to_have_attribute("aria-selected", "true")
def hide():
self.page.locator("#log-toggle").click()
expect(self.page.locator("#log-panel")).to_be_hidden()
def show():
self.page.locator("#log-toggle").click()
expect(self.page.locator("#log-panel")).to_be_visible()
def read_at(position):
total.evaluate("(node, position) => {node.scrollTop=position;node.dispatchEvent(new Event('scroll'));}", position)
expect(follow).not_to_be_checked()
return total.evaluate("node => node.scrollTop")
expect(total.locator(".log-entry")).to_have_count(85)
first_position = read_at(140)
hide()
switch(self.second)
expect(total).to_contain_text("second-hidden-084")
expect(follow).to_be_checked()
second_position = total.evaluate("node => node.scrollTop")
self.assertGreater(second_position, first_position)
hide()
for account in (self.first, self.second, self.first):
switch(account)
expect(self.page.locator("#log-panel")).to_be_hidden()
show()
expect(follow).not_to_be_checked()
self.assertEqual(total.evaluate("node => node.scrollTop"), first_position)
hide()
switch(self.second)
show()
expect(follow).to_be_checked()
self.assertEqual(total.evaluate("node => node.scrollTop"), second_position)
# Repeat with two different paused reading positions, so a hidden DOM's
# zero/stale scrollTop cannot replace either account's saved position.
second_position = read_at(260)
hide()
for account in (self.first, self.second, self.first, self.second):
switch(account)
expect(self.page.locator("#log-panel")).to_be_hidden()
show()
expect(follow).not_to_be_checked()
self.assertEqual(total.evaluate("node => node.scrollTop"), second_position)
hide()
switch(self.first)
show()
expect(follow).not_to_be_checked()
self.assertEqual(total.evaluate("node => node.scrollTop"), first_position)
def test_login_controls_receive_normal_clicks_with_expanded_logs_at_both_viewports(self):
login = {"account": "offline-layout", "has_saved_password": False,
"servers": [{"id": 7, "name": "合成区服一"}, {"id": 8, "name": "合成区服二"}],
"saved_sessions": [{"id": "layout-session-1", "label": "合成会话一"},
{"id": "layout-session-2", "label": "合成会话二"}]}
actions = []
def login_view(route):
response = route.fetch().json()
if response.get("data"):
response["data"]["login"] = login
self.fulfill(route, response)
def login_action(route):
operation = urlsplit(route.request.url).path.rsplit("/", 1)[1]
actions.append((operation, route.request.post_data_json))
self.fulfill(route, {"id": f"layout-{len(actions)}", "operation": operation,
"status": "succeeded", "result": login, "error": None})
self.page.route(f"**/api/accounts/{self.first}/views/login?*", login_view)
for operation in ("login", "enter_server", "restore_session"):
self.page.route(f"**/api/accounts/{self.first}/actions/{operation}", login_action)
self.add("login", "合成登录日志:验证表单按钮与日志区域互不覆盖。")
self.open()
for width, height in ((1280, 800), (390, 844)):
with self.subTest(viewport=(width, height)):
self.page.set_viewport_size({"width": width, "height": height})
panel = self.go("login")
task = panel.locator('.task-log-panel[data-task-log="login"]')
expect(task.locator(".task-log-body")).to_be_visible()
geometry = panel.evaluate("""node => {
const content=node.querySelector('.page-content').getBoundingClientRect();
const log=node.querySelector('.task-log-panel').getBoundingClientRect();
const controls=[...node.querySelectorAll('.login-layout button')].filter(button=>!button.hidden);
return {gap:log.top-content.bottom,
overflow:Math.max(...controls.map(button=>button.getBoundingClientRect().bottom))-content.bottom};
}""")
self.assertGreaterEqual(geometry["gap"], 0, geometry)
self.assertLessEqual(geometry["overflow"], 1, geometry)
panel.get_by_label("游戏账号", exact=True).fill("offline-layout")
panel.get_by_label("游戏密码", exact=True).fill("synthetic-layout-password")
for operation, label in (("login", "账号密码登录 / 获取区服"),
("enter_server", "进入选中区服"),
("restore_session", "恢复选中会话(无需重新输密码)")):
if operation == "enter_server":
panel.get_by_label("区服 / 角色", exact=True).select_option("8")
if operation == "restore_session":
panel.get_by_label("已保存的账号 / 区服 / 角色", exact=True).select_option("layout-session-2")
with self.page.expect_response(lambda response: response.url.endswith(f"/actions/{operation}")):
panel.get_by_role("button", name=label, exact=True).click()
self.assertEqual(actions[-1][0], operation)
expect(task.locator(".task-log-body")).to_be_visible()
if operation == "enter_server":
self.assertEqual(actions[-1][1], {"server_id": "8"})
if operation == "restore_session":
self.assertEqual(actions[-1][1], {"session_id": "layout-session-2"})
task.get_by_role("searchbox", name="登录日志搜索", exact=True).click()
expect(task.get_by_role("searchbox", name="登录日志搜索", exact=True)).to_be_focused()
def test_all_page_content_stays_separate_from_logs_and_remains_scroll_reachable(self):
self.open()
for width, height in ((1280, 800), (390, 844)):
self.page.set_viewport_size({"width": width, "height": height})
for key in "login incubator bag ranch daily hatching mainline battles gifts commissions exploration maps statistics plans yields".split():
with self.subTest(viewport=(width, height), page=key):
panel = self.go(key)
task = panel.locator(".task-log-panel")
if not task.count():
continue
geometry = panel.evaluate("""node => {
const content=node.querySelector('.page-content').getBoundingClientRect();
const log=node.querySelector('.task-log-panel').getBoundingClientRect();
return {height:content.height,gap:log.top-content.bottom};
}""")
self.assertGreaterEqual(geometry["height"], 160, geometry)
self.assertGreaterEqual(geometry["gap"], 0, geometry)
self.assertGreaterEqual(task.locator(".task-log-lines").bounding_box()["height"], 120)
task.get_by_role("searchbox").click()
expect(task.get_by_role("searchbox")).to_be_focused()
def test_populated_layout_visual_artifact_and_narrow_viewport(self):
def maps_view(route):
response = route.fetch().json()
data = response.get("data")
if data:
data.update(summary="合成离线关卡:仅用于日志交互与布局验证,不连接游戏。",
groups=[{"id": "demo", "label": "合成测试区域", "collapsed": False}],
columns=[{"key": key, "label": title} for key, title in
[("name", "关卡"), ("level", "难度"), ("cost", "体力"), ("today", "今日次数"), ("state", "状态")]],
rows=[{"id": f"synthetic-{i}", "group": "demo", "name": f"合成关卡 {i + 1}",
"level": 3, "cost": 6, "today": i % 3, "state": "等待下次扫荡"} for i in range(8)])
self.fulfill(route, response)
self.page.route(f"**/api/accounts/{self.first}/views/maps?*", maps_view)
for i in range(18):
self.add("maps", f"[扫荡] 合成关卡 {i + 1}:完成结算,获得金币与材料。", level="warning" if i == 12 else "info")
self.open()
task = self.task("maps")
page_panel = self.page.locator('.page-panel[data-page="maps"]:not([hidden])')
expect(page_panel.locator(".table-scroll").first).to_be_visible()
self.assertGreaterEqual(page_panel.locator(".table-scroll").first.bounding_box()["height"], 100)
self.assertGreaterEqual(page_panel.locator(".page-content").bounding_box()["height"], 160)
self.assertGreaterEqual(task.locator(".task-log-lines").bounding_box()["height"], 120)
target = Path(__file__).resolve().parents[3] / "test-artifacts" / "task-log-ui.png"
target.parent.mkdir(exist_ok=True)
task.scroll_into_view_if_needed()
self.page.screenshot(path=str(target))
self.page.set_viewport_size({"width": 390, "height": 844})
task.scroll_into_view_if_needed()
self.assertLessEqual(task.evaluate("node => node.scrollWidth-node.clientWidth"), 1)
expect(task.get_by_role("button", name="清空当前账号扫荡日志显示", exact=True)).to_be_visible()
self.page.screenshot(path=str(target.with_name("task-log-ui-narrow.png")))
if __name__ == "__main__":
unittest.main()