280 lines
17 KiB
Python
280 lines
17 KiB
Python
"""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
|
||
enable = fixtures.ServiceTests.enable
|
||
|
||
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):
|
||
for kind, category in (("hatch", "hatching"), ("gift", "gifts"), ("explore", "exploration"), ("breakthrough", "ranch"), ("auto_relogin", "login")):
|
||
with self.subTest(kind=kind):
|
||
# Each error owns a bounded retry deadline. Use independent
|
||
# enabled workers so one error cannot suppress the next case.
|
||
identifier = self.account()
|
||
self.enable(identifier)
|
||
self.job(identifier, self.manager.submit(identifier, "start"))
|
||
worker = self.manager._worker(identifier)
|
||
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 = []
|
||
primary = next(iter(engine.cultivation.select(engine.snapshot).values()))
|
||
food = next(mon for mon in engine.snapshot.monsters.values()
|
||
if mon.get("process") == 3 and mon.get("typeId") == primary["typeId"]
|
||
and int(mon["id"]) != int(primary["id"]) and not mon.get("lock") and not mon.get("sysLock"))
|
||
original_post = engine.client.http.post
|
||
|
||
def consume_feed(url, data, **kwargs):
|
||
if url.endswith("monsterService/monsterIntensify"):
|
||
payload = fixtures.decode(data, engine.client.session.key)
|
||
foods = {int(mid) for mid in payload["foods"]}
|
||
engine.client.raw["monsters"] = [mon for mon in engine.client.raw["monsters"] if int(mon["id"]) not in foods]
|
||
return original_post(url, data, **kwargs)
|
||
|
||
actions = [
|
||
Action("buy", "莉莉托斯市场十连抽蛋 ×10,花费100金币", "gachaService/gachaGetEggs", {"id": market, "num": 1}),
|
||
Action("sell", "派遣 测试魔物 #1", "monsterService/monsterSell", {"monsterIds": [1]}),
|
||
Action("feed", "喂养 测试魔物 ← 素材", "monsterService/monsterIntensify",
|
||
{"targetId": int(primary["id"]), "foods": [int(food["id"])]}),
|
||
]
|
||
for action in actions:
|
||
with self.subTest(kind=action.kind):
|
||
worker._running = True
|
||
after = self.manager.logs(identifier, debug=True)["next"]
|
||
calls_before = len(fixtures.FakeClient.calls)
|
||
with patch.object(engine, "plans", return_value=[action]), \
|
||
patch.object(engine.client.http, "post", side_effect=consume_feed):
|
||
self.tick(identifier, "poll")
|
||
if action.kind == "feed":
|
||
self.assertEqual([{key: payload[key] for key in action.payload}
|
||
for _, url, payload in fixtures.FakeClient.calls[calls_before:]
|
||
if url.endswith(action.path)], [action.payload])
|
||
self.assertNotIn(int(food["id"]), engine.snapshot.monsters)
|
||
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()
|