Add Web 2 workspace and controlled deployment updates
This commit is contained in:
@@ -0,0 +1,398 @@
|
||||
"""Parity checks with disposable offline Engines, fake transports and evidence."""
|
||||
from copy import deepcopy
|
||||
import base64
|
||||
import io
|
||||
import json
|
||||
from pathlib import Path
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
from types import SimpleNamespace
|
||||
import unittest
|
||||
from unittest.mock import Mock, patch
|
||||
|
||||
from ranch_assistant.engine import Engine, demo_snapshot
|
||||
from ranch_assistant.exploration import ExplorePlanner
|
||||
from ranch_assistant.maps import Stage
|
||||
from ranch_assistant.model import Catalog
|
||||
from ranch_web.actions import execute_action
|
||||
from ranch_web.policies import apply_config, default_config, export_config
|
||||
from ranch_web.views import build_view, PAGES, schema
|
||||
|
||||
|
||||
class OfflineWorker:
|
||||
def __init__(self, folder):
|
||||
self.profile_root = Path(folder)
|
||||
self.engine = Engine(Catalog(), budget_path=self.profile_root / "budget.json")
|
||||
self.engine.snapshot = demo_snapshot(self.engine.catalog)
|
||||
self.config = apply_config(self.engine, default_config())
|
||||
self.running, self.revision = False, 1
|
||||
self.messages = []
|
||||
self.trace = SimpleNamespace(path=self.profile_root / "network_debug.jsonl")
|
||||
|
||||
def stop(self):
|
||||
self.running = self.engine.auto = False
|
||||
|
||||
def result(self, snapshot, plans, message):
|
||||
self.engine.snapshot = snapshot
|
||||
self.messages.append(message)
|
||||
|
||||
def save_config(self, config):
|
||||
self.config = apply_config(self.engine, config)
|
||||
self.revision += 1
|
||||
return {"config": deepcopy(self.config), "revision": self.revision}
|
||||
|
||||
|
||||
class WebViewActionTests(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.temp = tempfile.TemporaryDirectory(prefix="ranch-web-parity-test-")
|
||||
self.addCleanup(self.temp.cleanup)
|
||||
self.worker = OfflineWorker(self.temp.name)
|
||||
self.engine = self.worker.engine
|
||||
|
||||
def view(self, page, query=None):
|
||||
return build_view(self.engine, page, self.worker.config, query)
|
||||
|
||||
def action(self, operation, **payload):
|
||||
return execute_action(self.worker, operation, payload)
|
||||
|
||||
def test_all_pages_are_public_json_without_qt_imports_or_network(self):
|
||||
self.engine.client = SimpleNamespace(call=Mock(side_effect=AssertionError("offline-only")))
|
||||
self.engine.demo = False
|
||||
for page, title in PAGES:
|
||||
with self.subTest(page=page):
|
||||
dto = self.view(page)
|
||||
self.assertEqual(dto["title"], title)
|
||||
json.dumps(dto, ensure_ascii=False, allow_nan=False)
|
||||
self.assertNotIn('"raw"', json.dumps(dto))
|
||||
self.engine.client.call.assert_not_called()
|
||||
script = """import sys, importlib.abc
|
||||
class BlockGUI(importlib.abc.MetaPathFinder):
|
||||
def find_spec(self,fullname,path=None,target=None):
|
||||
if fullname.startswith('PySide6') or fullname.endswith('_gui') or fullname == 'ranch_assistant.gui':
|
||||
raise AssertionError(fullname)
|
||||
sys.meta_path.insert(0,BlockGUI())
|
||||
import ranch_web.policies,ranch_web.views,ranch_web.actions
|
||||
"""
|
||||
result = subprocess.run([sys.executable, "-c", script], cwd=Path(__file__).resolve().parents[2], capture_output=True, text=True)
|
||||
self.assertEqual(result.returncode, 0, result.stderr)
|
||||
|
||||
def test_schema_exposes_only_current_gui_fields_and_chinese_labels(self):
|
||||
value = schema(self.engine.catalog)
|
||||
fields = [field for page in value["pages"] for field in page["form"]]
|
||||
self.assertTrue(all(field["label"] and isinstance(field["path"], list) for field in fields))
|
||||
self.assertNotIn(["policy", "feed_target"], [field["path"] for field in fields])
|
||||
self.assertNotIn(["progression_policy", "battle_mode"], [field["path"] for field in fields])
|
||||
self.assertEqual(dict(PAGES)["statistics"], "数据分析")
|
||||
self.assertEqual(dict(PAGES)["plans"], "执行计划")
|
||||
self.assertEqual(len(self.view("yields")["rows"]), 749)
|
||||
self.assertEqual([tab["title"] for tab in self.view("hatching")["tabs"]], ["孵蛋策略", "牧场策略", "喂养策略"])
|
||||
|
||||
def test_incubator_includes_closed_slots_and_vip_never_expandable(self):
|
||||
dto = self.view("incubator")
|
||||
self.assertEqual(len(dto["rows"]), 11)
|
||||
self.assertFalse(dto["rows"][3]["can_expand"])
|
||||
self.assertTrue(dto["rows"][6]["can_expand"])
|
||||
self.assertEqual(dto["rows"][0]["monster_id"], 101)
|
||||
|
||||
def test_bag_uses_real_category_and_groups_inventory_ids(self):
|
||||
catalog = self.engine.catalog
|
||||
categories = {"usable": 1, "consumables": 2, "materials": 3, "other": 4, "equipment": 5}
|
||||
items = []
|
||||
for category, code in categories.items():
|
||||
key = next(key for key in catalog.data["item_info"] if catalog.item_type(key) == code)
|
||||
items += [{"id": len(items) + 10000, "typeId": key, "num": number} for number in (3, 4)]
|
||||
self.engine.snapshot.raw["items"] += items
|
||||
for category, code in categories.items():
|
||||
with self.subTest(category=category):
|
||||
dto = self.view("bag", {"category": category})
|
||||
self.assertTrue(dto["rows"])
|
||||
self.assertTrue(all(catalog.item_type(row["id"]) == code for row in dto["rows"]))
|
||||
row = next(row for row in dto["rows"] if len(row["inventory_ids"]) == 2)
|
||||
self.assertEqual(row["count"], 7)
|
||||
self.assertEqual(row["rule_path"], ["policy", "gift_items", row["id"]])
|
||||
if code == 5:
|
||||
self.assertTrue(row["edits"]["enabled"]["disabled"])
|
||||
|
||||
def test_egg_keep_count_and_missing_stock_rule_bind_real_config(self):
|
||||
config = deepcopy(self.worker.config)
|
||||
config["policy"]["egg_rules"]["1001010"] = {"enabled": True, "keep_count": 5, "priority": 1, "market_id": "sc_city1"}
|
||||
self.worker.save_config(config)
|
||||
dto = self.view("bag", {"category": "eggs"})
|
||||
row = next(row for row in dto["rows"] if row["id"] == "1001010")
|
||||
column = next(column for column in dto["columns"] if column["key"] == "keep_count")
|
||||
self.assertEqual(column["label"], "牧场保留")
|
||||
self.assertEqual(row["keep_count"], 5)
|
||||
self.assertEqual(column["edit"]["path"], ["policy", "egg_rules", "{id}", "keep_count"])
|
||||
self.assertTrue(row["edits"]["market_id"]["options"])
|
||||
|
||||
def test_add_rule_species_defaults_follow_current_market_and_desktop_fallback(self):
|
||||
catalog = self.engine.catalog
|
||||
self.engine.snapshot.raw["items"] = []
|
||||
config = deepcopy(self.worker.config)
|
||||
config["policy"]["market_id"] = "sc_city10"
|
||||
self.worker.save_config(config)
|
||||
dto = self.view("bag", {"category": "eggs"})
|
||||
field = next(field for field in dto["form"] if field["type"] == "add_rule")
|
||||
defaults = field["defaults_by_id"]
|
||||
self.assertEqual(set(defaults), set(catalog.monsters))
|
||||
self.assertEqual(dto["rows"], [])
|
||||
self.assertEqual(defaults["1001010"]["market_id"], "sc_city10")
|
||||
fallback = next(key for key in catalog.monsters if catalog.markets_for(key) and "sc_city10" not in catalog.markets_for(key))
|
||||
self.assertEqual(defaults[fallback]["market_id"], catalog.markets_for(fallback)[0])
|
||||
unavailable = next(key for key in catalog.monsters if not catalog.markets_for(key))
|
||||
self.assertEqual(defaults[unavailable]["market_id"], "")
|
||||
config = deepcopy(self.worker.config)
|
||||
for key in ("1001010", fallback, unavailable):
|
||||
config["policy"]["egg_rules"][key] = deepcopy(defaults[key])
|
||||
self.worker.save_config(config)
|
||||
rows = {row["id"]: row for row in self.view("bag", {"category": "eggs"})["rows"]}
|
||||
for key in ("1001010", fallback, unavailable):
|
||||
with self.subTest(species=key):
|
||||
self.assertEqual(rows[key]["market_id"], defaults[key]["market_id"])
|
||||
self.assertEqual(rows[key]["rule_defaults"], defaults[key])
|
||||
self.assertFalse(rows[key]["enabled"])
|
||||
self.assertEqual(self.engine.policy.egg_rules[key], defaults[key])
|
||||
self.assertFalse(self.engine.auto)
|
||||
|
||||
def test_status_fields_expose_core_feed_draw_and_gift_timing(self):
|
||||
snapshot, catalog = self.engine.snapshot, self.engine.catalog
|
||||
config = deepcopy(self.worker.config)
|
||||
config["policy"]["feed_targets"] = {"900": 1}
|
||||
self.engine.last_draw = "offline draw: 3 eggs"
|
||||
self.worker.save_config(config)
|
||||
details = self.view("hatching")["details"]
|
||||
self.assertEqual(details["feed_status"], self.engine.planner.feed_status(snapshot, self.engine.policy))
|
||||
self.assertTrue(details["feed_status"][0])
|
||||
self.assertIsInstance(details["feed_status"][1], str)
|
||||
self.assertEqual(details["last_draw"], "offline draw: 3 eggs")
|
||||
self.assertIsNone(self.view("gifts")["details"]["next_ready_at"])
|
||||
likes = catalog.monster(snapshot.monsters[900]["typeId"]).get("like") or {}
|
||||
gift_id = next(str(key) for key, feel in likes.items() if feel > 0 and catalog.item_type(key) not in (5, 6) and catalog.item(key).get("sellable"))
|
||||
gifted_at = snapshot.now
|
||||
snapshot.monsters[900]["giftTime"] = gifted_at * 1000
|
||||
snapshot.raw["items"].append({"id": 8000, "typeId": int(gift_id), "num": 2})
|
||||
config["policy"].update(gift_enabled=True, gift_targets={"900": 1}, gift_items={gift_id: {"enabled": True, "reserve": 0}})
|
||||
self.worker.save_config(config)
|
||||
deadline = self.view("gifts")["details"]["next_ready_at"]
|
||||
self.assertEqual(deadline, gifted_at + int(catalog.data["game_setting"].get("monGiftTime", 7200)))
|
||||
|
||||
def test_ranch_targets_are_real_priorities_and_details_are_whitelisted(self):
|
||||
config = deepcopy(self.worker.config)
|
||||
for field, priority in (("feed_targets", 1), ("gift_targets", 2), ("breakthrough_targets", 3)):
|
||||
config["policy"][field] = {"900": priority}
|
||||
self.worker.save_config(config)
|
||||
self.engine.snapshot.monsters[900].update(password="synthetic-secret", raw={"token": "synthetic-secret"})
|
||||
dto = self.view("ranch", {"grouped": True})
|
||||
row = next(row for row in dto["rows"] if row["id"] == "900")
|
||||
self.assertTrue(row["feed_selected"])
|
||||
self.assertEqual(row["feed_priority"], 1)
|
||||
self.assertEqual(row["edits"]["feed_selected"]["path"], ["policy", "feed_targets", "900"])
|
||||
self.assertEqual(row["edits"]["feed_selected"]["type"], "target")
|
||||
self.assertEqual(self.engine.planner.feeding_target(self.engine.snapshot, self.engine.policy)[0]["id"], 900)
|
||||
self.assertTrue(dto["groups"])
|
||||
self.assertTrue(dto["feed_targets"])
|
||||
self.assertNotIn("synthetic-secret", json.dumps(dto))
|
||||
|
||||
def test_mainline_default_current_and_filters_with_chinese_record_messages(self):
|
||||
self.engine._progression_rows = [
|
||||
{"task_type_id": "a", "category": "main", "state": "active", "name": "当前主线", "dialogue": "对话", "supported": True},
|
||||
{"task_type_id": "b", "category": "mainline", "state": "completed", "name": "历史主线"},
|
||||
{"task_type_id": "c", "category": "sidequest", "state": "received", "name": "支线"}]
|
||||
self.assertEqual([row["name"] for row in self.view("mainline")["rows"]], ["当前主线"])
|
||||
dto = self.view("mainline", {"category": "", "state": "", "search": "历史"})
|
||||
self.assertEqual(dto["rows"][0]["state_label"], "已完成")
|
||||
self.engine._progression_records = [{"battle_kind": "ordinary_stage", "outcome": "loss", "started_at": 0,
|
||||
"battle_mode": "experimental", "damage_profile": "client_v4_x10", "message": "Unsupported monster controller: test", "response": {"token": "synthetic-secret"}}]
|
||||
record = self.view("battles")
|
||||
self.assertIn("打不过", record["rows"][0]["outcome_label"])
|
||||
self.assertIn("尚未支持", record["rows"][0]["message"])
|
||||
self.assertNotIn("synthetic-secret", json.dumps(record))
|
||||
|
||||
def test_exploration_three_members_options_and_diagnoses_use_planner(self):
|
||||
snapshot = self.engine.snapshot
|
||||
snapshot.raw["history"].update(passTask={"1001008": True}, passStage={"0101": {"1": True}})
|
||||
snapshot.raw["exploreTeams"] = [{"id": 1, "status": 0}]
|
||||
for mid, level in ((101, 30), (102, 10), (900, 20)):
|
||||
snapshot.monsters[mid].update(process=3, level=level, mode=2)
|
||||
self.engine.explore_planner = ExplorePlanner(self.engine.catalog, areas={"1": {"id": "1", "name": "测试地区", "passStage": "0101", "costTi": 10, "costTime": 3600, "level": [4, 1, 1], "team": "normal"}})
|
||||
config = deepcopy(self.worker.config)
|
||||
config["explore_policy"] = {"enabled": True, "reserve_ti": 2, "teams": {"1": {"enabled": True, "area": "1", "monsters": [101, 900, 102]}}}
|
||||
self.worker.save_config(config)
|
||||
dto = self.view("exploration")
|
||||
row = dto["rows"][0]
|
||||
self.assertEqual(row["monsters"], [101, 900, 102])
|
||||
self.assertEqual(row["state"], "可出发")
|
||||
self.assertEqual(row["edits"]["monsters"]["path"], ["explore_policy", "teams", "1", "monsters"])
|
||||
protected = next(option for option in row["member_options"] if option["value"] == 900)
|
||||
self.assertFalse(protected["automatic"])
|
||||
self.assertFalse(protected["disabled"])
|
||||
|
||||
def test_maps_resources_show_ticket_cost_and_filter_difficulty_one(self):
|
||||
snapshot = self.engine.snapshot
|
||||
snapshot.raw["items"] += [{"id": 7000, "typeId": 20009, "num": 5}, {"id": 7001, "typeId": 20009, "num": 100, "lock": True}]
|
||||
stages = [Stage("m101", str(level), "测试矿洞", 1, True, False, True, 10, "矿镐×2", city_name="测试地区", category="mine", battle_available=True) for level in (1, 2)]
|
||||
self.engine.stage_cache.get = Mock(return_value=stages)
|
||||
self.engine.stage_cache.catalog.data["stage_info"]["m101"] = {"cost": {"items": [{"typeId": 20009, "num": 2}]}}
|
||||
self.engine.map_stage_reason = Mock(return_value="")
|
||||
dto = self.view("maps", {"category": "resource"})
|
||||
self.assertEqual(len(dto["rows"]), 1)
|
||||
row = dto["rows"][0]
|
||||
self.assertEqual(row["level"], "1")
|
||||
self.assertEqual(row["costs"][1]["available"], 5)
|
||||
self.assertEqual(row["costs"][1]["required"], 2)
|
||||
self.assertIn("资源关开关", row["status"])
|
||||
self.assertTrue(dto["groups"][0]["collapsed"])
|
||||
self.assertEqual([option["value"] for option in row["edits"]["level"]["options"]], ["1"])
|
||||
|
||||
def test_statistics_all_event_and_known_stamina_follow_real_store(self):
|
||||
store = self.engine.sweeper.statistics
|
||||
owner = self.engine.snapshot.raw["master"]["id"]
|
||||
for index, kind, amount, spent in ((1, "sweep", 2, 10), (2, "event", 3, 20), (3, "event", 7, None)):
|
||||
store.record(owner, "0101", "3", kind, f"offline:{index}", index, {"money": 10, "items": [{"typeId": 30005, "num": amount}]}, spent)
|
||||
dto = self.view("statistics", {"stage_id": "0101", "level": "3", "source": "all"})
|
||||
row = next(row for row in dto["rows"] if row["typeId"] == "30005")
|
||||
self.assertEqual(dto["totals"]["n"], 3)
|
||||
self.assertEqual(dto["totals"]["spent"], 30)
|
||||
self.assertEqual(row["rate"], 1)
|
||||
self.assertAlmostEqual(row["per_stamina"], 5 / 30)
|
||||
self.assertEqual(next(point for point in dto["chart"]["series"] if point["id"] == row["id"])["value"], 1)
|
||||
self.assertEqual(self.view("statistics", {"stage": "0101", "source": "event"})["totals"]["n"], 2)
|
||||
self.assertEqual(self.view("statistics", {"stage_id": "0101", "source": "sweep"})["totals"]["n"], 1)
|
||||
with self.assertRaises(ValueError):
|
||||
self.view("statistics", {"source": "challenge"})
|
||||
|
||||
def test_lock_sell_feed_are_core_operations_and_require_confirmation(self):
|
||||
self.action("lock", monster_ids=[101])
|
||||
self.assertTrue(self.engine.snapshot.monsters[101]["lock"])
|
||||
self.action("unlock", monster_ids=[101])
|
||||
self.assertFalse(self.engine.snapshot.monsters[101]["lock"])
|
||||
with self.assertRaises(ValueError):
|
||||
self.action("sell", monster_ids=[101])
|
||||
self.action("sell", monster_ids=[101], confirm=True)
|
||||
self.assertNotIn(101, self.engine.snapshot.monsters)
|
||||
self.engine.snapshot.monsters[102].update(process=3, roomId=1, mode=2)
|
||||
self.action("feed", monster_ids=[102], target_id=900, confirm=True)
|
||||
self.assertNotIn(102, self.engine.snapshot.monsters)
|
||||
with self.assertRaises(ValueError):
|
||||
self.action("sell", monster_ids=[900], confirm=True)
|
||||
|
||||
def test_daily_refresh_is_preview_and_manual_selected_claims_use_ledger(self):
|
||||
snapshot = self.engine.snapshot
|
||||
yesterday = snapshot.now - 86400
|
||||
snapshot.raw["activityHistory"] = {"dailyGift": {"dailyGiftCheckTime": yesterday * 1000,
|
||||
"dailyGiftLevel": 1, "dailyGiftCount": 1}, "dailyCheck": {"checkDay": 1, "checkTime": yesterday * 1000}}
|
||||
snapshot.raw["mails"] = [{"id": 12, "title": "离线测试", "createTime": snapshot.now * 1000,
|
||||
"isGetReward": 0, "reward": {"money": 10}}]
|
||||
config = deepcopy(self.worker.config)
|
||||
config["daily_policy"]["selected"] = ["gift", "mail"]
|
||||
self.worker.save_config(config)
|
||||
self.action("refresh", page="daily")
|
||||
self.assertFalse(self.engine.daily_ledger.state)
|
||||
result = self.action("claim_daily")
|
||||
self.assertIn("2 项", result["message"])
|
||||
self.assertTrue(self.engine.daily_ledger.seen(snapshot, "gift"))
|
||||
self.assertFalse(self.engine.daily_ledger.seen(snapshot, "check"))
|
||||
self.assertTrue(self.engine.daily_ledger.seen(snapshot, "mail:12"))
|
||||
self.assertIn("0 项", self.action("claim_daily")["message"])
|
||||
|
||||
def test_commission_rewards_restrictions_and_gift_representatives_are_real(self):
|
||||
snapshot, catalog = self.engine.snapshot, self.engine.catalog
|
||||
key = next(key for key, row in catalog.data["task_info"].items() if row.get("type") == 4 and row.get("steps"))
|
||||
snapshot.raw["currentTasks"] = [{"id": 10000, "typeId": key, "curStep": 999}]
|
||||
dto = self.view("commissions")
|
||||
self.assertEqual(dto["rows"][0]["reward_ke"], catalog.data["task_info"][key]["reward"]["ke"])
|
||||
self.assertEqual(dto["rows"][0]["reason"], "可领取奖励")
|
||||
config = deepcopy(self.worker.config)
|
||||
config["policy"].update(gift_enabled=True, gift_auto_representative=True)
|
||||
self.worker.save_config(config)
|
||||
dto = self.view("gifts")
|
||||
self.assertEqual(dto["rows"][0]["monster_id"], 900)
|
||||
self.assertEqual(dto["rows"][0]["likes"], catalog.likes_text(snapshot.monsters[900]["typeId"]))
|
||||
|
||||
def test_engine_failure_does_not_return_success_or_reuse_paid_quote(self):
|
||||
quote = self.action("quote_expansion", kind="stack", currency="money", position=6)
|
||||
self.engine.expand = Mock(side_effect=TimeoutError("offline unknown response"))
|
||||
with self.assertRaises(TimeoutError):
|
||||
self.action("expand", quote_id=quote["quote_id"], confirm=True)
|
||||
with self.assertRaisesRegex(ValueError, "报价已失效"):
|
||||
self.action("expand", quote_id=quote["quote_id"], confirm=True)
|
||||
self.engine.expand.assert_called_once()
|
||||
|
||||
def test_expansion_quote_is_bound_one_use_and_cost_is_rechecked(self):
|
||||
quote = self.action("quote_expansion", kind="stack", currency="money", position=6)
|
||||
money = self.engine.snapshot.raw["master"]["money"]
|
||||
with self.assertRaises(ValueError):
|
||||
self.action("expand", quote_id=quote["quote_id"])
|
||||
self.action("expand", quote_id=quote["quote_id"], confirm=True)
|
||||
self.assertEqual(self.engine.snapshot.raw["master"]["money"], money - quote["cost"])
|
||||
self.assertTrue(any(row["position"] == 6 for row in self.engine.snapshot.raw["stacks"]))
|
||||
with self.assertRaises(ValueError):
|
||||
self.action("expand", quote_id=quote["quote_id"], confirm=True)
|
||||
quote = self.action("quote_expansion", kind="room", currency="money")
|
||||
record = self.worker._web_expansion_quotes[quote["quote_id"]][1]
|
||||
price = self.engine.catalog.data["room_price"][str(record.index)]
|
||||
price["money"] = int(price["money"]) + 1
|
||||
with self.assertRaisesRegex(ValueError, "费用或次数已变化"):
|
||||
self.action("expand", quote_id=quote["quote_id"], confirm=True)
|
||||
|
||||
def test_import_csv_xlsx_is_transactional_and_never_accepts_disk_paths(self):
|
||||
data = "编号,派遣金币,强化经验,孵化秒数\n1001010,999,18,120\n".encode("utf-8-sig")
|
||||
result = self.action("import_yields", filename="data.csv", content_base64=base64.b64encode(data).decode())
|
||||
self.assertEqual(result["count"], 1)
|
||||
self.assertEqual(self.engine.catalog.monster(1001010)["sell_money"], 999)
|
||||
old = deepcopy(self.worker.config)
|
||||
data = b"typeId,sell_money\n1001010,nan\n"
|
||||
with self.assertRaises(ValueError):
|
||||
self.action("import_yields", filename="data.csv", content_base64=base64.b64encode(data).decode())
|
||||
self.assertEqual(self.worker.config, old)
|
||||
with self.assertRaises(ValueError):
|
||||
self.action("import_yields", path="private-file.csv")
|
||||
import openpyxl
|
||||
workbook = openpyxl.Workbook()
|
||||
workbook.active.append(["typeId", "sell_money"])
|
||||
workbook.active.append([1001010, 123])
|
||||
stream = io.BytesIO()
|
||||
workbook.save(stream)
|
||||
workbook.close()
|
||||
result = self.action("import_yields", filename="data.xlsx", content_base64=base64.b64encode(stream.getvalue()).decode())
|
||||
self.assertEqual(result["overrides"]["1001010"]["sell_money"], 123)
|
||||
|
||||
def test_import_only_saves_and_never_executes_a_plan(self):
|
||||
self.worker.running = self.engine.auto = True
|
||||
document = export_config(self.worker.config, self.engine.snapshot)
|
||||
self.engine.poll = Mock(side_effect=AssertionError("import must not run"))
|
||||
result = self.action("import_config", config=document)
|
||||
self.assertIn("config", result)
|
||||
self.assertFalse(self.engine.auto)
|
||||
self.assertFalse(self.worker.running)
|
||||
self.engine.poll.assert_not_called()
|
||||
|
||||
def test_reset_pending_requires_real_role_matched_evidence_and_keeps_journal(self):
|
||||
pending = {"stage": "0101", "level": "3", "phase": "遇到事件或响应缺少事件状态,请在游戏内处理"}
|
||||
self.engine.sweeper.state["pending"] = pending
|
||||
with self.assertRaises(ValueError):
|
||||
self.action("reset_map_pending", confirm=True, server_verified=True)
|
||||
self.assertIs(self.engine.sweeper.state["pending"], pending)
|
||||
trace = [
|
||||
{"operation": "读取角色", "kind": "response", "body": {"master": {"id": 2}}},
|
||||
{"operation": "stageService/stageStart", "kind": "request", "request_id": "offline:1", "body": {"stageTypeId": "0101", "stageLevel": "3"}},
|
||||
{"operation": "stageService/stageStart", "kind": "response", "request_id": "offline:1", "http_status": 200,
|
||||
"body": {"resCode": 0, "triggerEvent": True, "stageEvent": {"resCode": 0, "result": {"money": 10}}}},
|
||||
]
|
||||
self.worker.trace.path.write_text("\n".join(json.dumps(event) for event in trace), encoding="utf-8")
|
||||
with self.assertRaises(ValueError):
|
||||
self.action("reset_map_pending", confirm=True, server_verified=True)
|
||||
trace[0]["body"]["master"]["id"] = 1
|
||||
self.worker.trace.path.write_text("\n".join(json.dumps(event) for event in trace), encoding="utf-8")
|
||||
result = self.action("reset_map_pending", confirm=True)
|
||||
self.assertTrue(result["cleared"])
|
||||
self.engine.sweeper.state["pending"] = pending
|
||||
self.engine.battle_journal.pending = Mock(return_value={"kind": "map_battle", "phase": "unknown"})
|
||||
with self.assertRaisesRegex(ValueError, "不能手动清除"):
|
||||
self.action("reset_map_pending", confirm=True, server_verified=True)
|
||||
self.assertIs(self.engine.sweeper.state["pending"], pending)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Reference in New Issue
Block a user