Release Web 2.0.2 task logs
This commit is contained in:
@@ -131,6 +131,9 @@ class BasePathBrowserTests(unittest.TestCase):
|
||||
panel = page.locator(f'.page-panel[data-page="{key}"]:not([hidden])')
|
||||
expect(panel.locator('.page-loading[data-loading="false"]')).to_have_count(1)
|
||||
self.assertEqual(panel.locator(".page-error:not([hidden])").count(), 0)
|
||||
if key in "login ranch daily hatching mainline gifts commissions exploration maps".split():
|
||||
expect(panel.locator(f'.task-log-panel[data-task-log="{key}"]')).to_have_count(1)
|
||||
expect(panel.locator('.task-log-lines')).to_have_attribute('aria-live', 'off')
|
||||
|
||||
# The server redirects an authenticated login URL back to this workbench.
|
||||
page.goto(base + "/login", wait_until="networkidle")
|
||||
@@ -149,6 +152,7 @@ class BasePathBrowserTests(unittest.TestCase):
|
||||
self.assertEqual(escapes, [], "Browser requests escaped the configured prefix or local server")
|
||||
self.assertEqual(errors, [], "JavaScript or CSP errors")
|
||||
self.assertTrue(any(request.url == base + "/static/paths.js" for request in requests))
|
||||
self.assertTrue(any(request.url == base + "/static/task-logs.js" for request in requests))
|
||||
|
||||
def test_preserved_prefix(self):
|
||||
self.check_deployment("/ranch")
|
||||
|
||||
@@ -0,0 +1,471 @@
|
||||
"""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 = '<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)
|
||||
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()
|
||||
@@ -9,6 +9,7 @@ import unittest
|
||||
from unittest.mock import patch
|
||||
|
||||
from ranch_web.activity import ActivityLog, ActivityLogError, MAX_MESSAGE_CHARS
|
||||
from ranch_web.log_categories import CATEGORIES
|
||||
|
||||
|
||||
class ActivityTests(unittest.TestCase):
|
||||
@@ -33,6 +34,34 @@ class ActivityTests(unittest.TestCase):
|
||||
fsync.assert_not_called()
|
||||
self.assertFalse(self.path.parent.exists())
|
||||
|
||||
def test_categories_and_error_level_persist_across_restart(self):
|
||||
log = self.log(sequence_block_size=8)
|
||||
for category in sorted(CATEGORIES):
|
||||
self.append(log, "attributed operation", category=category, level="error")
|
||||
for invalid in ("breakthrough", "unknown", "TOKEN_SECRET", {}, [], None):
|
||||
self.assertEqual(self.append(log, category=invalid)["category"], "general")
|
||||
debug = self.append(log, "transient categorized trace", category="gifts", debug=True)
|
||||
restored = self.log(sequence_block_size=8)
|
||||
self.assertEqual(restored.load(), log.load())
|
||||
self.assertEqual({entry["category"] for entry in restored.load() if entry["level"] == "error"}, CATEGORIES)
|
||||
self.assertGreater(self.append(restored, category="daily")["seq"], debug["seq"])
|
||||
self.assertNotIn("TOKEN_SECRET", self.path.read_text(encoding="utf-8"))
|
||||
|
||||
def test_legacy_categories_are_conservative_and_loading_never_migrates(self):
|
||||
self.path.parent.mkdir(parents=True)
|
||||
messages = [("自动赠礼:请先选择物品", "gifts"), ("突破请求待核对", "ranch"),
|
||||
("状态已刷新;自动赠礼:冷却中", "general"), ("事件已完成", "general"),
|
||||
("已推进普通剧情并保存本地检查点", "general")]
|
||||
record = {"schema": 1, "sequence": 20, "entries": [
|
||||
{"seq": index, "message": message} for index, (message, _) in enumerate(messages, 1)]}
|
||||
raw = json.dumps(record, ensure_ascii=False)
|
||||
self.path.write_text(raw, encoding="utf-8")
|
||||
with patch("ranch_web.activity.os.replace") as replace:
|
||||
entries = self.log().load()
|
||||
replace.assert_not_called()
|
||||
self.assertEqual([entry["category"] for entry in entries], [category for _, category in messages])
|
||||
self.assertEqual(self.path.read_text(encoding="utf-8"), raw)
|
||||
|
||||
def test_account_isolation_and_persistence(self):
|
||||
log = self.log()
|
||||
first = self.append(log, "account A operation", level="warning")
|
||||
@@ -161,7 +190,7 @@ class ActivityTests(unittest.TestCase):
|
||||
"response": {"raw": secret}, "seq": 90000, "id": 90000}
|
||||
log = self.log()
|
||||
saved = log.append(entry)
|
||||
self.assertEqual(set(saved), {"time", "message", "debug", "level", "id", "seq"})
|
||||
self.assertEqual(set(saved), {"time", "message", "category", "debug", "level", "id", "seq"})
|
||||
self.assertEqual(saved["seq"], 1)
|
||||
for filename in (self.path, self.watermark):
|
||||
raw = filename.read_text(encoding="utf-8")
|
||||
|
||||
@@ -0,0 +1,254 @@
|
||||
"""Offline task routing, bounded persistence, and lazy debug contract regressions."""
|
||||
from copy import deepcopy
|
||||
import json
|
||||
import threading
|
||||
from types import SimpleNamespace
|
||||
import unittest
|
||||
from unittest.mock import patch
|
||||
|
||||
from ranch_assistant.battles import CancelledBeforeDispatch
|
||||
from ranch_assistant.engine import Engine
|
||||
from ranch_assistant.model import Action
|
||||
from ranch_web.activity import MAX_MESSAGE_CHARS
|
||||
from ranch_web.log_categories import CATEGORIES, endpoint_category, legacy_category, route_message
|
||||
from ranch_web.service import WebManager
|
||||
from ranch_web.tests import test_service as fixtures
|
||||
|
||||
|
||||
class RoutingTests(unittest.TestCase):
|
||||
def test_reward_cooldown_and_purchase_continuations(self):
|
||||
for message, category in [
|
||||
("扫荡完成:2-11;金币32;经验64;蓝色黏液×1", "maps"),
|
||||
("自动赠礼:魔物还需等待;冷却尚未结束;好感上限100", "gifts"),
|
||||
("购蛋暂停:余额需保留100;今日额度剩余0;补货目标至少设为10", "hatching"),
|
||||
]:
|
||||
with self.subTest(category=category):
|
||||
self.assertEqual(route_message(message), [(category, message)])
|
||||
self.assertEqual(route_message("扫荡完成:2-11;金币32;状态已刷新", context="maps"),
|
||||
[("maps", "扫荡完成:2-11;金币32"), ("general", "状态已刷新")])
|
||||
|
||||
def test_uncertain_legacy_and_shared_endpoints_stay_general(self):
|
||||
for message in ("事件已完成", "未知结果", "状态已刷新;自动赠礼:冷却中", "魔物名为探险,普通提示"):
|
||||
self.assertEqual(legacy_category(message), "general")
|
||||
self.assertEqual(endpoint_category("taskService/taskCompleteStep"), "general")
|
||||
self.assertEqual(endpoint_category("taskService/taskCompleteStep", active="commissions"), "commissions")
|
||||
self.assertEqual(endpoint_category("https://offline.invalid/game/exploreService/finish"), "exploration")
|
||||
|
||||
|
||||
class TaskLogTests(unittest.TestCase):
|
||||
# Reuse the existing real-engine/offline HTTP fixture without inheriting its
|
||||
# unrelated test cases or adding browser/GUI dependencies to image CI.
|
||||
setUp = fixtures.ServiceTests.setUp
|
||||
account = fixtures.ServiceTests.account
|
||||
idle = fixtures.ServiceTests.idle
|
||||
job = fixtures.ServiceTests.job
|
||||
login = fixtures.ServiceTests.login
|
||||
|
||||
def tick(self, identifier, kind, *, status="succeeded"):
|
||||
worker = self.manager._worker(identifier)
|
||||
with patch.object(worker.schedule, "due", return_value=kind):
|
||||
return self.job(identifier, worker.enqueue("__tick"), status=status)
|
||||
|
||||
def entries(self, identifier, after=0, debug=False):
|
||||
return self.manager.logs(identifier, after=after, debug=debug)["entries"]
|
||||
|
||||
def test_mixed_poll_groups_hundreds_of_notes_into_bounded_writes(self):
|
||||
identifier = self.account()
|
||||
worker = self.manager._worker(identifier)
|
||||
hatch = [f"魔物{index}:资质未同步,等待成长结算;暂不派遣、喂养或收取" for index in range(160)]
|
||||
gifts = ["自动赠礼:代表还需等待;冷却尚未结束"]
|
||||
ranch = ["代表:材料不足,保留突破目标"]
|
||||
worker.engine.planner.notes = hatch + gifts + ranch
|
||||
worker.engine.gift_planner.notes = gifts
|
||||
worker.engine.breakthrough_planner.notes = ranch
|
||||
message = ";".join(["状态已刷新", *hatch, *gifts, *ranch, "探索奖励事件已结算:2-11", "金币32", "经验64", "蓝色黏液×1"])
|
||||
after = self.manager.logs(identifier)["next"]
|
||||
with patch.object(worker.engine, "poll", return_value=(worker.engine.snapshot, [], message)), \
|
||||
patch.object(worker._activity, "_write", wraps=worker._activity._write) as write:
|
||||
self.tick(identifier, "poll")
|
||||
entries = self.entries(identifier, after)
|
||||
by_category = {entry["category"]: entry for entry in entries}
|
||||
self.assertEqual(set(by_category), {"general", "hatching", "gifts", "ranch", "maps"})
|
||||
self.assertEqual(len(entries), len(by_category))
|
||||
self.assertEqual(sum(call.args[0] == worker.profile_root / "activity.json" for call in write.call_args_list), len(entries))
|
||||
self.assertLessEqual(len(entries), len(CATEGORIES))
|
||||
self.assertTrue(all(len(entry["message"]) <= MAX_MESSAGE_CHARS for entry in entries))
|
||||
self.assertEqual(by_category["general"]["message"], "状态已刷新")
|
||||
self.assertIn("蓝色黏液×1", by_category["maps"]["message"])
|
||||
self.assertIn("冷却尚未结束", by_category["gifts"]["message"])
|
||||
self.assertFalse(any(entry["message"] == message for entry in entries))
|
||||
|
||||
def test_actual_progression_context_routes_generic_results_and_errors(self):
|
||||
calls = []
|
||||
worker = None
|
||||
|
||||
def action(engine, intent=None):
|
||||
calls.append(intent)
|
||||
worker.trace.emit("response", "taskService/taskCompleteStep", body={"accepted": True})
|
||||
if intent.get("fail"):
|
||||
raise OSError("local checkpoint failed")
|
||||
return engine.snapshot, [], "已推进普通剧情并保存本地检查点"
|
||||
|
||||
with patch.object(Engine, "_run_progression_intent", action):
|
||||
identifier = self.account()
|
||||
worker = self.manager._worker(identifier)
|
||||
for task_type, category in ((1, "mainline"), (4, "commissions")):
|
||||
for fail in (False, True):
|
||||
intent = {"kind": "progression_dialogue", "task_type_id": "known-task", "fail": fail}
|
||||
after = self.manager.logs(identifier, debug=True)["next"]
|
||||
with patch.object(worker.engine, "game_data", SimpleNamespace(task=lambda _: {"type": task_type})), \
|
||||
patch.object(worker.engine, "poll", side_effect=lambda **_: worker.engine._run_progression_intent(intent)):
|
||||
self.tick(identifier, "poll", status="failed" if fail else "succeeded")
|
||||
entries = self.entries(identifier, after, debug=True)
|
||||
self.assertEqual({entry["category"] for entry in entries}, {category})
|
||||
self.assertEqual(len(entries), 2)
|
||||
self.assertEqual(entries[-1]["level"], "error" if fail else "info")
|
||||
detail = self.manager.debug_entry(identifier, entries[0]["id"])
|
||||
self.assertTrue(detail["details"]["body"]["accepted"])
|
||||
self.assertEqual(len(calls), 4)
|
||||
after = self.manager.logs(identifier)["next"]
|
||||
with patch.object(worker.engine, "poll", return_value=(worker.engine.snapshot, [], "状态已刷新")):
|
||||
self.job(identifier, self.manager.submit(identifier, "refresh"))
|
||||
self.assertEqual(self.entries(identifier, after)[0]["category"], "general")
|
||||
|
||||
def test_attribution_metadata_failure_does_not_fail_or_repeat_action(self):
|
||||
calls = []
|
||||
|
||||
def action(engine, intent):
|
||||
calls.append(intent)
|
||||
return engine.snapshot, [], "unattributed local result"
|
||||
|
||||
with patch.object(Engine, "_run_progression_intent", action):
|
||||
identifier = self.account()
|
||||
worker = self.manager._worker(identifier)
|
||||
after = self.manager.logs(identifier)["next"]
|
||||
with patch.object(worker.engine, "_is_commission", side_effect=ValueError("metadata unavailable")), \
|
||||
patch.object(worker.engine, "poll", side_effect=lambda **_: worker.engine._run_progression_intent({"kind": "progression_dialogue"})):
|
||||
self.tick(identifier, "poll")
|
||||
self.assertEqual(len(calls), 1)
|
||||
self.assertEqual(self.entries(identifier, after)[0]["category"], "general")
|
||||
|
||||
def test_fast_and_auth_errors_keep_source_category_and_error_level(self):
|
||||
identifier = self.account()
|
||||
worker = self.manager._worker(identifier)
|
||||
for kind, category in (("hatch", "hatching"), ("gift", "gifts"), ("explore", "exploration"), ("breakthrough", "ranch"), ("auto_relogin", "login")):
|
||||
with self.subTest(kind=kind):
|
||||
worker._running = True
|
||||
after = self.manager.logs(identifier)["next"]
|
||||
with patch.object(worker.engine, "poll_automation", side_effect=ValueError("task failed")), \
|
||||
patch.object(worker, "_auto_relogin_status", return_value={"state": "waiting"}), \
|
||||
patch.object(worker, "_auto_relogin", side_effect=ValueError("task failed")):
|
||||
self.tick(identifier, kind, status="failed")
|
||||
entry = self.entries(identifier, after)[-1]
|
||||
self.assertEqual((entry["category"], entry["level"]), (category, "error"))
|
||||
self.assertEqual(worker._activity.load()[-1]["category"], category)
|
||||
self.assertEqual(worker._activity.load()[-1]["level"], "error")
|
||||
|
||||
def test_manual_errors_use_operation_category(self):
|
||||
identifier = self.account()
|
||||
worker = self.manager._worker(identifier)
|
||||
for operation, method, category in (("claim_daily", "claim_daily", "daily"), ("refresh_maps", "refresh_stages", "maps")):
|
||||
after = self.manager.logs(identifier)["next"]
|
||||
with patch.object(worker.engine, method, side_effect=ValueError("manual operation failed")):
|
||||
self.job(identifier, self.manager.submit(identifier, operation), status="failed")
|
||||
self.assertEqual([(row["category"], row["level"]) for row in self.entries(identifier, after)], [(category, "error")])
|
||||
|
||||
def test_real_ordinary_poll_attributes_market_purchase_and_automatic_cleanup(self):
|
||||
identifier = self.account(False)
|
||||
self.login(identifier)
|
||||
worker = self.manager._worker(identifier)
|
||||
engine = worker.engine
|
||||
market = next(key for key, row in engine.catalog.data["markets"].items() if row.get("money", 0) > 0)
|
||||
engine.policy.daily_buy_money = 1000000
|
||||
engine.planner.notes = []
|
||||
actions = [
|
||||
Action("buy", "莉莉托斯市场十连抽蛋 ×10,花费100金币", "gachaService/gachaGetEggs", {"id": market, "num": 1}),
|
||||
Action("sell", "派遣 测试魔物 #1", "monsterService/monsterSell", {"monsterIds": [1]}),
|
||||
Action("feed", "喂养 测试魔物 ← 素材", "monsterService/monsterIntensify", {"targetId": 1, "foods": []}),
|
||||
]
|
||||
for action in actions:
|
||||
with self.subTest(kind=action.kind):
|
||||
worker._running = True
|
||||
after = self.manager.logs(identifier, debug=True)["next"]
|
||||
with patch.object(engine, "plans", return_value=[action]):
|
||||
self.tick(identifier, "poll")
|
||||
entries = self.entries(identifier, after, debug=True)
|
||||
result = [row for row in entries if not row["debug"]]
|
||||
self.assertEqual({row["category"] for row in result}, {"hatching"})
|
||||
self.assertIn(action.description, result[0]["message"])
|
||||
debug = [row for row in entries if action.path in row["message"]]
|
||||
self.assertTrue(debug)
|
||||
self.assertEqual({row["category"] for row in debug}, {"hatching"})
|
||||
# The same endpoint belongs to the explicit manual management operation.
|
||||
after = self.manager.logs(identifier, debug=True)["next"]
|
||||
self.job(identifier, self.manager.submit(identifier, "sell", {"monster_ids": [201], "confirm": True}), status="failed")
|
||||
self.assertEqual(self.entries(identifier, after)[-1]["category"], "ranch")
|
||||
|
||||
def test_redaction_before_splitting_restart_cursor_and_lazy_debug_isolation(self):
|
||||
identifier, other = self.account(), self.account()
|
||||
worker = self.manager._worker(identifier)
|
||||
secrets = ("secret;parts", "line-secret\nline-parts")
|
||||
worker.remember({"password": secrets[0], "token": secrets[1]})
|
||||
after = self.manager.logs(identifier)["next"]
|
||||
worker.result(worker.engine.snapshot, [], f"状态已刷新;自动赠礼:{secrets[0]};突破:{secrets[1]}")
|
||||
# A trace is exactly one summary/ID, even with a composite diagnostic.
|
||||
worker.trace.emit("response", "monsterService/monsterSendGift", message="赠礼;突破;探险",
|
||||
headers={"Authorization": secrets[0]}, body={"token": secrets[1], "ok": True})
|
||||
all_logs = self.manager.logs(identifier, after=after, debug=True)
|
||||
traces = [entry for entry in all_logs["entries"] if entry["details_available"]]
|
||||
self.assertEqual(len(traces), 1)
|
||||
trace = traces[0]
|
||||
self.assertEqual(trace["category"], "gifts")
|
||||
self.assertEqual(trace["id"], trace["seq"])
|
||||
self.assertTrue(self.manager.debug_entry(identifier, trace["id"])["details"]["body"]["ok"])
|
||||
with self.assertRaises(KeyError):
|
||||
self.manager.debug_entry(other, trace["id"])
|
||||
self.assertFalse(any(row["debug"] for row in self.entries(identifier, after)))
|
||||
self.assertEqual(self.manager.logs(identifier)["next"], all_logs["next"])
|
||||
self.assertEqual(self.manager.logs(identifier, after=all_logs["next"], debug=True)["entries"], [])
|
||||
serialized = json.dumps(all_logs, ensure_ascii=False) + (worker.profile_root / "activity.json").read_text(encoding="utf-8")
|
||||
for fragment in ("secret", "parts", "line-secret", "line-parts", '"headers"', '"body"'):
|
||||
self.assertNotIn(fragment, serialized)
|
||||
durable = deepcopy(worker._activity.load())
|
||||
self.manager.close()
|
||||
self.manager = WebManager(self.root, start_scheduler=False, login_factory=fixtures.FakeLogin)
|
||||
self.addCleanup(self.manager.close)
|
||||
self.idle(identifier)
|
||||
restored = self.entries(identifier, debug=True)
|
||||
for entry in durable:
|
||||
self.assertIn(entry | {"details_available": False}, restored)
|
||||
self.assertTrue(all(not row["debug"] for row in restored))
|
||||
self.assertGreater(self.manager._worker(identifier).log("after restart", category="daily"), all_logs["next"])
|
||||
self.assertNotIn("自动赠礼:<隐藏>", json.dumps(self.entries(other), ensure_ascii=False))
|
||||
|
||||
def test_cancelled_action_keeps_external_logs_and_other_accounts_isolated(self):
|
||||
entered, release = threading.Event(), threading.Event()
|
||||
self.addCleanup(release.set)
|
||||
|
||||
def action(engine, intent):
|
||||
entered.set()
|
||||
if not release.wait(5):
|
||||
raise AssertionError("test did not release action")
|
||||
raise CancelledBeforeDispatch()
|
||||
|
||||
with patch.object(Engine, "_run_progression_intent", action):
|
||||
identifier = self.account()
|
||||
other = self.account()
|
||||
worker = self.manager._worker(identifier)
|
||||
after = self.manager.logs(identifier)["next"]
|
||||
with patch.object(worker.engine, "poll", side_effect=lambda **_: worker.engine._run_progression_intent({"kind": "progression_loop_accept"})), \
|
||||
patch.object(worker.schedule, "due", return_value="poll"):
|
||||
pending = worker.enqueue("__tick")
|
||||
self.assertTrue(entered.wait(5))
|
||||
worker.log("external notice")
|
||||
self.manager._worker(other).log("other account notice")
|
||||
worker.stop()
|
||||
release.set()
|
||||
self.job(identifier, pending, status="cancelled")
|
||||
self.assertEqual([(row["message"], row["category"], row["level"]) for row in self.entries(identifier, after)],
|
||||
[("external notice", "general", "info")])
|
||||
self.assertFalse(any(row["message"] == "other account notice" for row in self.entries(identifier)))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Reference in New Issue
Block a user