Add v1.2 development quest progression and experimental battle runtime
This commit is contained in:
@@ -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()))
|
||||
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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()
|
||||
@@ -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)
|
||||
|
||||
Reference in New Issue
Block a user