"""Dashboard API endpoint tests over a real local HTTP server.""" import json import os import urllib.request import uuid from datetime import datetime import psycopg2 import pytest from api.main import DashboardState, serve_in_background from storage.event_schema import EventMode, SignalReadyEvent from storage.event_store import EventStore from tests.unit.test_trading_execution import FakeExecutor, make_service T0 = datetime(2026, 6, 11, 9, 45) @pytest.fixture(autouse=True) def _isolated_pg_schema(monkeypatch): """Pin every connection in this test to one throwaway schema, so the seed store and the dashboard's per-request stores share an ISOLATED database. Without this the file-path db_paths these tests pass fall through to the production ``public`` schema (the path is ignored under Postgres) — they'd read live data and pollute it with fixtures. The ``mem_`` prefix lets the session-scoped conftest cleanup catch any leak.""" schema = f"mem_{uuid.uuid4().hex[:12]}" monkeypatch.setenv("MOMENTUM_PG_SCHEMA", schema) yield url = os.environ.get("DATABASE_URL") if url: conn = psycopg2.connect(url) conn.autocommit = True conn.cursor().execute(f'DROP SCHEMA IF EXISTS "{schema}" CASCADE') conn.close() @pytest.fixture def server(tmp_path): db_path = str(tmp_path / "events.duckdb") # seed a ready signal store = EventStore(db_path) store.emit( SignalReadyEvent( timestamp=T0, mode=EventMode.PAPER, correlation_id="t", message="GOOD ready", symbol="GOOD", signal_type="bull_flag", confidence=0.9, signal_data={"entry_price": 14.0, "stop_loss_price": 13.45, "quality_score": 0.7}, ) ) service = make_service(store, FakeExecutor()) service.request_approvals_for_ready_signals() state = DashboardState(db_path, execution_service=service, execution_mode="alpaca_paper") httpd, _ = serve_in_background(state, host="127.0.0.1", port=0) base = f"http://127.0.0.1:{httpd.server_address[1]}" yield base, store httpd.shutdown() store.close() def get(base, path): with urllib.request.urlopen(base + path, timeout=5) as resp: return resp.status, json.loads(resp.read()) def post(base, path, body): request = urllib.request.Request( base + path, data=json.dumps(body).encode(), headers={"Content-Type": "application/json"}, method="POST", ) try: with urllib.request.urlopen(request, timeout=5) as resp: return resp.status, json.loads(resp.read()) except urllib.error.HTTPError as exc: return exc.code, json.loads(exc.read()) def test_snapshots_endpoint_shape(server): base, _ = server status, data = get(base, "/api/snapshots") assert status == 200 for key in ("execution_mode", "approval_queue", "ready_signals", "watch_states", "accounts", "positions", "orders", "order_lifecycle"): assert key in data assert data["execution_mode"] == "alpaca_paper" assert data["ready_signals"][0]["symbol"] == "GOOD" assert len(data["approval_queue"]) == 1 def test_approval_queue_endpoint(server): base, _ = server status, data = get(base, "/api/approval-queue") assert status == 200 assert data["approval_queue"][0]["symbol"] == "GOOD" def test_approve_endpoint_executes_and_clears_queue(server): base, _ = server _, data = get(base, "/api/approval-queue") order_id = data["approval_queue"][0]["order_id"] status, result = post(base, "/api/trading/approvals/approve", {"order_id": order_id}) assert status == 200 and result["ok"] _, after = get(base, "/api/approval-queue") assert after["approval_queue"] == [] def test_reject_endpoint(server): base, _ = server _, data = get(base, "/api/approval-queue") order_id = data["approval_queue"][0]["order_id"] status, result = post(base, "/api/trading/approvals/reject", {"order_id": order_id, "reason": "test"}) assert status == 200 and result["ok"] def test_approve_unknown_order_returns_400(server): base, _ = server status, result = post(base, "/api/trading/approvals/approve", {"order_id": "nope"}) assert status == 400 assert not result["ok"] def test_unknown_route_404(server): base, _ = server try: urllib.request.urlopen(base + "/api/nope", timeout=5) raised = False except urllib.error.HTTPError as exc: raised = exc.code == 404 assert raised def test_dashboard_html_served(server): base, _ = server with urllib.request.urlopen(base + "/", timeout=5) as resp: assert resp.status == 200 body = resp.read().decode() assert "Momentum" in body and "/api/snapshots" in body def test_actions_503_without_execution_service(tmp_path): state = DashboardState(str(tmp_path / "e.duckdb"), execution_service=None) httpd, _ = serve_in_background(state, host="127.0.0.1", port=0) base = f"http://127.0.0.1:{httpd.server_address[1]}" try: status, result = post(base, "/api/trading/exit-order", {"symbol": "GOOD"}) assert status == 503 assert not result["ok"] finally: httpd.shutdown() # --------------------------------------------------------------------------- # Interactive endpoints (SSE, criteria, bars, manual inject) + new snapshot keys # --------------------------------------------------------------------------- def test_snapshot_includes_pnl_and_fills(server): base, _ = server _, data = get(base, "/api/snapshots") assert "pnl" in data and "fills" in data and "has_execution" in data assert data["has_execution"] is True # pnl has the expected stat keys even with no closed trades yet for key in ("realized_pnl", "unrealized_pnl", "total_pnl", "win_rate", "open_positions", "closed_trades"): assert key in data["pnl"] def test_criteria_endpoint(tmp_path): from storage.event_schema import CriteriaEvaluatedEvent db_path = str(tmp_path / "crit.duckdb") store = EventStore(db_path) store.emit( CriteriaEvaluatedEvent( timestamp=T0, mode=EventMode.PAPER, message="c", symbol="GOOD", criteria_results={"passed": ["gap", "vwap"], "failed": ["impulse"]}, total_criteria=9, passed_criteria=2, success_score_pct=22.0, ) ) state = DashboardState(db_path, execution_mode="alpaca_paper") httpd, _ = serve_in_background(state, host="127.0.0.1", port=0) base = f"http://127.0.0.1:{httpd.server_address[1]}" try: status, data = get(base, "/api/criteria?symbol=GOOD") assert status == 200 assert data["symbol"] == "GOOD" assert data["score"] == 22.0 by_key = {c["key"]: c["passed"] for c in data["criteria"]} assert by_key["gap"] is True assert by_key["impulse"] is False finally: httpd.shutdown() store.close() def test_bars_endpoint_with_research_db(tmp_path): from research.ingestion.market_data import ( ingest_daily_history, ingest_live_minute_bars, ) from storage.db import get_connection from tests.integration.test_end_to_end import FakeAlpaca con = get_connection(":memory:") client = FakeAlpaca() ingest_daily_history(con, client, ["GOOD"]) ingest_live_minute_bars(con, client, ["GOOD"]) db_path = str(tmp_path / "bars.duckdb") EventStore(db_path).close() state = DashboardState(db_path, execution_mode="alpaca_paper", research_con=con) httpd, _ = serve_in_background(state, host="127.0.0.1", port=0) base = f"http://127.0.0.1:{httpd.server_address[1]}" try: status, data = get(base, "/api/bars?symbol=GOOD&minutes=40") assert status == 200 # falls back to the latest available session for the symbol assert len(data["bars"]) == 12 assert all("c" in b for b in data["bars"]) finally: httpd.shutdown() def test_bars_endpoint_no_research_db(server): base, _ = server status, data = get(base, "/api/bars?symbol=GOOD") assert status == 200 assert data["bars"] == [] def test_watch_add_endpoint(tmp_path): db_path = str(tmp_path / "watch.duckdb") EventStore(db_path).close() injected = [] state = DashboardState( db_path, execution_mode="alpaca_paper", watch_inject=lambda sym: injected.append(sym), ) httpd, _ = serve_in_background(state, host="127.0.0.1", port=0) base = f"http://127.0.0.1:{httpd.server_address[1]}" try: status, result = post(base, "/api/watch/add", {"symbol": "tsla"}) assert status == 200 and result["ok"] assert result["symbol"] == "TSLA" assert injected == ["TSLA"] finally: httpd.shutdown() def test_watch_add_503_without_inject(server): base, _ = server # this server has no watch_inject configured status, result = post(base, "/api/watch/add", {"symbol": "TSLA"}) assert status == 503 assert not result["ok"] def test_stream_delivers_snapshot_frame(server): base, _ = server # read the SSE stream until we see one snapshot event, then bail req = urllib.request.urlopen(base + "/api/stream", timeout=5) try: buf = b"" got = False for _ in range(50): line = req.readline() if not line: break buf += line if b"event: snapshot" in buf and buf.rstrip().endswith(b"}"): got = True break assert got, "no snapshot frame received from SSE stream" finally: req.close()