Add Web 2 workspace and controlled deployment updates

This commit is contained in:
AttilaNet
2026-11-10 16:33:14 +08:00
parent 7fe4c0ffdf
commit dbb31707ea
58 changed files with 11283 additions and 0 deletions
+595
View File
@@ -0,0 +1,595 @@
"""Account lifecycle/concurrency with temporary state and offline HTTP fakes."""
from copy import deepcopy
from dataclasses import replace
import json
from pathlib import Path
import subprocess
import sys
import tempfile
import threading
import time
from types import SimpleNamespace
import unittest
from unittest.mock import patch
from requests import Response
from requests.sessions import Session as HttpSession
from ranch_assistant.api import Client, Session, decode, encode
from ranch_assistant.engine import Engine, demo_snapshot
from ranch_assistant.model import Catalog
from ranch_web.service import RevisionConflict, WebManager
from ranch_web.store import session_identity
class FakeClient(Client):
catalog = Catalog()
calls = []
def __init__(self, session, trace=None):
super().__init__(session, trace=trace)
self.raw = deepcopy(demo_snapshot(self.catalog).raw)
role = session.role_id or 100 + (session.server_id or 1)
self.raw["master"].update(id=role, roleName="离线角色 " + str(role), level=1, exp=0, timeTi=int(time.time() * 1000))
for monster in self.raw["monsters"]:
monster.update(process=3, mode=2)
self.http.post = self._post
self.closed = False
def _post(self, url, data, **kwargs):
payload = decode(data, self.session.key)
self.calls.append((self.session.account_id, url, payload))
if url.endswith("masterService/masterQueryDetail"):
role = self.session.role_id or 100 + self.session.server_id
self.raw["master"].update(id=role, roleName="离线角色 " + str(role))
if url.endswith("monsterService/monsterLock"):
for monster in self.raw["monsters"]:
if monster["id"] == payload["monsterId"]:
monster["lock"] = payload["lock"]
return SimpleNamespace(status_code=200, content=encode(self.raw | {"resCode": 0}, self.session.key), headers={})
def close(self):
self.closed = True
super().close()
class FakeLogin:
client_factory = FakeClient
def __init__(self, catalog, device, *, trace=None):
self.catalog, self.device, self.trace = catalog, device, trace
def authenticate(self, account, password):
client = FakeClient(Session(token="synthetic-center-token", account_id=account,
account_name=account), trace=self.trace)
response = {"servers": [{"id": identifier, "serverName": "测试区 " + str(identifier),
"gameServerAddress": "https://offline.invalid/game/", "platform": "ANDROID"} for identifier in (1, 2)],
"masterInfos": [{"serverId": 1, "masterName": "离线角色 101"}],
"playerInfo": {"token": "synthetic-center-token"}}
return client, response, {"uid": account, "center_url": "https://offline.invalid/center/",
"channel": "DYD", "device_id": self.device}
class ServiceTests(unittest.TestCase):
def setUp(self):
self.temp = self.enterContext(tempfile.TemporaryDirectory(prefix="ranch-web-runtime-test-"))
self.root = Path(self.temp) / "web"
# Any unmocked requests call is an immediate test failure, never traffic.
self._http_request = HttpSession.request
self.enterContext(patch("requests.sessions.Session.request", side_effect=AssertionError("Live HTTP is forbidden")))
FakeClient.calls = []
self.manager = WebManager(self.root, start_scheduler=False, login_factory=FakeLogin)
self.addCleanup(self.manager.close)
def account(self, demo=True):
identifier = self.manager.create_account("测试页签", demo)["id"]
self.idle(identifier)
self.assertEqual(self.manager.status(identifier)["error"], "")
return identifier
def idle(self, identifier, timeout=10):
deadline = time.monotonic() + timeout
while time.monotonic() < deadline:
if not self.manager.status(identifier)["busy"]:
return
time.sleep(.005)
self.fail("Account did not become idle")
def job(self, identifier, job, *, status="succeeded"):
deadline = time.monotonic() + 10
while time.monotonic() < deadline:
result = self.manager.job(identifier, job["id"])
if result["status"] in {"succeeded", "failed", "cancelled"}:
self.assertEqual(result["status"], status, result)
self.idle(identifier)
return result
time.sleep(.005)
self.fail("Job did not complete")
def login(self, identifier, account="synthetic-owner", server=1):
login = self.job(identifier, self.manager.submit(identifier, "login",
{"account": account, "password": "synthetic-password", "remember": True}))
self.job(identifier, self.manager.submit(identifier, "enter_server", {"server_id": server}))
return login
def enable(self, identifier):
config = self.manager.get_config(identifier)
config["config"]["daily_policy"].update(enabled=True, selected=["gift"])
pending = self.manager.set_config(identifier, config["config"], config["revision"])
self.assertTrue(pending["pending"])
self.job(identifier, pending["job"])
def test_real_engine_demo_config_autosave_and_revision_conflict(self):
identifier = self.account()
self.assertIsInstance(self.manager._worker(identifier).engine, Engine)
self.assertEqual(self.manager.status(identifier)["player"]["name"], demo_snapshot(self.manager.catalog).raw["master"]["roleName"])
config = self.manager.get_config(identifier)
config["config"]["policy"]["keep_money"] = 2345
result = self.manager.set_config(identifier, config["config"], config["revision"])
self.assertEqual(result["revision"], 0)
self.job(identifier, result["job"])
self.assertEqual(self.manager.get_config(identifier)["config"]["policy"]["keep_money"], 2345)
self.assertEqual(self.manager._worker(identifier).engine.policy.keep_money, 2345)
with self.assertRaises(RevisionConflict):
self.manager.set_config(identifier, config["config"], 0)
def test_login_select_server_public_metadata_and_restart_restore(self):
identifier = self.account(False)
result = self.login(identifier)
public = json.dumps(result)
for secret in ("synthetic-password", "synthetic-center-token", "gameServerAddress", "center_url", "reqid"):
self.assertNotIn(secret, public)
self.assertEqual(result["result"]["servers"][0]["role_name"], "离线角色 101")
status = self.manager.status(identifier)
self.assertTrue(status["connected"])
self.assertFalse(status["demo"])
self.assertFalse(status["running"])
worker = self.manager._worker(identifier)
identity = worker.active_identity
before = worker.securestore.load(identity).reqid
self.enable(identifier)
self.job(identifier, self.manager.submit(identifier, "start"))
self.manager.close()
count = len(FakeClient.calls)
self.manager = WebManager(self.root, start_scheduler=False, login_factory=FakeLogin)
self.addCleanup(self.manager.close)
self.idle(identifier)
self.assertEqual(len(FakeClient.calls), count, "Restart issued an unsolicited request")
self.assertFalse(self.manager.status(identifier)["running"])
self.assertFalse(self.manager.status(identifier)["connected"])
self.assertTrue(self.manager.get_config(identifier)["config"]["daily_policy"]["enabled"])
self.job(identifier, self.manager.submit(identifier, "restore_session", {"session_id": identity}))
restored = self.manager._worker(identifier).securestore.load(identity)
self.assertGreater(restored.reqid, before)
self.assertFalse(self.manager.status(identifier)["running"])
def test_role_workspaces_do_not_copy_targets_or_other_profiles_overrides(self):
first, other = self.account(False), self.account()
self.login(first)
worker = self.manager._worker(first)
role_one = worker.state_root
config = self.manager.get_config(first)
config["config"]["policy"]["keep_money"] = 9876
config["config"]["overrides"] = {next(iter(worker.catalog.monsters)): {"sell_money": 123}}
self.job(first, self.manager.set_config(first, config["config"])["job"])
self.assertEqual(self.manager._worker(other).catalog.overrides, {})
self.manager.view(first, "incubator")
self.idle(first)
self.assertIsNotNone(self.manager.view(first, "incubator")["data"])
self.login(first, server=2)
self.assertNotEqual(worker.state_root, role_one)
self.assertIsNone(self.manager.view(first, "incubator")["data"], "Previous role view escaped the cache")
self.idle(first)
self.assertNotEqual(self.manager.get_config(first)["config"]["policy"]["keep_money"], 9876)
self.assertEqual(worker.catalog.overrides, {})
saved = next(row["session_id"] for row in worker.securestore.entries() if row["session_id"] != worker.active_identity)
self.job(first, self.manager.submit(first, "restore_session", {"session_id": saved}))
self.assertEqual(worker.state_root, role_one)
self.assertEqual(self.manager.get_config(first)["config"]["policy"]["keep_money"], 9876)
def test_duplicate_account_server_role_connection_is_refused(self):
first, second = self.account(False), self.account(False)
self.login(first)
self.job(second, self.manager.submit(second, "login", {"account": "synthetic-owner", "password": "synthetic-password"}))
result = self.job(second, self.manager.submit(second, "enter_server", {"server_id": 1}), status="failed")
self.assertIn("另一个", result["error"])
self.assertTrue(self.manager.status(first)["connected"])
self.assertFalse(self.manager.status(second)["connected"])
def test_stop_cancels_queued_start_and_consumer_but_not_read_only_jobs(self):
identifier = self.account()
self.enable(identifier)
entered, release = threading.Event(), threading.Event()
self.addCleanup(release.set)
calls = []
def action(worker, operation, payload):
calls.append(operation)
if payload.get("hold"):
entered.set()
release.wait(5)
return {"message": operation}
with patch("ranch_web.actions.execute_action", side_effect=action):
held = self.manager.submit(identifier, "refresh", {"hold": True})
self.assertTrue(entered.wait(2))
start = self.manager.submit(identifier, "start")
consumer = self.manager.submit(identifier, "consume_probe")
reader = self.manager.submit(identifier, "refresh")
stopped = self.manager.submit(identifier, "stop")
self.assertEqual(stopped["status"], "succeeded")
self.assertFalse(self.manager.status(identifier)["running"])
release.set()
self.job(identifier, held)
self.job(identifier, start, status="cancelled")
self.job(identifier, consumer, status="cancelled")
self.job(identifier, reader)
self.assertEqual(calls, ["refresh", "refresh"])
self.assertFalse(self.manager._worker(identifier).engine.auto)
self.assertTrue(self.manager._worker(identifier).engine._progression_cancel.is_set())
def test_policy_queued_before_stop_saves_without_reactivating(self):
identifier = self.account()
self.enable(identifier)
self.job(identifier, self.manager.submit(identifier, "start"))
entered, release = threading.Event(), threading.Event()
self.addCleanup(release.set)
def hold(worker, operation, payload):
entered.set()
release.wait(5)
return {}
with patch("ranch_web.actions.execute_action", side_effect=hold):
held = self.manager.submit(identifier, "refresh")
self.assertTrue(entered.wait(2))
config = self.manager.get_config(identifier)["config"]
config["policy"]["keep_money"] = 4567
pending = self.manager.set_config(identifier, config)
self.manager.submit(identifier, "stop")
release.set()
self.job(identifier, held)
self.job(identifier, pending["job"])
worker = self.manager._worker(identifier)
self.assertEqual(worker.engine.policy.keep_money, 4567)
self.assertFalse(worker.engine.auto)
self.assertTrue(worker.engine._progression_cancel.is_set())
self.assertFalse(worker.running)
def test_slow_account_does_not_block_other_account_status_or_cached_view(self):
first, second = self.account(), self.account()
self.manager.view(first, "incubator")
self.idle(first)
entered, release = threading.Event(), threading.Event()
self.addCleanup(release.set)
def action(worker, operation, payload):
if worker.id == first:
entered.set()
release.wait(5)
return {"message": "read"}
with patch("ranch_web.actions.execute_action", side_effect=action):
held = self.manager.submit(first, "refresh")
self.assertTrue(entered.wait(2))
started = time.monotonic()
self.assertTrue(self.manager.status(first)["busy"])
view = self.manager.view(first, "incubator")
self.assertIsNotNone(view["data"])
self.manager.logs(first)
self.assertLess(time.monotonic() - started, .2)
self.job(second, self.manager.submit(second, "refresh"))
self.assertTrue(self.manager.status(first)["busy"])
release.set()
self.job(first, held)
def test_worker_owned_manual_stop_preserves_confirmed_request(self):
identifier = self.account(False)
self.login(identifier)
worker = self.manager._worker(identifier)
monster = next(row for row in worker.engine.snapshot.raw["monsters"] if not row.get("lock"))
result = self.job(identifier, self.manager.submit(identifier, "lock", {"monster_ids": [monster["id"]]}))
self.assertTrue(worker.engine.snapshot.monsters[monster["id"]]["lock"])
self.assertIn("message", result["result"])
self.assertFalse(worker.running)
def test_enter_job_is_not_terminal_until_persistence_and_summary_are_published(self):
identifier = self.account(False)
self.job(identifier, self.manager.submit(identifier, "login", {"account": "synthetic-owner", "password": "synthetic-password"}))
worker = self.manager._worker(identifier)
entered, release = threading.Event(), threading.Event()
self.addCleanup(release.set)
original = worker._persist_session
def persist():
if worker.engine.client is not None:
entered.set()
release.wait(5)
return original()
with patch.object(worker, "_persist_session", side_effect=persist):
selected = self.manager.submit(identifier, "enter_server", {"server_id": 1})
self.assertTrue(entered.wait(2))
self.assertEqual(self.manager.job(identifier, selected["id"])["status"], "running")
release.set()
self.job(identifier, selected)
self.assertTrue(self.manager.status(identifier)["connected"])
def test_stop_between_manual_requests_prevents_remaining_dispatches(self):
identifier = self.account(False)
self.login(identifier)
worker = self.manager._worker(identifier)
client = worker.engine.client
ids = [row["id"] for row in worker.engine.snapshot.raw["monsters"] if not row.get("lock")][:2]
self.assertEqual(len(ids), 2)
entered, release = threading.Event(), threading.Event()
self.addCleanup(release.set)
original = client.http.post
def post(url, data, **kwargs):
value = original(url, data, **kwargs)
if url.endswith("monsterService/monsterLock"):
entered.set()
release.wait(5)
return value
with patch.object(client.http, "post", side_effect=post):
job = self.manager.submit(identifier, "lock", {"monster_ids": ids})
self.assertTrue(entered.wait(2))
self.manager.submit(identifier, "stop")
release.set()
self.job(identifier, job, status="cancelled")
locks = [call for call in FakeClient.calls if call[1].endswith("monsterService/monsterLock")]
self.assertEqual(len(locks), 1)
self.assertTrue(any(event["kind"] == "response" and event["operation"] == "monsterService/monsterLock"
for event in worker.trace.events), "Already-sent response evidence was discarded")
def test_stop_during_encoding_prevents_the_encoded_write_reaching_http(self):
identifier = self.account(False)
self.login(identifier)
worker = self.manager._worker(identifier)
monster = next(row for row in worker.engine.snapshot.raw["monsters"] if not row.get("lock"))
entered, release = threading.Event(), threading.Event()
self.addCleanup(release.set)
before = len(FakeClient.calls)
high_water = worker.securestore.load(worker.active_identity).reqid
def paused_encode(value, key):
encoded = encode(value, key)
if "monsterId" in value and "lock" in value:
entered.set()
if not release.wait(5):
raise AssertionError("Encoding gate was not released")
return encoded
with patch("ranch_assistant.api.encode", side_effect=paused_encode):
job = self.manager.submit(identifier, "lock", {"monster_ids": [monster["id"]]})
self.assertTrue(entered.wait(2))
stopped = self.manager.submit(identifier, "stop")
self.assertEqual(stopped["status"], "succeeded")
self.assertFalse(release.is_set())
release.set()
self.job(identifier, job, status="cancelled")
writes = sum(call[1].endswith("monsterService/monsterLock") for call in FakeClient.calls[before:])
self.assertEqual(writes, 0, "An encoded cancelled write reached HTTP")
self.assertGreater(worker.securestore.load(worker.active_identity).reqid, high_water)
def test_stop_during_requests_preparation_prevents_adapter_dispatch(self):
identifier = self.account(False)
self.login(identifier)
worker = self.manager._worker(identifier)
client = worker.engine.client
http = client.http
monster = next(row for row in worker.engine.snapshot.raw["monsters"] if not row.get("lock"))
entered, release = threading.Event(), threading.Event()
self.addCleanup(release.set)
original_prepare = http.prepare_request
before = len(FakeClient.calls)
def paused_prepare(request):
prepared = original_prepare(request)
if request.url.endswith("monsterService/monsterLock"):
entered.set()
if not release.wait(5):
raise AssertionError("Prepared-request gate was not released")
return prepared
def offline_send(request, **kwargs):
value = client._post(request.url, request.body)
response = Response()
response.status_code, response._content, response.headers = value.status_code, value.content, value.headers
response.url, response.request = request.url, request
return response
adapter = http.get_adapter("https://offline.invalid/")
# Exercise requests' real post -> request -> prepare -> send pipeline.
# The adapter stays fake; the class-wide live-HTTP prohibition stays on.
with patch.object(http, "post", HttpSession.post.__get__(http, HttpSession)), \
patch.object(http, "request", self._http_request.__get__(http, HttpSession)), \
patch.object(http, "prepare_request", side_effect=paused_prepare), \
patch.object(adapter, "send", side_effect=offline_send):
job = self.manager.submit(identifier, "lock", {"monster_ids": [monster["id"]]})
self.assertTrue(entered.wait(2))
started = time.monotonic()
self.manager.submit(identifier, "stop")
self.assertLess(time.monotonic() - started, .2)
release.set()
self.job(identifier, job, status="cancelled")
writes = sum(call[1].endswith("monsterService/monsterLock") for call in FakeClient.calls[before:])
self.assertEqual(writes, 0, "A prepared cancelled request reached the adapter")
def test_config_change_during_automatic_poll_keeps_execution_enabled(self):
identifier = self.account(False)
self.login(identifier)
self.enable(identifier)
self.job(identifier, self.manager.submit(identifier, "start"))
worker = self.manager._worker(identifier)
client = worker.engine.client
entered, release = threading.Event(), threading.Event()
self.addCleanup(release.set)
original = client.http.post
def paused_response(url, data, **kwargs):
response = original(url, data, **kwargs)
if url.endswith("masterService/masterQueryDetail"):
entered.set()
if not release.wait(5):
raise AssertionError("Snapshot response gate was not released")
return response
worker.engine.last_heartbeat = time.monotonic()
worker.schedule.next_poll = 0
with patch.object(client.http, "post", side_effect=paused_response):
worker.request_tick()
self.assertTrue(entered.wait(2))
self.assertTrue(worker.running)
config = self.manager.get_config(identifier)["config"]
config["policy"]["keep_money"] += 100
pending = self.manager.set_config(identifier, config)
self.assertTrue(worker.running)
release.set()
self.job(identifier, pending["job"])
self.assertTrue(self.manager.status(identifier)["running"], "Config cancellation disabled the execution switch")
self.assertTrue(worker.engine.auto)
self.assertEqual(worker.engine.policy.keep_money, config["policy"]["keep_money"])
def test_engine_pause_in_current_generation_still_disables_execution(self):
identifier = self.account()
self.enable(identifier)
self.job(identifier, self.manager.submit(identifier, "start"))
worker = self.manager._worker(identifier)
worker.schedule.next_poll = 0
def stopped_poll(**kwargs):
worker.engine.auto = False
return worker.engine.snapshot, [], "Engine paused after validation"
with patch.object(worker.engine, "poll", side_effect=stopped_poll):
worker.request_tick()
self.idle(identifier)
self.assertFalse(self.manager.status(identifier)["running"])
self.assertFalse(worker.engine.auto)
def test_view_task_indices_stay_bounded_after_many_filters_and_failure(self):
identifier = self.account()
worker = self.manager._worker(identifier)
for index in range(120):
view = self.manager.view(identifier, "incubator", {"search": str(index)})
self.job(identifier, {"id": view["job_id"]})
self.assertLessEqual(len(worker._views), 32)
self.assertLessEqual(len(worker._view_jobs), 32, "Completed view task indices grow with every filter")
self.assertFalse(self.manager.view(identifier, "incubator", {"search": "119"})["loading"])
with patch("ranch_web.views.build_view", side_effect=ValueError("synthetic view failure")):
view = self.manager.view(identifier, "incubator", {"search": "failed"})
self.job(identifier, {"id": view["job_id"]}, status="failed")
self.assertNotIn(("incubator", '{"search": "failed"}'), worker._view_jobs)
retry = self.manager.view(identifier, "incubator", {"search": "failed"})
self.job(identifier, {"id": retry["job_id"]})
self.assertFalse(self.manager.view(identifier, "incubator", {"search": "failed"})["loading"])
def test_failed_counter_save_blocks_http_and_a_repaired_store_can_retry(self):
identifier = self.account(False)
self.login(identifier)
worker = self.manager._worker(identifier)
before = len(FakeClient.calls)
with patch.object(worker.securestore, "save", side_effect=OSError("synthetic persistence failure")):
result = self.job(identifier, self.manager.submit(identifier, "refresh"), status="failed")
self.assertTrue(result["error"])
self.assertEqual(len(FakeClient.calls), before)
self.job(identifier, self.manager.submit(identifier, "refresh"))
self.assertGreater(len(FakeClient.calls), before)
def test_account_registry_failure_closes_worker_without_holding_manager_lock(self):
started = time.monotonic()
with patch.object(self.manager.store, "save_accounts", side_effect=OSError("registry unavailable")):
with self.assertRaisesRegex(OSError, "registry unavailable"):
self.manager.create_account()
self.assertLess(time.monotonic() - started, 2)
self.assertEqual(self.manager.list_accounts(), [])
def test_public_structural_keys_survive_but_real_secret_key_is_removed(self):
worker = self.manager._worker(self.account())
value = {name: [{"key": "binding", "label": "选项", "details": {"key": "secret-nested"}}]
for name in ("columns", "filters", "pages", "tabs", "form")}
value.update(key="secret-protocol", token="secret-token", reqid=17, raw={"hidden": True})
result = worker.public_json(value)
for name in ("columns", "filters", "pages", "tabs", "form"):
self.assertEqual(result[name][0]["key"], "binding")
self.assertNotIn("key", result[name][0]["details"])
self.assertNotIn("key", result)
self.assertNotIn("token", result)
self.assertNotIn("reqid", result)
self.assertNotIn("raw", result)
with self.assertRaises(ValueError):
worker.public_json(Session())
def test_debug_summaries_are_small_and_details_keep_redacted_body_headers(self):
identifier = self.account()
worker = self.manager._worker(identifier)
worker.trace.emit("response", "离线请求", headers={"Content-Type": "application/json", "Set-Cookie": "private-cookie"},
body={"monsters": [{"id": index, "name": "测试"} for index in range(80)],
"token": "private-token", "password": "private-password", "key": "private-key", "reqid": 187,
"file_path": str(worker.profile_root / "private.json")})
logs = self.manager.logs(identifier, debug=True)
entry = next(row for row in logs["entries"] if row["details_available"])
self.assertNotIn("body", entry)
self.assertLess(len(json.dumps(entry)), 1000)
details = self.manager.log_detail(identifier, entry["id"])["details"]
self.assertEqual(len(details["body"]["monsters"]), 80)
self.assertEqual(details["headers"]["Content-Type"], "application/json")
for field in ("token", "password", "key", "reqid"):
self.assertEqual(details["body"][field], "<隐藏>")
serialized = json.dumps(details)
for secret in ("private-cookie", "private-token", "private-password", "private-key", str(worker.profile_root)):
self.assertNotIn(secret, serialized)
for index in range(70):
worker.trace.emit("info", "entry", value=index)
with self.assertRaises(KeyError):
self.manager.debug_entry(identifier, entry["id"])
def test_shutdown_cancels_simulation_before_waiting_and_keeps_pending_evidence(self):
first, second = self.account(), self.account()
entered = threading.Event()
worker = self.manager._worker(first)
pending = worker.state_root / "uncertain-evidence.json"
pending.write_text('{"status":"unknown"}', encoding="utf-8")
def simulate(runtime, operation, payload):
entered.set()
runtime.engine._progression_cancel.wait(5)
runtime.check_intent()
return {}
with patch("ranch_web.actions.execute_action", side_effect=simulate):
job = self.manager.submit(first, "simulate_probe")
self.assertTrue(entered.wait(2))
started = time.monotonic()
self.manager.close()
self.assertLess(time.monotonic() - started, 1)
self.assertTrue(pending.exists())
self.assertEqual(self.manager.job(first, job["id"])["status"], "cancelled")
self.assertTrue(self.manager._worker(second)._closed.is_set())
def test_no_pyside_or_gui_import_is_required(self):
code = '''
import importlib.abc, sys, tempfile
class NoGui(importlib.abc.MetaPathFinder):
def find_spec(self, fullname, path=None, target=None):
if fullname.startswith("PySide6") or fullname.endswith("_gui") or fullname == "ranch_assistant.gui":
raise ImportError("GUI forbidden")
sys.meta_path.insert(0, NoGui())
from ranch_web.service import WebManager
with tempfile.TemporaryDirectory() as root:
manager = WebManager(root, start_scheduler=False)
manager.create_account(demo=True)
manager.close()
print("headless-ok")
'''
result = subprocess.run([sys.executable, "-c", code], cwd=Path(__file__).resolve().parents[2],
capture_output=True, text=True, timeout=15)
self.assertEqual(result.returncode, 0, result.stderr)
self.assertIn("headless-ok", result.stdout)
if __name__ == "__main__":
unittest.main()