"""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 = ' & ' 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()