Files
myrzx_bot/ranch_web/tests/browser/test_task_logs_browser.py

699 lines
39 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""The original bottom log region, with synthetic records and loopback HTTP only.
Run: python -B -m unittest ranch_web.tests.browser.test_task_logs_browser -v
"""
from __future__ import annotations
from pathlib import Path
import re
import time
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)
viewports = ((1920, 860), (1280, 800), (390, 844))
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.log_calls = [], [], []
self.records = {self.first: [], self.second: []}
self.poll_script = """(() => {
const original = window.setInterval;
window.setInterval = (callback, delay, ...args) => {
if (callback.name === 'tick') {window.__pollLogs = callback;return -1;}
return original(callback, delay, ...args);
};
})();"""
self.page.add_init_script(self.poll_script)
def local_only(route):
if route.request.url.startswith(self.base + "/"):
route.continue_()
else:
self.escapes.append(route.request.url)
route.abort()
self.local_only = local_only
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.serve_logs = logs
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):
self.page.wait_for_load_state("networkidle")
before = len(self.log_calls)
account = self.page.locator('.account-tab[aria-selected="true"]').get_attribute("data-account")
with self.page.expect_request(lambda request: f"/accounts/{account}/logs?" in request.url) as pending:
self.page.evaluate("async () => {await window.__pollLogs();}")
pending.value.response().finished()
self.assertEqual(len(self.log_calls), before + 1, "One shared log request per poll, regardless of visited pages")
def wait_saved(self):
# The fixture parks tick() to count shared fetches; keep its job polling
# moving while the real debounced configuration save is in flight.
deadline = time.monotonic() + 10
while self.page.locator("#save-status").inner_text() != "策略已自动保存" and time.monotonic() < deadline:
self.page.evaluate("async () => {await window.__pollLogs();}")
self.page.wait_for_timeout(50)
fixtures.WorkbenchBrowserTests.wait_saved(self)
def original_region(self):
panel = self.page.locator("#log-panel")
expect(panel).to_have_count(1)
expect(self.page.locator("#log-resizer")).to_have_count(1)
expect(self.page.locator("[data-task-log], .task-log-panel, .task-log-lines, .has-task-log, iframe")).to_have_count(0)
expect(self.page.locator('[role="log"]')).to_have_count(1)
expect(self.page.locator("#log-lines")).to_have_attribute("aria-live", "off")
expect(self.page.locator('[aria-controls="log-panel"]')).to_have_count(1)
self.assertTrue(panel.evaluate("""node => {
const workspace=document.querySelector('#workspace'), resizer=document.querySelector('#log-resizer');
window.__originalLogPanel ??= node;
window.__originalLogResizer ??= resizer;
return node===window.__originalLogPanel && resizer===window.__originalLogResizer
&& node.parentElement===workspace.parentElement && resizer.parentElement===workspace.parentElement
&& workspace.nextElementSibling===resizer && resizer.nextElementSibling===node
&& !workspace.contains(node) && !workspace.contains(resizer);
}"""), "Tabs and accounts must reuse the original siblings after #workspace")
self.assertNotRegex(panel.inner_text(), r"总日志|全部日志")
return panel
def task(self, key):
self.go(key)
panel = self.original_region()
label = self.page.locator(f'.page-tab[data-page="{key}"]').inner_text()
expect(self.page.locator("#log-heading")).to_have_text(label + "日志")
return panel
def toggle(self, visible):
panel = self.page.locator("#log-panel")
(expect(panel).to_be_hidden if visible else expect(panel).to_be_visible)()
self.page.locator("#log-toggle").click()
(expect(panel).to_be_visible if visible else expect(panel).to_be_hidden)()
expect(self.page.locator("#log-toggle")).to_have_attribute("aria-expanded", str(visible).lower())
(expect(self.page.locator("#log-resizer")).to_be_visible if visible
else expect(self.page.locator("#log-resizer")).to_be_hidden)()
def download(self):
with self.page.expect_download() as pending:
self.page.locator("#download-log").click()
return Path(pending.value.path()).read_text(encoding="utf-8")
def refresh_config(self, visible):
config = self.manager.get_config(self.first)["config"]
config.update(log_visible=visible, interval=60 if config["interval"] != 60 else 120)
response = self.manager.set_config(self.first, config)
self.await_job(self.first, response["job_id"])
with self.page.expect_response(self.base + f"/api/accounts/{self.first}/config"):
self.poll()
self.wait_saved()
def refresh_job(self):
with self.page.expect_response(self.base + f"/api/accounts/{self.first}/status"):
with self.page.expect_response(self.base + f"/api/accounts/{self.first}/actions/refresh") as pending:
self.page.locator("#refresh").click()
self.await_job(self.first, pending.value.json()["id"])
self.poll()
def click_unobscured(self, control):
expect(control).to_be_visible()
expect(control).to_be_enabled()
control.evaluate("""node => {
window.__logControlClick=null;
node.addEventListener('click', event => {window.__logControlClick=[event.isTrusted && event.detail>0,
node.contains(document.elementFromPoint(event.clientX,event.clientY)),
!document.querySelector('#log-panel').hidden];}, {once:true});
}""")
control.click(timeout=5000)
self.assertEqual(self.page.evaluate("window.__logControlClick"), [True, True, True],
"A normal pointer click must hit the original control with logs still open")
expect(self.page.locator("#log-panel")).to_be_visible()
def layout_artifact(self, key):
panel = self.original_region()
geometry = panel.evaluate("""node => {
const log=node.getBoundingClientRect(), workspace=document.querySelector('#workspace').getBoundingClientRect();
const resizer=document.querySelector('#log-resizer').getBoundingClientRect();
const content=document.querySelector('.page-panel:not([hidden])').getBoundingClientRect();
return {gap:log.top-workspace.bottom, splitterGap:resizer.top-workspace.bottom,
logGap:log.top-resizer.bottom, content:content.height, lines:document.querySelector('#log-lines').clientHeight,
overflow:document.documentElement.scrollWidth-innerWidth, right:log.right-innerWidth};
}""")
for gap in ("gap", "splitterGap", "logGap"):
self.assertGreaterEqual(geometry[gap], -1, geometry)
self.assertGreaterEqual(geometry["content"], 120, geometry)
self.assertGreaterEqual(geometry["lines"], 60, geometry)
self.assertLessEqual(geometry["overflow"], 1, geometry)
self.assertLessEqual(geometry["right"], 1, geometry)
viewport = self.page.viewport_size
target = Path(__file__).resolve().parents[3] / "test-artifacts" / "logfix"
target.mkdir(parents=True, exist_ok=True)
self.page.screenshot(path=str(target / f"{key}-{viewport['width']}x{viewport['height']}.png"))
def dense_fixture(self):
categories = ("general", "gifts", "maps", "login", "gifts", None, "gifts", "maps")
for i in range(1120):
category = categories[i % len(categories)]
message = f"synthetic-{category}-{i:04} 合成离线记录:" + "长文本赠礼与区服结算数据" * 20
if i % 3 == 0:
message += "\n多行明细:合成道具 × 3\n仅供布局回归,不连接游戏。"
self.add(category, message, level="warning" if i % 7 == 0 else "info")
login = {"account": "offline-layout-" + "synthetic" * 8, "has_saved_password": False,
"servers": [{"id": i, "name": f"合成区服 {i} " + "长区服名称" * 12,
"role_name": "离线角色" * 12} for i in range(1, 37)],
"saved_sessions": [{"id": f"layout-session-{i}", "label": f"合成会话 {i} " + "长账号区服角色说明" * 12}
for i in range(1, 37)]}
def view(route):
response = route.fetch().json()
data = response.get("data")
key = urlsplit(route.request.url).path.rsplit("/", 1)[1]
if data and key == "login":
data["login"] = login
for field in data["form"]:
field["help"] = field.get("help", "") + " 合成长表单说明:记住账号后,选择原区服角色并等待服务端状态。" * 5
elif data and key == "maps":
data["summary"] = "合成离线关卡:显示 48 关;仅供布局回归,不连接游戏。"
data["groups"] = [{"id": "demo", "label": "合成测试区域", "collapsed": False}]
data["rows"] = [{"id": f"synthetic{i}", "group": "demo", "number": f"1-{i + 1}",
"name": f"合成关卡 {i + 1}", "enabled": False, "level": "3", "limit": 3,
"stars_text": "★★★", "status": "等待下次扫荡", "used": i % 3,
"cost_text": "体力 单次 6 / 可用 100 / 保留 0", "drops": "合成金币与材料",
"rule_path": ["sweep_policy", "rules", f"synthetic{i}"],
"rule_defaults": {"enabled": False, "level": "3", "limit": 3}} for i in range(48)]
elif data and key == "gifts":
data["rows"] = [{"id": str(i), "species": f"合成魔物 {i + 1}", "monster_id": i + 1,
"level": 30, "feel_text": "60 / 100", "quality": "S / A / A / S",
"likes": "合成礼物", "cooldown": "可赠礼"} for i in range(48)]
self.fulfill(route, response)
for key in ("login", "maps", "gifts"):
self.page.route(f"**/api/accounts/{self.first}/views/{key}?*", view)
return login
def test_single_original_region_strict_categories_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-mixed-gift")
self.add("future-category", "unknown-mixed-gift")
unsafe = '<img src=x onerror="window.__unsafeLog=true"> & <script>bad()</script>'
self.add("hatching", unsafe)
self.open()
expect(self.page.locator(".page-tab")).to_have_count(15)
self.original_region()
expect(self.page.locator("#log-panel")).to_be_hidden()
self.toggle(True)
for key in categories[:9]:
with self.subTest(category=key):
panel = self.task(key)
expect(panel).to_be_visible()
body = panel.locator("#log-lines")
expect(body).to_contain_text(f"only-{key}")
expect(body.locator(".log-entry")).to_have_count(2 if key == "hatching" else 1)
for excluded in ("legacy-mixed-gift", "unknown-mixed-gift", *(f"only-{other}" for other in categories if other != key)):
expect(body).not_to_contain_text(excluded)
if key == "hatching":
expect(body).to_contain_text(unsafe)
expect(body.locator("img,script")).to_have_count(0)
self.task("incubator")
expect(self.page.locator("#log-lines")).to_contain_text("only-hatching")
expect(self.page.locator("#log-lines .log-entry")).to_have_count(2)
for key in "bag battles statistics plans yields".split():
self.task(key)
expect(self.page.locator("#log-lines .log-entry")).to_have_count(0)
self.assertEqual(self.download(), "", "Read-only pages have no invented all-category mode")
self.assertIsNone(self.page.evaluate("window.__unsafeLog"))
for _, _, _, query in self.log_calls:
self.assertEqual(set(query), {"after", "debug"})
def test_first_paint_both_legacy_configs_debug_and_passive_refreshes_stay_collapsed(self):
self.add("login", "login-before-config")
detail_marker = "LOGFIX_REFRESH_DETAIL_ONLY_IN_ORIGINAL_LOG_REGION_7c91"
self.page.route(self.base + f"/api/accounts/{self.first}/actions/refresh", lambda route: self.fulfill(route, {
"id": "logfix-refresh", "operation": "refresh", "status": "succeeded",
"result": {"message": detail_marker + "\nEngine diagnostic: synthetic mixed gift/login log details."},
"error": None,
}))
config_url = self.base + f"/api/accounts/{self.first}/config"
for legacy_visible in (True, False):
with self.subTest(legacy_log_visible=legacy_visible):
config = self.manager.get_config(self.first)["config"]
config["log_visible"] = legacy_visible
pending = self.manager.set_config(self.first, config)
self.await_job(self.first, pending["job_id"])
held = []
self.page.route(config_url, lambda route: held.append(route))
with self.page.expect_request(config_url):
response = self.page.goto(self.base, wait_until="domcontentloaded")
for identifier in ("log-panel", "log-resizer"):
tag = re.search(r'<[^>]+\bid="' + identifier + r'"[^>]*>', response.text())
self.assertIsNotNone(tag, f"Original #{identifier} must exist in the HTML")
self.assertRegex(tag.group(), r"\bhidden(?:\s|=|>)", "The HTML itself must be collapsed before config loads")
expect(self.page.locator("#" + identifier)).to_be_hidden()
self.original_region()
expect(self.page.locator("#log-toggle")).to_have_attribute("aria-expanded", "false")
self.assertEqual(len(held), 1)
self.page.unroute(config_url)
self.fulfill(held[0], self.manager.get_config(self.first))
self.wait_saved()
self.poll()
expect(self.page.locator("#log-panel")).to_be_hidden()
for debug in ("true", "false"):
with self.page.expect_response(lambda response: f"/logs?after=0&debug={debug}" in response.url):
self.page.locator("#debug-toggle").click()
expect(self.page.locator("#log-panel")).to_be_hidden()
self.refresh_config(not legacy_visible)
with self.page.expect_response(self.base + f"/api/accounts/{self.first}/status"):
self.page.locator("#refresh").click()
expect(self.page.locator("#status-text")).to_have_text("状态已刷新")
expect(self.page.locator("#log-panel")).to_be_hidden()
expect(self.page.locator("#notice")).not_to_contain_text(detail_marker)
outside_logs = self.page.locator("body").evaluate("""node => {
const copy=node.cloneNode(true);copy.querySelector('#log-panel')?.remove();return copy.textContent;
}""")
self.assertNotIn(detail_marker, outside_logs, "Refresh diagnostics belong only in the original log region")
for account in (self.second, self.first):
self.page.locator(f'.account-tab[data-account="{account}"]').click()
self.wait_saved()
expect(self.original_region()).to_be_hidden()
def test_explicit_toggle_tabs_close_reopen_bfcache_reload_reentry_and_new_context(self):
for key in ("login", "gifts", "maps"):
self.add(key, f"visible-{key}")
self.open()
self.toggle(True)
for key in ("login", "gifts", "maps", "login"):
expect(self.task(key)).to_be_visible()
expect(self.page.locator("#log-lines")).to_contain_text(f"visible-{key}")
self.refresh_config(False)
self.refresh_job()
expect(self.original_region()).to_be_visible()
self.page.locator("#log-search").fill("visible")
self.page.locator("#log-follow").uncheck()
self.toggle(False)
rows = self.page.locator("#log-lines").text_content()
self.add("login", "visible-arrived-while-closed")
self.poll()
self.refresh_config(True)
self.refresh_job()
expect(self.original_region()).to_be_hidden()
self.assertEqual(self.page.locator("#log-lines").text_content(), rows, "Closed regions do not update row DOM")
self.toggle(True)
expect(self.page.locator("#log-search")).to_have_value("visible")
expect(self.page.locator("#log-follow")).not_to_be_checked()
expect(self.page.locator("#log-lines")).to_contain_text("visible-arrived-while-closed")
# Exercise persisted lifecycle handlers even when instrumented Chromium does not use BFCache.
with self.page.expect_response(self.base + "/api/auth/status"):
self.page.evaluate("""() => {
window.dispatchEvent(new PageTransitionEvent('pagehide', {persisted:true}));
window.dispatchEvent(new PageTransitionEvent('pageshow', {persisted:true}));
}""")
expect(self.page.locator("#app")).to_be_visible()
expect(self.original_region()).to_be_hidden()
self.toggle(True)
self.wait_saved()
self.page.reload(wait_until="networkidle")
expect(self.original_region()).to_be_hidden()
self.toggle(True)
self.wait_saved()
self.page.goto(self.base + "/login", wait_until="networkidle")
expect(self.page).to_have_url(self.base + "/")
expect(self.original_region()).to_be_hidden()
self.toggle(True)
self.wait_saved()
fresh = self.browser.new_context(viewport={"width": 1280, "height": 800})
self.addCleanup(fresh.close)
fresh.route("**/*", self.local_only)
other = fresh.new_page()
other.add_init_script(self.poll_script)
other.route("**/api/accounts/*/logs?*", self.serve_logs)
other.on("pageerror", lambda failure: self.errors.append(str(failure)))
other.on("console", lambda message: self.errors.append(message.text) if message.type == "error" else None)
self.open(other)
expect(other.locator("#log-panel")).to_be_hidden()
expect(other.locator("#log-resizer")).to_be_hidden()
expect(other.locator("#log-toggle")).to_have_attribute("aria-expanded", "false")
expect(self.page.locator("#log-panel")).to_be_visible()
def test_clears_downloads_and_debug_replay_are_scoped_to_context_and_account(self):
for key in ("login", "gifts", "maps"):
self.add(key, f"{key}-before")
self.add("login", "debug-before", level="debug", debug=True)
self.add("general", "mixed-old-gift")
self.add("login", "second-login", account=self.second)
self.open()
self.task("login")
self.toggle(True)
self.assertIn("login-before", self.download())
self.assertNotIn("gift", self.download())
self.page.locator("#clear-log").click()
expect(self.page.locator("#log-lines .log-entry")).to_have_count(0)
self.assertEqual(self.download(), "")
for key in ("gifts", "maps"):
self.task(key)
self.assertIn(f"{key}-before", self.download())
self.page.locator("#clear-log").click()
self.assertEqual(self.download(), "")
self.page.locator(f'.account-tab[data-account="{self.second}"]').click()
self.task("login")
if self.page.locator("#log-panel").is_hidden():
self.toggle(True)
expect(self.page.locator("#log-lines")).to_contain_text("second-login")
self.assertNotIn("before", self.download())
self.page.locator(f'.account-tab[data-account="{self.first}"]').click()
self.task("login")
if self.page.locator("#log-panel").is_hidden():
self.toggle(True)
with self.page.expect_response(lambda response: "/logs?after=0&debug=true" in response.url):
self.page.locator("#debug-toggle").click()
expect(self.page.locator("#log-lines .log-entry")).to_have_count(0)
for key in ("login", "gifts", "maps"):
self.add(key, f"{key}-after")
self.poll()
for key in ("login", "gifts", "maps"):
self.task(key)
text = self.download()
self.assertIn(f"{key}-after", text)
for excluded in ("before", "second-login", "mixed-old", *(f"{other}-after" for other in ("login", "gifts", "maps") if other != key)):
self.assertNotIn(excluded, text)
self.assertTrue(all(request.method == "GET" for request in self.requests if "/logs" in request.url))
def test_context_filters_inputs_focus_and_single_active_dom_survive_switches(self):
self.add("hatching", "keep-first", level="warning")
self.add("gifts", "gift-initial")
self.add("hatching", "second-keep", account=self.second)
self.open()
panel = self.task("hatching")
self.toggle(True)
page_panel = self.page.locator('.page-panel[data-page="hatching"]:not([hidden])')
page_panel.locator(".subtab").last.click()
field = page_panel.locator('input[type="checkbox"]').first
checked = not field.is_checked()
field.set_checked(checked)
self.wait_saved()
field.evaluate("node => {window.__preservedInput=node;}")
query = panel.get_by_role("searchbox")
query.fill("keep")
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(panel.locator(".log-entry")).to_have_count(2)
self.assertNotIn("excluded-info", self.download())
gifts = self.task("gifts")
expect(query).to_have_value("")
gifts.get_by_role("searchbox").fill("gift")
self.add("hatching", "keep-hidden", level="warning")
self.add("gifts", "gift-new")
self.poll()
expect(gifts.locator("#log-lines")).to_contain_text("gift-new")
expect(self.page.locator(".page-panel .log-entry")).to_have_count(0)
expect(self.page.locator(".log-entry")).to_have_count(2)
self.task("hatching")
expect(query).to_have_value("keep")
expect(panel.locator(".log-entry")).to_have_count(3)
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()
self.task("hatching")
if panel.is_hidden():
self.toggle(True)
expect(query).to_have_value("")
expect(panel.locator("#log-lines")).to_contain_text("second-keep")
expect(panel.locator("#log-lines")).not_to_contain_text("keep-first")
self.page.locator(f'.account-tab[data-account="{self.first}"]').click()
self.task("hatching")
if panel.is_hidden():
self.toggle(True)
expect(query).to_have_value("keep")
expect(page_panel.locator('.subtab[aria-selected="true"]')).to_have_text("喂养策略")
self.task("gifts")
expect(query).to_have_value("gift")
def test_reading_follow_collapse_bounded_append_and_original_resizer(self):
for i in range(650):
self.add("maps", f"map-record-{i:04}")
self.open()
self.task("maps")
self.toggle(True)
lines, follow = self.page.locator("#log-lines"), self.page.locator("#log-follow")
expect(lines.locator(".log-entry")).to_have_count(600)
expect(follow).to_be_checked()
lines.evaluate("node => {node.scrollTop=node.scrollHeight/2;node.dispatchEvent(new Event('scroll'));}")
expect(follow).not_to_be_checked()
position = lines.evaluate("""node => {
window.__readingRow=[...node.children].find(row=>row.getBoundingClientRect().top>=node.getBoundingClientRect().top);
return {scroll:node.scrollTop, offset:window.__readingRow.getBoundingClientRect().top-node.getBoundingClientRect().top,
parent:document.querySelector('.page-panel:not([hidden])').scrollTop};
}""")
self.add("maps", "map-new")
self.poll()
self.assertTrue(lines.evaluate("node => node.contains(window.__readingRow)"))
self.assertAlmostEqual(position["offset"], lines.evaluate("node => window.__readingRow.getBoundingClientRect().top-node.getBoundingClientRect().top"), delta=1)
self.assertEqual(position["parent"], self.page.locator('.page-panel:not([hidden])').evaluate("node => node.scrollTop"))
self.page.locator("#log-search").fill("map-")
paused = lines.evaluate("node => node.scrollTop")
self.toggle(False)
self.toggle(True)
self.assertEqual(lines.evaluate("node => node.scrollTop"), paused, "Unchanged close/reopen restores reading position")
expect(follow).not_to_be_checked()
expect(self.page.locator("#log-search")).to_have_value("map-")
self.toggle(False)
previous = lines.text_content()
self.add("maps", "map-while-collapsed")
self.poll()
self.assertEqual(lines.text_content(), previous)
self.toggle(True)
expect(lines).to_contain_text("map-while-collapsed")
expect(follow).not_to_be_checked()
self.page.locator("#log-search").fill("")
follow.check()
self.assertLessEqual(lines.evaluate("node => node.scrollHeight-node.scrollTop-node.clientHeight"), 1)
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(self.page.locator(".log-entry")).to_have_count(600)
text = self.download()
self.assertEqual(len(text.splitlines()), 1200, "Downloads use the shared buffer, not only the 600 DOM rows")
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(), text, "Debug cursor rewinds cannot resurrect evicted records")
splitter = self.page.locator("#log-resizer")
old_height = int(splitter.get_attribute("aria-valuenow"))
box = splitter.bounding_box()
self.page.mouse.move(box["x"] + box["width"] / 2, box["y"] + box["height"] / 2)
self.page.mouse.down()
self.page.mouse.move(box["x"] + box["width"] / 2, box["y"] - 36, steps=5)
self.page.mouse.up()
self.assertGreater(int(splitter.get_attribute("aria-valuenow")), old_height)
splitter.focus()
resized = int(splitter.get_attribute("aria-valuenow"))
splitter.press("ArrowDown")
self.assertEqual(int(splitter.get_attribute("aria-valuenow")), resized - 16)
self.wait_saved()
self.assertEqual(self.manager.get_config(self.first)["config"]["log_sizes"][1], resized - 16)
self.original_region()
def test_hidden_account_context_switches_keep_reading_state_and_reject_late_other_account_logs(self):
for i in range(85):
self.add("maps", f"first-{i:03}")
self.add("gifts", f"gift-{i:03}")
self.add("maps", f"second-{i:03}", account=self.second)
self.open()
self.task("maps")
self.toggle(True)
lines, follow = self.page.locator("#log-lines"), self.page.locator("#log-follow")
def read_at(position):
lines.evaluate("(node, position) => {node.scrollTop=position;node.dispatchEvent(new Event('scroll'));}", position)
expect(follow).not_to_be_checked()
return lines.evaluate("node => node.scrollTop")
first_position = read_at(140)
self.task("gifts")
expect(follow).to_be_checked()
gift_position = read_at(280)
self.task("maps")
expect(follow).not_to_be_checked()
self.assertEqual(lines.evaluate("node => node.scrollTop"), first_position)
self.toggle(False)
self.page.locator(f'.account-tab[data-account="{self.second}"]').click()
self.task("maps")
expect(self.original_region()).to_be_hidden()
self.toggle(True)
expect(follow).to_be_checked()
second_position = read_at(260)
self.toggle(False)
self.page.locator(f'.account-tab[data-account="{self.first}"]').click()
self.task("maps")
expect(self.original_region()).to_be_hidden()
self.toggle(True)
expect(follow).not_to_be_checked()
self.assertEqual(lines.evaluate("node => node.scrollTop"), first_position)
self.task("gifts")
self.assertEqual(lines.evaluate("node => node.scrollTop"), gift_position)
self.task("maps")
held = []
self.add("maps", "late-first-account")
self.page.route(f"**/api/accounts/{self.first}/logs?*", lambda route: held.append(route))
with self.page.expect_request(lambda request: f"/accounts/{self.first}/logs?" in request.url):
self.page.evaluate("async () => {await window.__pollLogs();}")
self.add("maps", "second-after-switch", account=self.second)
self.page.locator(f'.account-tab[data-account="{self.second}"]').click()
self.task("maps")
if self.page.locator("#log-panel").is_hidden():
self.toggle(True)
expect(lines).to_contain_text("second-084")
expect(lines).to_contain_text("second-after-switch")
self.assertEqual(len(held), 1)
self.serve_logs(held[0])
self.poll()
expect(lines).not_to_contain_text("late-first-account")
expect(lines).not_to_contain_text("first-")
expect(follow).not_to_be_checked()
self.assertEqual(lines.evaluate("node => node.scrollTop"), second_position)
def test_dense_login_form_and_server_choices_receive_normal_clicks_at_three_viewports(self):
login = self.dense_fixture()
actions = []
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})
for operation in ("login", "enter_server", "restore_session"):
self.page.route(f"**/api/accounts/{self.first}/actions/{operation}", login_action)
self.open()
self.task("login")
self.toggle(True)
for width, height in self.viewports:
with self.subTest(viewport=(width, height)):
self.page.set_viewport_size({"width": width, "height": height})
self.task("login")
panel = self.page.locator('.page-panel[data-page="login"]:not([hidden])')
expect(self.page.locator("#log-lines .log-entry")).to_have_count(140)
expect(self.page.locator("#log-lines")).not_to_contain_text("synthetic-gifts-")
expect(self.page.locator("#log-lines")).not_to_contain_text("synthetic-general-")
account, password = panel.get_by_label("游戏账号", exact=True), panel.get_by_label("游戏密码", exact=True)
self.click_unobscured(account)
account.fill("offline-layout")
self.click_unobscured(password)
password.fill("synthetic-layout-password")
self.layout_artifact("login-form")
for operation, label in (("login", "账号密码登录 / 获取区服"),
("enter_server", "进入选中区服"),
("restore_session", "恢复选中会话(无需重新输密码)")):
if operation != "login":
choice = panel.get_by_label("区服 / 角色" if operation == "enter_server" else "已保存的账号 / 区服 / 角色", exact=True)
self.click_unobscured(choice)
choice.press("Escape")
choice.select_option("36" if operation == "enter_server" else "layout-session-36")
with self.page.expect_response(lambda response: response.url.endswith(f"/actions/{operation}")):
self.click_unobscured(panel.get_by_role("button", name=label, exact=True))
self.assertEqual(actions[-1][0], operation)
if operation == "login":
self.assertEqual(actions[-1][1], {"account": "offline-layout", "password": "synthetic-layout-password", "remember": True})
expect(password).to_have_value("")
else:
self.assertEqual(actions[-1][1], {"server_id": "36"} if operation == "enter_server" else {"session_id": "layout-session-36"})
self.layout_artifact("login-sessions")
self.assertEqual(self.page.evaluate("localStorage.length + sessionStorage.length"), 0)
self.assertNotIn("synthetic-layout-password", self.page.url)
def test_dense_maps_and_gifts_keep_original_workbench_controls_reachable_at_three_viewports(self):
self.dense_fixture()
self.open()
self.toggle(True)
for width, height in self.viewports:
self.page.set_viewport_size({"width": width, "height": height})
for key, label in (("maps", "启用勾选关卡自动刷图"), ("gifts", "启用自动赠礼")):
with self.subTest(viewport=(width, height), page=key):
self.task(key)
panel = self.page.locator(f'.page-panel[data-page="{key}"]:not([hidden])')
checkbox = panel.get_by_label(label, exact=True)
previous = checkbox.is_checked()
self.click_unobscured(checkbox)
self.assertEqual(checkbox.is_checked(), not previous)
self.wait_saved()
rows = panel.locator("tbody tr[data-row-id]")
expect(rows).to_have_count(48)
rows.last.scroll_into_view_if_needed()
self.assertTrue(rows.last.evaluate("""node => {
const r=node.getBoundingClientRect(), content=node.closest('.page-panel').getBoundingClientRect();
return r.top>=content.top-1 && r.bottom<=content.bottom+1;
}"""), "The final original table row must remain reachable above the bottom logs")
if key == "maps":
limit = rows.last.locator('td[data-column="limit"] input')
self.layout_artifact("maps-controls")
self.click_unobscured(limit)
limit.fill("7")
limit.press("Tab")
self.wait_saved()
self.assertEqual(self.manager.get_config(self.first)["config"]["sweep_policy"]["rules"]["synthetic47"]["limit"], 7)
body = self.page.locator("#log-lines")
expect(body).to_contain_text(f"synthetic-{key}-")
expect(body).not_to_contain_text("synthetic-login-")
expect(self.page.locator(".page-panel .log-entry")).to_have_count(0)
self.assertLessEqual(self.page.locator(".log-entry").count(), 600)
self.layout_artifact(key)
if __name__ == "__main__":
unittest.main()