ui: keep policy controls close to their labels

This commit is contained in:
AttilaNet
2026-11-13 08:08:12 +08:00
parent 1b1fa96984
commit 2cb50839b5
16 changed files with 444 additions and 58 deletions
@@ -228,9 +228,9 @@ class AutoReloginBrowserTests(unittest.TestCase):
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("#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()
@@ -429,7 +429,7 @@ class AutoReloginBrowserTests(unittest.TestCase):
running=True, strategy_requested=True, strategy_state="running")
expect(status).to_contain_text("已恢复监控并自动执行已勾选功能")
expect(self.page.locator("#strategy-toggle")).to_have_text("停止")
expect(self.page.locator("#data-summary")).to_contain_text("正在自动执行")
expect(self.page.locator("#data-summary")).to_contain_text("策略运行中")
self.assertEqual(self.configs[self.first], original)
self.assertEqual(self.actions, [])
@@ -0,0 +1,339 @@
"""Compact policy forms, using real renderers and disposable demo accounts.
Run: python -B -m unittest ranch_web.tests.browser.test_form_layout_browser -v
No private account files or game APIs are used. Desktop review screenshots are
written to test-artifacts/ui206; table editors keep their existing inline layout.
"""
from __future__ import annotations
import copy
from pathlib import Path
import unittest
from unittest.mock import patch
from . import test_quiet_ui_browser as quiet
from . import test_workbench_browser as fixtures
if fixtures.AVAILABLE:
from playwright.sync_api import expect
VIEWPORTS = ((1920, 900), (1280, 800), (800, 900), (390, 844))
ARTIFACTS = Path(__file__).resolve().parents[3] / "test-artifacts" / "ui206"
DAILY_CHOICES = (
("gift", "每日签到礼包"), ("check", "七日签到"), ("loop", "累计奖励"),
("vip", "VIP日奖"), ("mail", "邮件附件"),
)
def checkbox_pair(checkbox):
"""Measure actual text glyphs, including multiselect's bare text nodes."""
return checkbox.evaluate("""input => {
const label = input.closest('label');
if (!label) return null;
const walker = document.createTreeWalker(label, NodeFilter.SHOW_TEXT);
let text; while ((text = walker.nextNode()) && !text.textContent.trim()) {}
if (!text) return null;
const range = document.createRange(); range.selectNodeContents(text);
return {input: input.getBoundingClientRect().toJSON(),
text: range.getBoundingClientRect().toJSON(), label: label.getBoundingClientRect().toJSON(),
caption: label.textContent.trim(), first: label.firstElementChild === input,
controls: label.querySelectorAll('input, select, button').length,
font: parseFloat(getComputedStyle(text.parentElement).fontSize)};
}""")
def assert_checkbox_pair(test, checkbox, caption):
expect(checkbox).to_be_visible()
pair = checkbox_pair(checkbox)
test.assertIsNotNone(pair, "Each checkbox needs its own wrapping text label")
test.assertTrue(pair["first"], pair)
test.assertEqual(pair["controls"], 1, pair)
test.assertEqual(pair["caption"], caption)
for size in ("width", "height"):
test.assertGreaterEqual(pair["input"][size], 14, pair)
test.assertLessEqual(pair["input"][size], 18, pair)
gap = pair["text"]["left"] - pair["input"]["right"]
test.assertGreaterEqual(gap, 4, pair)
test.assertLessEqual(gap, 12, pair)
test.assertGreaterEqual(pair["font"], 11, pair)
test.assertLessEqual(pair["text"]["right"], pair["label"]["right"] + 1, pair)
test.assertLessEqual(pair["text"]["bottom"], pair["label"]["bottom"] + 1, pair)
test.assertLess(pair["text"]["top"], pair["input"]["bottom"], pair)
test.assertGreater(pair["text"]["bottom"], pair["input"]["top"], pair)
def click_checkbox_text(page, checkbox):
checkbox.scroll_into_view_if_needed()
pair = checkbox_pair(checkbox)
if pair is None:
raise AssertionError("Checkbox text must be in a wrapping label")
text = pair["text"]
page.mouse.click(text["x"] + text["width"] / 2, text["y"] + text["height"] / 2)
@unittest.skipUnless(fixtures.AVAILABLE, "Python Playwright and a system Chromium browser are required")
class PolicyFormLayoutBrowserTests(unittest.TestCase):
# Borrow the shared-renderer harness without inheriting its unrelated tests.
base = quiet.QuietUIBrowserTests.base
setUpClass = classmethod(quiet.QuietUIBrowserTests.setUpClass.__func__)
setUp = quiet.QuietUIBrowserTests.setUp
tearDown = quiet.QuietUIBrowserTests.tearDown
fixture = quiet.QuietUIBrowserTests.fixture
reply = staticmethod(quiet.QuietUIBrowserTests.reply)
open_shell = quiet.QuietUIBrowserTests.open_shell
render_form = quiet.QuietUIBrowserTests.render_form
def test_boolean_aliases_write_exact_paths_and_passive_sync_keeps_nodes_and_focus(self):
fields = [
{"path": ["policy", key], "label": label, "type": kind, "value": True}
for key, label, kind in (("enabled", "启用管理", "boolean"),
("buy", "自动购蛋", "bool"), ("fill", "填充空坑", "checkbox"))
] + [
{"path": ["policy", "buy_batch"], "label": "单抽时每批上限", "type": "integer", "value": 3, "min": 1, "max": 100},
{"path": ["policy", "market_id"], "label": "新增规则默认市场", "type": "select", "value": "first",
"options": {"first": "第一市场", "second": "第二市场"}},
]
self.render_form(fields)
host = self.page.locator("#page-host")
nodes = host.locator("input, select").element_handles()
count = host.get_by_role("spinbutton", name="单抽时每批上限", exact=True)
market = host.get_by_role("combobox", name="新增规则默认市场", exact=True)
count.focus()
latest = copy.deepcopy(fields)
latest[0]["value"], latest[3]["value"], latest[4]["value"] = False, 19, "second"
self.page.evaluate("fields => window.quietForm.update(fields)", latest)
expect(count).to_be_focused()
expect(count).to_have_value("3")
expect(market).to_have_value("second")
expect(host.get_by_role("checkbox", name="启用管理", exact=True)).not_to_be_checked()
market.focus()
latest[4]["value"] = "first"
self.page.evaluate("fields => window.quietForm.update(fields)", latest)
expect(market).to_be_focused()
expect(market).to_have_value("second")
expect(count).to_have_value("19")
self.page.locator("#log-toggle").focus()
self.page.evaluate("fields => window.quietForm.update(fields)", latest)
expect(self.page.locator("#log-toggle")).to_be_focused()
for index, original in enumerate(nodes):
self.assertTrue(host.locator("input, select").nth(index).evaluate("(node, old) => node === old", original))
self.assertEqual(self.page.evaluate("window.writes"), [], "Passive sync must never commit edits")
for index, field in enumerate(fields[:3]):
checkbox = host.get_by_role("checkbox", name=field["label"], exact=True)
assert_checkbox_pair(self, checkbox, field["label"])
peers = host.locator('input[type="checkbox"]').evaluate_all("nodes => nodes.map(node => node.checked)")
click_checkbox_text(self.page, checkbox)
peers[index] = not peers[index]
self.assertEqual(host.locator('input[type="checkbox"]').evaluate_all("nodes => nodes.map(node => node.checked)"), peers)
writes = self.page.evaluate("window.writes")
self.assertEqual(writes[-1], {"path": field["path"], "value": peers[index]})
self.assertEqual(len(writes), index + 1)
@unittest.skipUnless(fixtures.AVAILABLE, "Python Playwright and a system Chromium browser are required")
class DemoFormLayoutBrowserTests(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
field = staticmethod(fixtures.WorkbenchBrowserTests.field)
wait_saved = fixtures.WorkbenchBrowserTests.wait_saved
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.context.set_default_timeout(5000)
self.escapes, self.writes = [], []
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.writes.append(request)
if request.method in ("POST", "PUT", "DELETE", "PATCH") else None)
self.other_config = self.manager.get_config(self.second)["config"]
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")
for request in self.writes:
self.assertEqual((request.method, request.url), ("PUT", f"{self.base}/api/accounts/{self.first}/config"))
self.assertEqual(self.manager.get_config(self.second)["config"], self.other_config)
self.assertFalse(self.manager.status(self.first)["running"])
finally:
fixtures.WorkbenchBrowserTests.tearDown(self)
def screenshot(self, key, width):
if width in (1920, 1280):
ARTIFACTS.mkdir(parents=True, exist_ok=True)
self.page.screenshot(path=str(ARTIFACTS / f"{key}-{width}.png"))
def assert_grid(self, panel):
for grid in panel.locator(".policy-form .form-grid").all():
self.assertLessEqual(grid.bounding_box()["width"], 1024, "Settings should remain near 1000px on wide screens")
self.assertLessEqual(grid.evaluate("node => node.scrollWidth - node.clientWidth"), 1)
def toggle_and_save(self, checkbox, expected):
before = len(self.writes)
click_checkbox_text(self.page, checkbox)
expect(self.page.locator("#save-status")).to_have_text("修改待保存…")
self.wait_saved()
self.assertEqual(len(self.writes), before + 1, "One text click must produce one autosave")
self.assertEqual(self.writes[-1].post_data_json["config"], expected)
self.assertEqual(self.manager.get_config(self.first)["config"], expected)
def test_daily_choices_are_a_readable_group_below_enable_and_save_independently(self):
self.open()
panel = self.go("daily")
form = panel.locator(".policy-form")
enabled = self.field(form, ["daily_policy", "enabled"])
group = form.get_by_role("group", name="领取项目", exact=True)
for width, height in VIEWPORTS:
with self.subTest(width=width):
self.page.set_viewport_size({"width": width, "height": height})
self.screenshot("daily", width)
self.assert_grid(panel)
assert_checkbox_pair(self, enabled, "启用每日奖励领取")
expect(group.get_by_role("checkbox")).to_have_count(5)
self.assertEqual(group.locator("xpath=ancestor::label").count(), 0, "The options group must be separate from the enable label")
self.assertGreaterEqual(group.bounding_box()["y"], enabled.locator("xpath=ancestor::label").bounding_box()["y"]
+ enabled.locator("xpath=ancestor::label").bounding_box()["height"])
for _, label in DAILY_CHOICES:
assert_checkbox_pair(self, group.get_by_role("checkbox", name=label, exact=True), label)
self.page.set_viewport_size({"width": 1280, "height": 800})
expected = self.manager.get_config(self.first)["config"]
expected["daily_policy"]["enabled"] = not expected["daily_policy"]["enabled"]
self.toggle_and_save(enabled, expected)
for value, label in DAILY_CHOICES:
with self.subTest(choice=value):
selected = expected["daily_policy"]["selected"]
selected.remove(value)
self.toggle_and_save(group.get_by_role("checkbox", name=label, exact=True), expected)
self.assertEqual(enabled.is_checked(), expected["daily_policy"]["enabled"])
for peer, peer_label in DAILY_CHOICES:
self.assertEqual(group.get_by_role("checkbox", name=peer_label, exact=True).is_checked(), peer in selected)
self.assertEqual(expected["daily_policy"]["selected"], [])
def test_hatching_pairs_and_complete_stacked_labels_across_all_subtabs(self):
self.open()
panel = self.go("hatching")
form = panel.locator(".policy-form")
fields = self.manager.view(self.first, "hatching", {})["data"]["form"]
for width, height in VIEWPORTS:
self.page.set_viewport_size({"width": width, "height": height})
for tab in ("孵蛋策略", "牧场策略", "喂养策略"):
with self.subTest(width=width, tab=tab):
panel.locator(f'.subtab[data-key="{tab}"]').click()
if tab == "孵蛋策略":
self.screenshot("hatching", width)
self.assert_grid(panel)
for field in (field for field in fields if field.get("group") == tab):
control = self.field(form, field["path"])
if field["type"] == "boolean":
assert_checkbox_pair(self, control, field["label"])
elif field["type"] in ("integer", "select"):
expect(control).to_have_attribute("aria-label", field["label"])
geometry = control.evaluate("""node => {
const label = node.closest('.field').querySelector('.field-label');
const range = document.createRange(); range.selectNodeContents(label);
return {caption: label.textContent, label: label.getBoundingClientRect().toJSON(),
text: range.getBoundingClientRect().toJSON(), input: node.getBoundingClientRect().toJSON()};
}""")
self.assertEqual(geometry["caption"], field["label"])
self.assertLessEqual(geometry["label"]["bottom"], geometry["input"]["top"] + 1, geometry)
self.assertLessEqual(geometry["text"]["right"], geometry["label"]["right"] + 1, geometry)
self.assertLessEqual(geometry["text"]["bottom"], geometry["label"]["bottom"] + 1, geometry)
self.page.set_viewport_size({"width": 1280, "height": 800})
panel.locator('.subtab[data-key="孵蛋策略"]').click()
expected = self.manager.get_config(self.first)["config"]
for key in ("enabled", "buy", "fill", "dispatch", "collect"):
with self.subTest(toggle=key):
expected["policy"][key] = not expected["policy"][key]
self.toggle_and_save(self.field(form, ["policy", key]), expected)
for field in (field for field in fields if field.get("group") == "孵蛋策略" and field["type"] == "boolean"):
self.assertEqual(self.field(form, field["path"]).is_checked(), expected["policy"][field["path"][1]])
def test_remote_config_sync_preserves_focused_draft_and_control_identity(self):
self.open()
panel = self.go("hatching")
form = panel.locator(".policy-form")
count = self.field(form, ["policy", "buy_batch"])
peer = self.field(form, ["policy", "keep_money"])
original = count.element_handle()
count.fill("17")
self.wait_saved()
expect(count).to_be_focused()
self.assertEqual(self.manager.get_config(self.first)["config"]["policy"]["buy_batch"], 17)
count.fill("") # An incomplete numeric draft must survive a passive refresh.
before = len(self.writes)
remote = self.manager.get_config(self.first)["config"]
remote["policy"].update(buy_batch=19, keep_money=43210)
response = self.manager.set_config(self.first, remote)
self.await_job(self.first, response["job_id"])
expect(peer).to_have_value("43210", timeout=10000)
expect(count).to_have_value("")
expect(count).to_be_focused()
self.assertTrue(count.evaluate("(node, old) => node === old", original))
self.assertEqual(len(self.writes), before, "Passive server updates must not autosave a draft")
self.assertEqual(self.manager.get_config(self.first)["config"], remote)
def test_open_logs_leave_controls_in_bounds_and_bag_editors_inline(self):
self.open()
self.page.locator("#log-toggle").click()
expect(self.page.locator("#log-panel")).to_be_visible()
for width, height in VIEWPORTS:
self.page.set_viewport_size({"width": width, "height": height})
for key in ("daily", "hatching"):
with self.subTest(width=width, page=key):
panel = self.go(key)
geometry = panel.evaluate("""panel => {
const surface = panel.querySelector('.page-surface').getBoundingClientRect();
const log = document.querySelector('#log-panel').getBoundingClientRect();
const controls = [...panel.querySelectorAll('.policy-form input, .policy-form select, .page-toolbar button'),
...document.querySelectorAll('.run-controls button, .run-controls select')];
return {overflow: document.documentElement.scrollWidth - innerWidth,
overlap: document.querySelector('#workspace').getBoundingClientRect().bottom - log.top,
surfaceOverlap: surface.bottom - log.top,
outside: controls.filter(node => {const box = node.getBoundingClientRect();
return box.width && (box.left < 0 || box.right > innerWidth + 1);}).map(node => node.outerHTML)};
}""")
self.assertLessEqual(geometry["overflow"], 1, geometry)
self.assertLessEqual(geometry["overlap"], 1, geometry)
self.assertLessEqual(geometry["surfaceOverlap"], 1, geometry)
self.assertEqual(geometry["outside"], [], geometry)
for control in panel.locator(".policy-form input, .policy-form select, .page-toolbar button").all():
control.scroll_into_view_if_needed()
self.assertTrue(control.evaluate("""node => {
const box = node.getBoundingClientRect(), log = document.querySelector('#log-panel').getBoundingClientRect();
return box.bottom <= log.top + 1 && node.contains(document.elementFromPoint(box.x + box.width / 2, box.y + box.height / 2));
}"""), "Every main control must scroll into view without being covered by logs")
self.page.set_viewport_size({"width": 1280, "height": 800})
panel = self.go("bag")
row = panel.locator("tbody tr").first
species = row.get_attribute("data-row-id")
priority = row.locator('td[data-column="priority"] input')
action = row.locator('td[data-column="action"] select')
enabled = row.locator('td[data-column="enabled"] input')
self.assertEqual(row.locator(".field, .field-label").count(), 0)
for control in (priority, action, enabled):
self.assertLessEqual(control.bounding_box()["height"], 32)
self.assertLessEqual(priority.bounding_box()["width"], 130)
priority.fill("23")
action.select_option("keep")
enabled.check()
self.wait_saved()
rule = self.manager.get_config(self.first)["config"]["policy"]["egg_rules"][species]
self.assertEqual((rule["priority"], rule["action"], rule["enabled"]), (23, "keep", True))
if __name__ == "__main__":
unittest.main()
@@ -13,6 +13,7 @@ import time
import unittest
from urllib.parse import urlsplit
from ranch_web import __version__
from .test_workbench_browser import AVAILABLE, EDGE
if AVAILABLE:
@@ -315,7 +316,7 @@ class QuietUIBrowserTests(unittest.TestCase):
expect(spinner).to_have_attribute("aria-label", "加载中")
expect(spinner).to_have_text("")
expect(spinner.locator(".loading-spinner")).to_have_attribute("aria-hidden", "true")
expect(self.page.locator("#app-version")).to_have_text("2.0.5")
expect(self.page.locator("#app-version")).to_have_text(__version__)
expect(self.page.locator("#access-mode")).to_have_text("")
expect(self.page.locator("#log-panel")).to_have_count(1)
expect(self.page.locator('[role="log"]')).to_have_count(1)