Add v1.2 development quest progression and experimental battle runtime

This commit is contained in:
AttilaNet
2026-11-08 19:29:28 +08:00
parent 79b7672471
commit 0d3e231cde
71 changed files with 14349 additions and 172 deletions
+1
View File
@@ -274,6 +274,7 @@ class AccountGuiTests(unittest.TestCase):
hub.tabs.setCurrentWidget(first)
for page in (first.egg_page, first.monster_page, first.room_page):
first.tabs.setCurrentWidget(page)
self.wait(windows)
self.assertEqual([first.slots.rowCount(), first.eggs.rowCount(), len(first.monsters.monster_items)], [11, 4, 4])
self.assertFalse(first.monsters.group_items)
self.assertTrue(all(item.parent() is None for item in first.monsters.monster_items.values()))
+60
View File
@@ -0,0 +1,60 @@
"""AMF3 array shapes and object-reference regressions, entirely offline."""
import unittest
from ranch_assistant.amf import Reader
class ArrayReaderTests(unittest.TestCase):
def test_empty_dense_array_is_list_and_occupies_object_reference_slot(self):
reader = Reader(b"\x09\x01\x01\x09\x00")
value = reader.read()
self.assertIs(type(value), list)
self.assertEqual(value, [])
self.assertIs(reader.read(), value)
self.assertIs(reader.objects[0], value)
self.assertEqual(reader.pos, len(reader.data))
def test_pure_associative_array_preserves_self_reference(self):
# Array, zero dense entries, property 'x', array reference 0, end keys.
reader = Reader(b"\x09\x01\x03x\x09\x00\x01")
value = reader.read()
self.assertIs(type(value), dict)
self.assertIs(value["x"], value)
self.assertIs(reader.objects[0], value)
def test_dense_array_preserves_self_reference(self):
reader = Reader(b"\x09\x03\x01\x09\x00")
value = reader.read()
self.assertIs(type(value), list)
self.assertIs(value[0], value)
def test_nested_empty_array_keeps_parent_and_child_reference_order(self):
# [empty array, reference to that array, reference to parent]
reader = Reader(b"\x09\x07\x01\x09\x01\x01\x09\x02\x09\x00")
value = reader.read()
self.assertIs(type(value[0]), list)
self.assertIs(value[1], value[0])
self.assertIs(value[2], value)
self.assertIs(reader.objects[0], value)
self.assertIs(reader.objects[1], value[0])
def test_associative_first_key_can_use_string_reference(self):
reader = Reader(b"\x06\x03k\x09\x01\x00\x04\x07\x01")
self.assertEqual(reader.read(), "k")
self.assertEqual(reader.read(), {"k": 7})
self.assertEqual(len(reader.objects), 1)
def test_dynamic_empty_object_remains_mapping(self):
reader = Reader(b"\x0a\x0b\x01\x01\x0a\x00")
value = reader.read()
self.assertIs(type(value), dict)
self.assertEqual(value, {})
self.assertIs(reader.read(), value)
def test_mixed_arrays_still_rejected(self):
with self.assertRaisesRegex(ValueError, "Mixed AMF array unsupported"):
Reader(b"\x09\x03\x03k\x04\x01\x01\x04\x02").read()
if __name__ == "__main__":
unittest.main()
+1
View File
@@ -425,6 +425,7 @@ class AutomationGuiTests(unittest.TestCase):
before = len(window.engine.snapshot.raw["monsters"])
def select(mid):
window.tabs.setCurrentWidget(window.monster_page)
self.wait(window)
window.monsters.clearSelection()
window.monsters.setCurrentItem(window.monsters.monster_items[mid])
select(101)
File diff suppressed because it is too large Load Diff
@@ -0,0 +1,488 @@
from contextlib import ExitStack
from copy import deepcopy
from dataclasses import asdict, replace
import hashlib
import json
import os
from pathlib import Path
import struct
import sys
import threading
import time
from types import SimpleNamespace
import unittest
from unittest.mock import patch
import zipfile
import zlib
from ranch_assistant.battle_runtime import (
BattleRequest, BattleRuntime, ORIGINAL_APK_SHA256, ORIGINAL_MAIN_SHA256, original_fixture_request,
)
from ranch_assistant.tests.test_core import workspace_temp
from tools.battle_runtime.isolation import ProcessResult, run_isolated
from tools.battle_runtime.swf_library import encode_tag, library_only, symbols, tags
from tools.battle_runtime.trusted import verify_files
from tools.battle_runtime.inputs import ADD_FIELDS, MON_FIELDS, validate
from tools.battle_runtime.prepare import asset_index, write_atomic
class RuntimeContractTests(unittest.TestCase):
def setUp(self):
self.stack = ExitStack()
self.addCleanup(self.stack.close)
self.root = Path(self.stack.enter_context(workspace_temp()))
(self.root / "fixture_1.9.68.apk").write_bytes(b"Not an engine; contract tests never execute this")
self.stack.enter_context(patch("ranch_assistant.battle_runtime.ROOT", self.root))
self.stack.enter_context(patch("ranch_assistant.battle_runtime.LOCAL", self.root / "runtime"))
self.stack.enter_context(patch("ranch_assistant.battle_runtime.os", SimpleNamespace(name="nt")))
self.stack.enter_context(patch("tools.battle_runtime.trusted.verify_files", return_value=[]))
self.request = original_fixture_request()
def inspect(self, **changes):
return BattleRuntime().inspect(replace(self.request, **changes))
def codes(self, capability):
return {row["code"] for row in capability["reasons"]}
def test_native_fixture_support_never_grants_settlement_or_fidelity(self):
capability = self.inspect()
self.assertTrue(capability["supported"])
self.assertFalse(capability["faithful"])
self.assertFalse(capability["settlement_eligible"])
self.assertEqual(capability["coverage"]["validated_skills"], [3])
def test_default_purpose_refuses_before_starting_any_process(self):
request = BattleRequest("ordinary_stage", self.request.original_data, self.request.roster, stage_id="0101")
with patch("tools.battle_runtime.isolation.run_isolated") as execute:
result = BattleRuntime().run(request)
execute.assert_not_called()
self.assertEqual(result["status"], "unsupported")
self.assertIn("settlement_not_validated", self.codes(result["capability"]))
self.assertNotIn("outcome", result)
self.assertNotIn("offline_result", result)
def test_dict_contract_matches_dataclass_and_input_is_unchanged(self):
request = asdict(self.request)
before = json.loads(json.dumps(request))
self.assertEqual(BattleRuntime().inspect(request), BattleRuntime().inspect(self.request))
self.assertEqual(request, before)
def test_unknown_context_and_unhashable_context_refuse(self):
for context in ("boss", "pve", ["ordinary_stage"], None):
with self.subTest(context=context):
self.assertIn("unknown_context", self.codes(self.inspect(context=context)))
def test_task_routes_cannot_reuse_the_ordinary_stage_proof(self):
for context in ("task_battle", "task_pass_stage"):
capability = self.inspect(context=context, task_id="1001004", step_index=0)
self.assertFalse(capability["supported"])
self.assertIn("task_route_not_validated", self.codes(capability))
def test_other_stages_and_difficulties_refuse(self):
for changes in ({"stage_id":"0102"}, {"difficulty":2}, {"difficulty":True}, {"difficulty":"1"}):
self.assertIn("scene_not_validated", self.codes(self.inspect(**changes)))
def test_task_fields_are_rejected_even_with_ordinary_context(self):
self.assertIn("task_input_not_validated", self.codes(self.inspect(step_index=0)))
def test_unknown_roster_skills_equipment_and_estimates_refuse(self):
for roster in ({"hp":100,"atk":100}, {**self.request.roster,"skills":[9999]},
{**self.request.roster,"equipment":[123]}):
self.assertIn("roster_not_validated", self.codes(self.inspect(roster=roster)))
def test_unverified_original_tables_cannot_enable_unknown_mechanics(self):
data = {**self.request.original_data, "battle":{"controller":[{"type":"unimplemented"}]}}
self.assertIn("external_battle_data_unvalidated", self.codes(self.inspect(original_data=data)))
def test_claimed_original_identity_must_match_both_pins(self):
identity = {**self.request.original_data["resource_identity"], "main_swf_sha256":"0" * 64}
self.assertIn("resource_identity_mismatch", self.codes(self.inspect(original_data={
"source":"original_apk", "resource_identity":identity})))
def test_imported_commands_paths_and_unsigned_verified_manifests_never_execute(self):
for config in ({"command":["cmd","/c","anything"]}, {"executable":"evil.exe"},
{"backend":"original_air","verified":True,"supports":["*"]},
{"backend":"original_air","resource_root":"somewhere"}):
with self.subTest(config=config), patch("tools.battle_runtime.isolation.run_isolated") as execute:
result = BattleRuntime(config).run(self.request)
self.assertEqual(result["status"], "unsupported")
self.assertIn("untrusted_runtime_config", self.codes(result["capability"]))
execute.assert_not_called()
def test_foreign_backend_refuses(self):
result = BattleRuntime({"backend":"basic_estimate"}).inspect(self.request)
self.assertIn("unknown_backend", self.codes(result))
def test_unsigned_result_in_request_is_not_an_engine_result(self):
request = {**asdict(self.request), "result":{"win":True}, "verified":True}
result = BattleRuntime().run(request)
self.assertEqual(result["status"], "unsupported")
self.assertIn("unknown_request_fields", self.codes(result["capability"]))
def test_malformed_nonfinite_and_oversize_inputs_refuse(self):
for request in (None, [], {}, {**asdict(self.request),"roster":{"hp":float("nan")}},
{**asdict(self.request),"roster":{"payload":"x" * (4 * 1024 * 1024)}}):
self.assertFalse(BattleRuntime().inspect(request)["supported"])
def test_cancellation_before_run_does_not_inspect_or_launch(self):
event = threading.Event(); event.set()
runtime = BattleRuntime()
with patch.object(runtime,"inspect") as inspect:
result = runtime.run(self.request,cancel_event=event)
inspect.assert_not_called()
self.assertEqual(result["status"], "cancelled")
def test_timeout_must_be_finite_and_positive(self):
for value in (0, -1, True, float("nan"), float("inf"), "5"):
with self.subTest(value=value), self.assertRaises(ValueError):
BattleRuntime().run(self.request, timeout=value)
def fake_worker(self, mutate):
def execute(argv, **kwargs):
output = Path(argv[argv.index("--output")+1])
nonce = argv[argv.index("--nonce")+1]
payload = {"schema":1,"nonce":nonce,"evidence":{
"resource_identity":{"apk_sha256":ORIGINAL_APK_SHA256,"main_swf_sha256":ORIGINAL_MAIN_SHA256},
"resource_audit":{"all_present_assets_match_apk":True},"process_exit_code":0,
"result":{"status":"scene_completed","battle_executed":True,"settlement_eligible":False,
"scene_result":{"outcome":"win","battle_data":{"win":True,"cheatNum":0,"battlePosition":{
"battleType":"stage","stageLevel":"1","stageId":"0101","taskTypeId":None,"taskStep":0}},
"anomaly_records":{"text":"real anomaly","damages":[{"damage":999}]}}}}}
mutate(payload)
output.write_text(json.dumps(payload),encoding="utf-8")
return ProcessResult("completed",0,.1,"","")
return execute
def test_result_protocol_rejects_wrong_nonce_identity_claim_or_missing_execution(self):
mutations = [lambda p:p.update(nonce="wrong"),
lambda p:p["evidence"]["resource_identity"].update(apk_sha256="0" * 64),
lambda p:p["evidence"]["resource_identity"].update(main_swf_sha256="0" * 64),
lambda p:p["evidence"]["result"].update(settlement_eligible=True),
lambda p:p["evidence"]["result"].update(faithful=True),
lambda p:p["evidence"]["result"].update(battle_executed=False),
lambda p:p["evidence"]["resource_audit"].update(all_present_assets_match_apk=False),
lambda p:p["evidence"]["result"]["scene_result"].update(outcome="invented")]
for mutation in mutations:
with self.subTest(mutation=mutation), patch("tools.battle_runtime.isolation.run_isolated",side_effect=self.fake_worker(mutation)):
result = BattleRuntime().run(self.request)
self.assertEqual(result["status"], "error")
self.assertNotIn("outcome",result)
self.assertFalse(result["settlement_eligible"])
def test_original_anomaly_records_survive_protocol_without_filtering(self):
with patch("tools.battle_runtime.isolation.run_isolated",side_effect=self.fake_worker(lambda p:None)):
result = BattleRuntime().run(self.request)
self.assertEqual(result["status"],"completed")
self.assertEqual(result["offline_result"]["anomaly_records"]["text"],"real anomaly")
self.assertEqual(result["offline_result"]["anomaly_records"]["damages"],[{"damage":999}])
self.assertFalse(result["faithful"])
def test_positive_original_anomaly_count_preserves_completed_result(self):
def anomaly(payload):
payload["evidence"]["result"]["scene_result"]["battle_data"]["cheatNum"] = 4
with patch("tools.battle_runtime.isolation.run_isolated",side_effect=self.fake_worker(anomaly)):
result = BattleRuntime().run(self.request)
self.assertEqual(result["status"],"anomaly")
self.assertTrue(result["battle_completed"])
self.assertFalse(result["checks_passed"])
self.assertEqual(result["offline_result"]["anomaly_records"]["text"],"real anomaly")
def test_natural_native_time_limit_is_completed_loss_not_watchdog_timeout(self):
def expiry(payload):
scene = payload["evidence"]["result"]["scene_result"]
scene.update(outcome="loss",terminal_reason="time_limit")
scene["battle_data"].update(win=False,leftTime=0)
with patch("tools.battle_runtime.isolation.run_isolated",side_effect=self.fake_worker(expiry)):
result = BattleRuntime().run(self.request)
self.assertEqual(result["status"],"completed")
self.assertEqual(result["outcome"],"loss")
self.assertEqual(result["offline_result"]["terminal_reason"],"time_limit")
def test_default_deadline_allows_original_300_second_battle_and_explicit_is_preserved(self):
runtime=BattleRuntime()
with patch.object(runtime,"_execute",return_value={}) as execute:
runtime.run(self.request)
self.assertGreater(execute.call_args.kwargs["timeout"],600)
with patch.object(runtime,"_execute",return_value={}) as execute:
runtime.run(self.request,timeout=10)
self.assertGreater(execute.call_args.kwargs["timeout"],8)
self.assertLessEqual(execute.call_args.kwargs["timeout"],10)
def test_timed_out_worker_does_not_yield_a_battle_result(self):
with patch("tools.battle_runtime.isolation.run_isolated",return_value=ProcessResult("timeout",1,.1,"","")):
result = BattleRuntime().run(self.request)
self.assertEqual(result["status"],"timeout")
self.assertNotIn("outcome",result)
self.assertNotIn("offline_result",result)
class OriginalInputTests(unittest.TestCase):
"""Data-only preflight tests; no APK, AIR, account, or network is required."""
def setUp(self):
self.battle={"time":300,"groundType":1,"teams":[],"controller":[],"triggers":[],
"battleField":{"mapAreas":[],"mapObjects":[]}}
self.tables={"stage_info":{"0101":{"level":{"1":{"battle":self.battle}}}},
"task_info":{"original-task":{"steps":[
{"statusType":"battle","battle":self.battle},
{"statusType":"passStage","statusValue":{"stage":"0101","level":1}}]}},
"monster_info":{"1001010":{"skill_1":3,"skill_2":0,"imgFix":{"2":{"x":0,"y":0}}}},
"monster_skill":{"3":{}},"skin_info":{},"upstar_info":{},"item_info":{},
"team_info":{"battleTeam":{"0":{},"1":{}}},
"setting":{"groundType":{"1":{"battleImg":"background.png"}},"groundObject":{}},
"game_setting":{"normalBattleTime":300,"maxFeel":200},
"potential_info":{"potentialLevelMaxAdd":10}}
self.members={self.member(path) for path in ("data/img/bg/background.png","data/img/monster/q/1001010_q_2.png")}
mon=dict.fromkeys(MON_FIELDS,0)
mon.update(id=1000001,typeId=1001010,level=1,mode=2,process=3,potentialLevel=1,nicName="")
self.snapshot={"master":{"id":1,"level":1,"globalAtk":0,"globalDef":0,"globalHp":0,"globalDex":0},
"monsters":[mon],"monsterAttributes":[],"items":[],
"teams":[{"teamName":"teamB","teamType":"battleTeam","monsters":[1000001,0]}],
"history":{**dict.fromkeys(("numAddMoney","numChicken","countBattle"),0),
**{k:[] for k in ("monLib","equipLib","passAchi","guide_record","unlockCity")},
**{k:{} for k in ("numFeedMonsters","numKillMonsters","historyGacha","passTask","unlockTask","loopTask","unlockStage","passStage","payTypeCount","everyDayBuyProductNum")},
"guide_main":""}}
self.request={"context":"ordinary_stage","stage_id":"0101","difficulty":1,
"original_data":{"battle":self.battle},"roster":self.snapshot,"team":"teamB",
"battle_position":{"battleType":"stage","stageId":"0101","stageLevel":"1","taskTypeId":None,"taskStep":0}}
@staticmethod
def member(path):
return "assets/codes/"+hashlib.md5(path.encode()).hexdigest()
def validate(self,request=None):
return validate(self.request if request is None else request,source=(self.tables,self.members))
def codes(self,result):
return {r["code"] for r in result["reasons"]}
def test_raw_roster_contract_preserves_selected_team_b_and_empty_additions(self):
before=deepcopy(self.request);result=self.validate()
self.assertEqual(result["reasons"],[])
self.assertEqual(result["native_request"]["roster"]["team_name"],"teamB")
self.assertEqual(result["native_request"]["roster"]["snapshot"]["monsterAttributes"],[])
self.assertEqual(self.request,before)
def test_wrapper_and_raw_contract_produce_identical_native_input(self):
raw=self.validate()
wrapped=deepcopy(self.request);wrapped.pop("team")
wrapped["roster"]={"snapshot":self.snapshot,"team_name":"teamB"}
self.assertEqual(self.validate(wrapped)["native_request"],raw["native_request"])
def test_missing_or_conflicting_team_is_never_defaulted(self):
request=deepcopy(self.request);request.pop("team")
self.assertIn("invalid_roster",self.codes(self.validate(request)))
request["team"]="teamA"
self.assertIn("invalid_selected_team",self.codes(self.validate(request)))
request["roster"]={"snapshot":self.snapshot,"team_name":"teamB"}
self.assertIn("invalid_roster",self.codes(self.validate(request)))
def test_all_three_contexts_keep_original_position(self):
for context,index in (("task_battle",0),("task_pass_stage",1)):
request=deepcopy(self.request);request.update(context=context,stage_id=None,
task_id="account-instance",step_index=index,battle_position={"battleType":"task",
"stageId":None,"stageLevel":None,"taskTypeId":"original-task","taskStep":index})
result=self.validate(request)
self.assertEqual(result["reasons"],[])
self.assertEqual(result["position"],request["battle_position"])
request["battle_position"]["battleType"]="stage"
self.assertIn("battle_position_mismatch",self.codes(self.validate(request)))
def test_mismatched_task_status_step_and_authored_config_refuse(self):
request=deepcopy(self.request);request.update(context="task_battle",stage_id=None,
task_id="original-task",step_index=1,battle_position=None)
self.assertIn("invalid_battle_context",self.codes(self.validate(request)))
request=deepcopy(self.request);request["original_data"]["battle"]["time"]=1
self.assertIn("battle_config_mismatch",self.codes(self.validate(request)))
def test_unknown_original_mechanics_refuse_even_with_canonical_config(self):
for field,value,code in (("controller",[{"type":"unknown"}],"unknown_battle_controller"),
("triggers",[{"type":"time","effects":[{"type":"story"}]}],"unsupported_trigger_effect")):
with self.subTest(field=field):
self.battle[field]=value
self.assertIn(code,self.codes(self.validate()))
self.battle[field]=[]
self.battle["battleField"]["mapAreas"]=[{"type":"block"}]
self.assertIn("unknown_battle_area",self.codes(self.validate()))
def test_missing_assets_and_malformed_arrays_refuse(self):
self.members.remove(self.member("data/img/monster/q/1001010_q_2.png"))
self.assertIn("original_asset_missing",self.codes(self.validate()))
self.battle["teams"]={}
self.assertIn("invalid_battle_array",self.codes(self.validate()))
def test_missing_history_duplicate_slots_and_partial_attributes_refuse(self):
request=deepcopy(self.request);del request["roster"]["history"]["passTask"]
self.assertIn("incomplete_battle_history",self.codes(self.validate(request)))
request=deepcopy(self.request);request["roster"]["teams"][0]["monsters"]=[1000001,1000001]
self.assertIn("duplicate_selected_monster",self.codes(self.validate(request)))
request=deepcopy(self.request);request["roster"]["monsterAttributes"]=[{"monsterId":1000001,"atk":0}]
self.assertIn("incomplete_monster_additions",self.codes(self.validate(request)))
def test_skin_uses_visual_table_and_original_species_skills(self):
self.tables["skin_info"]["1001011"]={"monType":"1001010"}
self.tables["monster_info"]["1001011"]={"imgFix":{"2":{}},"skill_1":9999}
self.members.add(self.member("data/img/monster/q/1001011_q_2.png"))
self.snapshot["monsters"][0]["skin"]=1001011
result=self.validate()
self.assertEqual(result["reasons"],[])
self.assertEqual(result["coverage"]["skill_ids"],[3])
def test_equipment_requires_original_params_and_its_visible_asset(self):
self.snapshot["monsters"][0]["equip1"]=2000001
self.snapshot["items"]=[{"id":2000001,"typeId":50001,"num":1,"isUsed":1,
"itemClass":3,"equipParams":json.dumps(dict.fromkeys(ADD_FIELDS,0))}]
self.tables["item_info"]["50001"]={"position":{"position":1,"img":True}}
self.assertIn("original_asset_missing",self.codes(self.validate()))
self.members.add(self.member("data/img/item/item_50001_o.png"))
self.assertEqual(self.validate()["reasons"],[])
self.snapshot["items"][0]["equipParams"]='{}'
self.assertIn("incomplete_equipment",self.codes(self.validate()))
def test_public_dataclass_retains_canonical_raw_roster_fields(self):
request=BattleRequest(**self.request)
self.assertEqual(asdict(request)["team"],"teamB")
self.assertEqual(asdict(request)["battle_position"],self.request["battle_position"])
def test_public_inspector_routes_engine_raw_roster_to_snapshot_validation(self):
with patch("tools.battle_runtime.inputs.original_source",return_value=(self.tables,self.members)), \
patch("tools.battle_runtime.trusted.verify_files",return_value=[]), \
patch("ranch_assistant.battle_runtime.os",SimpleNamespace(name="nt")):
result=BattleRuntime().inspect(self.request)
self.assertTrue(result["supported"],result["reasons"])
self.assertEqual(result["native_position"],self.request["battle_position"])
self.assertEqual(result["watchdog_seconds"],690)
self.assertFalse(result["settlement_eligible"])
self.assertTrue(result["native_admission_validation_pending"])
self.assertTrue(result["faithful"])
self.assertFalse(result["server_acceptance_verified"])
class ArtifactIdentityTests(unittest.TestCase):
def swf(self, payloads):
raw = bytearray(b"FWS\x32\0\0\0\0\0\0\x1e\x01\0")
for code,payload in payloads:
raw.extend(encode_tag(code,payload))
raw.extend(encode_tag(0,b""));struct.pack_into("<I",raw,4,len(raw))
return bytes(raw)
def test_library_copy_cannot_invoke_original_document_and_preserves_abc(self):
abc = b"opaque original ABC byte identity fixture"
bindings = struct.pack("<H",2)+struct.pack("<H",0)+b"GameStartup\0"+struct.pack("<H",42)+b"BattleAnimation\0"
raw = self.swf([(76,bindings),(82,struct.pack("<I",0)+b"main\0"+abc)])
converted,identity = library_only(raw)
output = dict(tags(converted))
self.assertEqual(symbols(output[76]),[(42,b"BattleAnimation")])
self.assertEqual(output[82][output[82].index(0,4)+1:],abc)
self.assertEqual(struct.unpack_from("<I",output[82])[0],1)
self.assertEqual(identity["removed_document_classes"],["GameStartup"])
self.assertEqual(identity["abc_sha256"],[hashlib.sha256(abc).hexdigest()])
def test_compressed_swf_has_same_library_code(self):
raw = self.swf([(82,struct.pack("<I",1)+b"main\0abc")])
compressed = b"CWS"+raw[3:8]+zlib.compress(raw[8:])
self.assertEqual(library_only(raw)[0],library_only(compressed)[0])
def test_executable_or_import_tags_and_truncation_refuse(self):
for tag in (12,59,72,57,71):
with self.subTest(tag=tag),self.assertRaises(ValueError):
library_only(self.swf([(tag,b"not allowed")]))
with self.assertRaises(ValueError):library_only(self.swf([])[:-1])
def test_digest_validation_ignores_a_local_manifest_claiming_verification(self):
with workspace_temp() as directory:
root=Path(directory); (root/"runner.exe").write_bytes(b"replaced code")
(root/"identity.json").write_text(json.dumps({"verified":True,"files":{"runner.exe":hashlib.sha256(b"replaced code").hexdigest()}}))
reasons=verify_files(root,{"runner.exe":hashlib.sha256(b"reviewed code").hexdigest()})
self.assertEqual(reasons,[{"code":"dependency_digest_mismatch","detail":"runner.exe"}])
def test_identical_preparation_does_not_replace_a_resource_open_by_another_job(self):
with workspace_temp() as directory:
path=Path(directory)/"resource";path.write_bytes(b"verified immutable bytes")
with patch.object(Path,"replace",side_effect=PermissionError("shared reader")) as replace_file:
write_atomic(path,b"verified immutable bytes")
replace_file.assert_not_called()
self.assertEqual(path.read_bytes(),b"verified immutable bytes")
def test_zip_index_ranges_decode_exact_original_stored_and_deflated_bytes(self):
with workspace_temp() as directory:
path=Path(directory)/"source.zip"
originals={"a"*32:b"packed original bytes"*50,"b"*32:bytes(range(256))}
with zipfile.ZipFile(path,"w") as archive:
for index,(key,data) in enumerate(originals.items()):
archive.writestr("assets/codes/"+key,data,compress_type=zipfile.ZIP_DEFLATED if index else zipfile.ZIP_STORED)
with zipfile.ZipFile(path) as archive:
entries=asset_index(path,archive)
with path.open("rb") as stream:
for key,entry in entries.items():
stream.seek(entry["offset"]);packed=stream.read(entry["compressed_size"])
data=zlib.decompress(packed,-15) if entry["method"]==8 else packed
self.assertEqual(data,originals[key])
self.assertEqual(len(data),entry["size"])
self.assertEqual(zlib.crc32(data),entry["crc32"])
def test_zip_index_refuses_mismatched_local_header_and_unsafe_keys(self):
with workspace_temp() as directory:
path=Path(directory)/"source.zip"
with zipfile.ZipFile(path,"w") as archive:archive.writestr("assets/codes/"+"a"*32,b"data")
with path.open("r+b") as stream:stream.seek(8);stream.write(struct.pack("<H",8))
with zipfile.ZipFile(path) as archive,self.assertRaisesRegex(ValueError,"metadata"):
asset_index(path,archive)
with zipfile.ZipFile(path,"w") as archive:archive.writestr("assets/codes/../../escape",b"data")
with zipfile.ZipFile(path) as archive,self.assertRaisesRegex(ValueError,"Unsupported"):
asset_index(path,archive)
class ProcessIsolationTests(unittest.TestCase):
def test_child_executes_in_its_own_directory_and_nonzero_exit_is_error(self):
with workspace_temp() as directory:
root=Path(directory)
result=run_isolated([sys.executable,"-I","-c","from pathlib import Path; print(Path.cwd().name)"],cwd=root,timeout=5)
self.assertEqual(result.status,"completed",result.stderr)
self.assertEqual(result.stdout.strip(),root.name)
result=run_isolated([sys.executable,"-I","-c","raise SystemExit(7)"],cwd=root,timeout=5)
self.assertEqual(result.status,"error")
self.assertEqual(result.returncode,7)
def test_wall_timeout_terminates_child_promptly(self):
with workspace_temp() as directory:
result=run_isolated([sys.executable,"-I","-c","import time; time.sleep(30)"],cwd=Path(directory),timeout=.2)
self.assertEqual(result.status,"timeout")
self.assertLess(result.duration_seconds,3)
def test_mid_run_cancellation_terminates_child(self):
event=threading.Event();timer=threading.Timer(.2,event.set);timer.start()
try:
with workspace_temp() as directory:
result=run_isolated([sys.executable,"-I","-c","import time; time.sleep(30)"],cwd=Path(directory),timeout=5,cancel_event=event)
finally:timer.cancel()
self.assertEqual(result.status,"cancelled")
self.assertLess(result.duration_seconds,3)
def test_pre_cancelled_run_does_not_spawn(self):
event=threading.Event();event.set()
with workspace_temp() as directory,patch("tools.battle_runtime.isolation.subprocess.Popen") as popen:
result=run_isolated([sys.executable,"-I","-c","pass"],cwd=Path(directory),timeout=5,cancel_event=event)
popen.assert_not_called();self.assertEqual(result.status,"cancelled")
@unittest.skipUnless(os.name=="nt","Windows Job Object process-tree check")
def test_timeout_kills_worker_descendant_not_only_parent(self):
import ctypes
from ctypes import wintypes
with workspace_temp() as directory:
root=Path(directory)
script="import subprocess,sys,time; from pathlib import Path; p=subprocess.Popen([sys.executable,'-I','-c','import time; time.sleep(30)']); Path('child.pid').write_text(str(p.pid)); time.sleep(30)"
result=run_isolated([sys.executable,"-I","-c",script],cwd=root,timeout=.6)
self.assertEqual(result.status,"timeout")
self.assertTrue((root/"child.pid").exists())
pid=int((root/"child.pid").read_text())
kernel=ctypes.WinDLL("kernel32",use_last_error=True)
kernel.OpenProcess.argtypes=[wintypes.DWORD,wintypes.BOOL,wintypes.DWORD];kernel.OpenProcess.restype=wintypes.HANDLE
kernel.GetExitCodeProcess.argtypes=[wintypes.HANDLE,ctypes.POINTER(wintypes.DWORD)];kernel.CloseHandle.argtypes=[wintypes.HANDLE]
handle=kernel.OpenProcess(0x1000,False,pid)
if handle:
try:
code=wintypes.DWORD();kernel.GetExitCodeProcess(handle,ctypes.byref(code));self.assertNotEqual(code.value,259)
finally:kernel.CloseHandle(handle)
if __name__=="__main__":unittest.main()
@@ -0,0 +1,503 @@
"""Offline tests use synthetic ids/snapshots and public original static tables."""
from copy import deepcopy
import hashlib
import json
from pathlib import Path
import socket
import subprocess
import sys
import threading
from types import SimpleNamespace
import unittest
from unittest.mock import patch
from ranch_assistant.battle_simulator import (
ExperimentalBattleRuntime, ORIGINAL_APK_SHA256, Stats, _offline_audit,
combat_battles, combat_tables, damage_roll, simulate,
)
def monster(mid=101, species=1001010, level=20, **changes):
row = combat_tables()["monster_info"][str(species)]
result = {"id": mid, "typeId": species, "level": level, "mode": 2,
"tpLevel": 0, "feel": 0, "upStar": 0, "pAtk": 0,
"pDef": 0, "pHp": 0, "pDex": 0}
for name in ("Atk", "Def", "Hp", "Dex"):
stat = name.lower()
result["g" + name] = (row[stat + "_grow_min"] + row[stat + "_grow_max"]) / 2
result.update(changes)
return result
def enemy(**changes):
result = {"type": "1001010", "team": 2, "mode": 2, "level": 1,
"atk": 16, "def": 20, "hp": 101, "dex": 4, "spd_mov": .92,
"spd_atk": 1595, "atk_dis": 100, "skill_1": 0, "skill_2": 0,
"joinTime": -1, "wave": 1, "teamPos": 1, "ai": 0,
"joinPoint": "point_team2_fore2", "controller": []}
result.update(changes)
return result
def request(*, players=None, enemies=None, seconds=30, seed=0, master_level=43, **changes):
players = players if players is not None else [monster()]
result = {"context": "ordinary_stage", "seed": seed, "team": "teamA",
"battle_position": {"battleType": "stage", "stageId": "fixture", "stageLevel": "1"},
"roster": {"master": {"level": master_level}, "monsters": players,
"teams": [{"teamName": "teamA", "monsters": [m["id"] for m in players]}],
"monsterAttributes": []},
"original_data": {"battle": {"time": seconds, "winType": ["1"], "loseType": ["1", "2"],
"controller": [], "triggers": [], "teams": [{"team": 2, "numMax": 2, "ap": 80,
"mons": enemies if enemies is not None else [enemy()]}],
"battleField": {"fieldMode": True, "fieldName": "default", "mapAreas": [], "mapObjects": []}}}}
result.update(changes)
return result
def battle_of(value):
return value["original_data"]["battle"]
class Midpoint:
def uniform(self, low, high):
return (low + high) / 2
class CombatDataTests(unittest.TestCase):
def test_complete_original_data_is_cached_and_recursively_immutable(self):
data = combat_tables()
self.assertIs(data, combat_tables())
self.assertEqual(len(data["monster_info"]), 749)
self.assertEqual(len(data["monster_skill"]), 266)
self.assertEqual(len(combat_battles()["stage_info"]), 1178)
self.assertEqual(len(combat_battles()["task_info"]), 1165)
self.assertNotIn("stage_info", data) # Never decode the corpus in a battle worker.
with self.assertRaises(TypeError):
data["monster_info"]["1001010"]["atk"] = 999
self.assertEqual(data["game_setting"]["countDamagePerAtk"], .95)
self.assertEqual(data["game_setting"]["critAdd"], 1.5)
self.assertEqual(data["monster_skill"]["3"]["lv1"]["para"]["ability"], .4)
self.assertEqual(data["attack_profiles"]["43"]["source_class"], "AttackType2")
def test_manifest_identity_and_artifact_match(self):
root = Path(__file__).resolve().parents[1] / "data"
manifest = json.loads((root / "combat_manifest.json").read_text(encoding="utf-8"))
self.assertEqual(manifest["source"]["apk_sha256"], ORIGINAL_APK_SHA256)
for name, artifact in manifest["artifacts"].items():
self.assertEqual(hashlib.sha256((root / name).read_bytes()).hexdigest(), artifact["sha256"])
def test_damage_formula_uses_original_numbers_and_no_extra_multiplier(self):
defender = Stats(100, 100, 20, 10, 1600, .9, 100, 5)
# round(100*.95 - 20*(.25*.75 + .25*.125)) = 91.
self.assertEqual(damage_roll(100, 10, defender, combat_tables()["game_setting"], Midpoint()), 91)
self.assertEqual(damage_roll(1, 10, defender, combat_tables()["game_setting"], Midpoint()), 1)
class SimulatorTests(unittest.TestCase):
def test_snapshot_sanity_records_are_preserved_and_never_repaired(self):
mon = monster(mid=100001, pAtk=200000, feel=201, potentialLevel=1)
req = request(players=[mon])
inspected = ExperimentalBattleRuntime().inspect(req)
codes = {a["code"] for a in inspected["anomalies"]}
self.assertTrue({"+15overfeel", "+15overgrow", "+15overpoten", "+50overlv"}.issubset(codes))
result = simulate(req)
for record in inspected["anomalies"]:
self.assertIn(record, result["anomalies"])
self.assertGreater(result["units"][0]["stats"]["atk"], 200000)
self.assertEqual(mon["feel"], 201)
self.assertFalse(result["experimental_settlement_eligible"])
def test_authored_hidden_team_uses_only_original_configured_combatants(self):
req = request(enemies=[enemy(hp=10), enemy(team=1, atk=10000)])
battle_of(req)["hideTeamMon"] = True
result = simulate(req)
self.assertEqual(result["outcome"], "win")
self.assertTrue(all(not a["id"].startswith("player-") for a in result["units"]))
self.assertTrue(any(a["team"] == 1 for a in result["units"]))
self.assertEqual(result["battle_data"]["battleMonIds"], [])
def test_three_routes_preserve_position_and_ordered_roster_ids_including_waiting(self):
routes = {
"ordinary_stage": {"battleType": "stage", "stageId": "fixture-stage", "stageLevel": "2", "taskTypeId": None, "taskStep": 0},
"task_battle": {"battleType": "task", "stageId": None, "stageLevel": None, "taskTypeId": "fixture-task", "taskStep": 1},
"task_pass_stage": {"battleType": "task", "stageId": None, "stageLevel": None, "taskTypeId": "fixture-pass", "taskStep": 2},
}
expected_ids = [202, 105, 301, 101, 111]
for context, position in routes.items():
req = request(context=context, battle_position=position, seconds=1,
players=[monster(mid) for mid in expected_ids])
req["roster"]["monsters"].reverse() # Team order wins over inventory order.
result = simulate(req)
self.assertEqual(result["battle_data"]["battleMonIds"], expected_ids)
self.assertEqual(result["battle_data"]["battlePosition"],
{k: v for k, v in position.items() if v is not None})
self.assertEqual(sum(a["state"] == "waiting" and a["team"] == 1 for a in result["units"]), 1)
self.assertNotIn(1001010, result["battle_data"]["battleMonIds"])
def test_source_boss_points_are_updated_by_actual_damage_and_deaths(self):
for marker, expected in ((-1, 10), (7, 7)):
result = simulate(request(enemies=[enemy(hp=10, bossPoint=marker)]))
self.assertEqual(result["battle_data"]["bossDamage"], expected)
self.assertEqual(result["battle_data"]["totalDamage"], 0)
def test_cancellation_during_simulation_retains_partial_trace(self):
class CancelAfterTicks:
calls = 0
def is_set(self):
self.calls += 1
return self.calls > 10
result = simulate(request(), cancel_event=CancelAfterTicks())
self.assertEqual(result["outcome"], "cancelled")
self.assertGreater(result["elapsed_ms"], 0)
self.assertTrue(result["events"])
self.assertIsNone(result["battle_data"])
def test_model_failure_keeps_detected_records(self):
req = request(players=[monster(mid=100001, feel=201)])
with patch("ranch_assistant.battle_simulator._Battle.tick", side_effect=RuntimeError("fixture")):
result = simulate(req)
self.assertEqual(result["execution_status"], "error")
self.assertTrue(result["anomalies"])
self.assertIsNone(result["battle_data"])
def test_known_copy_skills_use_original_factors_and_summons_count_alive(self):
for species, skill_id, count, factor in ((1001010, 3, 1, .4), (1030010, 7, 3, .1)):
req = request(players=[monster(species=species, pHp=100000)],
enemies=[enemy(hp=1000000), enemy(hp=1000000)], seconds=20)
result = simulate(req)
summons = [u for u in result["units"] if u["summon_of"]]
self.assertEqual(len(summons), count)
parent = result["units"][0]
self.assertEqual(result["battle_data"]["aliveNum"], count + 1)
self.assertEqual(result["battle_data"]["battleMonIds"], [101])
for child in summons:
self.assertFalse(child["count_unit"])
self.assertFalse(child["skills"])
self.assertEqual(child["stats"]["atk"], int(parent["stats"]["atk"] * factor))
self.assertEqual(child["stats"]["defense"], int(parent["stats"]["defense"] * factor))
self.assertTrue(any(e["type"] == "skill" and e["skill"] == skill_id for e in result["events"]))
ap = result["ap"]["1"]
self.assertEqual(ap["current"], ap["initial"] - ap["spent"] + ap["recovered"])
self.assertEqual(ap["spent"], 18 if skill_id == 3 else 20)
def test_area_hit_cleave_uses_original_skill9_and_spatial_neighbors(self):
req = request(players=[monster(species=2004010, pHp=100000)],
enemies=[enemy(hp=1000000), enemy(hp=1000000)], seconds=20)
result = simulate(req)
area = [e for e in result["events"] if e.get("reason") == "skill9_area"]
self.assertTrue(area)
self.assertTrue(all(e["hp_lost"] > 0 for e in area))
stats = result["units"][0]["skills"][0]
self.assertEqual(stats["id"], 9)
self.assertEqual(stats["para"], {"areahurt": 1, "pow": 5})
def test_flash_move_and_four_hit_combo_are_executed(self):
req = request(players=[monster(species=3010010, pHp=100000)],
enemies=[enemy(hp=1000000), enemy(hp=1000000)], seconds=30)
battle_of(req)["battleField"]["fieldName"] = "longMapDefault"
result = simulate(req)
used = {e["skill"] for e in result["events"] if e["type"] == "skill"}
self.assertTrue({5, 38}.issubset(used))
self.assertTrue(any(e["type"] == "dash" for e in result["events"]))
casts = [e["at_ms"] for e in result["events"] if e["type"] == "skill" and e["skill"] == 38]
attacks = [e for e in result["events"] if e["type"] == "attack" and e["actor"] == "player-1"]
for start in casts:
burst = [e for e in attacks if start <= e["at_ms"] < start + 1600]
self.assertGreaterEqual(len(burst), 4)
self.assertEqual(burst[0]["hit_delay_ms"], 100)
def test_projectile_speed_and_launch_delay_produce_nonzero_travel(self):
result = simulate(request(players=[monster(species=1001020)], enemies=[enemy(hp=1000000)], seconds=8))
projectiles = [e for e in result["events"] if e["type"] == "projectile" and e["actor"] == "player-1"]
self.assertTrue(projectiles)
self.assertGreater(projectiles[0]["travel_ms"], 0)
attack = next(e for e in result["events"] if e["type"] == "attack" and e["actor"] == "player-1")
self.assertEqual(attack["hit_delay_ms"], 100)
self.assertGreaterEqual(projectiles[0]["at_ms"], attack["at_ms"] + 100)
def test_status_effects_healing_and_thorns_are_real_trajectory_events(self):
for attributes, event_type, reason in (({"atkStun": 100}, "stun", None),
({"atkPoi": 100, "atkPoiDmg": 15}, "damage", "poison"),
({"thorns": 100}, "damage", "thorns"),
({"atkVim": 50, "selfCure": 10}, "heal", None)):
req = request(players=[monster(level=1, pHp=10000)], enemies=[enemy(hp=1000000)], seconds=20)
req["roster"]["monsterAttributes"] = [dict(monsterId=101, **attributes)]
result = simulate(req)
self.assertTrue(any(e["type"] == event_type and (reason is None or e.get("reason") == reason)
for e in result["events"]), attributes)
if "atkVim" in attributes:
self.assertGreater(result["units"][0]["healed"], 0)
self.assertTrue(any(e.get("reason") == "selfCure" for e in result["events"]))
def test_overcure_preserves_exact_source_score_even_when_effective_heal_is_small(self):
req = request(seconds=6, trace_limit=0, enemies=[enemy(hp=1000000)])
req["roster"]["monsterAttributes"] = [{"monsterId": 101, "selfCure": 20001}]
result = simulate(req)
self.assertTrue(any(a["code"] == "+15overcure" and a["source_cheat_points"] == 19
for a in result["anomalies"]))
self.assertEqual(result["battle_data"]["cheatNum"], 19)
self.assertFalse(result["experimental_settlement_eligible"])
def test_experimental_eligibility_is_separate_and_requires_completed_clean_model(self):
report = ExperimentalBattleRuntime().inspect(request())
self.assertFalse(report["experimental_settlement_eligible"])
result = simulate(request())
self.assertTrue(result["experimental_settlement_eligible"])
self.assertFalse(result["settlement_eligible"])
self.assertFalse(result["faithful"])
anomaly = simulate(request(players=[monster(pAtk=200000)]))
self.assertFalse(anomaly["experimental_settlement_eligible"])
self.assertTrue(anomaly["experimental_eligibility_reasons"])
def test_original_stage_battle_executes_without_apk_or_network_reads(self):
req = request()
req["original_data"]["battle"] = combat_battles()["stage_info"]["0101"]["level"]["1"]["battle"]
with patch("socket.socket", side_effect=AssertionError("No network")), \
patch("zipfile.ZipFile", side_effect=AssertionError("No APK access")):
result = simulate(req)
self.assertEqual(result["outcome"], "win")
self.assertGreater(result["kills"], 1)
self.assertEqual(result["kill_monster"], {}) # Original stage enemies are mode 1.
self.assertTrue(any(e["type"] == "wave" for e in result["events"]))
def test_full_snapshot_stats_follow_monster_vo_including_server_attributes(self):
mon = monster(level=10, gAtk=3.125, gDef=2.5, gHp=30.25, gDex=1.25,
tpLevel=2, pAtk=12, pDef=8, pHp=80, pDex=3, feel=120, upStar=1)
req = request(players=[mon])
req["roster"]["master"].update(globalAtk=7, globalDef=4, globalHp=55, globalDex=2)
req["roster"]["monsterAttributes"] = [{"monsterId": 101, "atk": 13, "def": 9,
"hp": 45, "dex": 2, "atkSpd": 5, "crit": 4, "apCostSave": 1}]
inspected = ExperimentalBattleRuntime().inspect(req)
self.assertTrue(inspected["supported"], inspected["reasons"])
stats = inspected["units"][0]["stats"]
original = combat_tables()["monster_info"]["1001010"]
for stat, suffix in (("hp", "Hp"), ("atk", "Atk"), ("def", "Def"), ("dex", "Dex")):
expected = int(1.21 * (original[stat] + mon["g" + suffix] * 11 + mon["p" + suffix]
+ req["roster"]["master"]["global" + suffix]
+ req["roster"]["monsterAttributes"][0][stat]))
self.assertEqual(stats["defense" if stat == "def" else stat], expected)
self.assertEqual(stats["attack_ms"], 1600 + int(-stats["dex"] * 3 / 4) - 80)
self.assertEqual(stats["crit"], 4)
self.assertEqual(inspected["units"][0]["ap_cost"], 0)
def test_inspect_is_honest_and_does_not_mutate_inputs(self):
req = request()
before = deepcopy(req)
result = ExperimentalBattleRuntime().inspect(req)
self.assertTrue(result["supported"])
self.assertEqual(result["execution_mode"], "experimental")
self.assertTrue(result["approximate"])
self.assertFalse(result["faithful"])
self.assertFalse(result["settlement_eligible"])
self.assertTrue(result["requires_realtime_wait"])
self.assertTrue(result["ignored_mechanics"])
self.assertEqual(req, before)
def test_all_three_contexts_execute_deterministic_natural_win(self):
first = None
for context in ("ordinary_stage", "task_battle", "task_pass_stage"):
result = simulate(request(context=context))
self.assertEqual(result["outcome"], "win")
self.assertTrue(result["terminal"])
self.assertEqual(result["execution_status"], "completed")
self.assertEqual(result["kills"], 1)
self.assertEqual(result["battle_data"]["win"], True)
if first:
self.assertEqual(result["events"], first["events"])
first = result
def test_natural_defeat_retains_actual_state_and_evidence(self):
result = simulate(request(players=[monster(level=1)], enemies=[enemy(atk=10000, hp=10000)]))
self.assertEqual(result["outcome"], "loss")
self.assertEqual(result["terminal_reason"], "elimination")
self.assertFalse(result["battle_data"]["win"])
self.assertEqual(result["alive_num"], 0)
self.assertEqual(result["units"][0]["hp"], 0)
self.assertTrue(any(e["type"] == "death" for e in result["events"]))
def test_battle_clock_expiry_is_completed_loss_not_technical_timeout(self):
req = request(seconds=1, enemies=[enemy(hp=100000, moveImmune=True, atk_dis=1)])
result = simulate(req)
self.assertEqual(result["outcome"], "loss")
self.assertEqual(result["execution_status"], "completed")
self.assertEqual(result["terminal_reason"], "battle_time_limit")
self.assertEqual(result["elapsed_ms"], 1000)
self.assertEqual(result["battle_data"]["leftTime"], 0)
self.assertFalse(result["battle_data"]["win"])
self.assertGreater(result["units"][0]["hp"], 0)
def test_technical_timeout_and_cancellation_have_no_battle_data(self):
event = threading.Event()
event.set()
for result in (simulate(request(), timeout=0), simulate(request(), cancel_event=event)):
self.assertIn(result["execution_status"], ("timed_out", "cancelled"))
self.assertFalse(result["terminal"])
self.assertIsNone(result["battle_data"])
def test_source_selective_kill_map_differs_from_all_kills(self):
req = request(enemies=[enemy(hp=1, mode=1), enemy(hp=1, mode=2)])
result = simulate(req)
self.assertEqual(result["outcome"], "win")
self.assertEqual(result["kills"], 2)
self.assertEqual(result["all_kills"], {"1001010": 2})
self.assertEqual(result["battle_data"]["killMonster"], {"1001010": 1})
self.assertEqual(result["battle_data"]["totalDamage"], 0)
self.assertEqual(result["battle_data"]["killNum"], 0)
self.assertEqual(result["battle_data"]["deadNum"], 0)
self.assertGreater(result["damage_hp_lost"]["2"], 0)
def test_waiting_roster_counts_alive_and_respects_source_capacity(self):
players = [monster(i, level=1) for i in (101, 102, 103, 104, 105)]
result = simulate(request(players=players, seconds=1, master_level=18))
player_units = [a for a in result["units"] if a["team"] == 1]
self.assertEqual(sum(a["state"] == "active" for a in player_units), 4)
self.assertEqual(sum(a["state"] == "waiting" for a in player_units), 1)
self.assertEqual(result["battle_data"]["aliveNum"], 5)
self.assertTrue(all(e["ap_charged"] == 0 for e in result["events"] if e["type"] == "deploy"))
def test_order_reinforcements_and_wave_delay(self):
req = request(enemies=[enemy(hp=1), enemy(hp=1, wave=2, joinTime=4)])
result = simulate(req)
self.assertEqual(result["outcome"], "win")
wave_wait = next(e for e in result["events"] if e["type"] == "wave_wait")
wave = next(e for e in result["events"] if e["type"] == "wave")
self.assertEqual(wave["at_ms"] - wave_wait["at_ms"], 700)
second = next(e for e in result["events"] if e["type"] == "deploy" and e.get("wave") == 2)
self.assertGreaterEqual(second["at_ms"], 4000)
def test_unimplemented_skills_are_specific_and_explicit(self):
req = request(players=[monster(species=1001020)]) # actual skill 10
report = ExperimentalBattleRuntime().inspect(req)
self.assertTrue(report["supported"])
self.assertTrue(any(d["code"] == "unsupported_skill" and "10" in d["message"] for d in report["diagnostics"]))
self.assertTrue(any("Skill 10" in x for x in report["ignored_mechanics"]))
def test_controllers_triggers_and_non_elimination_are_rejected(self):
for key, value in (("controller", [{"type": "monMaker"}]),
("triggers", [{"type": "dead"}]), ("winType", ["2"])):
req = request()
battle_of(req)[key] = value
result = simulate(req)
self.assertEqual(result["outcome"], "unsupported")
self.assertFalse(result["supported"])
self.assertIsNone(result["battle_data"])
self.assertTrue(result["reasons"])
def test_missing_actual_growth_and_nonpositive_original_speed_are_rejected(self):
req = request()
req["roster"]["monsters"][0].pop("gAtk")
self.assertFalse(ExperimentalBattleRuntime().inspect(req)["supported"])
req = request()
req["roster"]["monsterAttributes"] = [{"monsterId": 101, "atkSpd": 200}]
report = ExperimentalBattleRuntime().inspect(req)
self.assertFalse(report["supported"])
self.assertTrue(any("nonpositive" in x for x in report["reasons"]))
def test_enemy_authored_stats_and_authored_scales_are_preserved(self):
req = request(enemies=[enemy(atk=31, hp=101, dex=7, spd_atk=1595)])
battle_of(req).update(scaleAbility=1.2, scaleHp=1.5)
stats = ExperimentalBattleRuntime().inspect(req)["units"][1]["stats"]
self.assertEqual(stats["atk"], 37)
self.assertEqual(stats["hp"], 151)
self.assertEqual(stats["dex"], 8)
self.assertEqual(stats["attack_ms"], 1595)
def test_trace_limit_never_erases_overdamage_anomalies(self):
req = request(players=[monster(pAtk=200000)], enemies=[enemy(hp=10)], trace_limit=1)
result = simulate(req)
self.assertEqual(result["outcome"], "win")
self.assertEqual(len(result["events"]), 1)
self.assertTrue(result["trace_truncated"])
records = [a for a in result["anomalies"] if a["code"] == "+10overdamage"]
self.assertTrue(records)
self.assertGreater(records[0]["damage"], 80000)
self.assertEqual(result["battle_data"]["cheatNum"], 10)
self.assertEqual(result["battle_data"]["cheatRecords"], result["anomalies"])
def test_stats_and_snapshot_never_mutate_across_runs(self):
req = request()
before = deepcopy(req)
a, b = simulate(req), simulate(req)
self.assertEqual(a, b)
self.assertEqual(req, before)
class WorkerTests(unittest.TestCase):
def test_object_request_and_snapshot_raw_have_the_same_contract(self):
req = request()
req["snapshot"] = SimpleNamespace(raw=req.pop("roster"))
result = ExperimentalBattleRuntime().run(SimpleNamespace(**req))
self.assertEqual(result["outcome"], "win")
self.assertEqual(result["battle_data"]["battlePosition"], req["battle_position"])
def test_fixed_module_subprocess_equals_direct_model(self):
req = request()
with patch("socket.socket", side_effect=AssertionError("No network")):
result = ExperimentalBattleRuntime().run(req)
self.assertEqual(result, simulate(req))
def test_worker_entrypoint_does_not_import_gui_or_production_engine(self):
completed = subprocess.run([sys.executable, "-c",
"import sys; import ranch_assistant.battle_simulator; "
"assert not any(n in sys.modules for n in "
"('ranch_assistant.gui','ranch_assistant.engine','ranch_assistant.__main__',"
"'ranch_assistant.battles','ranch_assistant.battle_runtime'))"], capture_output=True)
self.assertEqual(completed.returncode, 0, completed.stderr)
def test_worker_network_guard_rejects_socket_audit_events(self):
for event in ("socket.__new__", "socket.connect", "socket.getaddrinfo", "urllib.Request"):
with self.assertRaises(PermissionError):
_offline_audit(event, ())
program = """import socket,sys
from ranch_assistant.battle_simulator import _offline_audit
sys.addaudithook(_offline_audit)
try:
socket.socket()
except PermissionError:
pass
else:
raise AssertionError('worker socket creation must fail')
"""
completed = subprocess.run([sys.executable, "-c", program], capture_output=True)
self.assertEqual(completed.returncode, 0, completed.stderr)
def test_cancel_and_wall_timeout_kill_and_reap_worker(self):
for cancelled in (True, False):
event = threading.Event()
processes = []
real_popen = subprocess.Popen
def observe(*args, **kwargs):
self.assertEqual(args[0], [sys.executable, "-m", "ranch_assistant.battle_simulator", "--worker"])
self.assertNotIn("shell", kwargs)
self.assertEqual(kwargs["creationflags"], getattr(subprocess, "CREATE_NO_WINDOW", 0))
process = real_popen(*args, **kwargs)
processes.append(process)
if cancelled:
event.set()
return process
with patch("ranch_assistant.battle_simulator.subprocess.Popen", side_effect=observe):
result = ExperimentalBattleRuntime().run(request(), cancel_event=event,
timeout=10 if cancelled else .001)
self.assertEqual(result["outcome"], "cancelled" if cancelled else "timeout")
self.assertFalse(result["terminal"])
self.assertIsNone(result["battle_data"])
self.assertTrue(processes)
self.assertIsNotNone(processes[0].poll())
def test_keyboard_interrupt_terminates_child(self):
process = unittest.mock.MagicMock()
process.communicate.side_effect = [KeyboardInterrupt, (b"", b"")]
process.poll.return_value = None
with patch("ranch_assistant.battle_simulator.subprocess.Popen", return_value=process):
result = ExperimentalBattleRuntime().run(request())
self.assertEqual(result["outcome"], "cancelled")
process.kill.assert_called_once()
self.assertIsNone(result["battle_data"])
if __name__ == "__main__":
unittest.main()
+5
View File
@@ -199,6 +199,11 @@ class GrowthGuiTests(unittest.TestCase):
window.engine.snapshot = client.snapshot()
window.render(window.engine.snapshot, window.engine.plans())
window.tabs.setCurrentWidget(window.monster_page)
for _ in range(200):
self.app.processEvents()
QTest.qWait(5)
if not window.busy and 501 in window.monsters.monster_items:
break
row = next(i for i in range(window.slots.rowCount()) if window.slots.item(i, 1).text() == "1")
self.assertIn("待同步", window.slots.item(row, 5).text())
self.assertIn("待成熟", window.slots.item(row, 7).text())
@@ -0,0 +1,260 @@
"""Native AIR integration tests; fixtures contain no account data or networking.
The tests compile the actual bridge once, then run all cases in a child
ApplicationDomain with the pinned original SWFs. Missing local AIR assets skip
the suite; compilation/runtime failures with installed assets fail the suite.
"""
import copy
import unittest
from tools.battle_runtime.snapshot_bridge_check import (
dependencies_available, run_checks, synthetic_snapshot,
)
@unittest.skipUnless(dependencies_available(), "Prepared local Windows AIR SDK/original libraries required")
class NativeSnapshotBridgeTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
plain, rich = synthetic_snapshot(), synthetic_snapshot(rich=True)
cases = []
def case(name, source=plain, *, team="teamA", integrity=False):
snapshot = copy.deepcopy(source)
cases.append(dict(name=name, snapshot=snapshot, teamName=team, integrity=integrity))
return snapshot
case("plain", integrity=True)
case("rich", rich, integrity=True)
case("empty_attributes", integrity=True)["monsterAttributes"] = []
flat_skin = case("flat_skin_entry", rich, integrity=True)
flat_skin["items"] = []
flat_skin["monsters"][0].update(equip2=0, pAtk=0, pDef=0, pHp=0, pDex=0)
# Keep explicit server attributes independent of skin table abilities.
# The bridge must use the supplied values once, not recalculate them.
flat_skin["monsterAttributes"][0] = copy.deepcopy(plain["monsterAttributes"][0])
flat_skin["monsterAttributes"][1]["def"] = 7
case("shuffled_attributes", rich)["monsterAttributes"].reverse()
case("low_master_level")["master"]["level"] = 1
case("high_master_level")["master"]["level"] = 80
case("original_tp_clamp")["monsters"][0]["tpLevel"] = 9
case("original_skills")["monsters"][0].update(skill_1=999999, atk=999999, hp=999999)
alternate = case("alternate_team", team="teamB")
alternate["teams"].append(dict(teamName="teamB", teamType="pveBattleTeam",
monsters=[0, 100000002, 100000003, 100000001, 0, 0, 0]))
case("empty_padding")["teams"][0]["monsters"].append(0)
with_egg = case("unselected_incubator")
egg = copy.deepcopy(plain["monsters"][0])
egg.update(id=100000004, process=2, mode=0, level=0, potentialLevel=0)
with_egg["monsters"].append(egg)
case("bad_feel", integrity=True)["monsters"][0]["feel"] = 201
missing_global = case("missing_global")
del missing_global["master"]["globalAtk"]
missing_growth = case("missing_growth")
del missing_growth["monsters"][0]["gAtk"]
case("absent_attribute_row", integrity=True)["monsterAttributes"].pop(0)
missing_attribute_field = case("missing_attribute_field")
del missing_attribute_field["monsterAttributes"][0]["atk"]
missing_attributes = case("missing_attributes")
del missing_attributes["monsterAttributes"]
case("duplicate_attributes")["monsterAttributes"].append(copy.deepcopy(plain["monsterAttributes"][0]))
case("species_as_instance")["teams"][0]["monsters"][0] = 1001010
case("duplicate_member")["teams"][0]["monsters"][1] = 100000003
case("incubating_member")["monsters"][0]["process"] = 2
case("egg_member")["monsters"][0]["mode"] = 0
case("exploring_member")["monsters"][0]["inExploreTeam"] = 1
case("negative_member")["teams"][0]["monsters"][0] = -1
case("empty_team")["teams"][0]["monsters"] = [0] * 7
case("missing_team", team="absent")
case("occupied_padding")["teams"][0]["monsters"].append(100000002)
case("missing_equipment", rich)["items"] = []
missing_params = case("missing_equip_params", rich)
del missing_params["items"][0]["equipParams"]
case("bad_equip_params", rich)["items"][0]["equipParams"] = "{broken"
case("wrong_equipment_class", rich)["items"][0]["itemClass"] = 0
overflowing_equip = case("equipment_id_overflow", rich)
overflowing_equip["items"][0]["id"] = 2147483648
overflowing_equip["monsters"][0]["equip2"] = 2147483648
case("bad_entangle_json", rich)["monsters"][1]["entangleSkills"] = "null"
missing_history = case("missing_history")
del missing_history["history"]["monLib"]
case("string_stat")["monsters"][0]["gAtk"] = "4.9"
case("boolean_stat")["master"]["globalAtk"] = False
cls.evidence = run_checks(cases)
if not cls.evidence["result"].get("ok"):
raise AssertionError(cls.evidence["result"])
cls.results = {row["name"]: row for row in cls.evidence["result"]["cases"]}
def accepted(self, name):
result = self.results[name]
self.assertTrue(result["ok"], result.get("error"))
self.assertTrue(result["inputUnchanged"])
self.assertTrue(result["installed"])
self.assertTrue(result["contextUnchanged"])
return result
def rejected(self, name, code, path=None):
result = self.results[name]
self.assertFalse(result["ok"], name)
self.assertIn(f"SnapshotBridge[{code}]", result["error"], name)
if path:
self.assertIn(path, result["error"])
self.assertTrue(result["inputUnchanged"], name)
self.assertTrue(result["previousMasterRestored"], name)
def test_as3_compiles_and_runs_against_pinned_original_libraries(self):
self.assertEqual(self.evidence["compiler_exit_code"], 0)
self.assertEqual(self.evidence["process_exit_code"], 0)
self.assertEqual(len(self.evidence["source_sha256"]), 64)
def test_original_values_and_ordered_instance_ids_reach_native_team(self):
result = self.accepted("plain")
self.assertEqual(result["validation"]["selectedIds"], [100000003, 100000001, 100000002])
self.assertEqual(result["selectedSlots"], [100000003, 0, 100000001, 100000002, 0, 0, 0])
self.assertEqual(result["nativeMembers"], [dict(mid=100000003, teamPos=1),
dict(mid=100000001, teamPos=2),
dict(mid=100000002, teamPos=5)])
# Pinned original Lv1 slime values, independently of bridge mapping.
first = result["units"][0]
self.assertEqual(first["battle"], {"atk": 28, "def": 24, "hp": 335, "dex": 6})
self.assertEqual(first["skill_1"], 3)
def test_rich_snapshot_preserves_equipment_potential_skin_and_entangle(self):
result = self.accepted("rich")
first, second = result["units"][:2]
self.assertEqual(first["battle"], {"atk": 31, "def": 27, "hp": 393, "dex": 11})
self.assertEqual(first["potential"], 1)
self.assertEqual(first["equip2"], 100000101)
self.assertEqual(first["special"]["atkPoi"], 2)
self.assertEqual(first["special"]["atkPoiType"], 1)
self.assertEqual(second["skinVo"], 1003011)
self.assertEqual(second["entangleSkill"], {"1": 1001})
self.assertTrue(second["entangle"])
self.assertEqual(second["skill_1"], 6)
self.assertEqual(second["battle"], {"atk": 48, "def": 39, "hp": 209, "dex": 11})
self.assertEqual(result["inventory"], [dict(id=100000101, type=50001, num=1,
isUsed=True, atk=0, hp=50, atkPoiType=1)])
def test_attributes_join_by_instance_id_and_are_not_double_counted(self):
rich = self.accepted("rich")
reordered = self.accepted("shuffled_attributes")
self.assertEqual(rich["units"], reordered["units"])
# The two slime instances share a species, but only one has equipment.
self.assertEqual(rich["units"][0]["additions"]["hp"], 50)
self.assertEqual(rich["units"][2]["additions"]["hp"], 0)
def test_explicit_empty_and_absent_attribute_rows_preserve_original_defaults(self):
plain = self.accepted("plain")
for name, count in (("empty_attributes", 0), ("absent_attribute_row", 2)):
with self.subTest(name=name):
result = self.accepted(name)
self.assertEqual(result["validation"]["attributeCount"], count)
self.assertEqual(result["units"], plain["units"])
self.assertEqual(result["integrity"], plain["integrity"])
self.assertEqual(result["inventory"], [])
self.assertTrue(all(unit["skin"] == 0 for unit in result["units"]))
def test_flat_skin_table_resolves_original_entry_and_keeps_server_attributes(self):
result = self.accepted("flat_skin_entry")
skinned = result["units"][1]
self.assertEqual(skinned["skinVo"], 1003011)
self.assertEqual(skinned["skinEntry"], {"monType": "1003010",
"ability": {"def": 15, "atkVim": 2},
"sameOriginalEntry": True})
self.assertEqual(skinned["additions"]["def"], 7)
self.assertEqual(skinned["battle"]["def"], 31)
self.assertEqual(self.accepted("rich")["units"][1]["battle"]["def"], 39)
self.assertEqual(result["integrity"]["cheatNum"], 0)
self.assertEqual(len(result["integrity"]["records"]), 3)
def test_ap_and_tp_levels_use_original_source_semantics(self):
for name, level in (("low_master_level", 1), ("plain", 30), ("high_master_level", 80)):
with self.subTest(name=name):
result = self.accepted(name)
self.assertEqual(result["validation"]["masterLevel"], level)
self.assertEqual(result["nativeAP"], result["apFromRawLevel"])
self.assertEqual(result["validation"]["ap"], result["nativeAP"])
self.assertGreater(self.results["high_master_level"]["nativeAP"], self.results["plain"]["nativeAP"])
self.assertEqual(self.accepted("original_tp_clamp")["units"][0]["tplevel"], 4)
self.assertEqual(self.accepted("original_skills")["units"], self.accepted("plain")["units"])
def test_history_uses_original_flag_conversion_api(self):
history = self.accepted("rich")["history"]
self.assertEqual(history["guide_record"], {"firstOut": True})
self.assertEqual(history["unlockCity"], {"1": True})
self.assertEqual(history["passStage"], {"0101": {"1": True}})
self.assertEqual(history["unlockStage"], {"0101": {"1": True}})
self.assertEqual(history["monLib"], [1001010, 1003010])
self.assertEqual(self.results["rich"]["validation"]["historyLoader"], "HistoryVo.loadHistoryData")
def test_selected_team_and_original_loader_padding(self):
result = self.accepted("alternate_team")
self.assertEqual(result["validation"]["teamName"], "teamB")
self.assertEqual(result["validation"]["selectedIds"], [100000002, 100000003, 100000001])
padding = self.accepted("empty_padding")
self.assertEqual(padding["nativeMembers"], self.results["plain"]["nativeMembers"])
self.assertEqual(len(padding["validation"]["rawSlots"]), 8)
self.rejected("occupied_padding", "team_slot")
def test_unselected_incubation_does_not_change_selected_roster(self):
result = self.accepted("unselected_incubator")
self.assertEqual(result["loadedMonsterIds"], [100000001, 100000002, 100000003, 100000004])
self.assertEqual(result["validation"]["monsterCount"], 4)
self.assertEqual(result["validation"]["attributeCount"], 3)
self.assertEqual(result["units"], self.accepted("plain")["units"])
def test_real_integrity_checker_records_high_ids_and_detects_invalid_input(self):
for name in ("plain", "rich", "empty_attributes", "flat_skin_entry", "absent_attribute_row"):
integrity = self.accepted(name)["integrity"]
self.assertEqual(integrity["cheatNum"], 0)
ids = [int(record["mid"]) for record in integrity["records"]]
self.assertEqual(ids, [100000003, 100000001, 100000002])
self.assertTrue(all(mid > 100000000 for mid in ids))
self.assertIn("+0uneqmon100000001", integrity["text"])
self.assertIsNotNone(integrity["records"][0]["skillLevel1"])
invalid = self.accepted("bad_feel")
self.assertEqual(invalid["units"][0]["feel"], 201)
self.assertGreater(invalid["integrity"]["cheatNum"], 0)
self.assertIn("overfeel", invalid["integrity"]["text"])
self.assertEqual(len(invalid["integrity"]["records"]), 3)
self.assertIsNotNone(invalid["integrity"]["master"])
def test_missing_stats_fail_with_paths_without_zero_defaults(self):
for name, code, path in (
("missing_global", "missing_number", "master.globalAtk"),
("missing_growth", "missing_number", "monsters[0].gAtk"),
("missing_attribute_field", "missing_number", "monsterAttributes[0].atk"),
("missing_attributes", "missing_array", "monsterAttributes"),
("string_stat", "missing_number", "monsters[0].gAtk"),
("boolean_stat", "missing_number", "master.globalAtk"),
("missing_history", "missing_array", "history.monLib"),
):
with self.subTest(name=name):
self.rejected(name, code, path)
def test_selected_members_must_exist_and_be_available(self):
for name, code in (
("species_as_instance", "missing_team_member"), ("duplicate_member", "duplicate_member"),
("incubating_member", "incubating_member"), ("egg_member", "incubating_member"),
("exploring_member", "exploring_member"), ("negative_member", "team_member_id"),
("empty_team", "empty_team"), ("missing_team", "team_missing"),
("duplicate_attributes", "duplicate_attributes"),
):
with self.subTest(name=name):
self.rejected(name, code)
def test_incomplete_equipment_and_entangle_cannot_enter_original_error_fallbacks(self):
for name, code in (
("missing_equipment", "missing_equipment"), ("missing_equip_params", "json_string"),
("bad_equip_params", "json_string"), ("wrong_equipment_class", "equipment_class"),
("equipment_id_overflow", "equipment_id"),
("bad_entangle_json", "missing_object"),
):
with self.subTest(name=name):
self.rejected(name, code)
if __name__ == "__main__":
unittest.main()
+733
View File
@@ -0,0 +1,733 @@
"""Offline source-derived progression tests; no clients or game servers."""
from copy import deepcopy
from dataclasses import asdict, replace
import hashlib
import json
from pathlib import Path
import unittest
from unittest.mock import patch
import zipfile
from ranch_assistant.game_data import (
BATTLES_NAME, DATA_DIR, DATA_NAME, MANIFEST_NAME,
ORIGINAL_APK_SHA256, ProgressionData, ProgressionDataError, load_progression_data,
)
from ranch_assistant.model import Catalog, Policy, Snapshot
from ranch_assistant.progression import ProgressionPlanner, ProgressionPolicy
from ranch_assistant.quests import QuestPolicy
from tools.build_progression_data import farming_index, summarize_script
ROOT = Path(__file__).resolve().parents[2]
def step(kind="none", **changes):
return {"statusType": kind, "statusValue": {}, "story": "", "afterStory": "",
"position": "", "npc": "", "unlockStages": [], "condition": {}, **changes}
def task(type_id="100", *, steps=None, **changes):
return {"id": type_id, "name": "离线测试任务", "type": 1, "startStep": step(),
"steps": [step()] if steps is None else steps, "closed": False,
"nextTasks": [], "unlockTasks": [], "unlockStages": [], **changes}
def snapshot(**changes):
return Snapshot({"master": {"id": 1, "level": 20, "money": 2000, "ti": 50},
"items": [], "monsters": [], "stacks": [], "rooms": [], "teams": [],
"history": {"unlockCity": {"1": True}, "unlockStage": {"0101": [1, 2, 3]},
"passStage": {}, "passTask": {}, "unlockTask": {}, "openHardMode": True},
"currentTasks": [{"id": 11, "typeId": "100", "curStep": 1, "stepValue": None}],
**changes})
def config(tasks=None, **changes):
return {"task_info": tasks or {"100": task()}, "scripts": {
"linear": {"supported": True, "answer": None, "dialogue_lines": 5},
"accept": {"supported": True, "answer": True, "dialogue_lines": 3},
"choice": {"supported": False, "answer": None, "block_reasons": ["unsupported command: option"]}},
"game_setting": {"cityInfo": {"1": {"name": "莉莉托斯", "cid": "1"}}}, "setting": {},
"stage_info": {"0101": {"id": "0101", "name": "王城郊外 1-1", "city": 1, "cost": {"ti": 2},
"level": {str(i): {"cost": i, "battle_available": True} for i in (1, 2, 3)}}},
"npc_info": {"nina": {"name": "妮娜"}}, "stage_sp": {}, **changes}
class ProgressionTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.catalog = Catalog()
def setUp(self):
self.policy = ProgressionPolicy(enabled=True)
self.ranch = Policy(keep_money=1000)
self.snapshot = snapshot()
self.planner = ProgressionPlanner(self.catalog, config())
def plan(self):
return self.planner.plan(self.snapshot, self.policy, self.ranch)
def next(self, kind):
planned = self.plan()
self.assertTrue(planned)
self.assertEqual(planned[0].kind, kind, planned[0].description)
return planned[0]
def test_policy_defaults_roundtrip_and_validation(self):
policy = ProgressionPolicy()
self.assertFalse(policy.enabled)
self.assertEqual(ProgressionPolicy.from_dict(json.loads(json.dumps(asdict(policy)))), policy)
for changes in ({"enabled": "false"}, {"reserve_ti": -1}, {"stop_after_loss": 0},
{"max_money": float("nan")}, {"allow_items": 1}, {"team": ""},
{"team": "has\nnewline"}, {"team": " too much space "}, {"team": "x" * 65},
{"battle_mode": "faithful_estimate"},
{"item_reserves": {"20001": -2}}, {"item_reserves": {"token": 1}}):
with self.subTest(changes=changes), self.assertRaises(ValueError):
ProgressionPolicy(**changes)
with self.assertRaises(ValueError):
ProgressionPolicy.from_dict({"session": "must-not-import"})
self.assertEqual(ProgressionPolicy(team="自定义编队").team, "自定义编队")
self.assertEqual(ProgressionPolicy(team="bonusTeam4").battle_mode, "original")
self.assertEqual(ProgressionPolicy(battle_mode="experimental").to_dict()["battle_mode"], "experimental")
self.assertEqual(self.planner.plan(self.snapshot, ProgressionPolicy(), self.ranch), [])
def test_nonbattle_server_ack_then_local_complete_then_reward(self):
original = deepcopy(self.snapshot.raw)
action = self.next("progression_step")
self.assertEqual(action.path, "taskService/taskCompleteStep")
self.assertEqual(action.payload, {"taskId": 11, "taskTypeId": "100", "removeIds": None})
self.assertNotIn("battleData", action.payload)
self.planner.mark_started(self.snapshot, action)
self.assertTrue(self.plan()[0].block_reason)
self.planner.acknowledge(self.snapshot, action, {"taskStepValue": None})
self.assertFalse(self.planner.acknowledge(self.snapshot, action, {}))
local = self.next("progression_local_step")
self.assertEqual(local.path, "")
self.planner.acknowledge(self.snapshot, local)
reward = self.next("progression_complete")
self.assertEqual(reward.payload, {"taskId": 11, "taskTypeId": "100"})
self.planner.acknowledge(self.snapshot, reward, {"reward": {}})
self.assertEqual(self.plan(), [])
self.assertEqual(self.snapshot.raw, original)
def test_ordinary_dialogue_and_navigation_are_logical_and_do_not_submit_twice(self):
self.planner = ProgressionPlanner(self.catalog, config({"100": task(steps=[
step(story="linear", afterStory="linear", position="city1_market", npc="nina"), step()])}))
nav = self.next("progression_navigate")
self.assertEqual(nav.position, "city1_market")
self.assertEqual(nav.payload, {})
self.assertEqual(nav.npc_name, "妮娜")
self.assertIn("市场", nav.location)
self.planner.acknowledge(self.snapshot, nav)
before = self.next("progression_dialogue")
self.assertEqual(before.phase, "before")
self.planner.acknowledge(self.snapshot, before)
server = self.next("progression_step")
self.assertEqual(self.snapshot.raw["currentTasks"][0]["curStep"], 1)
self.planner.acknowledge(self.snapshot, server, {})
after = self.next("progression_dialogue")
self.assertEqual(after.phase, "after")
self.planner.acknowledge(self.snapshot, after)
self.planner.acknowledge(self.snapshot, self.next("progression_local_step"))
following = self.next("progression_step")
self.assertEqual(following.step_number, 2)
self.assertEqual(self.snapshot.raw["currentTasks"][0]["curStep"], 1)
def test_empty_before_story_does_not_skip_after_story(self):
self.planner = ProgressionPlanner(self.catalog, config({"100": task(steps=[step(afterStory="linear")])}))
self.planner.acknowledge(self.snapshot, self.next("progression_step"), {})
self.assertEqual(self.next("progression_dialogue").phase, "after")
def test_server_step_advance_does_not_skip_unfinished_acknowledged_after_story(self):
self.planner = ProgressionPlanner(self.catalog, config({"100": task(steps=[step(afterStory="linear"), step()])}))
self.planner.acknowledge(self.snapshot, self.next("progression_step"), {})
self.snapshot.raw["currentTasks"][0]["curStep"] = 2
self.assertEqual(self.next("progression_dialogue").step_number, 1)
def test_finished_received_unlocked_states_deduplicate(self):
self.snapshot.raw["history"]["unlockTask"] = {"100": True}
rows = self.planner.rows(self.snapshot, self.policy, self.ranch)
self.assertEqual(len(rows), 1)
self.assertEqual(rows[0]["state"], "received")
self.assertEqual(self.next("progression_step").task_id, 11)
self.snapshot.raw["history"]["passTask"] = {"100": True}
self.assertEqual(self.plan(), [])
self.assertEqual(self.planner.rows(self.snapshot, self.policy, self.ranch)[0]["state"], "finished")
def test_task_history_id_lists_are_supported_alongside_flag_mappings(self):
self.snapshot.raw["currentTasks"] = []
self.snapshot.raw["history"]["unlockTask"] = [100]
self.next("progression_accept")
self.snapshot.raw["history"]["passTask"] = [100]
self.assertEqual(self.plan(), [])
def test_accept_uses_verified_payload_and_success_instance(self):
self.snapshot.raw["currentTasks"] = []
self.snapshot.raw["history"]["unlockTask"] = {"100": True}
accept = self.next("progression_accept")
self.assertEqual(accept.path, "taskService/taskReceive")
self.assertEqual(accept.payload, {"taskTypeId": "100"})
self.planner.acknowledge(self.snapshot, accept, {"task": {"id": 15, "typeId": "100", "stepValue": None}})
self.assertEqual(self.next("progression_step").task_id, 15)
def test_start_answer_is_required_and_choice_scripts_are_blocked(self):
self.snapshot.raw["currentTasks"] = []
self.snapshot.raw["history"]["unlockTask"] = {"100": True}
for name in ("linear", "choice", "missing"):
with self.subTest(name=name):
self.planner = ProgressionPlanner(self.catalog, config({"100": task(startStep=step(story=name))}))
self.assertTrue(self.plan()[0].block_reason)
self.planner = ProgressionPlanner(self.catalog, config({"100": task(startStep=step(story="accept"))}))
self.planner.acknowledge(self.snapshot, self.next("progression_dialogue"))
self.next("progression_accept")
def test_missing_accept_response_never_invents_an_instance(self):
self.snapshot.raw["currentTasks"] = []
self.snapshot.raw["history"]["unlockTask"] = {"100": True}
action = self.next("progression_accept")
self.assertFalse(self.planner.acknowledge(self.snapshot, action, {}))
self.assertIn("禁止自动重发", self.plan()[0].block_reason)
def test_reward_reply_received_successor_and_unlocked_sidequest(self):
self.planner = ProgressionPlanner(self.catalog, config({
"100": task(), "101": task("101"), "200": task("200", type=2)}))
self.snapshot.raw["currentTasks"][0]["curStep"] = 2
action = self.next("progression_complete")
self.planner.acknowledge(self.snapshot, action, {
"nextTasks": [{"id": 12, "typeId": "101", "curStep": 1}], "unlockTasks": ["200"]})
following = self.next("progression_step")
self.assertEqual(following.task_type_id, "101")
states = {row["task_type_id"]: row["state"] for row in self.planner.rows(self.snapshot, self.policy, self.ranch)}
self.assertEqual(states, {"100": "finished", "101": "received", "200": "unlocked"})
def test_graph_repair_uses_explicit_edges_and_three_exact_arrays(self):
self.planner = ProgressionPlanner(self.catalog, config({
"100": task(nextTasks=["500", "501"], unlockTasks=["700"]),
"500": task("500"), "501": task("501", closed=True), "700": task("700", type=2)}))
self.snapshot.raw["currentTasks"] = []
self.snapshot.raw["history"]["passTask"] = {"100": True, "unrelated": False}
self.policy.sidequests = True
action = self.next("progression_update")
self.assertEqual(action.path, "taskService/taskUpdate")
self.assertEqual(action.payload, {"receiveTasks": [{"prev": "100", "taskTypeId": "500"}],
"unlockTasks": [{"prev": "100", "taskTypeId": "700"}], "removeTasks": []})
self.snapshot.raw["history"]["unlockTask"] = {"500": True, "700": True}
self.policy.accept = False
self.assertNotIn("progression_update", [action.kind for action in self.plan()])
def test_graph_no_guessed_first_task_and_legacy_root_is_respected(self):
self.snapshot.raw["currentTasks"] = []
self.assertEqual(self.plan(), [])
data = config({"999": task("999", nextTasks=["100"]), "100": task()}, setting={"useOldNewTaskFunction": True})
self.planner = ProgressionPlanner(self.catalog, data)
self.snapshot.raw["history"]["passTask"] = {"999": True}
self.assertEqual(self.plan(), [])
def test_closed_task_removal_ack_is_not_replayed_on_a_stale_snapshot(self):
self.planner = ProgressionPlanner(self.catalog, config({"100": task(closed=True)}))
action = self.next("progression_update")
self.assertEqual(action.payload, {"unlockTasks": [], "receiveTasks": [], "removeTasks": [11]})
self.planner.acknowledge(self.snapshot, action, {})
self.assertEqual(self.plan(), [])
def test_declared_conditions_time_and_loader_anomaly_are_conservative(self):
self.assertFalse(self.planner.condition({"minLevel": 21}, self.snapshot)[0])
self.assertFalse(self.planner.condition({"maxLevel": 19}, self.snapshot)[0])
self.assertFalse(self.planner.condition({"close": True}, self.snapshot)[0])
self.assertFalse(self.planner.condition({"unfinishTask": ["100"]}, self.snapshot)[0])
self.assertFalse(self.planner.condition({"passStage": ["0101"]}, self.snapshot)[0])
self.assertTrue(self.planner.condition({"unlockStage": ["0101"]}, self.snapshot)[0])
self.assertFalse(self.planner.condition({"lang": "CN"}, self.snapshot)[0])
self.snapshot.raw["client_context"] = {"lang": "CN", "platform": "ANDROID", "channel": "DYD"}
self.assertTrue(self.planner.condition({"lang": "CN", "platform": "ANDROID"}, self.snapshot)[0])
self.assertFalse(self.planner.condition({"futureFlag": True}, self.snapshot)[0])
with patch("ranch_assistant.model.time.time", return_value=1794112200):
# 2026-11-08 12:30 UTC+8, Sunday == AS3 day 0.
self.assertTrue(self.planner.condition({"week": [0], "startTime": 1230, "endTime": 1230}, self.snapshot)[0])
self.assertFalse(self.planner.condition({"week": [1]}, self.snapshot)[0])
self.assertFalse(self.planner.condition({"endTimestamp": 1}, self.snapshot)[0])
def test_guide_gates_and_special_gacha_stay_blocked(self):
self.planner = ProgressionPlanner(self.catalog, config({"100": task(steps=[step(passGuide="minefail")])}))
self.assertTrue(self.plan()[0].block_reason)
self.snapshot.raw["history"]["guide_record"] = {"minefail": True}
self.next("progression_step")
self.planner = ProgressionPlanner(self.catalog, config({"1001006": task("1001006", steps=[step()] * 4)}))
self.snapshot.raw["currentTasks"] = [{"id": 12, "typeId": "1001006", "curStep": 4}]
self.assertIn("特殊抽蛋", self.plan()[0].block_reason)
def test_item_reserve_locks_and_exact_remove_ids(self):
self.planner = ProgressionPlanner(self.catalog, config({"100": task(steps=[step("getItem", statusValue={"type": 30001, "num": 3, "remove": True})])}))
self.snapshot.raw["items"] = [{"id": 1, "typeId": 30001, "num": 2}, {"id": 2, "typeId": 30001, "num": 4},
{"id": 3, "typeId": 30001, "num": 100, "lock": True}]
self.assertIn("未启用", self.plan()[0].block_reason)
self.policy.allow_items = True
self.policy.item_reserves = {"30001": 4}
self.assertIn("保留", self.plan()[0].block_reason)
self.policy.item_reserves = {"30001": 3}
action = self.next("progression_step")
self.assertEqual(action.payload["removeIds"], [1, 2])
self.assertEqual(self.snapshot.raw["items"][1]["num"], 4)
def test_observation_only_items_still_send_source_ids_without_allowing_consumption(self):
self.planner = ProgressionPlanner(self.catalog, config({"100": task(steps=[step("getItem", statusValue={"type": 30001, "num": 2, "remove": False})])}))
self.snapshot.raw["items"] = [{"id": 1, "typeId": 30001, "num": 2}]
self.policy.item_reserves = {"30001": 100}
self.assertEqual(self.next("progression_step").payload["removeIds"], [1])
def test_money_removal_respects_maximum_and_ranch_reserve(self):
self.planner = ProgressionPlanner(self.catalog, config({"100": task(steps=[step("getMoney", statusValue={"money": 1200, "remove": True})])}))
self.assertIn("上限", self.plan()[0].block_reason)
self.policy.max_money = 1200
self.assertIn("保留", self.plan()[0].block_reason)
self.snapshot.raw["master"]["money"] = 2200
self.next("progression_step")
def test_monster_submission_never_consumes_team_locked_or_reserved_monsters(self):
self.planner = ProgressionPlanner(self.catalog, config({"100": task(steps=[step("getMonster", statusValue={"type": 1001010, "num": 1, "mode": 2, "remove": True})])}))
base = self.catalog.monster(1001010)
monster = {"id": 1, "typeId": 1001010, "mode": 2, "process": 3, "level": 1,
**{"g" + stat.capitalize(): base[stat + "_grow_min"] for stat in ("atk", "def", "hp", "dex")}}
self.snapshot.raw["monsters"] = [monster]
self.policy.allow_monsters = True
self.ranch.protect_quality = 5
self.assertEqual(self.next("progression_step").payload["removeIds"], [1])
for changes in ({"lock": True}, {"entangle": True}, {"equip1": 3}, {"inExploreTeam": True}):
with self.subTest(changes=changes):
self.snapshot.raw["monsters"] = [monster | changes]
self.assertTrue(self.plan()[0].block_reason)
self.snapshot.raw["monsters"] = [monster]
self.snapshot.raw["teams"] = [{"monsters": [1]}]
self.assertTrue(self.plan()[0].block_reason)
self.snapshot.raw["teams"] = []
self.ranch.reserved_types = [1001010]
self.assertTrue(self.plan()[0].block_reason)
def test_kill_target_uses_step_value_and_never_configured_relative_count(self):
self.planner = ProgressionPlanner(self.catalog, config({"100": task(steps=[step("killMonster", statusValue={"type": 1001010, "num": 2})])}))
self.snapshot.raw["currentTasks"][0]["stepValue"] = 150
self.snapshot.raw["history"]["numKillMonsters"] = {"1001010": 149}
self.assertTrue(self.plan()[0].block_reason)
self.snapshot.raw["history"]["numKillMonsters"]["1001010"] = 150
self.next("progression_step")
self.snapshot.raw["currentTasks"][0]["stepValue"] = None
self.assertIn("未同步", self.plan()[0].block_reason)
def test_pass_stage_and_task_battle_route_are_distinct_and_never_sweeps(self):
for kind in ("battle", "passStage"):
with self.subTest(kind=kind):
value = {"stage": "0101", "level": "1"} if kind == "passStage" else {}
self.planner = ProgressionPlanner(self.catalog, config({"100": task(steps=[step(kind, statusValue=value, battle={"teams": [{"mons": []}]})])}))
self.snapshot.raw["history"]["passStage"] = {"0101": [1, 2, 3]}
action = self.next("progression_battle")
self.assertEqual(action.path, "battleService/battleStart")
self.assertEqual(action.payload, {"battleType": "task", "taskTypeId": "100"})
self.assertEqual(action.battle_kind, "task" if kind == "battle" else "passStage")
self.assertEqual(action.stage_id, "" if kind == "battle" else "0101")
self.assertNotIn("battleData", action.payload)
self.planner.battle_lost(self.snapshot, action)
self.assertIn("战败", self.plan()[0].block_reason)
def test_task_pass_stage_stamina_and_hard_mode_gates(self):
self.planner = ProgressionPlanner(self.catalog, config({"100": task(steps=[step("passStage", statusValue={"stage": "0101", "level": 2})])}))
self.snapshot.raw["history"]["openHardMode"] = False
self.assertIn("高难度", self.plan()[0].block_reason)
self.snapshot.raw["history"]["openHardMode"] = True
self.policy.reserve_ti = 47
self.assertIn("体力", self.plan()[0].block_reason)
self.policy.reserve_ti = 46
self.next("progression_battle")
def test_battle_start_or_local_win_is_not_a_step_settlement(self):
self.planner = ProgressionPlanner(self.catalog, config({"100": task(steps=[step("battle", battle={"teams": []})])}))
action = self.next("progression_battle")
for response in ({"resCode": 0}, {"win": True}, {"resCode": 1, "reward": {}}):
with self.subTest(response=response), self.assertRaises(ValueError):
self.planner.acknowledge(self.snapshot, action, response)
def test_pass_stage_local_flags_require_confirmed_settlement(self):
self.planner = ProgressionPlanner(self.catalog, config({"100": task(steps=[
step("passStage", statusValue={"stage": "0101", "level": 1}),
step(condition={"passStage": ["0101"]})])}))
action = self.next("progression_battle")
self.assertFalse(self.planner.condition({"passStage": ["0101"]}, self.snapshot)[0])
self.planner.acknowledge(self.snapshot, action, {"costTi": 3, "unlockStage": [], "lockStage": []})
self.assertTrue(self.planner.condition({"passStage": ["0101"]}, self.snapshot)[0])
self.planner.acknowledge(self.snapshot, self.next("progression_local_step"))
self.assertEqual(self.next("progression_step").step_number, 2)
def test_wrong_account_stale_and_invalid_wire_steps_are_not_accepted(self):
action = self.next("progression_step")
other = snapshot(master={"id": 2})
with self.assertRaises(ValueError):
self.planner.acknowledge(other, action, {})
with self.assertRaises(ValueError):
self.planner.acknowledge(self.snapshot, replace(action, payload={}), {})
self.snapshot.raw["currentTasks"][0]["curStep"] = 0
self.planner = ProgressionPlanner(self.catalog, config())
self.assertIn("一基步骤", self.plan()[0].block_reason)
def test_pending_request_survives_restore_and_is_not_replayed(self):
action = self.next("progression_step")
self.planner.mark_started(self.snapshot, action)
restored = ProgressionPlanner(self.catalog, config())
restored.restore_state(json.loads(json.dumps(self.planner.export_state())))
self.assertTrue(restored.plan(self.snapshot, self.policy, self.ranch)[0].block_reason)
self.snapshot.raw["currentTasks"][0]["curStep"] = 2
planned = restored.plan(self.snapshot, self.policy, self.ranch)[0]
self.assertEqual(planned.kind, "progression_local_step")
def test_local_progress_import_requires_an_actual_step_ack(self):
cursor = {"11:100": {"task_id": 11, "task_type_id": "100", "steps": {
"1": {"kind": "progression_dialogue", "phase": "before", "acknowledged": True}}}}
planned = self.planner.plan(self.snapshot, self.policy, self.ranch, local_progress=cursor)
self.assertEqual(planned[0].kind, "progression_step")
cursor["11:100"]["steps"]["1"] = {"kind": "progression_step", "acknowledged": True, "response": {"taskStepValue": None}}
planned = self.planner.plan(self.snapshot, self.policy, self.ranch, local_progress=cursor)
self.assertEqual(planned[0].kind, "progression_local_step")
def test_unknown_types_are_visible_and_commissions_are_not_duplicated(self):
self.planner = ProgressionPlanner(self.catalog, config({"100": task(type=6), "400": task("400", type=4)}))
self.snapshot.raw["currentTasks"].append({"id": 12, "typeId": "400", "curStep": 1})
rows = self.planner.rows(self.snapshot, self.policy, self.ranch)
self.assertEqual({row["category"] for row in rows}, {"unknown", "commission"})
self.policy.commissions = True
self.assertTrue(all(not action.path for action in self.plan()))
self.assertIn("QuestPolicy", next(row for row in rows if row["category"] == "commission")["block_reason"])
class CommissionProgressionTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.catalog = Catalog()
def setUp(self):
self.snapshot = snapshot(currentTasks=[{"id": 40, "typeId": "400", "curStep": 1}])
self.snapshot.raw["history"].update(loopTaskTime=int(self.snapshot.now), loopTaskNum=6, loopTask={"1": []})
self.quest = QuestPolicy(enabled=True)
self.ranch = Policy(keep_money=1000)
self.battle_policy = ProgressionPolicy(team="teamB", reserve_ti=5)
self.planner = ProgressionPlanner(self.catalog, config({"400": task("400", type=4)}))
def plans(self):
return self.planner.commission_plan(self.snapshot, self.quest, self.ranch, battle_policy=self.battle_policy)
def next(self, kind):
actions = self.plans()
self.assertTrue(actions)
self.assertEqual(actions[0].kind, kind, actions[0].description)
return actions[0]
def offers(self, values=None):
self.snapshot.raw["currentTasks"] = []
self.snapshot.raw["history"]["loopTask"] = {"1": ["400"] if values is None else values}
def test_current_commission_uses_full_nonbattle_acknowledgement_flow(self):
self.snapshot.raw["history"]["passTask"] = {"400": True} # Prior day's same type.
action = self.next("progression_step")
self.planner.acknowledge(self.snapshot, action, {})
self.planner.acknowledge(self.snapshot, self.next("progression_local_step"))
reward = self.next("progression_complete")
self.planner.acknowledge(self.snapshot, reward, {})
self.assertEqual(self.plans(), [])
self.assertEqual(self.planner.commission_rows(self.snapshot, self.quest, self.ranch)[0]["state"], "finished")
def test_battle_and_pass_stage_use_quest_battle_switch_and_task_route(self):
for kind in ("battle", "passStage"):
with self.subTest(kind=kind):
value = {"stage": "0101", "level": 1} if kind == "passStage" else {}
self.planner = ProgressionPlanner(self.catalog, config({"400": task("400", type=4, steps=[
step(kind, battle={"teams": []}, statusValue=value, afterStory="linear")])}))
self.quest.battle_tasks = False
self.assertIn("战斗开关", self.plans()[0].block_reason)
self.quest.battle_tasks = True
action = self.next("progression_battle")
self.assertEqual(action.payload, {"battleType": "task", "taskTypeId": "400"})
self.assertEqual(action.battle_kind, "task" if kind == "battle" else "passStage")
self.assertEqual(action.team, "teamB")
self.assertEqual(action.battle_mode, "original")
self.planner.acknowledge(self.snapshot, action, {"reward": {}})
self.assertEqual(self.next("progression_dialogue").phase, "after")
def test_offer_acceptance_has_exact_loop_payload_and_spends_one_slot_once(self):
self.offers()
self.snapshot.raw["history"]["loopTaskNum"] = 1
action = self.next("progression_loop_accept")
self.assertEqual(action.path, "taskService/taskLoopReceive")
self.assertEqual(action.payload, {"taskTypeId": "400", "city": 1})
response = {"task": {"id": 41, "typeId": "400", "curStep": 1}}
self.assertTrue(self.planner.acknowledge(self.snapshot, action, response))
self.assertFalse(self.planner.acknowledge(self.snapshot, action, response))
account = next(iter(self.planner.export_state()["accounts"].values()))
self.assertEqual(account["commissions"]["remaining"], 0)
self.assertEqual(self.next("progression_step").task_id, 41)
self.planner.acknowledge(self.snapshot, self.next("progression_step"), {})
self.planner.acknowledge(self.snapshot, self.next("progression_local_step"))
self.planner.acknowledge(self.snapshot, self.next("progression_complete"), {})
self.assertEqual(self.plans(), [])
def test_quest_enabled_accept_city_and_quota_are_authoritative(self):
self.offers()
self.quest.enabled = False
self.assertEqual(self.plans(), [])
self.quest.enabled = True
self.quest.accept = False
self.assertEqual(self.plans(), [])
self.quest.accept = True
self.quest.city = 2
self.assertEqual(self.plans(), [])
self.quest.city = 1
self.snapshot.raw["history"]["loopTaskNum"] = 0
self.assertEqual(self.plans(), [])
self.snapshot.raw["history"]["loopTaskNum"] = 1
self.next("progression_loop_accept")
def test_quest_resources_control_offer_acceptance(self):
self.planner = ProgressionPlanner(self.catalog, config({"400": task("400", type=4, steps=[
step("getItem", statusValue={"type": 30001, "num": 3, "remove": True}, afterStory="linear")])}))
self.offers()
self.snapshot.raw["items"] = [{"id": 1, "typeId": 30001, "num": 5}]
self.assertEqual(self.plans(), [])
self.quest.allow_items = True
self.quest.item_reserves = {"30001": 3}
self.assertEqual(self.plans(), [])
row = self.planner.commission_rows(self.snapshot, self.quest, self.ranch)[0]
self.assertIn("保留", row["block_reason"])
self.assertFalse(row["supported"])
self.quest.item_reserves = {"30001": 2}
self.next("progression_loop_accept")
def test_offer_with_linear_stories_is_accepted_and_choice_is_not(self):
self.offers()
for name, expected in (("linear", True), ("choice", False)):
with self.subTest(name=name):
self.planner = ProgressionPlanner(self.catalog, config({"400": task("400", type=4, steps=[step(story=name)])}))
self.assertEqual(bool(self.plans()), expected)
def test_battle_offers_need_existing_battle_tasks_opt_in(self):
self.offers()
self.planner = ProgressionPlanner(self.catalog, config({"400": task("400", type=4, steps=[step("battle", battle={"teams": []})])}))
self.assertEqual(self.plans(), [])
self.quest.battle_tasks = True
self.next("progression_loop_accept")
def test_reset_expires_old_instance_and_uses_confirmed_new_offers(self):
self.snapshot.raw["history"]["loopTaskTime"] -= 86400
self.snapshot.raw["history"]["loopTaskNum"] = 0
action = self.next("progression_loop_reset")
self.assertEqual(action.path, "taskService/taskLoopFlush")
self.assertEqual(action.payload, {})
self.planner.acknowledge(self.snapshot, action, {"loopTask": {"1": [400]}})
following = self.next("progression_loop_accept")
self.assertEqual(following.payload, {"taskTypeId": "400", "city": 1})
account = next(iter(self.planner.export_state()["accounts"].values()))
self.assertIn("40", account["commissions"]["expired_ids"])
self.assertEqual(account["commissions"]["remaining"], 6)
def test_uncertain_loop_accept_reconciles_without_spending_quota_twice(self):
self.offers()
self.snapshot.raw["history"]["loopTaskNum"] = 1
action = self.next("progression_loop_accept")
self.planner.mark_uncertain(self.snapshot, action)
self.assertTrue(self.plans()[0].block_reason)
self.snapshot.raw["currentTasks"] = [{"id": 41, "typeId": "400", "curStep": 1}]
self.snapshot.raw["history"]["loopTaskNum"] = 0
self.next("progression_step")
account = next(iter(self.planner.export_state()["accounts"].values()))
self.assertEqual(account["commissions"]["remaining"], 0)
def test_cn_reset_uses_ten_second_grace(self):
midnight = 1794067200 # 2026-11-08 00:00 UTC+8.
with patch("ranch_assistant.model.time.time", return_value=midnight + 5):
self.snapshot.raw["history"]["loopTaskTime"] = midnight - 100
self.assertNotEqual(self.plans()[0].kind, "progression_loop_reset")
with patch("ranch_assistant.model.time.time", return_value=midnight + 11):
self.assertEqual(self.plans()[0].kind, "progression_loop_reset")
class RecoveredProgressionDataTests(unittest.TestCase):
def test_full_original_tasks_static_manifest_and_battle_archive(self):
data = load_progression_data()
self.assertEqual(len(data.tasks), 1165)
self.assertEqual(sum(len(task["steps"]) for task in data.tasks.values()), 3462)
self.assertEqual(len(data.stages), 1178)
self.assertEqual(len(data.scripts), 4269)
self.assertEqual(data.manifest["source"]["apk_sha256"], ORIGINAL_APK_SHA256)
self.assertEqual(len(Catalog().data["task_info"]), 83)
self.assertEqual(data.task("1001002")["steps"][0]["story"], "task_1001002")
self.assertIs(type(data.task("1001001")["unlockTasks"]), list)
self.assertEqual(data.manifest["source"]["amf_reader_sha256"], hashlib.sha256((ROOT / "ranch_assistant/amf.py").read_bytes()).hexdigest())
self.assertTrue(data.script("task_1001002")["supported"])
for name, record in data.manifest["artifacts"].items():
self.assertEqual(hashlib.sha256((DATA_DIR / name).read_bytes()).hexdigest(), record["sha256"])
self.assertLess((DATA_DIR / BATTLES_NAME).stat().st_size, 3_000_000)
with zipfile.ZipFile(DATA_DIR / BATTLES_NAME) as archive:
self.assertEqual(len(archive.namelist()), 1178)
self.assertTrue(all(name.startswith("stages/") and name.endswith(".json") for name in archive.namelist()))
self.assertTrue(all(info.date_time == (1980, 1, 1, 0, 0, 0) for info in archive.infolist()))
self.assertTrue(data.stage_battle("0101", 1))
self.assertTrue(data.task_battle("1001001", 1))
def test_loader_never_opens_apk_or_eagerly_reads_battles(self):
with patch("ranch_assistant.game_data.zipfile.ZipFile", side_effect=AssertionError("eager archive read")):
data = ProgressionData()
self.assertEqual(len(data.tasks), 1165)
def test_artifact_tampering_is_rejected(self):
with patch("ranch_assistant.game_data.Path.read_bytes", return_value=b"tampered"):
with self.assertRaisesRegex(ProgressionDataError, "hash mismatch"):
ProgressionData()
def test_shared_static_data_is_not_mutated_by_account_planning(self):
data = load_progression_data()
before = json.dumps(data.data, sort_keys=True, ensure_ascii=True)
planner = ProgressionPlanner(Catalog(), data)
planner.rows(snapshot(), ProgressionPolicy(), Policy())
planner.plan(snapshot(master={"id": 2}), ProgressionPolicy(enabled=True), Policy())
self.assertEqual(json.dumps(data.data, sort_keys=True, ensure_ascii=True), before)
def test_linear_hide_newlines_and_placeholders_are_presentation(self):
expressions = [
{"key": "text", "para": {"text": "[show]你好 [{gn.myName}][r]下一行\n[hide][cm]"}},
{"key": "event", "para": {"event": "GAoEvent", "eventData": "true"}},
]
summary = summarize_script(json.dumps({"exps": expressions}).encode(), "fixture")
self.assertTrue(summary["supported"], summary)
self.assertTrue(summary["answer"])
self.assertEqual(summary["dialogue_lines"], 1)
for expression in ({"key": "option", "para": {"options": []}}, {"key": "jump", "para": {"tag": "x"}},
{"key": "event", "para": {"event": "GAoEvent", "eventData": '{"action":"gacha"}'}}):
with self.subTest(expression=expression):
summary = summarize_script(json.dumps({"exps": [expression]}).encode(), "fixture")
self.assertFalse(summary["supported"])
class FarmingAndAreaTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.catalog = Catalog()
def setUp(self):
self.snapshot = snapshot()
self.policy = ProgressionPolicy(enabled=True)
self.ranch = Policy(keep_money=1000)
self.data = config(farming={"kills": {"1001010": [{"stage_id": "0101", "difficulty": 1, "configured_enemies": 2}]},
"items": {key: [{"stage_id": "0101", "difficulty": 1}] for key in ("30001", "1001010")}})
def planner(self, current_step):
data = deepcopy(self.data)
data["task_info"]["100"]["steps"] = [current_step]
return ProgressionPlanner(self.catalog, data)
def test_kill_farming_has_no_task_wire_context_and_never_uses_sweep(self):
planner = self.planner(step("killMonster", statusValue={"type": 1001010, "num": 5}))
self.snapshot.raw["currentTasks"][0]["stepValue"] = 5
self.snapshot.raw["history"]["numKillMonsters"] = {"1001010": 0}
self.snapshot.raw["history"]["passStage"] = {"0101": [1, 2, 3]}
action = planner.plan(self.snapshot, self.policy, self.ranch)[0]
self.assertEqual(action.kind, "stage_battle")
self.assertEqual(action.battle_kind, "ordinary_stage")
self.assertEqual((action.task_id, action.task_type_id), (0, ""))
self.assertEqual((action.source_task_id, action.source_task_type_id, action.source_step_number), (11, "100", 1))
self.assertEqual(action.payload, {"stageTypeId": "0101", "stageLevel": "1"})
self.assertEqual(action.path, "stageService/stageStart")
with self.assertRaises(ValueError):
planner.acknowledge(self.snapshot, action, {"reward": {}})
self.assertEqual(self.snapshot.raw["currentTasks"][0]["curStep"], 1)
self.snapshot.raw["history"]["numKillMonsters"]["1001010"] = 5
self.assertEqual(planner.plan(self.snapshot, self.policy, self.ranch)[0].kind, "progression_step")
def test_loot_uses_sweep_only_after_three_difficulties_are_cleared(self):
planner = self.planner(step("getItem", statusValue={"type": 30001, "num": 3, "remove": False}))
self.snapshot.raw["history"]["passStage"] = {"0101": [3]}
self.assertEqual(planner.plan(self.snapshot, self.policy, self.ranch)[0].kind, "stage_battle")
self.snapshot.raw["history"]["passStage"] = {"0101": [1, 2, 3]}
action = planner.plan(self.snapshot, self.policy, self.ranch)[0]
self.assertEqual(action.kind, "sweep")
self.assertEqual(action.task_id, 0)
self.assertEqual(action.source_task_type_id, "100")
self.policy.allow_sweep = False
self.assertEqual(planner.plan(self.snapshot, self.policy, self.ranch)[0].kind, "stage_battle")
def test_egg_farming_and_reserves_wait_for_actual_inventory(self):
planner = self.planner(step("getMonster", statusValue={"type": 1001010, "num": 2, "mode": 0, "remove": True}))
self.policy.allow_items = True
self.policy.item_reserves = {"1001010": 2}
self.snapshot.raw["items"] = [{"id": 1, "typeId": 1001010, "num": 3}]
self.assertEqual(planner.plan(self.snapshot, self.policy, self.ranch)[0].kind, "stage_battle")
self.snapshot.raw["items"][0]["num"] = 4
self.assertEqual(planner.plan(self.snapshot, self.policy, self.ranch)[0].kind, "progression_step")
def test_farming_respects_disabled_consumption_stamina_locks_and_premium(self):
planner = self.planner(step("getItem", statusValue={"type": 30001, "num": 3, "remove": True}))
self.assertTrue(planner.plan(self.snapshot, self.policy, self.ranch)[0].block_reason)
self.policy.allow_items = True
self.policy.reserve_ti = 48
self.assertTrue(planner.plan(self.snapshot, self.policy, self.ranch)[0].block_reason)
self.policy.reserve_ti = 0
self.snapshot.raw["history"]["unlockStage"] = {}
self.assertTrue(planner.plan(self.snapshot, self.policy, self.ranch)[0].block_reason)
self.snapshot.raw["history"]["unlockStage"] = {"0101": [1]}
self.data["stage_info"]["0101"]["cost"]["ke"] = 1
self.assertTrue(self.planner(step("getItem", statusValue={"type": 30001, "num": 1})).plan(self.snapshot, self.policy, self.ranch)[0].block_reason)
def test_task_interception_and_auto_farm_switch_are_honored(self):
current = step("getItem", statusValue={"type": 30001, "num": 3})
planner = self.planner(current)
self.policy.auto_farm = False
self.assertTrue(planner.plan(self.snapshot, self.policy, self.ranch)[0].block_reason)
self.policy.auto_farm = True
data = deepcopy(self.data)
data["task_info"]["100"]["steps"] = [current]
data["task_info"]["200"] = task("200", type=2, steps=[step(position="city1_wild_stage0101_level1")])
planner = ProgressionPlanner(self.catalog, data)
self.snapshot.raw["currentTasks"].append({"id": 12, "typeId": "200", "curStep": 1})
self.assertTrue(planner.plan(self.snapshot, self.policy, self.ranch)[0].block_reason)
def test_farming_ticket_locks_and_gift_reserves_are_protected(self):
self.data["stage_info"]["0101"]["cost"]["items"] = [{"typeId": 30002, "num": 1}]
self.policy.allow_items = True
self.snapshot.raw["items"] = [{"id": 2, "typeId": 30002, "num": 1, "sysLock": True}]
planner = self.planner(step("getItem", statusValue={"type": 30001, "num": 2}))
self.assertTrue(planner.plan(self.snapshot, self.policy, self.ranch)[0].block_reason)
self.snapshot.raw["items"][0]["sysLock"] = False
self.ranch.gift_items = {"30002": {"enabled": True, "reserve": 1}}
self.assertTrue(planner.plan(self.snapshot, self.policy, self.ranch)[0].block_reason)
def test_static_index_excludes_juveniles_allies_objects_and_zero_chance(self):
monsters = [
{"type": "1001010", "team": 2, "mode": 2},
{"type": "1001020", "team": 2, "mode": 1},
{"type": "1001030", "team": 1, "mode": 2},
{"type": "1001040", "team": 2, "mode": 2, "isObject": True},
]
reward = {"rewards": [
{"item_num": 1, "item_chance": 1, "items": [{"name": "30001,1,2", "value": 1}]},
{"item_num": 1, "item_chance": 0, "items": [{"name": "30002,1,1", "value": 1}]},
{"num": 1, "chance": 1, "monMode": 0, "monsters": [{"name": "1001010", "value": 1}]},
{"num": 1, "chance": 1, "monMode": 2, "monsters": [{"name": "1001020", "value": 1}]},
]}
index = farming_index({"0101": {"level": {"1": {"battle": {"teams": [{"mons": monsters}]}, "reward": reward}}}})
self.assertEqual(set(index["kills"]), {"1001010"})
self.assertEqual(set(index["items"]), {"30001", "1001010"})
def test_area_and_dungeon_navigation_use_recovered_conditions_and_labels(self):
self.data["area_info"] = {"areaInfo": {"1f": {"name": "森林", "city": "1", "openStage": "0101"}},
"areaMap": {"1": {"positions": [
{"posId": "city1_wild_1f", "action": "area", "actionPara": {"area": "1f"}, "condition": {"finishTask": ["200"]}},
{"posId": "city1_dungeon1", "action": "dungeon", "actionPara": {"dungeon": "dungeon1"}, "condition": {}},
]}}}
self.data["mine_info"] = {"mines": {"dungeon1": {"pos": "city1_dungeon1", "name": "试炼矿洞"}}}
planner = self.planner(step(position="city1_wild_1f", story="linear"))
self.assertTrue(planner.plan(self.snapshot, self.policy, self.ranch)[0].block_reason)
self.snapshot.raw["history"]["passTask"] = {"200": True}
action = planner.plan(self.snapshot, self.policy, self.ranch)[0]
self.assertEqual(action.kind, "progression_navigate")
self.assertIn("森林", action.location)
planner = self.planner(step(position="city1_dungeon1", story="linear"))
action = planner.plan(self.snapshot, self.policy, self.ranch)[0]
self.assertEqual(action.kind, "progression_navigate")
self.assertIn("试炼矿洞", action.location)
if __name__ == "__main__":
unittest.main()
@@ -0,0 +1,749 @@
import os
os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
from dataclasses import asdict
from types import SimpleNamespace
import copy
import json
import threading
import time
import unittest
from unittest.mock import Mock, patch
from PySide6 import QtCore as C, QtWidgets as W
from PySide6.QtTest import QTest
from ranch_assistant import gui
from ranch_assistant.policy_io import import_config, portable_config
from ranch_assistant.progression import ProgressionPolicy
from ranch_assistant.progression_gui import CachedTable, prepare_progression_views
from ranch_assistant.tests.test_core import workspace_temp
def configured_policy():
policy = ProgressionPolicy(enabled=True, mainline=True, sidequests=True, commissions=True, accept=False,
auto_dialogue=False, team="teamC", reserve_ti=24, allow_sweep=False, max_money=42,
allow_items=True, allow_monsters=True, item_reserves={"30001": 17}, stop_after_loss=3, repair_chain=False,
battle_mode="experimental")
if hasattr(policy, "auto_farm"):
policy.auto_farm = False
return policy
TASKS = [
{"task_type_id": "1001", "name": "主线测试", "category": "mainline", "state": "active", "step_number": 2,
"total_steps": 4, "position": "地图0101", "requirement": "与NPC对话", "next_action": "dialogue", "battle_kind": "task_battle",
"dialogue": "测试对话内容", "supported": True, "status": "等待对话"},
{"task_type_id": "1002", "name": "支线测试", "category": "sidequest", "state": "blocked", "step_number": 1,
"total_steps": 2, "position": "地图0102", "requirement": "战斗", "next_action": "", "battle_kind": "task_battle",
"supported": False, "blocked_reason": "战斗运行时尚未支持"},
{"task_type_id": "1003", "name": "委托测试", "category": "commission", "state": "available", "step_number": 0,
"total_steps": 1, "position": "村庄", "requirement": "物品", "next_action": "accept", "battle_kind": ""},
{"task_type_id": "1004", "name": "未知测试", "category": "new_category", "state": 999, "step_number": None,
"total_steps": None, "position": None, "requirement": None, "next_action": None, "battle_kind": None},
]
RECORDS = [
{"timestamp": 1700000000, "battle_kind": "task_battle", "task_type_id": "1001", "team": "teamC", "outcome": "unsupported", "reason": "未支持"},
{"timestamp": 1700000001, "battle_kind": "sweep", "stage_id": "0101", "outcome": "completed", "message": "扫荡记录"},
{"timestamp": 1700000002, "battle_kind": "map_reward_event", "stage_id": "0102", "outcome": "event", "message": "奖励事件"},
]
class ProgressionPolicyIOTests(unittest.TestCase):
def test_round_trip_preserves_choices_without_session_or_runtime_state(self):
policy = configured_policy()
source = {"progression_policy": asdict(policy), "token": "test-secret", "account": "private-account",
"progression_records": RECORDS, "progression_rows": TASKS, "runtime_path": "private-runtime"}
exported = portable_config(source)
self.assertEqual(exported["assistantVersion"], "1.2.0.dev1")
self.assertEqual(import_config(exported)["progression_policy"], asdict(policy))
text = json.dumps(exported)
for secret in ("test-secret", "private-account", "private-runtime", "progression_records", "progression_rows"):
self.assertNotIn(secret, text)
self.assertEqual(policy, configured_policy())
def test_defaults_and_older_bundles_do_not_enable_or_replace_progression(self):
exported = portable_config({})
self.assertFalse(exported["progression_policy"]["enabled"])
self.assertEqual(exported["progression_policy"]["battle_mode"], "original")
if hasattr(ProgressionPolicy(), "auto_farm"):
self.assertEqual(exported["progression_policy"]["auto_farm"], ProgressionPolicy().auto_farm)
del exported["progression_policy"]["auto_farm"]
self.assertEqual(import_config(exported)["progression_policy"]["auto_farm"], ProgressionPolicy().auto_farm)
del exported["progression_policy"]["battle_mode"]
self.assertEqual(import_config(exported)["progression_policy"]["battle_mode"], "original")
del exported["progression_policy"]
self.assertNotIn("progression_policy", import_config(exported))
def test_invalid_progression_rejected_atomically(self):
exported = portable_config({"progression_policy": asdict(configured_policy())})
for field, invalid in (("enabled", 1), ("mainline", "true"), ("reserve_ti", -1), ("reserve_ti", True),
("max_money", -1), ("max_money", 1_000_000_001), ("stop_after_loss", 0), ("stop_after_loss", 1000),
("team", ""), ("team", None), ("team", True), ("battle_mode", "automatic"), ("battle_mode", True),
("battle_mode", ["experimental"]), ("item_reserves", {"30001": -1}), ("item_reserves", {"30001": True}),
("item_reserves", {"invalid": 1}), ("item_reserves", {"0": 1}), ("allow_items", "yes"),
("auto_farm", "true"), ("auto_farm", 1), ("auto_farm", None)):
with self.subTest(field=field, invalid=invalid):
value = copy.deepcopy(exported)
value["progression_policy"][field] = invalid
with self.assertRaises((ValueError, TypeError)):
import_config(value)
for invalid in (None, [], {"unknown_field": True}):
with self.assertRaises((ValueError, TypeError)):
import_config(exported | {"progression_policy": invalid})
class ProgressionGuiTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.app = W.QApplication.instance() or W.QApplication([])
def wait(self, window, predicate=lambda: True):
deadline = time.monotonic() + 6
while time.monotonic() < deadline:
self.app.processEvents()
QTest.qWait(5)
if (not window.busy and not window.progression_table.row_batch.running
and not window.battle_records_table.row_batch.running and predicate()):
return
self.fail("Offline Qt job did not complete: " + window.log.toPlainText())
def mock_readers(self, window):
threads = []
def tasks():
threads.append(C.QThread.currentThread())
return copy.deepcopy(TASKS)
def records():
threads.append(C.QThread.currentThread())
return copy.deepcopy(RECORDS)
task_mock = Mock(side_effect=tasks)
record_mock = Mock(side_effect=records)
window.engine.progression_rows = task_mock
window.engine.progression_records = record_mock
return threads, task_mock, record_mock
def login_fixture(self, window, events):
from ranch_assistant.api import Session
session = Session("http://127.0.0.1/fixture/", "fixture-token", account_id="fixture-account", server_id=1, role_id=101)
client = SimpleNamespace(session=session, trace=None, persist_session=Mock(),
close=Mock(side_effect=lambda: events.append("client_closed")))
window.engine.client = client
window.engine.demo = False
window.engine.last_heartbeat = time.monotonic()
window.engine.master_sync_due = Mock(return_value=False)
window.engine.growth_sync_due = Mock(return_value=False)
window.engine.heartbeat_enabled = True
window.monitoring = True
window.set_strategy_checked(True)
window.next_poll = 0
window.account.setText("fixture-account")
window.password.setText("fixture-password")
window.credentials.save("fixture-account", "fixture-password", True)
window.session_store.save(session, "fixture account")
window.reload_saved_sessions()
return client
def test_logout_nested_confirmation_cannot_report_clear_before_client_release(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
release = threading.Event()
events = []
try:
self.wait(window)
client = self.login_fixture(window, events)
def held_poll(**kwargs):
if not release.wait(4):
raise TimeoutError("logout fixture was not released")
return window.engine.snapshot, [], "fixture poll finished"
window.engine.poll = Mock(side_effect=held_poll)
save = window.credentials.save
def record_save(account, password, remember):
if not remember and not account and not password:
events.append("credentials_cleared")
return save(account, password, remember)
def confirm(*args):
window.schedule() # The real modal runs this nested event loop.
self.app.processEvents()
return W.QMessageBox.StandardButton.Yes
with patch.object(gui.W.QMessageBox, "question", side_effect=confirm), patch.object(window.credentials, "save", side_effect=record_save):
window.logout_and_clear()
if "credentials_cleared" in events:
self.assertIn("client_closed", events, "credentials were cleared while the original client was active")
self.assertLess(events.index("client_closed"), events.index("credentials_cleared"))
release.set()
self.wait(window, lambda: window.engine.demo)
client.close.assert_called_once_with()
self.assertEqual(window.credentials.load(), (False, "", ""))
self.assertEqual(window.session_store.entries(), [])
self.assertFalse(window.monitoring)
self.assertFalse(window.engine.auto)
self.assertFalse(window.strategy_toggle.isChecked())
finally:
release.set()
self.wait(window)
window.close()
def test_logout_cancel_freezes_scheduler_but_preserves_credentials_and_stopped_intent(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
events, observed = [], []
try:
self.wait(window)
client = self.login_fixture(window, events)
engine = window.engine
window.ranch_enabled.setChecked(False)
window.progression_enabled.setChecked(True)
engine.auto = True
engine.poll = Mock(return_value=(engine.snapshot, [], "fixture refresh"))
def cancel(*args):
observed.append((engine.auto, window.monitoring, window.strategy_toggle.isChecked(), engine.heartbeat_enabled))
window.schedule()
window.start_workflow() # A previously queued start must also stay frozen.
self.app.processEvents()
observed.append((engine.auto, window.monitoring, window.strategy_toggle.isChecked(), engine.heartbeat_enabled))
return W.QMessageBox.StandardButton.No
with patch.object(gui.W.QMessageBox, "question", side_effect=cancel):
window.logout_and_clear()
self.wait(window)
self.assertEqual(observed, [(False, False, False, False)] * 2)
engine.poll.assert_not_called()
self.assertIs(window.engine, engine)
client.close.assert_not_called()
self.assertEqual(window.credentials.load(), (True, "fixture-account", "fixture-password"))
self.assertEqual(len(window.session_store.entries()), 1)
self.assertFalse(window.strategy_toggle.isChecked())
self.assertFalse(engine.auto)
finally:
window.close()
def test_confirmed_busy_logout_waits_for_worker_before_clear(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
release = threading.Event()
events = []
try:
self.wait(window)
client = self.login_fixture(window, events)
engine = window.engine
def held_poll():
if not release.wait(4):
raise TimeoutError("logout fixture was not released")
return engine.snapshot, [], "fixture poll finished"
window.submit("poll", held_poll)
with patch.object(gui.W.QMessageBox, "question", return_value=W.QMessageBox.StandardButton.Yes) as question:
window.logout_and_clear()
question.assert_called_once()
self.assertTrue(window.busy)
client.close.assert_not_called()
self.assertEqual(window.credentials.load(), (True, "fixture-account", "fixture-password"))
self.assertNotIn("已清除当前账号页签的登录记录", window.log.toPlainText())
release.set()
self.wait(window, lambda: window.engine.demo)
client.close.assert_called_once_with()
self.assertEqual(window.credentials.load(), (False, "", ""))
self.assertFalse(window.engine.auto)
self.assertFalse(engine.auto)
self.assertFalse(engine.heartbeat_enabled)
finally:
release.set()
self.wait(window)
window.close()
def test_failed_client_release_does_not_clear_credentials_or_report_success(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
try:
self.wait(window)
client = self.login_fixture(window, [])
client.close.side_effect = RuntimeError("fixture close failed")
with patch.object(gui.W.QMessageBox, "question", return_value=W.QMessageBox.StandardButton.Yes):
window.logout_and_clear()
self.assertEqual(window.credentials.load(), (True, "fixture-account", "fixture-password"))
self.assertEqual(len(window.session_store.entries()), 1)
self.assertNotIn("已清除当前账号页签的登录记录", window.log.toPlainText())
self.assertIn("fixture close failed", window.log.toPlainText())
self.assertFalse(window.engine.auto)
self.assertFalse(window.engine.heartbeat_enabled)
self.assertFalse(window.monitoring)
client.close.side_effect = None
finally:
window.close()
def test_confirmed_logout_still_clears_sessions_if_window_closes_while_waiting(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
release = threading.Event()
try:
self.wait(window)
client = self.login_fixture(window, [])
window.submit("logout_fixture", lambda: release.wait(4))
with patch.object(gui.W.QMessageBox, "question", return_value=W.QMessageBox.StandardButton.Yes):
window.logout_and_clear()
window.close()
release.set()
for _ in range(600):
self.app.processEvents()
QTest.qWait(5)
if not window.busy and client.close.called:
break
self.assertEqual(window.session_store.entries(), [])
self.assertEqual(window.credentials.load(), (False, "", ""))
client.close.assert_called_once_with()
finally:
release.set()
self.wait(window)
window.close()
def test_tabs_stopped_defaults_and_progression_only_global_start(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
try:
self.wait(window)
labels = [window.tabs.tabText(i) for i in range(window.tabs.count())]
self.assertEqual(labels[labels.index("自动孵蛋") + 1], "自动主线")
self.assertIn("战斗记录", labels)
self.assertEqual(labels[-1], "收益资料")
self.assertEqual(window.styleSheet(), "")
self.assertFalse(window.progression_enabled.isChecked())
self.assertTrue(window.progression_mainline.isChecked())
self.assertFalse(window.progression_sidequests.isChecked())
self.assertFalse(window.progression_commissions.isChecked())
if hasattr(ProgressionPolicy(), "auto_farm"):
self.assertEqual(window.progression_auto_farm.isChecked(), ProgressionPolicy().auto_farm)
else:
self.assertFalse(hasattr(window, "progression_auto_farm"))
self.assertEqual(window.progression_battle_mode.currentData(), "original")
self.assertIn("近似", window.progression_battle_mode.toolTip())
self.assertIn("委托", window.progression_battle_mode.toolTip())
self.assertFalse(window.strategy_toggle.isChecked())
for widget in (window.ranch_enabled, window.quest_enabled, window.daily_enabled, window.map_enabled, window.gift_enabled):
widget.setChecked(False)
window.progression_enabled.setChecked(True)
window.engine.cancel_progression = Mock()
with patch.object(window, "refresh"):
window.start_workflow()
self.assertTrue(window.strategy_toggle.isChecked())
self.assertIn("主线推进", window.workflow_status.text())
window.stop_workflow()
window.engine.cancel_progression.assert_called_once_with()
self.assertFalse(window.strategy_toggle.isChecked())
buttons = [b.text() for b in window.findChildren(W.QPushButton)]
self.assertEqual(buttons.count("开启"), 1)
self.assertNotIn("开始监控", buttons)
finally:
window.close()
def test_per_account_autosave_and_restart_round_trip(self):
with workspace_temp() as folder:
expected = asdict(configured_policy())
window = gui.Window(folder / "one")
window.timer.stop()
try:
self.wait(window)
window.load_progression_policy(configured_policy())
window.progression_max_money.setValue(43)
expected["max_money"] = 43
QTest.qWait(350)
self.wait(window)
self.assertEqual(json.loads((folder / "one" / "settings.json").read_text(encoding="utf-8"))["progression_policy"], expected)
self.assertEqual(asdict(window.engine.progression_policy), expected)
self.assertFalse(window.engine.auto)
finally:
window.close()
first = gui.Window(folder / "one")
second = gui.Window(folder / "two")
first.timer.stop()
second.timer.stop()
try:
self.wait(first)
self.wait(second)
self.assertEqual(asdict(first.read_progression_policy()), expected)
self.assertEqual(asdict(second.read_progression_policy()), asdict(ProgressionPolicy()))
self.assertFalse(first.strategy_toggle.isChecked())
self.assertFalse(second.strategy_toggle.isChecked())
finally:
first.close()
second.close()
def test_unified_import_keeps_choices_and_execution_stopped(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
try:
self.wait(window)
source = window.config_value() | {"progression_policy": asdict(configured_policy())}
path = folder / "policies.json"
path.write_text(json.dumps(portable_config(source)), encoding="utf-8")
window.set_strategy_checked(True)
window.engine.auto = True
window.engine.run_progression_once = Mock()
with patch.object(gui.W.QFileDialog, "getOpenFileName", return_value=(str(path), "")):
window.import_policies()
self.assertEqual(asdict(window.read_progression_policy()), asdict(configured_policy()))
self.assertEqual(asdict(window.engine.progression_policy), asdict(configured_policy()))
self.assertFalse(window.strategy_toggle.isChecked())
self.assertFalse(window.engine.auto)
window.engine.run_progression_once.assert_not_called()
with patch.object(gui.W.QFileDialog, "getSaveFileName", return_value=(str(path), "")):
window.export_policies()
self.assertEqual(import_config(json.loads(path.read_text(encoding="utf-8")))["progression_policy"], asdict(configured_policy()))
finally:
window.close()
def test_battle_mode_autosaves_without_starting_and_reaches_worker_policy(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
try:
self.wait(window)
window.engine.run_progression_once = Mock()
self.assertEqual(window.progression_battle_mode.currentData(), "original")
window.progression_battle_mode.setCurrentIndex(window.progression_battle_mode.findData("experimental"))
QTest.qWait(350)
self.wait(window)
saved = json.loads((folder / "settings.json").read_text(encoding="utf-8"))
self.assertEqual(saved["progression_policy"]["battle_mode"], "experimental")
self.assertEqual(window.engine.progression_policy.battle_mode, "experimental")
self.assertIn("实验模拟", window.progression_status.text())
self.assertIn("近似", window.progression_status.text())
self.assertFalse(window.strategy_toggle.isChecked())
self.assertFalse(window.engine.auto)
window.engine.run_progression_once.assert_not_called()
observations = []
def preview():
observations.append((window.engine.progression_policy.battle_mode, C.QThread.currentThread()))
return window.engine.snapshot, [], "已预览所选战斗模式"
window.engine.refresh_progression = Mock(side_effect=preview)
window.refresh_progression()
self.wait(window)
self.assertEqual(observations[0][0], "experimental")
self.assertNotEqual(observations[0][1], self.app.thread())
self.assertFalse(window.engine.auto)
finally:
window.close()
def test_additional_and_unavailable_teams_round_trip_visibly_without_starting(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
try:
self.wait(window)
policy = configured_policy()
policy.team = "Raid42"
exported = portable_config(window.config_value() | {"progression_policy": asdict(policy)})
value = import_config(exported)
self.assertEqual(value["progression_policy"]["team"], "Raid42")
window.load_config(window.config_value() | value)
self.assertEqual(window.progression_team.currentData(), "Raid42")
self.assertIn("当前账号未找到", window.progression_team.currentText())
window.engine.snapshot.raw["teams"] = [{"teamType": "battleTeam", "teamName": "Raid42", "monsters": [900]},
{"teamType": "battleTeam", "teamName": "teamD", "monsters": [900]}]
window.refresh_progression_teams(window.engine.snapshot)
self.assertEqual(window.progression_team.currentText(), "Raid42")
self.assertGreaterEqual(window.progression_team.findData("teamD"), 0)
self.assertEqual(window.read_progression_policy().team, "Raid42")
self.assertFalse(window.strategy_toggle.isChecked())
self.assertFalse(window.engine.auto)
finally:
window.close()
@unittest.skipUnless(hasattr(ProgressionPolicy(), "auto_farm"), "Planner has not exposed ProgressionPolicy.auto_farm yet")
def test_auto_farm_autosaves_without_starting_or_duplicate_controls(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
try:
self.wait(window)
checks = [check for check in window.findChildren(W.QCheckBox)
if check.text() == "自动收集任务材料 / 击杀目标"]
self.assertEqual(checks, [window.progression_auto_farm])
window.engine.run_progression_once = Mock()
selected = not ProgressionPolicy().auto_farm
window.progression_auto_farm.setChecked(selected)
QTest.qWait(350)
self.wait(window)
saved = json.loads((folder / "settings.json").read_text(encoding="utf-8"))
self.assertEqual(saved["progression_policy"]["auto_farm"], selected)
self.assertEqual(window.engine.progression_policy.auto_farm, selected)
exported = portable_config(window.config_value())
self.assertEqual(import_config(exported)["progression_policy"]["auto_farm"], selected)
self.assertFalse(window.strategy_toggle.isChecked())
self.assertFalse(window.engine.auto)
window.engine.run_progression_once.assert_not_called()
finally:
window.close()
def test_hidden_page_and_account_skip_task_getters_and_cached_view_is_lazy(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
try:
self.wait(window)
threads, tasks, records = self.mock_readers(window)
window.refresh()
self.wait(window)
tasks.assert_not_called()
records.assert_not_called()
window.set_presentation_active(False)
window.tabs.setCurrentWidget(window.progression_page)
window.refresh()
self.wait(window)
tasks.assert_not_called()
records.assert_not_called()
window.set_presentation_active(True)
self.wait(window, lambda: window.progression_table.rowCount() == 4)
self.assertTrue(all(thread != self.app.thread() for thread in threads))
self.assertEqual(tasks.call_count, 1)
window.render_progression()
window.render_current_page()
self.assertEqual(tasks.call_count, 1)
records.assert_not_called()
window.tabs.setCurrentWidget(window.battle_records_page)
self.wait(window, lambda: window.battle_records_table.rowCount() == 3)
self.assertEqual(records.call_count, 1)
tasks.reset_mock()
window.refresh()
self.wait(window)
tasks.assert_not_called()
self.assertEqual(TASKS[0]["state"], "active")
finally:
window.close()
def test_account_views_share_static_data_without_mutating_it_or_loading_battles(self):
with workspace_temp() as folder:
first, second = gui.Window(folder / "one"), gui.Window(folder / "two")
first.timer.stop()
second.timer.stop()
try:
self.wait(first)
self.wait(second)
with patch("ranch_assistant.game_data.zipfile.ZipFile", side_effect=AssertionError("task UI must not load battle archives")):
first.refresh_progression()
self.wait(first)
second.refresh_progression()
self.wait(second)
data = first.engine.game_data
self.assertIsNotNone(data)
self.assertIs(data, second.engine.game_data)
original = repr(data.tasks)
self.assertIsNot(first.progression_views, second.progression_views)
self.assertIsNot(first.progression_views.tasks, second.progression_views.tasks)
if first.progression_views.tasks:
first.progression_views.tasks[0]["values"][2] = "account-one-only"
self.assertEqual(repr(data.tasks), original)
self.assertFalse(second.progression_views.tasks and second.progression_views.tasks[0]["values"][2] == "account-one-only")
finally:
first.close()
second.close()
def test_leaving_task_page_drops_its_queued_local_view(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
release = threading.Event()
try:
self.wait(window)
_, tasks, records = self.mock_readers(window)
window.run_job("held_request", lambda: release.wait(4))
window.tabs.setCurrentWidget(window.progression_page)
self.assertTrue(window.pending_progression_view)
window.tabs.setCurrentWidget(window.automation_page)
self.assertFalse(window.pending_progression_view)
release.set()
self.wait(window)
tasks.assert_not_called()
records.assert_not_called()
finally:
release.set()
self.wait(window)
window.close()
def test_filters_details_unknown_support_and_records_contexts(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
try:
self.wait(window)
self.mock_readers(window)
window.tabs.setCurrentWidget(window.progression_page)
self.wait(window, lambda: window.progression_table.rowCount() == 4)
for kind, expected in (("mainline", "主线测试"), ("sidequest", "支线测试"), ("commission", "委托测试"), ("unknown", "未知测试")):
window.progression_filter.setCurrentIndex(window.progression_filter.findData(kind))
self.wait(window, lambda: window.progression_table.rowCount() == 1)
self.assertEqual(window.progression_table.item(0, 2).text(), expected)
window.progression_table.selectRow(0)
if kind == "mainline":
detail = window.progression_detail.toPlainText()
for text in ("测试对话内容", "2 / 4", "地图0101", "等待对话"):
self.assertIn(text, detail)
elif kind == "sidequest":
self.assertIn("战斗运行时尚未支持", window.progression_detail.toPlainText())
elif kind == "unknown":
self.assertIn("支持状态未确认", window.progression_table.item(0, 9).text())
window.tabs.setCurrentWidget(window.battle_records_page)
self.wait(window, lambda: window.battle_records_table.rowCount() == 3)
for kind, label in (("sweep", "扫荡"), ("map_reward_event", "地图奖励事件"), ("task_battle", "任务战斗")):
window.battle_records_filter.setCurrentIndex(window.battle_records_filter.findData(kind))
self.wait(window, lambda: window.battle_records_table.rowCount() == 1)
self.assertEqual(window.battle_records_table.item(0, 1).text(), label)
finally:
window.close()
def test_refresh_and_step_use_worker_prepare_and_result_paths(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
try:
self.wait(window)
threads, tasks, _ = self.mock_readers(window)
def refresh():
threads.append(C.QThread.currentThread())
return window.engine.snapshot, [], "离线任务刷新完成"
window.engine.refresh_progression = Mock(side_effect=refresh)
window.engine.run_progression_once = Mock(side_effect=refresh)
with patch.object(window, "run_job", wraps=window.run_job) as run_job:
window.refresh_progression()
self.wait(window)
self.assertEqual(run_job.call_args[0][0], "progression_refresh")
self.assertIsNotNone(window.progression_views)
self.assertEqual(tasks.call_count, 1)
self.assertIn("离线任务刷新完成", window.log.toPlainText())
window.run_progression_once()
window.engine.run_progression_once.assert_not_called()
window.progression_enabled.setChecked(True)
window.monitoring = True
window.set_strategy_checked(True)
window.run_progression_once()
self.wait(window)
self.assertEqual(run_job.call_args[0][0], "progression_run")
self.assertEqual(window.engine.run_progression_once.call_count, 1)
self.assertTrue(all(thread != self.app.thread() for thread in threads))
finally:
window.close()
def test_policy_changes_wait_for_serial_request_but_stop_cancels_immediately(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
release = threading.Event()
entered = threading.Event()
try:
self.wait(window)
policy = window.engine.progression_policy
def held_request():
entered.set()
if not release.wait(4):
raise TimeoutError("test worker was not released")
window.engine.cancel_progression = Mock()
window.run_job("held_request", held_request)
self.assertTrue(entered.wait(1))
window.progression_enabled.setChecked(True)
window.progression_reserve_ti.setValue(77)
window.progression_battle_mode.setCurrentIndex(window.progression_battle_mode.findData("experimental"))
window.persist_settings()
self.assertIs(window.engine.progression_policy, policy)
self.assertIsNotNone(window.pending_policy)
window.stop_workflow()
window.engine.cancel_progression.assert_called_once_with()
self.assertTrue(window.busy)
release.set()
self.wait(window)
self.assertEqual(window.engine.progression_policy.reserve_ti, 77)
self.assertEqual(window.engine.progression_policy.battle_mode, "experimental")
self.assertFalse(window.engine.auto)
finally:
release.set()
self.wait(window)
window.close()
def test_stop_before_queued_step_starts_prevents_engine_entry(self):
with workspace_temp() as folder:
window = gui.Window(folder)
window.timer.stop()
try:
self.wait(window)
window.progression_enabled.setChecked(True)
window.monitoring = True
window.set_strategy_checked(True)
window.engine.run_progression_once = Mock()
queued = []
with patch.object(window.pool, "start", side_effect=queued.append):
window.run_progression_once()
self.assertEqual(len(queued), 1)
self.assertTrue(window.busy)
window.stop_workflow()
window.pool.start(queued[0])
self.wait(window)
window.engine.run_progression_once.assert_not_called()
self.assertIn("未开始执行", window.log.toPlainText())
self.assertFalse(window.engine.auto)
finally:
window.close()
def test_bad_task_contract_errors_are_reported(self):
engine = Mock()
engine.progression_rows.return_value = [{"task_type_id": "ok"}, None]
engine.progression_records.return_value = []
with self.assertRaisesRegex(TypeError, r"progression_rows\(\)"):
prepare_progression_views(engine)
def test_journal_timestamps_use_beijing_and_preserve_original_records(self):
source = [
{"kind": "battle", "task_id": 12, "battle_kind": "passStage", "started_at": 1700000000, "finished_at": 1700000010},
{"kind": "battle", "battle_kind": "ordinary_stage", "started_at": 1700000000, "outcome": "event"},
{"kind": "sweep", "battle_kind": "normal", "started_at": 1700000000},
]
original = copy.deepcopy(source)
engine = SimpleNamespace(snapshot=object(), progression_rows=lambda: TASKS, progression_records=lambda: source)
views = prepare_progression_views(engine)
self.assertEqual(views.records[0]["values"][0], "2023-11-15 06:13:30")
self.assertEqual(views.records[1]["values"][0], "2023-11-15 06:13:20")
self.assertEqual([row["category"] for row in views.records], ["task_pass_stage", "map_reward_event", "sweep"])
self.assertEqual(source, original)
def test_experimental_record_outcomes_keep_their_approximate_label(self):
records = [
{"battle_mode": "experimental", "faithful": False, "approximate": True, "outcome": "win"},
{"battle_mode": "original", "outcome": "win"},
{"outcome": "win"},
]
engine = SimpleNamespace(snapshot=object(), progression_rows=lambda: [], progression_records=lambda: records)
rows = prepare_progression_views(engine).records
self.assertIn("实验近似", rows[0]["values"][4])
self.assertIn("近似,未完整验证", rows[0]["detail"])
self.assertEqual(rows[1]["values"][4], "胜利")
self.assertIn("原版运行时", rows[1]["detail"])
self.assertIn("记录未标明", rows[2]["detail"])
self.assertEqual(records[0]["outcome"], "win")
def test_repeated_sorted_table_updates_do_not_reinsert_owned_items(self):
table = CachedTable(["编号", "名称"])
messages = []
previous = C.qInstallMessageHandler(lambda level, context, message: messages.append(message))
try:
for count in (80, 4, 35, 80):
rows = [{"key": str(i), "values": [str(i), "name " + str(i)], "detail": str(i)} for i in range(count)]
table.set_rows(rows)
deadline = time.monotonic() + 2
while table.row_batch.running and time.monotonic() < deadline:
self.app.processEvents()
QTest.qWait(2)
self.assertFalse(table.row_batch.running)
table.sortItems(0, C.Qt.SortOrder.DescendingOrder)
self.assertEqual(table.rowCount(), count)
self.assertEqual(table.item(0, 0).text(), str(count - 1))
self.assertFalse(any("already owned" in message.lower() or "cannot insert" in message.lower() for message in messages), messages)
finally:
C.qInstallMessageHandler(previous)
table.row_batch.stop()
table.deleteLater()
if __name__ == "__main__":
unittest.main()
@@ -11,6 +11,7 @@ from PySide6 import QtCore as C, QtWidgets as W
from PySide6.QtTest import QTest
from ranch_assistant.gui import Window
from ranch_assistant import presentation
from ranch_assistant.engine import demo_snapshot
from ranch_assistant.engine import Engine
from ranch_assistant.api import Client, Session, encode
@@ -62,6 +63,134 @@ class ResponsivenessTests(unittest.TestCase):
finally:
window.close()
def test_hidden_account_skips_worker_monster_preparation_and_prepares_on_show(self):
with workspace_temp() as folder:
window = Window(folder)
window.timer.stop()
try:
self.wait(window)
snapshot = demo_snapshot(window.catalog)
template = snapshot.raw["monsters"][-1]
snapshot.raw["monsters"] = [copy.deepcopy(template) | {"id": 1000 + i} for i in range(500)]
window.set_presentation_active(False)
window.tabs.setCurrentWidget(window.monster_page)
window.engine.poll = lambda **kwargs: (snapshot, [], "fixture poll")
threads = []
build = presentation.monster_rows
def record_build(*args, **kwargs):
threads.append(threading.get_ident())
return build(*args, **kwargs)
with patch.object(presentation, "monster_rows", side_effect=record_build) as preparing, patch("ranch_assistant.gui.monster_rows", side_effect=AssertionError("GUI thread monster fallback")):
window.refresh()
self.wait(window)
self.assertEqual(preparing.call_count, 0, "hidden account formatted monster rows")
window.set_presentation_active(True)
for _ in range(600):
self.app.processEvents()
QTest.qWait(5)
if not window.busy and len(window.monsters.monster_items) == 500:
break
self.assertEqual(len(window.monsters.monster_items), 500)
self.assertTrue(threads)
self.assertTrue(all(tid != threading.get_ident() for tid in threads))
self.assertTrue(window.engine.presentation_active)
finally:
self.wait(window)
window.close()
def test_visible_other_page_skips_monster_preparation_on_poll(self):
with workspace_temp() as folder:
window = Window(folder)
window.timer.stop()
try:
self.wait(window)
window.tabs.setCurrentIndex(0)
with patch.object(presentation, "monster_rows", wraps=presentation.monster_rows) as preparing:
window.refresh()
self.wait(window)
self.assertEqual(preparing.call_count, 0, "another page formatted monster rows")
finally:
window.close()
def test_warm_monster_view_finishes_preparation_when_unchanged_after_show(self):
with workspace_temp() as folder:
window = Window(folder)
window.timer.stop()
try:
self.wait(window)
window.tabs.setCurrentWidget(window.monster_page)
for _ in range(500):
self.app.processEvents()
QTest.qWait(2)
if not window.busy and not window.monster_render_timer.running:
break
original = dict(window.monsters.monster_items)
self.assertTrue(original)
window.set_presentation_active(False)
self.assertIsNone(window.prepared_views.monsters)
window.set_presentation_active(True)
for _ in range(500):
self.app.processEvents()
QTest.qWait(2)
if not window.busy and not window.monster_render_timer.running:
break
self.assertFalse(window.busy)
self.assertFalse(window.monster_render_timer.running)
self.assertEqual(window.monsters.monster_items, original)
finally:
self.wait(window)
window.close()
def test_prepare_views_default_stays_complete_and_opt_out_marks_monsters_dirty(self):
with workspace_temp() as folder:
window = Window(folder)
window.timer.stop()
try:
self.wait(window)
snapshot = window.engine.snapshot
with patch.object(presentation, "monster_rows", wraps=presentation.monster_rows) as preparing:
full = presentation.prepare_views(window.catalog, snapshot, set())
self.assertEqual(preparing.call_count, 1)
thin = presentation.prepare_views(window.catalog, snapshot, set(), include_monsters=False)
self.assertEqual(preparing.call_count, 1)
self.assertEqual(len(full.monsters), len(snapshot.raw["monsters"]))
self.assertEqual(full.monster_source, repr(snapshot.raw["monsters"]))
self.assertIsNone(thin.monsters)
self.assertIsNone(thin.monster_source)
self.assertIsInstance(full.maps, list)
self.assertIsInstance(thin.maps, list)
finally:
window.close()
def test_hidden_connection_sets_engine_visibility_before_first_plan(self):
from ranch_assistant.model import Snapshot
from ranch_assistant.tests.test_accounts import fake_client, role_snapshot
with workspace_temp() as folder:
window = Window(folder)
window.timer.stop()
try:
self.wait(window)
window.set_presentation_active(False)
previous = window.engine
session = Session("http://127.0.0.1/fixture/", "fixture-token", account_id="fixture", server_id=1, role_id=101)
client = fake_client(session, window.catalog, [])
window.result("connected", (client, Snapshot(role_snapshot(window.catalog, 101))))
engine = window.engine
self.assertIsNot(engine, previous)
self.assertFalse(engine.presentation_active)
self.assertFalse(engine.progression_view_active)
observed = []
def plan():
observed.append((engine.presentation_active, threading.get_ident()))
return []
with patch.object(engine, "plans", side_effect=plan):
window.preview_cultivation()
self.wait(window)
self.assertEqual([active for active, _ in observed], [False])
self.assertTrue(all(tid != threading.get_ident() for _, tid in observed))
finally:
window.close()
def test_unchanged_maps_reuse_controls_and_keep_edits(self):
with workspace_temp() as folder:
window = Window(folder)
@@ -194,6 +194,7 @@ class ManualGuiTests(unittest.TestCase):
self.assertEqual(window.eggs.item(row, 2).text(), "0")
self.assertTrue(window.eggs.cellWidget(row, 3).isChecked())
window.tabs.setCurrentWidget(window.monster_page)
self.wait(window)
item = window.monsters.monster_items[900]
window.monsters.itemWidget(item, 8).setChecked(True)
window.monsters.itemWidget(item, 9).setValue(1)
@@ -276,6 +277,7 @@ class ManualGuiTests(unittest.TestCase):
self.wait(window)
def select(mid):
window.tabs.setCurrentWidget(window.monster_page)
self.wait(window)
window.monsters.clearSelection()
window.monsters.setCurrentItem(window.monsters.monster_items[mid])
select(101)