Download tests/test_console_processes_safety.py from bryceweiner/fly-trader: direct link, hf CLI and curl.
- Browser
- Download file 32.1 kB
-
https://huggingface.co/bryceweiner/fly-trader/resolve/main/tests/test_console_processes_safety.py
- Command line
-
hf download hf://bryceweiner/fly-trader/tests/test_console_processes_safety.py
-
curl -L -o test_console_processes_safety.py https://huggingface.co/bryceweiner/fly-trader/resolve/main/tests/test_console_processes_safety.py
32.1 kB
| """The console's Processes and Safety & wallet pages (fly_trader/ui/api/processes.py, safety.py): worker start/stop and their | |
| refusals, the autostart map, the rails controls on a real circuit_state row, resets refused while an engine runs, the | |
| Kalshi key never shown and dormant Kalshi hidden, and real-money withdrawals: one send per dialog opening, one in flight per | |
| chain, every guard re-checked on the server (the Streamlit AppTest of tests/test_withdraw.py, ported).""" | |
| import json | |
| import threading | |
| import pytest | |
| from solders.keypair import Keypair | |
| from fly_trader import config | |
| from fly_trader.db.connection import transaction | |
| from fly_trader.ui import runtime | |
| LAM = config.LAMPORTS_PER_SOL | |
| KEY = "KEYID-SECRET-7f3a9c21-test" | |
| def _fresh(monkeypatch): | |
| """Each test starts with Kalshi dormant, RH off, empty caches and no withdrawal remembered.""" | |
| from fly_trader.ui.api import safety | |
| monkeypatch.setattr(config, "KALSHI_API_KEY_ID", ""); monkeypatch.setattr(config, "RH_ENABLED", False) | |
| safety.wallet_summary.cache_clear(); safety.withdraw_limits.cache_clear() | |
| safety._WD_USED.clear(); safety._WD_INFLIGHT.clear() | |
| yield | |
| safety.wallet_summary.cache_clear(); safety.withdraw_limits.cache_clear() | |
| safety._WD_USED.clear(); safety._WD_INFLIGHT.clear() | |
| def _max_id(table: str) -> int: | |
| with transaction() as conn: | |
| return int(conn.execute(f"SELECT COALESCE(max(id), 0) AS m FROM {table}").fetchone()["m"]) | |
| # ---------------------------------------------------------------- Processes | |
| def test_worker_cards_are_grouped_as_the_menu_and_without_dormant_kalshi(console, monkeypatch): | |
| d = console.topic("processes.workers").json() | |
| assert [g["title"] for g in d["groups"]] == ["Memecoins"] | |
| assert not any(w["name"].startswith("kalshi") for g in d["groups"] for w in g["workers"]) | |
| assert d["pid"] == console.sup.pid and d["observer"] is False and d["external"] == [] | |
| monkeypatch.setattr(config, "KALSHI_API_KEY_ID", KEY) | |
| console.sup.alive_set.add("runner") | |
| d = console.topic("processes.workers").json() | |
| assert [g["title"] for g in d["groups"]] == ["Memecoins", "Prediction markets"] | |
| runner = d["groups"][0]["workers"][0] | |
| assert runner["name"] == "runner" and runner["state"] == "running" and runner["alive"] | |
| assert KEY not in json.dumps(d) and KEY[:8] not in json.dumps(d) | |
| def test_start_and_stop_go_through_the_supervisor_and_refuse_what_the_buttons_disable(console, monkeypatch): | |
| sup = console.sup | |
| r = console.act("processes.start", {"name": "replay"}) | |
| assert r.status_code == 200 and sup.calls == [("start", "replay", "console")] | |
| r = console.act("processes.start", {"name": "replay"}) # already running | |
| assert r.status_code == 409 and "already running" in r.json()["error"] and len(sup.calls) == 1 | |
| r = console.act("processes.stop", {"name": "replay"}) | |
| assert r.status_code == 200 and sup.calls[-1] == ("request_stop", "replay") | |
| r = console.act("processes.stop", {"name": "train"}) # not running | |
| assert r.status_code == 409 and "not running" in r.json()["error"] and sup.calls[-1] == ("request_stop", "replay") | |
| assert console.act("processes.start", {"name": "nope"}).status_code == 400 | |
| assert console.act("processes.start", {"name": "kalshi_runner"}).status_code == 400 # dormant Kalshi: no card, no control | |
| monkeypatch.setattr(sup, "external", lambda: {"discover": {"pid": 4242, "started_at": None}}) | |
| r = console.act("processes.start", {"name": "discover"}) | |
| assert r.status_code == 409 and "pid 4242" in r.json()["error"] and ("start", "discover", "console") not in sup.calls | |
| monkeypatch.setattr(sup, "external", dict) | |
| def boom(name, started_by="console"): | |
| raise RuntimeError("cannot register discover: UniqueViolation") | |
| monkeypatch.setattr(sup, "start", boom) | |
| r = console.act("processes.start", {"name": "discover"}) | |
| assert r.status_code == 409 and "cannot register discover" in r.json()["error"] | |
| sup.alive_set.add("pumpstream") | |
| monkeypatch.setattr(sup, "status", lambda: {n: {"alive": n == "pumpstream", "started_at": None, "stopped_at": None, "error": None, | |
| "stopping": n == "pumpstream"} for n in sup.workers}) | |
| r = console.act("processes.stop", {"name": "pumpstream"}) # already stopping | |
| assert r.status_code == 409 and "already stopping" in r.json()["error"] | |
| def test_stop_external_refuses_without_one_and_calls_procs_stop(console, monkeypatch): | |
| from fly_trader.ops import procs | |
| stopped = [] | |
| monkeypatch.setattr(procs, "stop", lambda name, grace_s=30.0: stopped.append(name) or True) | |
| r = console.act("processes.stop_external", {"name": "runner"}) | |
| assert r.status_code == 409 and stopped == [] | |
| monkeypatch.setattr(console.sup, "external", lambda: {"runner": {"pid": 777, "started_at": None}}) | |
| d = console.topic("processes.workers").json() | |
| assert d["external"] == [{"name": "runner", "title": "Trading engine", "pid": 777, "started_at": None}] | |
| runner = d["groups"][0]["workers"][0] | |
| assert runner["external"] is True and runner["state"] == "external" and runner["ext_pid"] == 777 | |
| assert d["counts"]["external"] == 1 and d["counts"]["running"] == 0 and d["counts"]["total"] == len([w for g in d["groups"] for w in g["workers"]]) | |
| r = console.act("processes.stop_external", {"name": "runner"}) | |
| assert r.status_code == 200 and stopped == ["runner"] and "777" in r.json()["message"] | |
| def test_autostart_toggle_upserts_the_whole_map_and_records_it(console): | |
| with transaction() as conn: | |
| before = conn.execute("SELECT value FROM ui_settings WHERE key = 'autostart'").fetchone() | |
| ev0 = _max_id("events") | |
| try: | |
| with transaction() as conn: | |
| conn.execute("INSERT INTO ui_settings (key, value) VALUES ('autostart', %s) ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value", | |
| (json.dumps({"runner": True, "pumpstream": True}),)) | |
| assert console.act("processes.autostart", {"name": "discover", "on": True}).status_code == 200 | |
| assert console.act("processes.autostart", {"name": "runner", "on": False}).status_code == 200 | |
| with transaction() as conn: | |
| val = conn.execute("SELECT value FROM ui_settings WHERE key = 'autostart'").fetchone()["value"] | |
| ev = conn.execute("SELECT detail FROM events WHERE id > %s AND source = 'console' AND message = 'autostart changed' ORDER BY id", (ev0,)).fetchall() | |
| assert val == {"runner": False, "pumpstream": True, "discover": True} | |
| assert [e["detail"] for e in ev] == [{"runner": True, "pumpstream": True, "discover": True}, val] | |
| d = console.topic("processes.workers").json() | |
| cards = {w["name"]: w for g in d["groups"] for w in g["workers"]} | |
| assert cards["discover"]["autostart"] and not cards["runner"]["autostart"] and cards["pumpstream"]["autostart"] | |
| assert console.act("processes.autostart", {"name": "discover", "on": "yes"}).status_code == 400 | |
| assert console.act("processes.autostart", {"name": "kalshi_stream", "on": True}).status_code == 400 # dormant | |
| finally: | |
| with transaction() as conn: | |
| if before: | |
| conn.execute("UPDATE ui_settings SET value = %s WHERE key = 'autostart'", (json.dumps(before["value"]),)) | |
| else: | |
| conn.execute("DELETE FROM ui_settings WHERE key = 'autostart'") | |
| conn.execute("DELETE FROM events WHERE id > %s AND source = 'console' AND message = 'autostart changed'", (ev0,)) | |
| def test_activity_shows_the_last_12_log_lines_newest_first(console, monkeypatch): | |
| lines = [json.dumps({"ts": f"2026-10-16T12:00:{i:02d}.000Z", "level": "INFO", "msg": f"line {i}"}) for i in range(20)] + ["", "not json at all"] | |
| monkeypatch.setattr(console.sup, "log_tail", lambda name, n=60: "\n".join(lines)) | |
| d = console.topic("processes.activity", worker="runner").json() | |
| assert len(d["rows"]) == 12 and d["rows"][0] == {"time": "", "level": "", "what": "not json at all"} | |
| assert d["rows"][1] == {"time": "12:00:19", "level": "INFO", "what": "line 19"} and d["rows"][-1]["what"] == "line 9" | |
| assert console.topic("processes.activity", worker="evil").status_code == 400 | |
| def test_event_log_filters_by_level_and_falls_back_to_errors(console): | |
| ev0 = _max_id("events") | |
| with transaction() as conn: | |
| conn.execute("INSERT INTO events (level, source, message) VALUES ('warning', 'test_console_ps', 'a warning'), ('error', 'test_console_ps', 'an error')") | |
| try: | |
| def msgs(**p): | |
| return [r["message"] for r in console.topic("processes.events", **p).json()["rows"] if r["source"] == "test_console_ps"] | |
| assert msgs(levels=["warning", "error"]) == ["an error", "a warning"] | |
| assert msgs(levels=["warning"]) == ["a warning"] | |
| d = console.topic("processes.events", levels=[]).json() | |
| assert d["levels"] == ["error"] and "a warning" not in [r["message"] for r in d["rows"]] | |
| finally: | |
| with transaction() as conn: | |
| conn.execute("DELETE FROM events WHERE id > %s AND source = 'test_console_ps'", (ev0,)) | |
| def test_worker_counts_and_the_last_24_hours_of_events(console): | |
| console.sup.alive_set.update({"runner", "pumpstream"}) | |
| c = console.topic("processes.workers").json()["counts"] | |
| assert c["running"] == 2 and c["trade_up"] == 2 and c["stopped"] == c["total"] - 2 and c["crashed"] == 0 | |
| before = console.topic("processes.event_stats").json() | |
| ev0 = _max_id("events") | |
| with transaction() as conn: | |
| conn.execute("INSERT INTO events (level, source, message) VALUES ('warning', 'test_console_ps', 'w'), ('error', 'test_console_ps', 'e'), ('error', 'test_console_ps', 'e')") | |
| try: | |
| after = console.topic("processes.event_stats").json() | |
| assert len(after["hours"]) == 24 == len(after["error"]) == len(after["warning"]) | |
| assert after["levels"]["error"] - before["levels"]["error"] >= 2 and after["levels"]["warning"] - before["levels"]["warning"] >= 1 | |
| assert after["error"][-1] - before["error"][-1] >= 2 or after["error"][-2] >= 2 # in the current hour's bucket | |
| finally: | |
| with transaction() as conn: | |
| conn.execute("DELETE FROM events WHERE id > %s AND source = 'test_console_ps'", (ev0,)) | |
| def test_live_drawdown_is_read_against_each_circuits_kill_limit(console, monkeypatch): | |
| monkeypatch.setattr(config, "KILL_SWITCH_DRAWDOWN", 0.3) | |
| d = {b["id"]: b for b in console.topic("safety.live_books").json()["books"]} | |
| assert list(d) == [1] and d[1]["book"] == "live" and d[1]["limit"] == 0.3 | |
| with transaction() as conn: | |
| conn.execute("INSERT INTO wealth_marks (beat_id, book, ts, wealth, peak, drawdown, n_open) VALUES " | |
| "(-515151, 'live', '2100-01-02 00:00+00', 5.0, 5.0, 0.0, 1), (-515152, 'live', '2100-01-02 00:01+00', 4.4, 5.0, 0.12, 2)") | |
| try: | |
| b = console.topic("safety.live_books").json()["books"][0] | |
| assert b["wealth"] == 4.4 and b["peak"] == 5.0 and abs(b["drawdown"] - 0.12) < 1e-6 and b["n_open"] == 2 | |
| assert [p[1] for p in b["series"]][-2:] == [5.0, 4.4] | |
| monkeypatch.setattr(config, "RH_ENABLED", True); monkeypatch.setattr(config, "KALSHI_API_KEY_ID", KEY) | |
| books = {x["id"]: x for x in console.topic("safety.live_books").json()["books"]} | |
| assert list(books) == [1, 3, 2] and books[3]["book"] == "live_rh" and books[2]["unit"] == "USD" | |
| assert books[2]["limit"] == config.KALSHI_KILL_SWITCH_DRAWDOWN | |
| finally: | |
| with transaction() as conn: | |
| conn.execute("DELETE FROM wealth_marks WHERE beat_id IN (-515151, -515152)") | |
| def test_an_observer_refuses_every_worker_control_withdrawal_and_reset(console, monkeypatch): | |
| obs = runtime.Observer() | |
| monkeypatch.setattr(runtime, "sup", lambda: obs) | |
| for name, body in (("processes.start", {"name": "replay"}), ("processes.stop", {"name": "replay"}), ("processes.stop_external", {"name": "replay"}), | |
| ("processes.autostart", {"name": "replay", "on": True}), ("safety.reset_training", {}), ("safety.entries", {"circuit": 1, "paused": True}), | |
| ("safety.kill_clear", {"circuit": 1}), ("safety.circuit_reset", {"circuit": 1}), ("safety.clear_halt", {"circuit": 1, "book": "paper_selector"})): | |
| r = console.act(name, body) | |
| assert r.status_code == 409, name | |
| d = console.topic("processes.workers").json() | |
| assert d["observer"] is True | |
| assert console.topic("safety.rails").json()["observer"] is True and console.topic("safety.maintenance").json()["observer"] is True | |
| _withdraw_setup(monkeypatch, blockers=[]) | |
| r = console.act("safety.withdraw", {"chain": "sol", "to": DEST, "amount": 0.5, "opening": "observer-0001"}) | |
| assert r.status_code == 409 and "only observes" in r.json()["error"] | |
| # ---------------------------------------------------------------- rails | |
| def circuits(): | |
| """circuit_state rows 1..3 and the halts as they were, restored after; the circuit events the test wrote, removed.""" | |
| with transaction() as conn: | |
| rows = {r["id"]: dict(r) for r in conn.execute("SELECT * FROM circuit_state WHERE id IN (1, 2, 3)").fetchall()} | |
| for cid in (1, 2, 3): | |
| conn.execute("INSERT INTO circuit_state (id) VALUES (%s) ON CONFLICT DO NOTHING", (cid,)) | |
| conn.execute("UPDATE circuit_state SET fail_count = 0, tripped = false, kill_switch = false, kill_reason = NULL, entries_paused = false WHERE id = %s", (cid,)) | |
| ce0, ev0 = _max_id("circuit_events"), _max_id("events") | |
| def set_(cid, **kw): | |
| with transaction() as conn: | |
| conn.execute("UPDATE circuit_state SET " + ", ".join(f"{k} = %s" for k in kw) + " WHERE id = %s", (*kw.values(), cid)) | |
| def get(cid): | |
| with transaction() as conn: | |
| return dict(conn.execute("SELECT * FROM circuit_state WHERE id = %s", (cid,)).fetchone()) | |
| yield type("C", (), {"set": staticmethod(set_), "get": staticmethod(get)}) | |
| with transaction() as conn: | |
| for cid, r in rows.items(): | |
| conn.execute("UPDATE circuit_state SET fail_count = %s, tripped = %s, kill_switch = %s, kill_reason = %s, peak_wealth = %s, entries_paused = %s WHERE id = %s", | |
| (r["fail_count"], r["tripped"], r["kill_switch"], r["kill_reason"], r["peak_wealth"], r["entries_paused"], cid)) | |
| conn.execute("DELETE FROM book_state WHERE book IN ('paper_selector', 'paper_rh_fly', 'paper_kalshi_taker')") | |
| conn.execute("DELETE FROM circuit_events WHERE id > %s AND kind IN ('reset', 'paused', 'resumed', 'book_resumed')", (ce0,)) | |
| conn.execute("DELETE FROM events WHERE id > %s AND source = 'rails'", (ev0,)) | |
| def test_kill_switch_clear_is_refused_until_it_trips_then_rebases(console, circuits): | |
| r = console.act("safety.kill_clear", {"circuit": 1}) | |
| assert r.status_code == 409 and "not tripped" in r.json()["error"] | |
| circuits.set(1, kill_switch=True, kill_reason="wealth 3.0 SOL <= 0.70 x peak 5.0 SOL", peak_wealth=5.0, fail_count=2) | |
| d = console.topic("safety.rails").json()["circuits"][0] | |
| assert d["id"] == 1 and d["kill_switch"] and d["kill_reason"].startswith("wealth 3.0") | |
| r = console.act("safety.kill_clear", {"circuit": 1}) | |
| assert r.status_code == 200 and r.json()["message"] == "Kill switch cleared" | |
| c = circuits.get(1) | |
| assert not c["kill_switch"] and c["kill_reason"] is None and c["peak_wealth"] is None and c["fail_count"] == 0 | |
| assert console.act("safety.kill_clear", {"circuit": "1"}).status_code == 400 | |
| def test_circuit_reset_and_entries_pause_toggle(console, circuits): | |
| r = console.act("safety.circuit_reset", {"circuit": 1}) | |
| assert r.status_code == 409 and "nothing to reset" in r.json()["error"] | |
| circuits.set(1, fail_count=2) | |
| assert console.act("safety.circuit_reset", {"circuit": 1}).status_code == 200 and circuits.get(1)["fail_count"] == 0 | |
| assert console.act("safety.entries", {"circuit": 1, "paused": True}).status_code == 200 and circuits.get(1)["entries_paused"] | |
| assert console.topic("safety.rails").json()["circuits"][0]["entries_paused"] is True | |
| r = console.act("safety.entries", {"circuit": 1, "paused": True}) # a stale page: nothing changes | |
| assert r.status_code == 409 and "already paused" in r.json()["error"] | |
| assert console.act("safety.entries", {"circuit": 1, "paused": False}).status_code == 200 and not circuits.get(1)["entries_paused"] | |
| assert console.act("safety.entries", {"circuit": 1}).status_code == 400 | |
| def test_circuits_and_halts_follow_what_the_install_trades(console, circuits, monkeypatch): | |
| with transaction() as conn: | |
| for b in ("paper_selector", "paper_rh_fly", "paper_kalshi_taker"): | |
| conn.execute("INSERT INTO book_state (book, halted, reason) VALUES (%s, true, 'wealth below peak') ON CONFLICT (book) DO UPDATE SET halted = true", (b,)) | |
| d = console.topic("safety.rails").json()["circuits"] | |
| assert [c["id"] for c in d] == [1] and [b["book"] for b in d[0]["halted"]] == ["paper_selector"] | |
| for cid in (2, 3): # dormant Kalshi, RH off: not on the page, not controllable | |
| assert console.act("safety.entries", {"circuit": cid, "paused": True}).status_code == 400 | |
| r = console.act("safety.clear_halt", {"circuit": 1, "book": "paper_kalshi_taker"}) # not a book of circuit 1 | |
| assert r.status_code == 400 | |
| monkeypatch.setattr(config, "RH_ENABLED", True); monkeypatch.setattr(config, "KALSHI_API_KEY_ID", KEY) | |
| d = {c["id"]: c for c in console.topic("safety.rails").json()["circuits"]} | |
| assert list(d) == [1, 3, 2] and d[3]["section"] == "Robinhood Chain memecoins" and d[2]["title"] == "Kalshi trading rails" | |
| assert [b["book"] for b in d[3]["halted"]] == ["paper_rh_fly"] and [b["book"] for b in d[2]["halted"]] == ["paper_kalshi_taker"] | |
| assert console.act("safety.clear_halt", {"circuit": 3, "book": "paper_selector"}).status_code == 400 | |
| assert console.act("safety.clear_halt", {"circuit": 1, "book": "paper_selector"}).status_code == 200 | |
| r = console.act("safety.clear_halt", {"circuit": 1, "book": "paper_selector"}) | |
| assert r.status_code == 409 and "not halted" in r.json()["error"] | |
| assert console.act("safety.clear_halt", {"circuit": 2, "book": "paper_kalshi_taker"}).status_code == 200 | |
| # ---------------------------------------------------------------- maintenance | |
| def test_resets_are_refused_while_an_engine_runs(console, monkeypatch): | |
| from fly_trader.ops import reset | |
| from fly_trader.ui.api import safety | |
| calls = [] | |
| monkeypatch.setattr(reset, "reset_training_state", lambda reason="", archive=True: calls.append(("paper", reason)) or {"archived_to": "/tmp/a", "rows": {}}) | |
| monkeypatch.setattr(reset, "reset_kalshi_fly", lambda reason="", archive=True: calls.append(("kalshi", reason)) or {"archived_to": "/tmp/k", "rows": {}}) | |
| console.sup.alive_set.add("runner") | |
| assert console.topic("safety.maintenance").json()["runner_alive"] is True | |
| r = console.act("safety.reset_training") | |
| assert r.status_code == 409 and "Stop the trading engine first." == r.json()["error"] and calls == [] | |
| console.sup.alive_set.discard("runner") | |
| monkeypatch.setattr(safety, "runs_elsewhere", lambda name: "it runs outside the console (pid 99)" if name == "runner" else None) | |
| r = console.act("safety.reset_training") # a CLI runner, or another console's, counts too | |
| assert r.status_code == 409 and "pid 99" in r.json()["error"] and calls == [] | |
| monkeypatch.setattr(safety, "runs_elsewhere", lambda name: None) | |
| r = console.act("safety.reset_training") | |
| assert r.status_code == 200 and r.json()["message"] == "Archived to /tmp/a" and calls == [("paper", "console button")] | |
| assert console.act("safety.reset_kalshi_fly").status_code == 409 and len(calls) == 1 # dormant Kalshi | |
| monkeypatch.setattr(config, "KALSHI_API_KEY_ID", KEY) | |
| console.sup.alive_set.add("kalshi_runner") | |
| r = console.act("safety.reset_kalshi_fly") | |
| assert r.status_code == 409 and "Kalshi engine" in r.json()["error"] and len(calls) == 1 | |
| console.sup.alive_set.discard("kalshi_runner") | |
| assert console.act("safety.reset_kalshi_fly").status_code == 200 and calls[-1] == ("kalshi", "console button") | |
| with safety.no_reset(): # an engine never starts under a reset | |
| r = console.act("processes.start", {"name": "runner"}) | |
| assert r.status_code == 409 and "reset" in r.json()["error"] | |
| assert console.act("safety.reset_training").status_code == 409 | |
| assert ("start", "runner", "console") not in console.sup.calls and len(calls) == 2 | |
| # ---------------------------------------------------------------- Kalshi: the key never shown, dormant Kalshi hidden | |
| def _summary(chain, address, native, px): | |
| return {"chain": chain, "unit": "SOL" if chain == "sol" else "ETH", "address": address, "native": native, "error": None, "n_open": 0, | |
| "positions": 0.0, "marked_at": None, "price_usd": px, "price_at": None, "native_usd": native * px, "positions_usd": 0.0, "total_usd": native * px} | |
| def test_the_kalshi_key_id_never_appears_in_any_topic(console, monkeypatch): | |
| from fly_trader.ops import wallets | |
| monkeypatch.setattr(config, "KALSHI_API_KEY_ID", KEY); monkeypatch.setenv("KALSHI_API_KEY_ID", KEY) | |
| monkeypatch.setattr(wallets, "summary", lambda chain: _summary(chain, None, 0.0, 100.0)) | |
| monkeypatch.setattr(wallets, "address", lambda chain: None) | |
| acct = console.topic("safety.kalshi_account").json() | |
| assert acct["enabled"] is True and acct["key"] == "configured" | |
| assert "kalshi" in console.topic("safety.settings").json()["tables"] | |
| assert console.topic("safety.maintenance").json()["kalshi"] is True | |
| for name in ("safety.wallets", "safety.rails", "safety.settings", "safety.kalshi_account", "safety.maintenance", "safety.api_errors", | |
| "processes.workers", "processes.events"): | |
| text = console.topic(name).text | |
| assert KEY not in text and KEY[:8] not in text and KEY[:6] not in text, name | |
| def test_dormant_kalshi_leaves_no_trace_on_the_safety_page(console): | |
| assert console.topic("safety.kalshi_account").json() == {"enabled": False} | |
| assert list(console.topic("safety.settings").json()["tables"]) == ["sol"] | |
| assert [c["id"] for c in console.topic("safety.rails").json()["circuits"]] == [1] | |
| m = console.topic("safety.maintenance").json() | |
| assert m["kalshi"] is False and m["kalshi_runner_alive"] is False | |
| # ---------------------------------------------------------------- withdrawals (tests/test_withdraw.py's page test, ported) | |
| DEST = str(Keypair().pubkey()) | |
| LIM = {"balance": 2 * LAM, "fee": 5_000, "keep": 0, "n_open": 0, "max": 2 * LAM - 5_000, "to_balance": LAM} | |
| def _withdraw_setup(monkeypatch, blockers=None, sent=None, result=None): | |
| from fly_trader.ops import wallets | |
| monkeypatch.setattr(config, "FUNDING_ADDRESSES", [DEST]) | |
| if blockers is not None: | |
| monkeypatch.setattr(wallets, "withdraw_blockers", lambda chain: list(blockers)) | |
| monkeypatch.setattr(wallets, "summary", lambda chain: _summary(chain, "So1" + "1" * 40, 2.0, 100.0)) | |
| monkeypatch.setattr(wallets, "limits", lambda chain, dest: dict(LIM)) | |
| sent = sent if sent is not None else [] | |
| monkeypatch.setattr(wallets, "withdraw", lambda chain, amt, dest: sent.append((chain, amt, dest)) or (result or {"status": "confirmed", "tx": "sig1", "amount": amt, "to": dest})) | |
| return sent | |
| def test_safety_shows_both_wallets_in_usd_and_withdraw_is_blocked_without_a_funding_address(console, monkeypatch): | |
| from fly_trader.ops import wallets | |
| from fly_trader.ui.state import usd | |
| sol_addr = str(Keypair().pubkey()) | |
| fake = {"sol": _summary("sol", sol_addr, 2.0, 100.0), "rh": _summary("rh", "0x" + "ab" * 20, 0.5, 2600.0)} | |
| monkeypatch.setattr(config, "RH_ENABLED", True); monkeypatch.setattr(config, "FUNDING_ADDRESSES", []) | |
| monkeypatch.setattr(wallets, "summary", lambda chain: fake[chain]) | |
| monkeypatch.setattr(wallets, "address", lambda chain: fake[chain]["address"]) | |
| d = {c["chain"]: c for c in console.topic("safety.wallets").json()["chains"]} | |
| assert list(d) == ["sol", "rh"] and d["sol"]["name"] == "Solana" and d["rh"]["unit"] == "ETH" | |
| assert {usd(d["sol"]["summary"]["native_usd"]), usd(d["rh"]["summary"]["native_usd"])} == {"$200.00", "$1,300.00"} | |
| assert d["sol"]["explorer"] == f"https://solscan.io/account/{sol_addr}" | |
| assert any("FUNDING_ADDRESSES" in b for b in d["sol"]["blockers"]) # nowhere to send: Withdraw disabled | |
| p = console.topic("safety.withdraw_plan", chain="sol").json() | |
| assert p["destinations"] == [] and p["to"] is None | |
| r = console.act("safety.withdraw", {"chain": "sol", "to": DEST, "amount": 0.5, "opening": "dialog-000001"}) | |
| assert r.status_code == 409 and "FUNDING_ADDRESSES" in r.json()["error"] | |
| def test_the_dialog_plans_then_sends_exactly_once_per_opening(console, monkeypatch): | |
| sent = _withdraw_setup(monkeypatch, blockers=[]) | |
| p = console.topic("safety.withdraw_plan", chain="sol").json() | |
| assert p["destinations"] == [DEST] and p["to"] == DEST and p["why"] == "enter an amount" and not p["show_why"] and p["button"] == "Withdraw" | |
| assert p["everything_label"] == "Everything withdrawable: 1.999995 SOL" and p["placeholder"] == "at most 1.999995" | |
| p = console.topic("safety.withdraw_plan", chain="sol", to=DEST, amount=0.5).json() | |
| assert p["why"] is None and p["button"] == "Withdraw 0.500000 SOL" | |
| assert p["summary"] == f"Sends **0.500000 SOL** ($50.00) to `{DEST[:6]}…{DEST[-4:]}`; fee ≈ 0.000005 SOL." | |
| p = console.topic("safety.withdraw_plan", chain="sol", to=DEST, amount=5.0).json() | |
| assert p["show_why"] and "at most 1.999995 SOL" in p["why"] and p["button"] == "Withdraw" | |
| assert console.topic("safety.withdraw_plan", chain="sol", to="NotMine111").status_code == 400 | |
| assert sent == [] # planning never sends | |
| body = {"chain": "sol", "to": DEST, "amount": 0.5, "opening": "dialog-000002"} | |
| r = console.act("safety.withdraw", body) | |
| assert r.status_code == 200 and sent == [("sol", 0.5, DEST)] | |
| res = r.json()["result"] | |
| assert res["status"] == "confirmed" and res["tx"] == "sig1" and res["tx_url"] == "https://solscan.io/tx/sig1" and res["amount"] == 0.5 | |
| r = console.act("safety.withdraw", body) # the same opening clicked again: no second send | |
| assert r.status_code == 409 and "already sent" in r.json()["error"] and sent == [("sol", 0.5, DEST)] | |
| r = console.act("safety.withdraw", {"chain": "sol", "to": DEST, "all": True, "opening": "dialog-000003"}) | |
| assert r.status_code == 200 and sent[-1] == ("sol", None, DEST) # everything: wallets.withdraw(chain, None, to) | |
| def test_every_guard_is_checked_again_on_the_server(console, monkeypatch): | |
| from fly_trader.ops import wallets | |
| sent = _withdraw_setup(monkeypatch, blockers=["no bot key in this process (BOT_PRIVATE_KEY)"]) | |
| r = console.act("safety.withdraw", {"chain": "sol", "to": DEST, "amount": 0.5, "opening": "guard-000001"}) | |
| assert r.status_code == 409 and "no bot key" in r.json()["error"] | |
| monkeypatch.setattr(wallets, "withdraw_blockers", lambda chain: []) | |
| bad = [({"chain": "sol", "to": "NotMine111", "amount": 0.5}, 400), ({"chain": "sol", "to": DEST}, 400), # no amount never means everything | |
| ({"chain": "sol", "to": DEST, "amount": 0.5, "all": True}, 400), ({"chain": "sol", "to": DEST, "amount": -1}, 400), | |
| ({"chain": "sol", "to": DEST, "amount": "0.5"}, 400), ({"chain": "rh", "to": DEST, "amount": 0.5}, 400), # RH off | |
| ({"chain": "sol", "to": DEST, "amount": 0.5, "opening": "x"}, 400)] | |
| for i, (b, code) in enumerate(bad): | |
| r = console.act("safety.withdraw", {"opening": f"guard-bad-{i:04d}", **b}) | |
| assert r.status_code == code, (b, r.json()) | |
| r = console.act("safety.withdraw", {"chain": "sol", "to": DEST, "amount": 5.0, "opening": "guard-000002"}) # over the max: the fresh plan refuses | |
| assert r.status_code == 409 and "at most" in r.json()["error"] | |
| monkeypatch.setattr(wallets, "limits", lambda chain, dest: (_ for _ in ()).throw(TimeoutError("rpc down"))) | |
| r = console.act("safety.withdraw", {"chain": "sol", "to": DEST, "amount": 0.5, "opening": "guard-000003"}) | |
| assert r.status_code == 409 and "Cannot read the wallet" in r.json()["error"] | |
| assert sent == [] | |
| def test_refusals_and_unknown_outcomes_become_results(console, monkeypatch): | |
| from fly_trader.chain import withdraw as sw | |
| from fly_trader.ops import wallets | |
| _withdraw_setup(monkeypatch, blockers=[]) | |
| monkeypatch.setattr(wallets, "withdraw", lambda chain, amt, dest: (_ for _ in ()).throw(sw.WithdrawRefused("a swap is still in flight: try again in a minute"))) | |
| res = console.act("safety.withdraw", {"chain": "sol", "to": DEST, "amount": 0.5, "opening": "result-0001"}).json()["result"] | |
| assert res["status"] == "refused" and "swap is still in flight" in res["error"] | |
| monkeypatch.setattr(wallets, "withdraw", lambda chain, amt, dest: (_ for _ in ()).throw(RuntimeError("socket closed"))) | |
| res = console.act("safety.withdraw", {"chain": "sol", "to": DEST, "amount": 0.5, "opening": "result-0002"}).json()["result"] | |
| assert res["status"] == "error" and res["error"] == "RuntimeError: socket closed" | |
| monkeypatch.setattr(wallets, "withdraw", lambda chain, amt, dest: {"status": "pending", "tx": "sig9", "amount": amt, "to": dest}) | |
| res = console.act("safety.withdraw", {"chain": "sol", "to": DEST, "amount": 0.5, "opening": "result-0003"}).json()["result"] | |
| assert res["status"] == "pending" and res["tx_url"].endswith("/sig9") | |
| def test_one_withdrawal_per_chain_is_in_flight_at_a_time(console, monkeypatch): | |
| from fly_trader.ops import wallets | |
| from fly_trader.ui.api import safety | |
| _withdraw_setup(monkeypatch, blockers=[]) | |
| inside, release, sent = threading.Event(), threading.Event(), [] | |
| def slow(chain, amt, dest): | |
| sent.append((chain, amt, dest)); inside.set(); release.wait(10) | |
| return {"status": "confirmed", "tx": "sigA", "amount": amt, "to": dest} | |
| monkeypatch.setattr(wallets, "withdraw", slow) | |
| out = {} | |
| t = threading.Thread(target=lambda: out.update(first=safety.withdraw({"chain": "sol", "to": DEST, "amount": 0.5, "opening": "flight-0001"}))) | |
| t.start() | |
| assert inside.wait(10) | |
| r = console.act("safety.withdraw", {"chain": "sol", "to": DEST, "amount": 0.25, "opening": "flight-0002"}) # a second dialog, meanwhile | |
| assert r.status_code == 409 and "already in flight" in r.json()["error"] | |
| release.set(); t.join(10) | |
| assert out["first"]["result"]["status"] == "confirmed" and sent == [("sol", 0.5, DEST)] | |
| assert console.act("safety.withdraw", {"chain": "sol", "to": DEST, "amount": 0.25, "opening": "flight-0003"}).status_code == 200 | |
| assert len(sent) == 2 | |
| def test_a_withdrawal_drops_the_cached_balance(console, monkeypatch): | |
| from fly_trader.ops import wallets | |
| _withdraw_setup(monkeypatch, blockers=[]) | |
| reads = [] | |
| monkeypatch.setattr(wallets, "summary", lambda chain: reads.append(chain) or _summary(chain, "So1" + "1" * 40, 2.0, 100.0)) | |
| monkeypatch.setattr(wallets, "address", lambda chain: "So1" + "1" * 40) | |
| console.topic("safety.wallets"); console.topic("safety.wallets") | |
| assert reads == ["sol"] # cached 15 s | |
| assert console.act("safety.withdraw", {"chain": "sol", "to": DEST, "amount": 0.5, "opening": "cache-00001"}).status_code == 200 | |
| console.topic("safety.wallets") | |
| assert reads == ["sol", "sol"] | |