"""Independent HTTP -> WebManager -> existing Engine offline integration checks. Run: python -m unittest ranch_web.tests.test_web_integration -v Only the game Client/login boundary and release source are fakes. Each test owns a new temporary root, disables the scheduler, and blocks external socket I/O. Fixtures stay in this file to avoid other agents' test/fixture ownership. """ from __future__ import annotations import base64 from contextlib import ExitStack from copy import deepcopy import hashlib import ipaddress import json import os from pathlib import Path import socket import subprocess import sys import tempfile import textwrap import threading import time import unittest from unittest.mock import patch PAGES = "login incubator bag ranch daily hatching mainline battles gifts commissions exploration maps statistics plans yields".split() TERMINAL = {"succeeded", "failed", "cancelled"} TOKEN = "web-integration-synthetic-token-82719" KEY = "web-integration-synthetic-key-49281" PASSWORD = "web-integration-synthetic-password-18374" REQID = 98271948 REQSID = 91283741 ROOT = Path(__file__).resolve().parents[2] class NoExternalSockets: """Allow Windows asyncio's loopback socketpair, reject external addresses.""" def __init__(self): self.stack = ExitStack() self.attempts = [] def check(self, address): host = address[0] if isinstance(address, tuple) else address if host == "localhost": return try: value = ipaddress.ip_address(host) if value.is_loopback or (getattr(value, "ipv4_mapped", None) and value.ipv4_mapped.is_loopback): return except (ValueError, TypeError): pass self.attempts.append(str(host)) raise AssertionError("External socket blocked by Web integration fixture") def __enter__(self): for name in ("connect", "connect_ex", "sendto"): original = getattr(socket.socket, name) def guarded(sock, *args, _original=original, _name=name, **kwargs): address = args[-1] if _name == "sendto" else args[0] self.check(address) return _original(sock, *args, **kwargs) self.stack.enter_context(patch.object(socket.socket, name, guarded)) original_dns = socket.getaddrinfo def dns(host, *args, **kwargs): self.check(host) return original_dns(host, *args, **kwargs) self.stack.enter_context(patch.object(socket, "getaddrinfo", dns)) return self def __exit__(self, *args): return self.stack.__exit__(*args) class SnapshotGate: def __init__(self): self.entered = threading.Event() self.release = threading.Event() def wait(self): self.entered.set() if not self.release.wait(8): raise AssertionError("Integration snapshot gate was not released") def seeded_snapshot(catalog, role_id=1): from ranch_assistant.engine import demo_snapshot from ranch_assistant.resource_stages import item_requirements, with_resource_data snapshot = demo_snapshot(catalog) snapshot.raw["master"]["id"] = role_id snapshot.raw["master"]["roleName"] = "Integration offline role" snapshot.raw["teams"][0]["teamName"] = "teamA" for index, monster in enumerate(snapshot.raw["monsters"][:4]): monster.update(process=3, mode=2, roomId=1, level=20 - index * 4) for slot in snapshot.raw["stacks"]: slot["monsterId"] = 0 snapshot.raw["history"].update( unlockStage={"0101": [1, 2, 3], "0109": [1, 2, 3]}, passStage={"0101": {"1": True, "2": True, "3": True}, "0109": {"1": True}}, passTask={"1001008": True}, unlockTask={"1001004": True}, openHardMode=True, ) snapshot.raw["currentTasks"] = [{"id": 711, "typeId": "1001004", "curStep": 1, "stepValue": None}] snapshot.raw["exploreTeams"] = [{"id": 1, "status": 0, "area": "", "monsters": ""}] for code in range(1, 6): item_id = next(key for key in catalog.data["item_info"] if catalog.item_type(key) == code) snapshot.raw["items"].extend({"id": 11000 + code * 10 + index, "typeId": item_id, "num": count} for index, count in enumerate((3, 4))) required_items = {} for stage in with_resource_data(catalog).data["stage_info"].values(): for item_id, count in item_requirements((stage.get("cost") or {}).get("items") or []).items(): required_items[item_id] = max(required_items.get(item_id, 0), count * 3) snapshot.raw["items"].extend({"id": 12000 + index, "typeId": item_id, "num": count} for index, (item_id, count) in enumerate(sorted(required_items.items()))) return snapshot def real_engine_factory(catalog, client=None, budget_path=None): from ranch_assistant.engine import Engine engine = Engine(catalog, client, budget_path) if client is None: engine.snapshot = seeded_snapshot(catalog) role_id = client.session.role_id if client else 1 # Persist through the real SQLite statistics service; no DTOs are injected. statistics = engine.sweeper.statistics for source, operation, reward, spent in ( ("sweep", "integration-sweep-hit", {"items": [{"typeId": 30005, "num": 2}]}, 10), ("sweep", "integration-sweep-miss", {"items": []}, 10), ("event", "integration-event-hit", {"items": [{"typeId": 30005, "num": 3}]}, 5), ): statistics.record(role_id, "0101", "3", source, operation, 1, reward, spent=spent) return engine class OfflineClient: def __init__(self, catalog, account="fixture", **kwargs): from ranch_assistant.api import Session role_id = 100 + int(hashlib.sha256(account.encode()).hexdigest()[:6], 16) self.catalog = catalog self.session = Session(server_url="https://game.invalid/", token=TOKEN, key=KEY, reqid=REQID, reqsid=REQSID, account_id=account, server_id=7, role_id=role_id, account_name=account) self.raw = seeded_snapshot(catalog, role_id).raw self.trace = kwargs.get("trace") self.on_session_change = kwargs.get("on_session_change") self.gate = None self.fail_snapshot = False self.reads = 0 self.writes = [] self.closed = False def enter_server(self, *args, **kwargs): return {"resCode": 0} def snapshot(self): from ranch_assistant.model import Snapshot self.reads += 1 if self.gate: self.gate.wait() if self.fail_snapshot: raise ValueError("离线读取失败 " + PASSWORD + " token=" + TOKEN + " key=" + KEY) if self.trace: self.trace.emit("response", "masterService/masterQueryDetail", http_status=200, body={"safe_marker": "integration-readable-detail", "token": TOKEN, "nested": {"password": PASSWORD, "key": KEY, "reqid": REQID}}, message="离线响应 password=" + PASSWORD) return Snapshot(deepcopy(self.raw)) def call(self, path, payload=None, **kwargs): self.writes.append((path, deepcopy(payload))) raise AssertionError("Unexpected game write in integration fixture: " + path) def close(self): self.closed = True class OfflineLoginFactory: def __init__(self): self.clients = [] def __call__(self, catalog, device, trace=None): owner = self class Flow: def authenticate(self, account, password): client = OfflineClient(catalog, account, trace=trace) owner.clients.append(client) return client, {"token": TOKEN, "key": KEY, "servers": [{"id": 7, "serverName": "Offline server", "gameServerAddress": "https://game.invalid/"}], "masterInfos": [{"serverId": 7, "masterName": "Offline role"}]}, { "center_url": "https://center.invalid/", "uid": account, "channel": "DYD", "device_id": "integration-device"} return Flow() class WebIntegrationTests(unittest.TestCase): def setUp(self): from fastapi.testclient import TestClient from ranch_web.app import create_app from ranch_web.config import WebConfig from ranch_web.service import WebManager from ranch_web.updates import UpdateService self.stack = ExitStack() self.addCleanup(self.stack.close) self.network = self.stack.enter_context(NoExternalSockets()) self.folder = Path(self.stack.enter_context(tempfile.TemporaryDirectory(prefix="web-integration-"))) self.root = self.folder / "new-web-root" self.stack.enter_context(patch.dict(os.environ, {"RANCH_WEB_UPDATER_DIR": ""})) self.source = self.stack.enter_context(patch("ranch_web.updates.github_releases", return_value=[])) self.login = OfflineLoginFactory() self.manager = WebManager(self.root, start_scheduler=False, engine_factory=real_engine_factory, login_factory=self.login) self.stack.callback(lambda: self.manager.close()) self.updates = UpdateService(self.root, "2.0.0.dev1") self.app = create_app(manager=self.manager, updates=self.updates, config=WebConfig(data_dir=self.root)) self.http = self.stack.enter_context(TestClient(self.app, base_url="http://127.0.0.1:8765", client=("127.0.0.1", 50000))) self.account = self.create_account() def tearDown(self): self.assertEqual(self.network.attempts, [], "An external socket was attempted") def response(self, response, status=200): self.assertEqual(response.status_code, status, response.text[:3000]) return response.json() def create_account(self, demo=True, label="integration"): value = self.response(self.http.post("/api/accounts", json={"label": label, "demo": demo}), 201) self.wait_idle(value["id"]) return value["id"] def path(self, suffix, account=None): return "/api/accounts/" + (account or self.account) + "/" + suffix def wait_idle(self, account=None): deadline = time.monotonic() + 8 while time.monotonic() < deadline: status = self.manager.status(account or self.account) if not status["busy"]: self.assertFalse(status["error"], status) return status time.sleep(.005) self.fail("Account worker did not become idle") def job(self, value, account=None, expected="succeeded"): deadline = time.monotonic() + 8 while time.monotonic() < deadline: current = self.response(self.http.get(self.path("jobs/" + value["id"], account))) self.assertIn(current["status"], TERMINAL | {"queued", "running"}) if current["status"] in TERMINAL: self.assertEqual(current["status"], expected, current) return current time.sleep(.005) self.fail("Job did not finish: " + str(value)) def action(self, operation, payload=None, account=None, expected="succeeded"): value = self.response(self.http.post(self.path("actions/" + operation, account), json=payload or {}), 202) return self.job(value, account, expected) def config(self, account=None): return self.response(self.http.get(self.path("config", account))) def save(self, value, account=None): current = self.config(account) response = self.http.put(self.path("config", account), json={"config": value, "revision": current["revision"]}) self.assertIn(response.status_code, (200, 202), response.text) pending = response.json() if pending.get("pending"): self.job(pending["job"], account) applied = self.config(account) self.assertGreater(applied["revision"], current["revision"]) return applied def view(self, page, query=None, account=None, simple=False): params = query if simple else {"query": json.dumps(query)} if query is not None else None value = self.response(self.http.get(self.path("views/" + page, account), params=params)) if value["loading"]: self.assertIsInstance(value["job_id"], str) self.job({"id": value["job_id"]}, account) value = self.response(self.http.get(self.path("views/" + page, account), params=params)) self.assertFalse(value["loading"], value) self.assertIsInstance(value["revision"], int) self.assertIsInstance(value["data"], dict) return value["data"] def hatch_config(self, account=None, enabled=True, priority=13): row = self.view("bag", account=account)["rows"][0] config = deepcopy(self.config(account)["config"]) config["policy"].update(enabled=True, fill=True, buy=False, collect=False, dispatch=False, feed=False, manual_eggs=True, egg_rules={row["id"]: row["rule_defaults"] | { "enabled": enabled, "priority": priority, "action": "keep", "keep_count": 2}}) return config, row def logged_account(self): account = self.create_account(False, "fake login") result = self.action("login", {"account": "fixture-account", "password": PASSWORD, "remember": True}, account) self.assertEqual(result["result"]["servers"][0]["id"], 7) self.assertTrue(result["result"]["has_saved_password"]) self.action("enter_server", {"server_id": 7}, account) self.assertTrue(self.manager.status(account)["connected"]) return account, self.login.clients[-1] def assert_dto(self, page): from ranch_assistant.engine import Engine self.assertIs(type(self.manager._worker(self.account).engine), Engine) dto = self.view(page) self.assertEqual(dto["page"], page) self.assertTrue(dto["title"]) for field in ("rows", "columns", "filters", "form"): self.assertIsInstance(dto[field], list, (page, field)) if page != "login": self.assertTrue(dto["columns"], page) for column in dto["columns"]: self.assertTrue(column["key"], (page, column)) self.assertTrue(column["label"], (page, column)) if "edit" in column: self.assertIsInstance(column["edit"]["path"], list) for row in dto["rows"]: self.assertIn("id", row, (page, row)) for field in dto["form"]: self.assertTrue({"path", "type", "label", "value"} <= field.keys(), (page, field)) def test_default_queries_schema_and_all_six_bag_categories(self): schema = self.response(self.http.get("/api/schema")) self.assertEqual([p["key"] for p in schema["pages"]], PAGES) self.assertTrue(schema["settings"]) defaults = {"bag": {"category": "eggs"}, "ranch": {"grouped": False}, "mainline": {"category": "mainline", "state": "current"}, "maps": {"category": "all", "only_unlocked": True}, "statistics": {"source": "all", "metric": "rate"}} for page, filters in defaults.items(): with self.subTest(page=page): implicit, explicit = self.view(page), self.view(page, filters) self.assertEqual([r["id"] for r in implicit["rows"]], [r["id"] for r in explicit["rows"]]) values = {f["key"]: f["value"] for f in implicit["filters"]} for key, value in filters.items(): self.assertEqual(values[key], value) maps = self.view("maps") self.assertTrue(maps["groups"]) self.assertTrue(all(group["collapsed"] for group in maps["groups"])) for category in ("eggs", "usable", "consumables", "materials", "other", "equipment"): dto = self.view("bag", {"category": category}, simple=True) self.assertEqual(dto["filters"][0]["value"], category) self.assertTrue(dto["rows"], category) if category != "eggs": self.assertTrue(any(len(row["inventory_ids"]) >= 2 and row["count"] >= 7 for row in dto["rows"]), category) mixed = self.http.get(self.path("views/bag"), params={"query": "{}", "category": "eggs"}) self.response(mixed, 400) def test_seeded_maps_tasks_and_exploration_have_business_data(self): maps = self.view("maps") stage = next(row for row in maps["rows"] if row["id"] == "0101") self.assertTrue(stage["unlocked"]) self.assertEqual(len(stage["edits"]["level"]["options"]), 3) self.assertTrue(stage["costs"]) resource = self.view("maps", {"category": "resource", "only_unlocked": False}) self.assertTrue(resource["rows"]) self.assertTrue(all(row["category"] in ("mine", "ticket") for row in resource["rows"])) self.assertTrue(any(any(cost["kind"] == "item" for cost in row["costs"]) for row in resource["rows"])) self.assertTrue(any(any(cost["kind"] == "item" and cost["available"] > 0 for cost in row["costs"]) for row in resource["rows"])) # Engine deliberately gates full-table task planning until the user # refreshes tasks or enables that feature. Exercise its real HTTP action. self.assertEqual(self.manager._worker(self.account).engine.snapshot.raw["currentTasks"][0]["typeId"], "1001004") self.action("refresh_tasks") mainline = self.view("mainline") self.assertTrue(mainline["rows"]) self.assertTrue(any(str(row.get("task_type_id")) == "1001004" for row in mainline["rows"])) config = self.config()["config"] config["explore_policy"].update(enabled=True, teams={"1": {"enabled": True, "area": "1", "monsters": [101, 102, 103]}}) self.save(config) explore = self.view("exploration") self.assertTrue(explore["rows"]) team = next(row for row in explore["rows"] if str(row["id"]) == "1") self.assertEqual(team["rule_path"], ["explore_policy", "teams", "1"]) self.assertTrue(team["edits"]["monsters"]["options"]) self.assertEqual(self.manager._worker(self.account).engine.explore_policy.teams["1"].monsters, [101, 102, 103]) self.assertEqual(team["monsters"], [101, 102, 103]) self.assertGreater(team["cost_ti"], 0) self.assertTrue(any(action.kind == "explore_start" for action in self.manager._worker(self.account).engine.plans())) self.assertFalse(self.manager.status(self.account)["running"]) def test_job_stays_running_until_persistence_and_status_summary_are_published(self): account = self.create_account(False, "publication barrier") self.action("login", {"account": "barrier-account", "password": PASSWORD, "remember": False}, account) worker = self.manager._worker(account) gate = SnapshotGate() self.stack.callback(gate.release.set) persist = worker._persist_session def blocked_persist(): if worker.engine.client is not None: gate.wait() persist() with patch.object(worker, "_persist_session", blocked_persist): value = self.response(self.http.post(self.path("actions/enter_server", account), json={"server_id": 7}), 202) self.assertTrue(gate.entered.wait(3)) try: current = self.response(self.http.get(self.path("jobs/" + value["id"], account))) self.assertEqual(current["status"], "running", "A terminal job must not precede persisted/public status") finally: gate.release.set() self.job(value, account) self.assertTrue(self.response(self.http.get(self.path("status", account)))["connected"]) def test_seeded_sqlite_statistics_compute_rates_sources_and_stamina(self): for source, samples, units, rate, efficiency in (("sweep", 2, 2, .5, .1), ("event", 1, 3, 1, .6), ("all", 3, 5, 2/3, .2)): with self.subTest(source=source): dto = self.view("statistics", {"stage_id": "0101", "level": "3", "source": source}) row = next(row for row in dto["rows"] if row["id"] == "item:30005") self.assertEqual((row["samples"], row["units"]), (samples, units)) self.assertAlmostEqual(row["rate"], rate) self.assertAlmostEqual(row["per_stamina"], efficiency) self.assertTrue(row["interval"]) point = next(point for point in dto["charts"][0]["series"] if point["id"] == row["id"]) self.assertAlmostEqual(point["value"], rate) dto = self.view("statistics", {"stage_id": "0101", "level": "3", "metric": "per_stamina"}) point = next(point for point in dto["chart"]["series"] if point["id"] == "item:30005") self.assertAlmostEqual(point["value"], .2) def test_dto_egg_edit_autosaves_and_restart_preserves_explicit_execution_request(self): config, row = self.hatch_config() column = next(column for column in self.view("bag")["columns"] if column["key"] == "enabled") self.assertEqual([row["id"] if part == "{id}" else part for part in column["edit"]["path"]], row["rule_path"] + ["enabled"]) applied = self.save(config) engine = self.manager._worker(self.account).engine self.assertEqual(engine.policy.egg_rules[row["id"]]["priority"], 13) plans = engine.plans() self.assertTrue(plans) self.assertTrue(all(plan.kind == "hatch" for plan in plans)) self.assertTrue(all(plan.payload["eggs"][0]["itemId"] in row["inventory_ids"] for plan in plans)) preview = self.view("plans") self.assertTrue(preview["rows"]) self.assertFalse(engine.auto) self.action("start") self.assertTrue(self.manager.status(self.account)["running"]) self.manager.close() from ranch_web.service import WebManager self.manager = WebManager(self.root, start_scheduler=False, engine_factory=real_engine_factory, login_factory=self.login) self.app.state.manager = self.manager self.wait_idle() self.assertEqual(self.config(), applied) state = self.manager.status(self.account) self.assertTrue(state["running"]) self.assertTrue(state["strategy_requested"]) self.assertFalse(state["manual_stop"]) self.assertFalse(self.manager._worker(self.account).engine.auto) def test_same_species_config_and_catalog_overrides_are_independent_between_accounts(self): other = self.create_account(label="account B") first, row = self.hatch_config() second, other_row = self.hatch_config(other, enabled=False, priority=91) self.assertEqual(row["id"], other_row["id"]) first["overrides"] = {row["id"]: {"sell_money": 123456}} self.save(first) self.save(second, other) engine_a, engine_b = (self.manager._worker(a).engine for a in (self.account, other)) self.assertIsNot(engine_a.catalog, engine_b.catalog) self.assertEqual(engine_a.catalog.monster(row["id"])["sell_money"], 123456) self.assertNotEqual(engine_b.catalog.monster(row["id"])["sell_money"], 123456) self.assertTrue(engine_a.plans()) self.assertEqual(engine_b.plans(), []) self.assertEqual(next(r for r in self.view("bag", account=other)["rows"] if r["id"] == row["id"])["priority"], 91) def test_http_reads_with_running_real_engine_do_not_dispatch_game_writes(self): account, client = self.logged_account() config, _ = self.hatch_config(account) self.save(config, account) self.action("start", account=account) reads = client.reads before = deepcopy(client.raw) for page in PAGES: self.view(page, account=account) self.response(self.http.get(self.path("status", account))) self.assertEqual(client.writes, []) self.assertEqual(client.reads, reads) self.assertEqual(client.raw, before) self.assertTrue(self.manager.status(account)["running"]) def test_blocked_game_job_keeps_http_cached_views_and_other_account_available(self): account, client = self.logged_account() cached = self.view("bag", account=account) gate = client.gate = SnapshotGate() self.stack.callback(gate.release.set) refresh = self.response(self.http.post(self.path("actions/refresh", account), json={"page": "incubator"}), 202) self.assertTrue(gate.entered.wait(3)) for endpoint in ("/api/health", "/api/meta", self.path("status", account), self.path("logs", account), self.path("config", account), self.path("views/bag", account), self.path("views/mainline", account)): with self.subTest(endpoint=endpoint): start = time.monotonic() result = self.response(self.http.get(endpoint)) self.assertLess(time.monotonic() - start, 1.5, endpoint) self.assertFalse(gate.release.is_set()) if endpoint.endswith("views/bag"): self.assertEqual(result["data"], cached) self.assertEqual(self.manager.job(account, refresh["id"])["status"], "running") self.assertTrue(self.view("bag")["rows"]) old = self.config(account) config = deepcopy(old["config"]) config["interval"] = 60 pending = self.response(self.http.put(self.path("config", account), json={"config": config, "revision": old["revision"]}), 202) self.assertTrue(pending["pending"]) self.assertEqual(pending["revision"], old["revision"]) self.assertEqual(self.config(account), old) gate.release.set() self.job(refresh, account) self.job(pending["job"], account) self.assertEqual(self.config(account)["config"]["interval"], 60) def test_stop_cancels_queued_start_without_later_resurrection(self): account, client = self.logged_account() config, _ = self.hatch_config(account) self.save(config, account) gate = client.gate = SnapshotGate() self.stack.callback(gate.release.set) refresh = self.response(self.http.post(self.path("actions/refresh", account), json={}), 202) self.assertTrue(gate.entered.wait(3)) start = self.response(self.http.post(self.path("actions/start", account), json={}), 202) self.assertEqual(self.manager.job(account, start["id"])["status"], "queued") begin = time.monotonic() stop = self.response(self.http.post(self.path("actions/stop", account), json={}), 202) self.assertLess(time.monotonic() - begin, 1.5) self.assertEqual(stop["status"], "succeeded") self.assertFalse(self.manager.status(account)["running"]) self.assertFalse(self.manager._worker(account).engine.auto) self.job(start, account, "cancelled") gate.release.set() self.job(refresh, account) self.wait_idle(account) self.assertFalse(self.manager.status(account)["running"]) self.assertFalse(self.manager._worker(account).engine.auto) self.assertEqual(client.writes, []) def test_legacy_schema_one_import_preserves_execution_request_without_inline_writes(self): from ranch_assistant.model import Policy from ranch_assistant.policy_io import portable_policy config, row = self.hatch_config() self.save(config) self.action("start") engine = self.manager._worker(self.account).engine bundle = portable_policy(Policy(**config["policy"]), engine.snapshot) self.assertEqual((bundle["schema"], bundle["assistantVersion"]), (1, "1.2.0")) bundle["policy"].update(enabled=True, fill=True) before = deepcopy(engine.snapshot.raw) value = self.response(self.http.post(self.path("config/import"), json={"config": bundle}), 202) self.job(value) state = self.manager.status(self.account) self.assertTrue(state["running"]) self.assertTrue(state["strategy_requested"]) self.assertFalse(state["manual_stop"]) self.assertFalse(engine.auto) self.assertEqual(engine.snapshot.raw, before) self.assertTrue(self.config()["config"]["policy"]["egg_rules"][row["id"]]["enabled"]) self.action("stop") self.job(self.response(self.http.post(self.path("config/import"), json={"config": bundle}), 202)) state = self.manager.status(self.account) self.assertFalse(state["running"]) self.assertFalse(state["strategy_requested"]) self.assertTrue(state["manual_stop"]) self.assertFalse(engine.auto) self.assertEqual(engine.snapshot.raw, before) exported = self.job(self.response(self.http.get(self.path("config/export")), 202))["result"] self.assertEqual(exported["schema"], 2) self.assertEqual(exported["format"], "ranch-helper-policies") def test_yield_csv_import_is_saved_and_changes_real_view(self): row = self.view("bag")["rows"][0] content = f"typeId,sell_money,sell_exp,time_total\n{row['id']},7777,123,600\n".encode() result = self.action("import_yields", {"filename": "uploaded.csv", "content_base64": base64.b64encode(content).decode()})["result"] self.assertEqual(result["count"], 1) self.assertEqual(self.config()["config"]["overrides"][row["id"]]["sell_money"], 7777) view = self.view("yields", {"search": row["id"]}) self.assertEqual(next(r for r in view["rows"] if r["id"] == row["id"])["sell_money"], 7777) def test_http_manual_lock_sell_and_feed_confirmations_reach_real_engine(self): engine = self.manager._worker(self.account).engine self.action("lock", {"monster_ids": [101]}) self.assertTrue(engine.snapshot.monsters[101]["lock"]) self.action("unlock", {"monster_ids": [101]}) self.assertFalse(engine.snapshot.monsters[101]["lock"]) before = deepcopy(engine.snapshot.raw) self.action("sell", {"monster_ids": [101]}, expected="failed") self.assertEqual(engine.snapshot.raw, before) self.action("sell", {"monster_ids": [101], "confirm": True}) self.assertNotIn(101, engine.snapshot.monsters) self.action("feed", {"monster_ids": [102], "target_id": 900}, expected="failed") self.assertIn(102, engine.snapshot.monsters) self.action("feed", {"monster_ids": [102], "target_id": 900, "confirm": True}) self.assertNotIn(102, engine.snapshot.monsters) self.assertIn(900, engine.snapshot.monsters) self.action("sell", {"monster_ids": [900], "confirm": True}, expected="failed") self.assertIn(900, engine.snapshot.monsters) self.assertFalse(self.manager.status(self.account)["running"]) def test_http_expansion_quote_is_confirmed_once_and_bound_to_account(self): other = self.create_account(label="quote scope") quote = self.action("quote_expansion", {"kind": "stack", "currency": "money", "position": 6})["result"] self.assertGreater(quote["cost"], 0) before = self.manager._worker(self.account).engine.snapshot.raw["master"]["money"] self.action("expand", {"quote_id": quote["quote_id"], "confirm": True}, other, expected="failed") self.action("expand", {"quote_id": quote["quote_id"]}, expected="failed") self.assertEqual(self.manager._worker(self.account).engine.snapshot.raw["master"]["money"], before) self.action("expand", {"quote_id": quote["quote_id"], "confirm": True}) engine = self.manager._worker(self.account).engine self.assertEqual(engine.snapshot.raw["master"]["money"], before - quote["cost"]) self.assertTrue(any(row["position"] == 6 for row in engine.snapshot.raw["stacks"])) self.assertEqual(self.response(self.http.get(self.path("status")))["player"]["money"], before - quote["cost"]) self.action("expand", {"quote_id": quote["quote_id"], "confirm": True}, expected="failed") self.assertEqual(engine.snapshot.raw["master"]["money"], before - quote["cost"]) def test_local_auth_host_csrf_and_remote_client_boundary(self): from fastapi.testclient import TestClient before = self.response(self.http.get("/api/accounts")) invalid_host = self.response(self.http.post("/api/accounts", json={"demo": True}, headers={"Host": "rebind.invalid"}), 400) self.assertEqual(invalid_host["error"]["code"], "invalid_host") for headers in ({"Origin": "https://cross-site.invalid"}, {"Sec-Fetch-Site": "cross-site"}): self.response(self.http.post("/api/accounts", json={"demo": True}, headers=headers), 403) self.assertEqual(self.response(self.http.get("/api/accounts")), before) self.response(self.http.post("/api/accounts", json={"demo": True}, headers={"Origin": "http://127.0.0.1:8765", "Sec-Fetch-Site": "same-origin"}), 201) with TestClient(self.app, base_url="http://127.0.0.1:8765", client=("203.0.113.2", 51234)) as remote: self.response(remote.get("/api/accounts", headers={"X-Forwarded-For": "127.0.0.1", "X-Forwarded-Host": "localhost"}), 403) def test_password_auth_cookie_revocation_and_cross_site_login(self): from fastapi.testclient import TestClient from ranch_web.app import create_app from ranch_web.config import COOKIE_NAME, WebConfig app = create_app(manager=self.manager, updates=self.updates, config=WebConfig(data_dir=self.root, password="integration-admin-password")) with TestClient(app, base_url="http://127.0.0.1:8765", client=("127.0.0.1", 50001)) as http: self.response(http.get("/api/accounts"), 401) self.response(http.post("/api/auth/login", json={"password": "wrong"}), 401) self.response(http.post("/api/auth/login", json={"password": "integration-admin-password"}, headers={"Origin": "https://cross-site.invalid"}), 403) response = http.post("/api/auth/login", json={"password": "integration-admin-password"}) self.response(response) self.assertIn("httponly", response.headers["set-cookie"].lower()) self.assertIn("samesite=strict", response.headers["set-cookie"].lower()) token = http.cookies.get(COOKIE_NAME) self.assertTrue(token) self.assertNotIn("integration-admin-password", token) self.response(http.get("/api/accounts")) self.response(http.post("/api/auth/logout")) self.response(http.get("/api/accounts", headers={"Cookie": COOKIE_NAME + "=" + token}), 401) def assert_no_secrets(self, value): encoded = json.dumps(value, ensure_ascii=False) for secret in (TOKEN, KEY, PASSWORD, str(REQID), str(REQSID), str(self.root), self.root.as_posix()): self.assertNotIn(secret, encoded) self.assertNotIn("Traceback (most recent call last)", encoded) def test_game_credentials_are_absent_from_http_views_config_jobs_and_logs(self): account, client = self.logged_account() for page in PAGES: self.assert_no_secrets(self.view(page, account=account)) for suffix in ("status", "config", "logs", "logs?debug=true"): self.assert_no_secrets(self.response(self.http.get(self.path(suffix, account)))) self.assert_no_secrets(self.action("export_config", account=account)) client.fail_snapshot = True failed = self.action("refresh", account=account, expected="failed") self.assert_no_secrets(failed) self.assert_no_secrets(self.response(self.http.get(self.path("logs?debug=true", account)))) self.assert_no_secrets(self.response(self.http.get(self.path("status", account)))) def test_lazy_log_detail_is_available_and_keeps_structure_with_secrets_masked(self): account, _ = self.logged_account() logs = self.response(self.http.get(self.path("logs?debug=true", account))) entries = [entry for entry in logs["entries"] if entry.get("details_available")] self.assertTrue(entries, logs) self.assertTrue(all("body" not in entry and "details" not in entry for entry in logs["entries"])) detail = self.response(self.http.get(self.path("logs/" + str(entries[-1]["id"]), account))) self.assert_no_secrets(detail) self.assertIn("integration-readable-detail", json.dumps(detail)) self.assertIn("body", json.dumps(detail)) def test_updates_use_fake_source_and_no_stable_v2_means_no_upgrade(self): self.response(self.http.get("/api/meta")) self.response(self.http.get("/api/system/updates")) self.source.assert_not_called() for releases in ([], [{"tag_name": "v1.2.0", "draft": False, "prerelease": False}], [{"tag_name": "v2.0.0.dev1", "draft": False, "prerelease": True}, {"tag_name": "v2.0.0", "draft": True, "prerelease": False}, {"tag_name": "v3.0.0", "draft": False, "prerelease": False}]): self.source.return_value = releases result = self.response(self.http.post("/api/system/updates/check")) self.assertFalse(result["available"]) self.assertIsNone(result["latest_version"]) self.assertEqual(result["status"], "no_release") self.assertEqual(self.source.call_count, 3) result = self.response(self.http.post("/api/system/updates/apply", json={}), 202) self.assertEqual(result["status"], "unavailable") self.assertFalse((self.root / "update-request.json").exists()) def test_config_revisions_and_invalid_input_are_atomic(self): old = self.config() value = deepcopy(old["config"]) value["interval"] = 60 applied = self.save(value) self.response(self.http.put(self.path("config"), json={"config": old["config"], "revision": old["revision"]}), 409) bad = deepcopy(value) bad["policy"]["egg_rules"] = {"1001010": {"enabled": "false"}} self.response(self.http.put(self.path("config"), json={"config": bad, "revision": applied["revision"]}), 400) self.assertEqual(self.config(), applied) self.response(self.http.post(self.path("actions/import_yields"), json={"path": "C:/private/account.csv"}), 400) def _page_test(page): def check(self): self.assert_dto(page) check.__name__ = "test_page_" + page return check for _page in PAGES: setattr(WebIntegrationTests, "test_page_" + _page, _page_test(_page)) class FreshProcessIntegrationTests(unittest.TestCase): def child(self, program): env = {key: value for key, value in os.environ.items() if not key.startswith("RANCH_WEB_")} env["PYTHONIOENCODING"] = "utf-8" result = subprocess.run([sys.executable, "-X", "utf8", "-c", textwrap.dedent(program)], cwd=ROOT, env=env, capture_output=True, text=True, encoding="utf-8", timeout=35, creationflags=getattr(subprocess, "CREATE_NO_WINDOW", 0)) self.assertEqual(result.returncode, 0, result.stdout + result.stderr) return json.loads(result.stdout.strip().splitlines()[-1]) def test_fresh_web_process_blocks_gui_imports_and_serves_demo_strategy(self): result = self.child(''' import importlib.abc, json, sys, tempfile, time from pathlib import Path attempted = [] class BlockGUI(importlib.abc.MetaPathFinder): def find_spec(self, fullname, path=None, target=None): if fullname.startswith('PySide6') or fullname.endswith('_gui') or fullname == 'ranch_assistant.gui': attempted.append(fullname) raise ImportError('GUI import blocked in fresh Web integration process') sys.meta_path.insert(0, BlockGUI()) from ranch_web.tests.test_web_integration import NoExternalSockets, real_engine_factory from ranch_web.app import create_app from ranch_web.config import WebConfig from ranch_web.service import WebManager from fastapi.testclient import TestClient with NoExternalSockets() as network, tempfile.TemporaryDirectory(prefix='web-fresh-process-') as temporary: manager = WebManager(Path(temporary) / 'new-root', start_scheduler=False, engine_factory=real_engine_factory) try: app = create_app(manager=manager, config=WebConfig(data_dir=Path(temporary) / 'new-root')) with TestClient(app, base_url='http://127.0.0.1', client=('127.0.0.1', 50000)) as http: assert http.get('/api/health').json()['status'] == 'ok' account = http.post('/api/accounts', json={'demo': True}).json()['id'] value = http.get('/api/accounts/' + account + '/config').json() value['config']['interval'] = 60 saved = http.put('/api/accounts/' + account + '/config', json=value) assert saved.status_code in (200, 202), saved.text deadline = time.monotonic() + 8 while manager.status(account)['busy'] and time.monotonic() < deadline: time.sleep(.005) assert http.get('/api/accounts/' + account + '/config').json()['config']['interval'] == 60 assert http.get('/api/schema').status_code == 200 view = http.get('/api/accounts/' + account + '/views/bag').json() if view['loading']: deadline = time.monotonic() + 8 while manager.job(account, view['job_id'])['status'] not in ('succeeded', 'failed') and time.monotonic() < deadline: time.sleep(.005) bag = http.get('/api/accounts/' + account + '/views/bag').json()['data'] assert bag['rows'] and bag['columns'][0]['key'] assert not network.attempts finally: manager.close() assert not attempted, attempted assert not any(n.startswith('PySide6') for n in sys.modules) print(json.dumps({'health': 'ok', 'demo_rows': len(bag['rows']), 'interval': 60, 'blocked_import_attempts': attempted})) ''') self.assertEqual(result["blocked_import_attempts"], []) self.assertGreater(result["demo_rows"], 0) def test_real_engine_battle_worker_subprocess_still_runs_after_web_imports(self): result = self.child(''' import json, sys, tempfile from pathlib import Path from unittest.mock import patch import subprocess from ranch_web.app import create_app from ranch_web.service import WebManager from ranch_web.tests.test_web_integration import NoExternalSockets, real_engine_factory from ranch_assistant.battle_simulator import combat_tables from ranch_assistant.battle_quick import simulate_quick row = combat_tables()['monster_info']['1001010'] mon = {'id': 101, 'typeId': 1001010, 'level': 20, 'mode': 2, 'tpLevel': 0, 'feel': 0, 'upStar': 0, 'pAtk': 0, 'pDef': 0, 'pHp': 0, 'pDex': 0} for name in ('Atk', 'Def', 'Hp', 'Dex'): mon['g' + name] = (row[name.lower() + '_grow_min'] + row[name.lower() + '_grow_max']) / 2 enemy = {'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': []} request = {'context': 'ordinary_stage', 'seed': 0, 'team': 'teamA', 'battle_position': {'battleType': 'stage', 'stageId': 'fixture', 'stageLevel': '1'}, 'roster': {'master': {'level': 43}, 'monsters': [mon], 'teams': [{'teamName': 'teamA', 'monsters': [101]}], 'monsterAttributes': []}, 'original_data': {'battle': {'time': 30, 'winType': ['1'], 'loseType': ['1', '2'], 'controller': [], 'triggers': [], 'teams': [{'team': 2, 'numMax': 2, 'ap': 80, 'mons': [enemy]}], 'battleField': {'fieldMode': True, 'fieldName': 'default', 'mapAreas': [], 'mapObjects': []}}}} with NoExternalSockets() as network, tempfile.TemporaryDirectory(prefix='web-battle-process-') as temporary: manager = WebManager(Path(temporary) / 'new-root', start_scheduler=False, engine_factory=real_engine_factory) try: account = manager.create_account(demo=True)['id'] engine = manager._worker(account).engine engine._select_battle_runtime('experimental') with patch('subprocess.Popen', wraps=subprocess.Popen) as launch: result = engine.battles.runtime.run(request, timeout=15) assert launch.call_count == 1 assert 'ranch_assistant.battle_simulator' in launch.call_args.args[0] expected = simulate_quick(request) assert {k: v for k, v in result.items() if k != 'wall_time_ms'} == { k: v for k, v in expected.items() if k != 'wall_time_ms'}, result assert result['simulation_method'] == 'aggregate_hp_dps', result assert result['outcome'] == 'win', result assert not any(n.startswith('PySide6') or n == 'ranch_assistant.gui' or n.endswith('_gui') for n in sys.modules) assert not network.attempts print(json.dumps({'outcome': result['outcome'], 'execution_mode': result['execution_mode'], 'simulation_method': result['simulation_method'], 'real_worker_processes': launch.call_count})) finally: manager.close() ''') self.assertEqual(result["real_worker_processes"], 1) self.assertEqual(result["outcome"], "win") self.assertEqual(result["simulation_method"], "aggregate_hp_dps") if __name__ == "__main__": unittest.main()