fix: recover interrupted Web battles in 2.0.10

This commit is contained in:
AttilaNet
2026-11-14 10:56:43 +08:00
parent bbdf578c87
commit 9f3945a717
24 changed files with 1912 additions and 127 deletions
+12 -10
View File
@@ -1,10 +1,10 @@
# 牧羊人之心牧场助手 · Web 2.0.9
# 牧羊人之心牧场助手 · Web 2.0.10
## 产品约束
把现有桌面助手的功能和操作结构迁移至单管理员 Web 工作台。桌面版是页面顺序、信息密度、业务名称、保护条件与交互的依据,保留桌面兼容。Web `2.0.9`,源码发布入口 `main`,游戏数据版本 `1.9.68`;桌面正式版保留 `1.2.0`。启动与配置见 [运行说明](README.md),Docker 与更新条件见 [部署说明](../deploy/web/README.md),既有功能与历史验证见 [2.0.8 发布说明](../analysis/RELEASE_2_0_8.md)。
把现有桌面助手的功能和操作结构迁移至单管理员 Web 工作台。桌面版是页面顺序、信息密度、业务名称、保护条件与交互的依据,保留桌面兼容。Web `2.0.10`,源码发布入口 `main`,游戏数据版本 `1.9.68`;桌面正式版保留 `1.2.0`。启动与配置见 [运行说明](README.md),Docker 与更新条件见 [部署说明](../deploy/web/README.md),既有功能与历史验证见 [2.0.8 发布说明](../analysis/RELEASE_2_0_8.md)。
2.0.9 包含界面清理、委托补缺、默认快速战斗与潜能误报修复;保留账号简短状态、错误、表格、表单与原单一底部分类日志,见 [本版发布说明](../analysis/RELEASE_2_0_9.md)。
2.0.10 聚焦战斗输入传输、中断恢复、启停意愿与能力状态纠正;保留账号简短状态、错误、表格、表单与原单一底部分类日志,见 [本版发布说明](../analysis/RELEASE_2_0_10.md)。
使用者在 Windows 本机配置、验证,随后可在 Linux Docker 常驻运行。多个浏览器访问同一个管理员工作台;账号互相隔离,各账号串行执行,账号之间可以并行。
@@ -28,13 +28,15 @@
- 帮助可检查 GitHub 正式版本并提交受控更新请求。未配置部署器时明确显示原因,更新提交不表示更新成功。
- 已在 2.0.1 完成私有仓库和 GHCR 认证的部署,稳定 Release 与正式镜像发布后,可直接通过“帮助 → 检查版本更新…”升级,无需先安装 2.0.2、重复初始化或替换宿主机更新器;升级完成后刷新网页以加载新版界面,安装结果以宿主机健康检查为准。
## 2.0.9 本轮范围
## 2.0.10 本轮范围
默认使用快速数值模型,委托按剩余步骤统一计算采购和提交需求:
- Linux 战斗子进程从匿名临时文件一次读取完整 stdin,保留取消、超时及输入大小检查。
- 升级后,旧委托备料记录若已确认入场、未发送结算且符合技术失败条件,按原客户端协议记录失败并退出一次;兼容来源任务与步骤均为0的记录,不重新入场或提交胜利。
- 保存的原始战斗输入最多用于一次本地恢复;完整战果校验通过后按战斗时钟续交尚未发送的结果。未知已发送写请求不重放。
- 手动停止阻止恢复提交;内部暂停保留用户运行意愿,来源策略关闭时明确等待启用,不自动开启策略。
- 状态接口透出5个安全策略状态字段,区分运行意愿、实际执行与等待原因;修复导航及策略关闭时的能力误报,保留真实不支持、资源不足及失败原因。具体行为见 [发布说明](../analysis/RELEASE_2_0_10.md)。
- 委托用明确中文说明未接取的实际原因;成熟魔物交付需求联动购蛋、孵化,优先备齐所需资源再接取。锁定、培养、优质备份等魔物继续受保护,采购与孵蛋遵守耗用预算和需求缺口限制。
- 正常执行默认使用现有内置实验运行时入口的快速 HP/DPS 模型,保留现有伤害配置,无需选择新模式;逐帧实现仅供研发。模型结合双方属性、血量、每秒伤害(DPS)、有效血量(EHP)、时间与关卡目标估算胜利、战败或超时,仍有机制简化,不保证全部关卡可通关或与客户端结果一致。
- 潜能检查依据合法的 `PotentialPanel` 上限区分正常数值与异常,修复正常潜能的误报。
沿用 2.0.9 的快速 HP/DPS 模型、伤害配置、按剩余步骤计算的委托备料及正常潜能误报修复,历史范围见 [2.0.9 发布说明](../analysis/RELEASE_2_0_9.md)。
## 2.0.8 自动委托与每日历史
@@ -89,9 +91,9 @@
## 安全与验证
2.0.9 快速模型可读取358/358份主线与委托战斗配置,表示输入可计算。离线样本有胜有败,8个20氪金委托战斗为5胜3败;当前卡点样本的默认路径结果及耗时见 [发布说明](../analysis/RELEASE_2_0_9.md#验证)。
2.0.10 后端、模型与更新器共 **550 项唯一测试:548 通过、2 项 Windows 预期跳过**;另有 **14 项全新浏览器测试全部通过**,8组独立探针复核通过。范围见 [本版发布说明](../analysis/RELEASE_2_0_10.md#验证);战斗模型仍为近似实现。
617项唯一回归用例中615项通过,2项因Windows环境跳过;另有8项界面浏览器测试通过。多步骤采购修复已通过独立复核;未在线提交游戏结算。
2.0.9 的历史验证见 [历史发布说明](../analysis/RELEASE_2_0_9.md#验证),不计入本版。
2.0.8 共验证739项独立测试:736通过、3项 Windows 跳过;其中非浏览器662项(659通过、3跳过),浏览器77项全部验证通过。证据与发布门禁见 [发布说明](../analysis/RELEASE_2_0_8.md#验证);历史版本结果不计入本版。
+11 -7
View File
@@ -1,8 +1,8 @@
# Web 2.0.9 运行说明
# Web 2.0.10 运行说明
Web **2.0.9**,源码发布入口 `main`,游戏资料基线 **1.9.68**。桌面正式版保留 **1.2.0**,入口为 `python -m ranch_assistant`;Web 使用独立依赖与数据根。自动委托提供当前委托与每日记录,功能和历史验证状态见 [2.0.8 发布说明](../analysis/RELEASE_2_0_8.md)。
Web **2.0.10**,源码发布入口 `main`,游戏资料基线 **1.9.68**。桌面正式版保留 **1.2.0**,入口为 `python -m ranch_assistant`;Web 使用独立依赖与数据根。自动委托提供当前委托与每日记录,功能和历史验证状态见 [2.0.8 发布说明](../analysis/RELEASE_2_0_8.md)。
2.0.9 清理重复运行提示,补齐委托资源准备、默认快速战斗及正常潜能误报修复。委托明确显示中文未接取原因,成熟魔物需求联动购蛋、孵化;按剩余步骤备料,遵守预算、需求缺口及魔物保护设置。详情继续使用原单一底部分类日志,见 [本版发布说明](../analysis/RELEASE_2_0_9.md)。
2.0.10 修复 Linux 战斗子进程大输入传输、停止检查及导航能力误报。升级后按保存的入场、原始输入与战果证据恢复:符合条件的旧委托备料技术失败记录退出一次,完整战果续交尚未发送的结果;未知已发送写请求不重放。中文状态明确指出等待原因,详情继续使用原单一底部分类日志,见 [本版发布说明](../analysis/RELEASE_2_0_10.md)。
正常执行默认使用现有内置实验运行时入口的快速 HP/DPS 模型,保留现有伤害配置,无需选择新模式;逐帧实现仅供研发。模型按双方属性、血量、每秒伤害、时间与目标估算胜利、战败或超时,仍有机制简化,不保证全部关卡可通关或与客户端结果一致。
@@ -49,7 +49,7 @@ py -3 -m venv .venv-web
关闭网页或退出 Web 管理登录不会停止服务器上的账号监控和已开启策略。账号监控、重登及策略执行都由服务端管理。手动“停止”只暂停策略,连接监控与掉线重登继续;该暂停在重新登录和服务重启后仍保留,点击“开启”恢复。
临时网络故障采用退避后的只读状态检查,确认角色连接恢复后自动继续原先启用的策略。会话失效时按登录页等待时长自动重新登录。账号状态区分用户暂停、临时恢复和请求待核对,心跳成功不等于策略已经运行;日志保留失败原因及恢复结果。未确认的消耗请求仍保留核对记录,不自动重复提交。
临时网络故障采用退避后的只读状态检查,确认角色连接恢复后自动继续原先启用的策略。会话失效时按登录页等待时长自动重新登录。账号状态区分用户暂停、临时恢复和请求待核对,心跳成功不等于策略已经运行;日志保留失败原因及恢复结果。内部暂停保留用户运行意愿;来源策略关闭时明确等待启用,不自动勾选。已保存的完整战果仅在用户允许运行、来源策略已启用、原入场及来源校验通过且战斗时钟满足时续交尚未发送的结果;手动停止阻止恢复提交,未知已发送写请求保留核对记录,不自动重发。
服务重启会保留配置、加密会话及启停选择,并自动恢复有登录记录的账号。只有清除登录记录或移除账号才取消持续自动登录;缺少密码、区服或原角色信息时显示具体原因。运行日志按账号限量持久保存,旧角色数据会标注缓存状态。
@@ -108,13 +108,17 @@ sh start-web.sh --no-browser
Web 检查固定官方 GitHub Releases 的稳定 `v2.x.y`,跳过桌面 1.x、未来 3.x、草稿和预发布。开发版本 `2.0.0.dev1` 可升级至同数字的正式 `v2.0.0`;没有正式 Web 2 发布时明确显示暂无更新。Windows 默认仅检查;Web “更新”按钮仅在宿主机显式启用并有有效只读心跳时可提交 `pending` 请求,安装、备份和回滚由宿主机执行。默认定时检查只通知,自动安装需操作者 opt-in。
已在 **2.0.1** 完成私有仓库和 GHCR 认证的部署,稳定 Release 和正式镜像就绪、宿主机心跳有效后,可直接通过“帮助 → 检查版本更新…”升级 **2.0.9**,无需先安装 2.0.2、重复初始化或替换宿主机更新器。升级完成后刷新网页以加载新版界面,底部日志默认收起。安装结果以宿主机健康检查为准;首次配置仅供尚未初始化的宿主机参考。
已在 **2.0.1** 完成私有仓库和 GHCR 认证的部署,稳定 Release 和正式镜像就绪、宿主机心跳有效后,可直接通过“帮助 → 检查版本更新…”升级 **2.0.10**,无需先安装 2.0.2、重复初始化或替换宿主机更新器。升级完成后刷新网页以加载新版界面,底部日志默认收起。安装结果以宿主机健康检查为准;首次配置仅供尚未初始化的宿主机参考。
## 离线验证
2.0.9 快速模型的输入预检覆盖358/358份主线与委托战斗配置。当前卡点的真实账号离线样本预计战斗5秒,直接计算约1.2毫秒,含隔离进程启动与检查约0.21秒;8个20氪金委托战斗的离线结果为5胜3败,见 [本版发布说明](../analysis/RELEASE_2_0_9.md#验证)。
2.0.10 后端、模型与更新器共 **550 项唯一测试:548 通过、2 项 Windows 预期跳过**;另有 **14 项全新浏览器测试全部通过**,8组独立探针复核通过,见 [本版发布说明](../analysis/RELEASE_2_0_10.md#验证)。镜像工作流新增子进程传输、战斗恢复、能力展示、Web 生命周期、恢复契约及状态 API 六个定向模块:
617项唯一回归用例中615项通过,2项因Windows环境跳过;另有8项界面浏览器测试通过。多步骤采购循环已经修复并独立复核。本轮未在线提交游戏结算或手动部署X99。
```console
python -B -m unittest ranch_assistant.tests.test_battle_worker_transport ranch_assistant.tests.test_battle_recovery ranch_assistant.tests.test_battle_capability_presentation ranch_web.tests.test_lifecycle_recovery ranch_web.tests.test_battle_recovery_contract ranch_web.tests.test_status_recovery_api -v
```
2.0.9 的历史验证见 [历史发布说明](../analysis/RELEASE_2_0_9.md#验证),不计入本版。
2.0.8 共验证739项独立测试:736通过、3项 Windows 跳过;其中非浏览器662项(659通过、3跳过),浏览器77项全部验证通过。分组结果与证据见 [发布说明](../analysis/RELEASE_2_0_8.md#验证)。2.0.7 的结果保留在 [历史发布说明](../analysis/RELEASE_2_0_7.md#验证),以下历史记录也不计入本版验收。
+1 -1
View File
@@ -1,6 +1,6 @@
"""Headless Web workspace for the ranch assistant."""
__version__ = "2.0.9"
__version__ = "2.0.10"
GAME_VERSION = "1.9.68"
__all__ = ["__version__", "GAME_VERSION"]
+3 -1
View File
@@ -577,9 +577,11 @@ def create_app(data_dir=None, manager=None, config=None, updates=None) -> FastAP
if not isinstance(value, dict):
raise HTTPException(500, "账号状态返回格式不正确")
result = {field: value.get(field) for field in ("id", "label", "connected", "demo", "running", "busy", "revision", "error",
"connection_state", "connection_message", "last_game_success_at", "next_retry_at")}
"connection_state", "connection_message", "last_game_success_at", "next_retry_at",
"strategy_requested", "manual_stop", "strategy_state", "strategy_message", "strategy_retry_at")}
result["error"] = public_error(result["error"])
result["connection_message"] = public_error(result["connection_message"])
result["strategy_message"] = public_error(result["strategy_message"])
auto = value.get("auto_relogin_status")
result["auto_relogin_status"] = ({field: auto.get(field) for field in ("state", "message", "next_attempt_at")}
if isinstance(auto, dict) else None)
+70 -14
View File
@@ -335,12 +335,54 @@ class AccountWorker:
self._legacy_pending.pop(identity)
self._save_run_intents()
def _pending_battle_recovery(self):
classify = getattr(self.engine, "pending_battle_recovery", None)
if callable(classify):
status = classify()
return status if isinstance(status, dict) else {}
# Compatibility for older Engine test doubles without the public API.
if self.engine.snapshot is not None:
record = self.engine.battle_journal.pending(self.engine.snapshot)
if record:
if self.engine.battles.resumable_task_clock(record) is True:
return {"resumable": True, "message": "战果已保存;等待结算时间及对应策略启用后续交"}
return {}
def _pending_execution_reason(self):
suffix = ";禁止自动重发,请在游戏内核对结果"
if self.active_identity in self._legacy_pending:
return "赠礼、装填或喂养请求结果待核对,禁止自动重发;后台继续读取游戏状态,确认后自动恢复已勾选策略"
if self.engine.snapshot is not None and (self.engine._progression_pending()
or self.engine.explore_planner.pending(self.engine.snapshot) or self.engine._breakthrough_pending):
return "存在未确认的任务、战斗、探险或突破请求,禁止自动重发;后台继续核对,核对完成后恢复已勾选策略"
kind = self._legacy_pending[self.active_identity]["kind"]
return {"gift": "赠礼", "hatch": "装填", "feed": "喂养"}[kind] + "请求结果待核对" + suffix
if self.engine.snapshot is None:
return ""
if self.engine._progression_pending():
sweep = self.engine.sweeper.state.get("pending")
if sweep:
return f"扫荡(关卡 {sweep.get('stage', '')}):{sweep.get('phase') or '请求结果待核对'}" + suffix
recovery = self._pending_battle_recovery()
if recovery.get("state") == "blocked_policy":
return recovery.get("message") or "等待启用本次战斗的来源策略后恢复"
if recovery.get("resumable") is not True:
record = self.engine.battle_journal.pending(self.engine.snapshot) or {}
label = record.get("description") or ("战斗" if record.get("stage_id") else "任务")
if record.get("stage_id"):
label += f"(关卡 {record['stage_id']},难度 {record.get('difficulty') or 1})"
detail = record.get("message") or "请求结果待核对"
if record.get("execution_status") == "timed_out" or record.get("terminal_reason") == "worker_wall_clock_limit":
detail = "本地战斗计算超时"
if (not record.get("battle_data") and not record.get("settlement_dispatched")
and not record.get("settlement_confirmed")
and record.get("path") in ("", "battleService/battleStart", "stageService/stageStart")):
detail += ",尚未提交结算"
return label + ":" + detail + suffix
explore = self.engine.explore_planner.pending(self.engine.snapshot)
if explore:
label = "探险出发" if explore.get("kind") == "explore_start" else "探险领奖"
return f"{label}(队伍 {explore.get('team_id', '')}):{explore.get('message') or '请求结果待核对'}" + suffix
if self.engine._breakthrough_pending:
record = self.engine._breakthrough_pending
label = "潜能提升" if record.get("kind") == "potential" else "突破"
return label + ":" + (record.get("message") or "请求结果待核对") + suffix
return ""
def _refresh_execution(self):
@@ -372,6 +414,9 @@ class AccountWorker:
state, message = "recovering", self.connection_message
elif not self._running:
state, message = "offline", self.connection_message
elif (recovery := self._pending_battle_recovery()).get("resumable") is True:
state = "recovering"
message = recovery.get("message") or "等待对应策略允许恢复"
else:
state, message = "running", "已勾选的策略将自动执行"
return {"strategy_requested": requested, "manual_stop": not requested,
@@ -1117,15 +1162,24 @@ class AccountWorker:
self.schedule.next_fast[kind] = math.inf
auto = True
value = self.engine.poll_automation(kind)
elif kind == "poll":
auto = self._set_auto(self._running)
value = self.engine.poll(defer_hatch=True)
self.schedule.poll_finished(self.config)
elif kind == "reconcile":
self._set_auto(False)
# Engine's durable pending barriers reconcile before planning.
# A check never silently replays an uncertain write.
value = self.engine.poll(defer_hatch=True)
elif kind in ("poll", "reconcile"):
recovering = self._pending_battle_recovery().get("resumable") is True
with self.lock:
# Recover only the original entry, with general automation
# disabled. Stop/config changes still revoke this job.
auto = self._set_auto(self._running and kind == "poll" and not recovering)
resume_pending = bool(recovering and self._running and self.strategy_requested
and not self._closing and not self.manager._closing and job.generation == self._generation)
if resume_pending:
job.consuming = True
self.check_intent()
if callable(getattr(self.engine, "pending_battle_recovery", None)):
value = self.engine.poll(defer_hatch=True, resume_pending=resume_pending)
else:
# Older Engine doubles use auto to authorize saved results.
if resume_pending:
auto = self._set_auto(True)
value = self.engine.poll(defer_hatch=True)
self.schedule.poll_finished(self.config)
else:
self._set_auto(False)
@@ -1140,7 +1194,9 @@ class AccountWorker:
# by the current Engine generation turns that switch off.
if auto and job.generation == self._generation and not self.engine.auto:
if self._pending_execution_reason():
self.stop()
# A pending barrier pauses execution, not user intent
# or the generation of other queued local edits.
self._refresh_execution()
else:
self._execution_failed(ValueError(value[2] or "策略暂不可用"))
elif auto and job.generation == self._generation:
+2 -2
View File
@@ -415,7 +415,7 @@ async function exportYields(account=current()) {
async function command(name,account=current()) {
try {
if(name==='add-account'||name==='add-demo')return await addAccount(name==='add-demo');
if(name==='about')return dialog('关于牧场助手',el('div',{},el('p',{text:`牧羊人之心牧场助手 Web ${state.meta?.version || '2.0.9'}`}),el('p',{text:`游戏数据版本 ${state.meta?.gameVersion || '1.9.68'}`})),{info:true});
if(name==='about')return dialog('关于牧场助手',el('div',{},el('p',{text:`牧羊人之心牧场助手 Web ${state.meta?.version || '2.0.10'}`}),el('p',{text:`游戏数据版本 ${state.meta?.gameVersion || '1.9.68'}`})),{info:true});
if(name==='updates')return await showUpdates();
if(name==='admin-logout'){hideWorkbench();try{await api.logout();}finally{requireAuth();}return;}
if(!account)throw new Error('请先新增或选择账号。');
@@ -640,7 +640,7 @@ async function bootstrap() {
$('#app').hidden=false;
const [meta,schema]=await Promise.all([api.meta(),api.schema()]);state.meta=meta;state.schema=schema;
if(state.redirecting)return;
$('#app-version').textContent=meta.version || '2.0.9';$('#game-version').textContent=meta.gameVersion || '1.9.68';$('#access-mode').textContent=auth.access_mode==='local'||auth.access_mode==='loopback'?'本机工作台':auth.required?'管理工作台':'本机工作台';
$('#app-version').textContent=meta.version || '2.0.10';$('#game-version').textContent=meta.gameVersion || '1.9.68';$('#access-mode').textContent=auth.access_mode==='local'||auth.access_mode==='loopback'?'本机工作台':auth.required?'管理工作台':'本机工作台';
await syncAccounts();if(state.redirecting)return;state.ready=true;setStatus('工作台已连接');
}catch(failure){if(failure.status===401||$('#app').hidden){requireAuth();return;}if(state.redirecting)return;setStatus(failure.message);$('#page-host').replaceChildren(el('div',{class:'initial-state'},el('p',{text:failure.message}),el('button',{text:'重新连接',onClick:bootstrap})));}
}
+1 -1
View File
@@ -26,7 +26,7 @@
</div></details>
<details class="menu"><summary accesskey="h">帮助<span class="access-key">(H)</span></summary><div class="menu-popup"><button data-command="updates">检查版本更新…</button><button data-command="debug">调试日志</button><button data-command="about">关于…</button></div></details>
</nav>
<span class="window-title">牧羊人之心牧场助手 <span id="app-version">2.0.9</span></span>
<span class="window-title">牧羊人之心牧场助手 <span id="app-version">2.0.10</span></span>
<span id="access-mode" class="muted"></span>
</header>
<div class="account-bar"><div id="account-tabs" class="account-tabs" role="tablist" aria-label="账号"></div><button id="add-account" class="compact" title="新增账号">+ 新增账号</button></div>
@@ -0,0 +1,247 @@
"""Web authorization of Engine-classified recovery, using offline clients only."""
from copy import deepcopy
import math
import time
from types import SimpleNamespace
import unittest
from unittest.mock import Mock, patch
from ranch_assistant.game_data import ProgressionData
from ranch_assistant.model import Snapshot
from ranch_web.service import AccountWorker
from ranch_web.tests import test_lifecycle_recovery as lifecycle
from ranch_web.tests import test_service as fixtures
from ranch_web.views import build_view
class RecoveryGuardContractTests(unittest.TestCase):
def worker(self, runtime):
worker = AccountWorker.__new__(AccountWorker)
worker.active_identity, worker._legacy_pending = None, {}
record = {"kind": "stage_battle", "stage_id": "0102", "phase": "unknown",
"execution_status": "timed_out", "terminal_reason": "worker_wall_clock_limit",
"path": "stageService/stageStart"}
worker.engine = SimpleNamespace(snapshot=object(), battles=runtime,
battle_journal=SimpleNamespace(pending=lambda snapshot: record),
_progression_pending=lambda: record, sweeper=SimpleNamespace(state={}),
explore_planner=SimpleNamespace(pending=lambda snapshot: None), _breakthrough_pending=None)
return worker, record
def test_engine_recovery_contract_overrides_old_clock_predicate(self):
for allowed in (False, True):
with self.subTest(allowed=allowed):
runtime = SimpleNamespace(recovery_status=Mock(return_value={
"state": "abandon_stage" if allowed else "blocked", "resumable": allowed,
"message": "已确认开战,按原客户端协议退出"}),
resumable_task_clock=Mock(return_value=not allowed))
worker, record = self.worker(runtime)
worker.engine.pending_battle_recovery = Mock(return_value=runtime.recovery_status.return_value)
self.assertEqual(worker._pending_execution_reason() == "", allowed)
worker.engine.pending_battle_recovery.assert_called_once_with()
runtime.recovery_status.assert_not_called()
runtime.resumable_task_clock.assert_not_called()
def test_truthy_recovery_flag_does_not_grant_write_permission(self):
for flag in (1, "true", None):
with self.subTest(flag=flag):
worker, _ = self.worker(SimpleNamespace(recovery_status=lambda *args, **kwargs: {
"state": "abandon_stage", "resumable": flag, "message": ""},
resumable_task_clock=lambda record: True))
worker.engine.pending_battle_recovery = lambda: {"state": "abandon_stage", "resumable": flag, "message": ""}
self.assertTrue(worker._pending_execution_reason())
def test_runtime_without_recovery_helper_keeps_old_clock_fallback(self):
for allowed in (False, True):
with self.subTest(allowed=allowed):
worker, _ = self.worker(SimpleNamespace(resumable_task_clock=lambda record: allowed))
self.assertEqual(worker._pending_execution_reason() == "", allowed)
def test_disabled_origin_uses_specific_engine_policy_message(self):
worker, _ = self.worker(SimpleNamespace(resumable_task_clock=lambda record: True))
message = "对应委托策略已关闭,等待启用委托策略后恢复原战斗"
worker.engine.pending_battle_recovery = lambda: {
"state": "blocked_policy", "resumable": False, "message": message}
self.assertEqual(worker._pending_execution_reason(), message)
class LegacyBattleRecoveryTests(unittest.TestCase):
setUp = fixtures.ServiceTests.setUp
account = fixtures.ServiceTests.account
idle = fixtures.ServiceTests.idle
job = fixtures.ServiceTests.job
connected = lifecycle.LifecycleRecoveryTests.connected
tick = lifecycle.LifecycleRecoveryTests.tick
paths = lifecycle.LifecycleRecoveryTests.paths
def login(self, identifier):
return fixtures.ServiceTests.login(self, identifier, account="recovery-" + identifier)
def legacy_timeout(self, *, unaccepted=False):
identifier, worker = self.connected()
engine = worker.engine
source_id, source_type, source_step = (0, "4001004", 0) if unaccepted else (51, "1002013", 1)
engine.client.raw["currentTasks"] = ([] if unaccepted else [
{"id": source_id, "typeId": source_type, "curStep": source_step, "stepValue": 0}])
engine.snapshot = Snapshot(deepcopy(engine.client.raw))
engine.game_data = ProgressionData({"task_info": {source_type: {"type": 4, "name": "离线材料委托",
"steps": [{"statusType": "none", "statusValue": {}}]}}})
config = self.manager.get_config(identifier)
config["config"]["quest_policy"]["enabled"] = True
self.job(identifier, self.manager.set_config(identifier, config["config"], config["revision"])["job"])
journal = engine.battle_journal
record = journal.begin(engine.snapshot, {"kind": "stage_battle", "stage_id": "0102", "difficulty": 1,
"battle_kind": "ordinary_stage", "description": "离线委托材料关卡", "task_id": None,
"task_type_id": None, "source_task_id": source_id,
"source_task_type_id": source_type, "source_step_number": source_step})
journal.update(record, "unknown", path="stageService/stageStart", start_path="stageService/stageStart",
start_response={"resCode": 0, "triggerEvent": False, "stageEvent": None},
battle_mode="experimental", execution_mode="experimental", execution_status="timed_out", terminal=False,
terminal_reason="worker_wall_clock_limit", message="战斗已取消、超时或结果不确定,等待核对")
self.assertEqual(engine.battles.recovery_status(record, snapshot=engine.snapshot)["state"], "abandon_stage")
engine.last_pending_check = time.monotonic() - 121
worker.schedule.next_poll = math.inf
return identifier, worker
def test_legacy_timeout_blocked_by_default_when_engine_denies_recovery(self):
identifier, worker = self.legacy_timeout()
evidence = deepcopy(worker.engine.battle_journal.pending(worker.engine.snapshot))
before = len(fixtures.FakeClient.calls)
with patch.object(worker.engine, "pending_battle_recovery", return_value={
"state": "blocked", "resumable": False, "message": "尚无可验证的安全恢复证据"}):
self.job(identifier, self.manager.submit(identifier, "start"), status="failed")
self.tick(identifier, worker)
self.assertFalse(worker.running)
self.assertTrue(worker.strategy_requested)
self.assertTrue(all(path == "masterService/masterQueryDetail" for path in self.paths(before)))
self.assertEqual(worker.engine.battle_journal.pending(worker.engine.snapshot), evidence)
def test_strict_safe_legacy_timeout_starts_then_exits_on_reconcile_without_reentry(self):
identifier, worker = self.legacy_timeout()
self.assert_failure_exit(identifier, worker)
def test_unaccepted_commission_legacy_timeout_exits_without_reentry_or_reward(self):
identifier, worker = self.legacy_timeout(unaccepted=True)
self.assert_failure_exit(identifier, worker)
def assert_failure_exit(self, identifier, worker):
before = len(fixtures.FakeClient.calls)
self.job(identifier, self.manager.submit(identifier, "start"))
self.assertTrue(worker.running)
self.assertFalse(worker.engine.auto, "Start must not dispatch recovery inline")
self.assertEqual(len(fixtures.FakeClient.calls), before)
state = self.manager.status(identifier)
self.assertEqual(state["strategy_state"], "recovering")
self.assertIn("退出", state["strategy_message"])
self.assertNotIn("战果已保存", state["strategy_message"])
worker.schedule.next_poll = math.inf
after = self.manager.logs(identifier)["next"]
poll = worker.engine.poll
def recovery_poll(**kwargs):
self.assertFalse(worker.engine.auto, "Recovery must not enable other strategies")
self.assertIs(kwargs.get("resume_pending"), True)
return poll(**kwargs)
with patch.object(worker.engine, "poll", side_effect=recovery_poll):
self.assertEqual(self.tick(identifier, worker)["result"]["kind"], "reconcile")
writes = [("/".join(url.rsplit("/", 2)[-2:]),
{key: value for key, value in payload.items() if key not in {"token", "reqid", "reqsid"}})
for _, url, payload in fixtures.FakeClient.calls[before:]
if not url.endswith("masterService/masterQueryDetail")]
self.assertEqual(writes, [("battleService/recordBattleResult", {"stageId": "0102", "cityId": "1", "result": 0})])
self.assertIsNone(worker.engine.battle_journal.pending(worker.engine.snapshot))
self.assertTrue(worker.running)
self.assertTrue(worker.strategy_requested)
record = worker.engine.battle_journal.records(worker.engine.snapshot)[0]
self.assertEqual(record["outcome"], "abandoned")
self.assertNotIn("battle_data", record)
rows = build_view(worker.engine, "battles", worker.config)["rows"]
row = next(row for row in rows if row["outcome"] == "abandoned")
self.assertIn("已放弃(本地计算失败)", row["outcome_label"])
self.assertNotIn("打不过", row["outcome_label"])
logs = self.manager.logs(identifier, after=after)["entries"]
self.assertTrue(any("退出" in row["message"] for row in logs))
self.assertFalse(any("打不过" in row["message"] for row in logs))
def test_manual_refresh_never_authorizes_safe_source_zero_recovery(self):
identifier, worker = self.legacy_timeout(unaccepted=True)
self.job(identifier, self.manager.submit(identifier, "start"))
before = len(fixtures.FakeClient.calls)
evidence = deepcopy(worker.engine.battle_journal.pending(worker.engine.snapshot))
self.job(identifier, self.manager.submit(identifier, "refresh"))
self.assertTrue(worker.running)
self.assertFalse(worker.engine.auto)
self.assertEqual(worker.engine.battle_journal.pending(worker.engine.snapshot), evidence)
self.assertTrue(all(path == "masterService/masterQueryDetail" for path in self.paths(before)))
def test_manual_stop_prevents_safe_legacy_failure_exit(self):
identifier, worker = self.legacy_timeout()
self.manager.submit(identifier, "stop")
before = len(fixtures.FakeClient.calls)
evidence = deepcopy(worker.engine.battle_journal.pending(worker.engine.snapshot))
self.tick(identifier, worker)
self.assertTrue(self.manager.status(identifier)["manual_stop"])
self.assertFalse(worker.running)
self.assertEqual(worker.engine.battle_journal.pending(worker.engine.snapshot), evidence)
self.assertTrue(all(path == "masterService/masterQueryDetail" for path in self.paths(before)))
def test_disabled_source_policy_prevents_safe_legacy_failure_exit(self):
identifier, worker = self.legacy_timeout(unaccepted=True)
config = self.manager.get_config(identifier)
config["config"]["quest_policy"]["enabled"] = False
config["config"]["daily_policy"].update(enabled=True, selected=["gift"])
self.job(identifier, self.manager.set_config(identifier, config["config"], config["revision"])["job"])
worker.schedule.next_poll = math.inf
before = len(fixtures.FakeClient.calls)
evidence = deepcopy(worker.engine.battle_journal.pending(worker.engine.snapshot))
self.job(identifier, self.manager.submit(identifier, "start"), status="failed")
self.tick(identifier, worker)
self.assertEqual(worker.engine.battle_journal.pending(worker.engine.snapshot), evidence)
self.assertTrue(all(path == "masterService/masterQueryDetail" for path in self.paths(before)))
state = self.manager.status(identifier)
self.assertFalse(state["running"])
self.assertEqual(state["strategy_state"], "blocked")
self.assertTrue(state["strategy_requested"])
self.assertFalse(state["manual_stop"])
recovery = worker.engine.pending_battle_recovery()
self.assertEqual(recovery["state"], "blocked_policy")
self.assertEqual(state["strategy_message"], recovery["message"])
self.assertIn("委托", state["strategy_message"])
self.assertIn("启用", state["strategy_message"])
self.assertFalse(worker.engine.quest_policy.enabled)
self.assertTrue(worker.engine.daily_policy.enabled)
config = self.manager.get_config(identifier)
config["config"]["quest_policy"]["enabled"] = True
self.job(identifier, self.manager.set_config(identifier, config["config"], config["revision"])["job"])
self.assertEqual(worker.engine.battle_journal.pending(worker.engine.snapshot), evidence)
worker.engine.last_pending_check = time.monotonic() - 121
worker.schedule.next_poll = math.inf
self.tick(identifier, worker)
writes = [("/".join(url.rsplit("/", 2)[-2:]), payload.get("result"))
for _, url, payload in fixtures.FakeClient.calls[before:]
if not url.endswith("masterService/masterQueryDetail")]
self.assertEqual(writes, [("battleService/recordBattleResult", 0)])
self.assertIsNone(worker.engine.battle_journal.pending(worker.engine.snapshot))
self.assertTrue(worker.running)
self.assertTrue(worker.strategy_requested)
def test_unknown_start_settlement_or_failure_reply_never_grants_recovery(self):
for changes in ({"start_response": None}, {"settlement_dispatched": True, "path": "battleService/battleEnd"},
{"record_dispatched": True}):
with self.subTest(changes=changes):
identifier, worker = self.legacy_timeout()
journal = worker.engine.battle_journal
journal.update(journal.pending(worker.engine.snapshot), "unknown", **changes)
evidence = deepcopy(journal.pending(worker.engine.snapshot))
before = len(fixtures.FakeClient.calls)
self.job(identifier, self.manager.submit(identifier, "start"), status="failed")
self.tick(identifier, worker)
self.assertFalse(worker.running)
self.assertTrue(worker.strategy_requested)
self.assertEqual(journal.pending(worker.engine.snapshot), evidence)
self.assertTrue(all(path == "masterService/masterQueryDetail" for path in self.paths(before)))
if __name__ == "__main__":
unittest.main()
+345
View File
@@ -0,0 +1,345 @@
"""Web recovery through real Engine barriers, temporary stores and offline HTTP."""
from copy import deepcopy
import json
import math
import threading
import time
import unittest
from unittest.mock import patch
import requests
from ranch_assistant.game_data import ProgressionData
from ranch_assistant.model import Snapshot
from ranch_assistant.tests.test_battle_orchestration import ExperimentalRuntime
from ranch_web.service import WebManager
from ranch_web.tests import test_service as fixtures
class LifecycleRecoveryTests(unittest.TestCase):
setUp = fixtures.ServiceTests.setUp
account = fixtures.ServiceTests.account
idle = fixtures.ServiceTests.idle
job = fixtures.ServiceTests.job
login = fixtures.ServiceTests.login
def connected(self):
identifier = self.account(False)
self.login(identifier)
worker = self.manager._worker(identifier)
self.now = 1000.0
worker.schedule.clock = lambda: self.now
worker.schedule.uniform = lambda low, high: high
worker.engine.last_heartbeat = self.now
self.enterContext(patch.object(worker.engine, "master_sync_due", return_value=False))
self.enterContext(patch.object(worker.engine, "growth_sync_due", return_value=False))
return identifier, worker
def battle(self, identifier, worker, *, timed_out=False):
"""Small task fixture already used by Engine's orchestration regressions."""
engine = worker.engine
raw = engine.client.raw
raw["master"].update(ti=1000, money=1000, timeTi=0)
raw["currentTasks"] = [{"id": 51, "typeId": "100", "curStep": 1, "stepValue": 0}]
raw["history"] = {"unlockCity": {"1": True}, "unlockStage": {"0101": [1, 2, 3]}}
raw["teams"] = [{"teamName": "teamA", "teamType": "battleTeam", "monsters": [raw["monsters"][0]["id"]]}]
raw["taskStepValue"] = 0
engine.snapshot = Snapshot(deepcopy(raw))
engine.game_data = ProgressionData({
"task_info": {"100": {"type": 1, "name": "离线任务", "steps": [
{"statusType": "passStage", "statusValue": {"stage": "0101", "level": 1}}]}},
"game_setting": {"cityInfo": {"1": {"name": "离线城市"}}},
"stage_info": {"0101": {"city": 1, "cost": {"ti": 6}, "level": {
str(n): {"cost": 0, "battle": {"fixture": True}} for n in (1, 2, 3)}}}})
runtime = ExperimentalRuntime()
original = runtime._run
if timed_out:
runtime.run.return_value = {"outcome": "timeout", "execution_mode": "experimental",
"execution_status": "timed_out", "terminal_reason": "worker_wall_clock_limit"}
runtime.run.side_effect = None
else:
runtime.run.side_effect = lambda request, cancel_event: original(request, cancel_event=cancel_event) | {
"requires_realtime_wait": True, "model_elapsed_ms": 10000}
engine._battle_runtimes["experimental"] = runtime
engine.battles.request_builder = None
config = self.manager.get_config(identifier)
config["config"]["progression_policy"].update(enabled=True, battle_mode="experimental", reserve_ti=0)
self.job(identifier, self.manager.set_config(identifier, config["config"], config["revision"])["job"])
worker.schedule.next_poll = 0
return runtime
def tick(self, identifier, worker):
return self.job(identifier, worker.enqueue("__tick"))
def paths(self, start=0):
return ["/".join(url.rsplit("/", 2)[-2:]) for _, url, _ in fixtures.FakeClient.calls[start:]]
def interrupted_clock(self):
identifier, worker = self.connected()
runtime = self.battle(identifier, worker)
entered = threading.Event()
original = worker.engine.battles.wait_for_battle_clock
def computed_wait(record, request, result, data, started, cancel):
wait = cancel.wait
def clock_wait(timeout):
entered.set()
return wait(timeout)
with patch.object(cancel, "wait", side_effect=clock_wait):
return original(record, request, result, data, started, cancel)
with patch.object(worker.engine.battles, "wait_for_battle_clock", side_effect=computed_wait):
tick = worker.enqueue("__tick")
self.assertTrue(entered.wait(3), "Offline battle never entered the computed clock wait")
config = self.manager.get_config(identifier)
config["config"]["policy"]["keep_money"] += 1
changed = self.manager.set_config(identifier, config["config"], config["revision"])
self.job(identifier, tick)
self.job(identifier, changed["job"])
record = worker.engine.battle_journal.pending(worker.engine.snapshot)
self.assertTrue(worker.engine.battles.resumable_task_clock(record), record)
self.assertTrue(worker.engine._progression_cancel.is_set())
return identifier, worker, runtime, record
def ready(self, worker):
journal = worker.engine.battle_journal
record = journal.pending(worker.engine.snapshot)
journal.update(record, record["phase"], battle_ready_at=1)
worker.engine.last_pending_check = time.monotonic() - 121
worker.schedule.next_poll = math.inf
def test_config_cancelled_computed_clock_resumes_on_reconcile_without_new_start(self):
identifier, worker, runtime, record = self.interrupted_clock()
saved = deepcopy(record["battle_data"])
self.ready(worker)
before = len(fixtures.FakeClient.calls)
self.assertEqual(self.tick(identifier, worker)["result"]["kind"], "reconcile")
self.assertIsNone(worker.engine.battle_journal.pending(worker.engine.snapshot))
writes = [path for path in self.paths(before) if path != "masterService/masterQueryDetail"]
self.assertEqual(writes, ["taskService/taskCompleteStep"])
payload = next(payload for _, url, payload in fixtures.FakeClient.calls[before:]
if url.endswith("taskService/taskCompleteStep"))
self.assertEqual(payload["battleData"], saved)
self.assertEqual(runtime.run.call_count, 1)
self.assertEqual(self.paths().count("battleService/battleStart"), 1)
self.assertTrue(self.manager.status(identifier)["strategy_requested"])
self.assertTrue(worker.running)
def test_start_accepts_saved_computed_result_but_does_not_settle_inline(self):
identifier, worker, _, _ = self.interrupted_clock()
self.manager.submit(identifier, "stop")
before = len(fixtures.FakeClient.calls)
self.job(identifier, self.manager.submit(identifier, "start"))
self.assertTrue(worker.running)
self.assertFalse(worker.engine.auto)
self.assertEqual(len(fixtures.FakeClient.calls), before)
self.assertEqual(self.manager.status(identifier)["strategy_state"], "recovering")
def test_computed_result_waits_for_deadline_and_manual_refresh_stays_read_only(self):
identifier, worker, runtime, _ = self.interrupted_clock()
journal = worker.engine.battle_journal
record = journal.pending(worker.engine.snapshot)
journal.update(record, record["phase"], battle_ready_at=time.time() + 3600)
worker.engine.last_pending_check = time.monotonic() - 121
worker.schedule.next_poll = math.inf
before = len(fixtures.FakeClient.calls)
self.tick(identifier, worker)
self.job(identifier, self.manager.submit(identifier, "refresh"))
self.assertTrue(all(path == "masterService/masterQueryDetail" for path in self.paths(before)))
self.assertIsNotNone(journal.pending(worker.engine.snapshot))
self.assertEqual(runtime.run.call_count, 1)
self.assertTrue(worker.running)
self.assertFalse(worker.engine.auto)
self.assertEqual(self.manager.status(identifier)["strategy_state"], "recovering")
def test_lost_resumed_settlement_reply_becomes_query_only_without_replay(self):
identifier, worker, runtime, _ = self.interrupted_clock()
self.ready(worker)
post = worker.engine.client.http.post
attempted = []
def lost_reply(url, *args, **kwargs):
if url.endswith("taskService/taskCompleteStep"):
attempted.append(url)
raise requests.ReadTimeout("offline lost settlement reply")
return post(url, *args, **kwargs)
with patch.object(worker.engine.client.http, "post", side_effect=lost_reply):
self.job(identifier, worker.enqueue("__tick"), status="failed")
record = worker.engine.battle_journal.pending(worker.engine.snapshot)
self.assertTrue(record["settlement_dispatched"])
self.assertFalse(worker.engine.battles.resumable_task_clock(record))
for _ in range(3):
self.now += 121
worker.engine.last_heartbeat = self.now
worker.engine.last_pending_check = time.monotonic() - 121
self.tick(identifier, worker)
self.assertEqual(len(attempted), 1)
self.assertEqual(runtime.run.call_count, 1)
self.assertEqual(self.paths().count("battleService/battleStart"), 1)
self.assertFalse(worker.running)
self.assertTrue(worker.strategy_requested)
def test_manual_stop_keeps_computed_result_unsent_through_config_and_restart(self):
identifier, worker, _, _ = self.interrupted_clock()
self.manager.submit(identifier, "stop")
self.ready(worker)
journal_path = worker.engine.battle_journal.path
evidence = journal_path.read_bytes()
config = self.manager.get_config(identifier)
config["config"]["policy"]["keep_money"] += 1
self.job(identifier, self.manager.set_config(identifier, config["config"], config["revision"])["job"])
before = len(fixtures.FakeClient.calls)
self.tick(identifier, worker)
self.assertEqual(journal_path.read_bytes(), evidence)
self.assertTrue(all(path == "masterService/masterQueryDetail" for path in self.paths(before)))
self.assertTrue(self.manager.status(identifier)["manual_stop"])
self.manager.close()
self.manager = WebManager(self.root, start_scheduler=False, login_factory=fixtures.FakeLogin)
self.addCleanup(self.manager.close)
self.idle(identifier)
self.assertTrue(self.manager.status(identifier)["manual_stop"])
self.assertEqual(journal_path.read_bytes(), evidence)
def test_stop_racing_authorized_reconcile_cancels_settlement_before_dispatch(self):
identifier, worker, _, _ = self.interrupted_clock()
self.ready(worker)
entered, release = threading.Event(), threading.Event()
poll = worker.engine.poll
journal_path = worker.engine.battle_journal.path
evidence = journal_path.read_bytes()
def held_poll(**kwargs):
self.assertFalse(worker.engine.auto)
self.assertIs(kwargs.get("resume_pending"), True)
entered.set()
self.assertTrue(release.wait(3))
return poll(**kwargs)
before = len(fixtures.FakeClient.calls)
with patch.object(worker.engine, "poll", side_effect=held_poll):
tick = worker.enqueue("__tick")
try:
self.assertTrue(entered.wait(3), self.manager.job(identifier, tick["id"]))
self.manager.submit(identifier, "stop")
finally:
release.set()
self.job(identifier, tick, status="cancelled")
self.assertEqual(len(fixtures.FakeClient.calls), before)
self.assertEqual(journal_path.read_bytes(), evidence)
self.assertFalse(worker.running)
self.assertTrue(self.manager.status(identifier)["manual_stop"])
def test_runtime_recovery_timeout_stays_blocked_after_single_local_retry(self):
identifier, worker = self.connected()
runtime = self.battle(identifier, worker, timed_out=True)
self.tick(identifier, worker)
record = worker.engine.battle_journal.pending(worker.engine.snapshot)
self.assertEqual(record["execution_status"], "timed_out")
self.assertFalse(worker.engine.battles.resumable_task_clock(record))
self.assertNotIn("battle_data", record)
self.assertTrue(worker.engine.pending_battle_recovery()["resumable"])
self.job(identifier, self.manager.submit(identifier, "start"))
worker.engine.last_pending_check = time.monotonic() - 121
worker.schedule.next_poll = math.inf
self.tick(identifier, worker)
record = worker.engine.battle_journal.pending(worker.engine.snapshot)
self.assertEqual(record["runtime_recovery_attempts"], 1)
self.assertFalse(worker.engine.pending_battle_recovery()["resumable"])
evidence = worker.engine.battle_journal.path.read_bytes()
before = len(fixtures.FakeClient.calls)
self.job(identifier, self.manager.submit(identifier, "start"), status="failed")
for _ in range(3):
self.now += 121
worker.engine.last_heartbeat = self.now
worker.engine.last_pending_check = time.monotonic() - 121
self.tick(identifier, worker)
self.assertTrue(all(path == "masterService/masterQueryDetail" for path in self.paths(before)))
self.assertEqual(worker.engine.battle_journal.path.read_bytes(), evidence)
self.assertEqual(runtime.run.call_count, 2)
self.assertEqual(self.paths().count("battleService/battleStart"), 1)
state = self.manager.status(identifier)
self.assertFalse(state["running"])
self.assertTrue(state["strategy_requested"])
self.assertFalse(state["manual_stop"])
self.assertIn("本地战斗计算超时", state["strategy_message"])
self.assertIn("尚未提交结算", state["strategy_message"])
def test_stage_farming_timeout_reports_its_operation_without_promising_resolution(self):
identifier, worker = self.connected()
fixtures.ServiceTests.enable(self, identifier)
self.job(identifier, self.manager.submit(identifier, "start"))
journal = worker.engine.battle_journal
record = journal.begin(worker.engine.snapshot, {"kind": "stage_battle", "stage_id": "0102",
"difficulty": 1, "path": "stageService/stageStart", "task_id": 0})
journal.update(record, "unknown", start_response={"resCode": 0, "triggerEvent": False, "stageEvent": None},
execution_status="timed_out", terminal_reason="worker_wall_clock_limit",
message="战斗已取消、超时或结果不确定,等待核对")
self.tick(identifier, worker)
state = self.manager.status(identifier)
self.assertTrue(state["connected"])
self.assertFalse(state["running"])
self.assertIn("0102", state["strategy_message"])
self.assertIn("本地战斗计算超时", state["strategy_message"])
worker.schedule.monitor(False)
reason = worker._pending_execution_reason()
self.assertNotIn("后台继续", reason)
self.assertNotIn("自动恢复", reason)
config = self.manager.get_config(identifier)
config["config"]["policy"]["keep_money"] += 1
self.job(identifier, self.manager.set_config(identifier, config["config"], config["revision"])["job"])
self.assertEqual(worker.config["policy"]["keep_money"], config["config"]["policy"]["keep_money"])
self.assertTrue(worker.strategy_requested)
intent = json.loads((worker.profile_root / "run_intent.json").read_text(encoding="utf-8"))
self.assertTrue(intent["roles"][worker.active_identity])
def test_config_cancellation_before_start_dispatch_replans_without_unknown_barrier(self):
identifier, worker = self.connected()
runtime = self.battle(identifier, worker, timed_out=True)
update = worker.engine.battle_journal.update
changed = []
def cancel_before_send(record, phase, **fields):
update(record, phase, **fields)
if phase == "start_pending":
config = self.manager.get_config(identifier)
config["config"]["policy"]["keep_money"] += 1
changed.append(self.manager.set_config(identifier, config["config"], config["revision"])["job"])
with patch.object(worker.engine.battle_journal, "update", side_effect=cancel_before_send):
self.tick(identifier, worker)
self.job(identifier, changed[0])
self.assertNotIn("battleService/battleStart", self.paths())
self.assertFalse(worker.engine._progression_pending())
self.assertIsNone(worker.engine.battle_journal.pending(worker.engine.snapshot))
self.assertIsNone(worker.engine.progression_planner.pending(worker.engine.snapshot))
runtime.run.assert_not_called()
self.assertTrue(worker.running)
self.assertTrue(worker.strategy_requested)
worker.schedule.next_poll = 0
self.tick(identifier, worker)
self.assertEqual(self.paths().count("battleService/battleStart"), 1)
def test_internal_pending_pause_does_not_revoke_generation_or_persist_manual_stop(self):
identifier, worker = self.connected()
worker.schedule.next_poll = 0
generation = worker._generation
def paused(**kwargs):
journal = worker.engine.battle_journal
record = journal.begin(worker.engine.snapshot, {"kind": "stage_battle", "stage_id": "0102"})
journal.update(record, "unknown", message="请求结果未知")
worker.engine.auto = False
return worker.engine.snapshot, [], "请求结果未知"
with patch.object(worker.engine, "poll", side_effect=paused):
self.tick(identifier, worker)
self.assertEqual(worker._generation, generation)
self.assertTrue(worker.strategy_requested)
self.assertFalse(self.manager.status(identifier)["manual_stop"])
if __name__ == "__main__":
unittest.main()
@@ -0,0 +1,44 @@
"""Public account summaries preserve execution intent without private recovery data."""
import unittest
from ranch_web.tests import test_api as fixtures
class RecoveryStatusApiTests(unittest.TestCase):
setUp = fixtures.ApiTests.setUp
def test_accounts_and_status_preserve_blocked_intent_and_explicit_stop(self):
source = self.manager.accounts[self.account_id]
fields = {"strategy_requested": True, "manual_stop": False, "strategy_state": "blocked",
"strategy_message": "本地战斗计算超时,尚未提交结算", "strategy_retry_at": None}
source.update(fields, running=False, journal={"payload": "PRIVATE_RECOVERY"})
for values in (fields, fields | {"strategy_requested": False, "manual_stop": True,
"strategy_state": "stopped", "strategy_message": "已按用户选择停止策略"}):
source.update(values)
for url in ("/api/accounts", self.url + "/status"):
with self.subTest(url=url, state=values["strategy_state"]):
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
body = response.json()
summary = body[0] if isinstance(body, list) else body
for field, expected in values.items():
self.assertEqual(summary.get(field), expected, field)
self.assertFalse(summary["running"])
self.assertNotIn("journal", summary)
self.assertNotIn("PRIVATE_RECOVERY", response.text)
def test_strategy_message_uses_the_connection_error_redactor(self):
source = self.manager.accounts[self.account_id]
for message in ("本地计算失败 token=STATUS_PRIVATE C:/private/battle.json", "Traceback: STATUS_PRIVATE"):
source.update(strategy_message=message, connection_message=message)
response = self.client.get(self.url + "/status")
self.assertEqual(response.status_code, 200)
body = response.json()
self.assertIsInstance(body.get("strategy_message"), str)
self.assertEqual(body["strategy_message"], body["connection_message"])
self.assertNotIn("STATUS_PRIVATE", response.text)
self.assertNotIn("C:/private", response.text)
if __name__ == "__main__":
unittest.main()
+1 -1
View File
@@ -463,7 +463,7 @@ STATES = {"available": "可接取", "unaccepted": "未接取", "active": "进行
STATE_ALIASES = {"active": "received", "in_progress": "received", "available": "unlocked", "unaccepted": "unlocked", "offered": "unlocked", "ready": "ready_to_reward",
"completed": "finished", "complete": "finished", "claimed": "finished", "blocked": "received"}
STATE_FILTERS = [("current", "当前(进行中 + 待接取 + 待领奖)"), ("received", "进行中"), ("unlocked", "待接取"), ("ready_to_reward", "待领奖"), ("finished", "已完成"), ("locked", "未解锁"), ("", "全部状态")]
OUTCOMES = {"win": "胜利", "loss": "打不过", "unsupported": "暂不支持", "event": "地图奖励事件", "completed": "已完成", "cancelled": "已取消", "timeout": "超时", "unknown": "结果待核对"}
OUTCOMES = {"win": "胜利", "loss": "打不过", "unsupported": "暂不支持", "event": "地图奖励事件", "completed": "已完成", "cancelled": "已取消", "abandoned": "已放弃(本地计算失败)", "timeout": "超时", "unknown": "结果待核对"}
CHINA_TIME = timezone(timedelta(hours=8))