58c30b7273
First sub-project of the "make contact feel real" arc (spec: docs/superpowers/specs/2026-07-23-possession-presentation-design.md). Direct Contact replies now feel like a spirit fighting through static to hold the channel rather than a plain chat bubble: - backend/app/possession.py: compute_stability(rarity, magnitude, rng) — a 0.05-0.98 score per reply (rarer entity + stronger triggering anomaly = cleaner signal), rng injectable for a later quantum-RNG source. - ws.py sends stability on reply_start; audio synthesis for that reply gets noise/bitcrush scaled by instability (1 - stability) via a new instability param on synthesize_spirit_voice — effects.py itself is untouched, only the params fed into it. - frontend/src/lib/possession.ts: renderPossessedText — pure, deterministic (tick-seeded, no Math.random) text corruption with self-correcting glitch bursts, wired into Transcript.tsx's streaming reply display. Stored transcript/reply text is unaffected — this is presentation only. 78/78 backend, 137/137 frontend tests passing.
269 lines
10 KiB
Python
269 lines
10 KiB
Python
import asyncio
|
|
|
|
import pytest
|
|
from sqlalchemy import select
|
|
|
|
import app.ws
|
|
from app.entities import fallback_profile
|
|
from app.models.contact_session import ContactSession
|
|
from app.models.event import Event
|
|
from app.rate_limit import RateLimiter
|
|
|
|
|
|
class FakeSpiritService:
|
|
async def mint_profile(self, signature, channel, anomalies, language="en"):
|
|
return fallback_profile(signature)
|
|
|
|
async def fragment(self, source, anomaly, language="en"):
|
|
return "listen"
|
|
|
|
async def wire_whisper(self, telemetry, language="en"):
|
|
return "the wire hums"
|
|
|
|
def chat_stream(self, entity, question, history, language="en"):
|
|
async def gen():
|
|
for token in ["I ", "am ", "here."]:
|
|
yield token
|
|
|
|
return gen()
|
|
|
|
def ambient_ready(self):
|
|
return False
|
|
|
|
|
|
async def _fake_synth(text, voice, profile, instability=0.0):
|
|
return b"RIFFfake wav bytes"
|
|
|
|
|
|
@pytest.fixture(autouse=True)
|
|
def _fake_spirits(monkeypatch):
|
|
monkeypatch.setattr(app.ws, "spirit_service", FakeSpiritService())
|
|
monkeypatch.setattr(app.ws, "synthesize_spirit_voice", _fake_synth)
|
|
|
|
|
|
def _read_until(ws, msg_type, max_frames=30, **match):
|
|
for _ in range(max_frames):
|
|
frame = ws.receive_json()
|
|
if frame.get("type") != msg_type:
|
|
continue
|
|
if all(frame.get(key) == value for key, value in match.items()):
|
|
return frame
|
|
raise AssertionError(f"never saw frame of type {msg_type!r} matching {match!r}")
|
|
|
|
|
|
def _login(sync_client, username="wsmedium"):
|
|
sync_client.post("/auth/register", json={"username": username, "password": "spookyspooky"})
|
|
sync_client.post("/auth/login", json={"username": username, "password": "spookyspooky"})
|
|
return sync_client.cookies.get("qm_session")
|
|
|
|
|
|
def _ws_connect(sync_client, token):
|
|
# TestClient upgrades over ws:// (insecure), so the jar withholds the
|
|
# Secure qm_session cookie. Pass it explicitly — real browsers on https
|
|
# send it on the upgrade automatically.
|
|
return sync_client.websocket_connect(
|
|
"/ws/session", headers={"cookie": f"qm_session={token}"}
|
|
)
|
|
|
|
|
|
def test_websocket_requires_authentication(sync_client):
|
|
with pytest.raises(Exception):
|
|
with sync_client.websocket_connect("/ws/session"):
|
|
pass
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_websocket_ping_pong_and_session_lifecycle(sync_client, db_session):
|
|
_login(sync_client)
|
|
|
|
with _ws_connect(sync_client, sync_client.cookies.get("qm_session")) as ws:
|
|
_read_until(ws, "session")
|
|
ws.send_json({"type": "ping"})
|
|
assert _read_until(ws, "pong") == {"type": "pong"}
|
|
|
|
sessions = (await db_session.execute(select(ContactSession))).scalars().all()
|
|
assert len(sessions) == 1
|
|
assert sessions[0].ended_at is None
|
|
|
|
# The server marks the session ended in its disconnect handler; give the
|
|
# portal loop a moment to commit before asserting.
|
|
for _ in range(40):
|
|
await asyncio.sleep(0.05)
|
|
db_session.expire_all()
|
|
sessions = (await db_session.execute(select(ContactSession))).scalars().all()
|
|
if sessions[0].ended_at is not None:
|
|
break
|
|
assert sessions[0].ended_at is not None
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_summon_mints_entity_and_greets(sync_client, db_session):
|
|
_login(sync_client, "summoner")
|
|
|
|
with _ws_connect(sync_client, sync_client.cookies.get("qm_session")) as ws:
|
|
_read_until(ws, "session")
|
|
ws.send_json({"type": "summon"})
|
|
entity_frame = _read_until(ws, "entity")
|
|
assert entity_frame["is_new"] is True
|
|
assert entity_frame["entity"]["name"]
|
|
assert entity_frame["entity"]["rarity"] in ("common", "uncommon", "rare", "mythic")
|
|
assert entity_frame["entity"]["voice"]["voice_id"]
|
|
greeting = _read_until(ws, "utterance")
|
|
assert greeting["kind"] == "greeting"
|
|
assert greeting["text"]
|
|
|
|
sessions = (await db_session.execute(select(ContactSession))).scalars().all()
|
|
assert sessions[0].entity_id is not None
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_question_streams_reply_and_records_history(sync_client, db_session):
|
|
_login(sync_client, "seeker")
|
|
|
|
with _ws_connect(sync_client, sync_client.cookies.get("qm_session")) as ws:
|
|
_read_until(ws, "session")
|
|
ws.send_json({"type": "question", "text": "Are you at peace?"})
|
|
_read_until(ws, "entity") # auto-summoned before answering
|
|
reply_start = _read_until(ws, "reply_start")
|
|
assert 0.05 <= reply_start["stability"] <= 0.98
|
|
reply_end = _read_until(ws, "reply_end")
|
|
assert reply_end["text"] == "I am here."
|
|
|
|
events = (await db_session.execute(select(Event).order_by(Event.created_at))).scalars().all()
|
|
kinds = [event.kind for event in events]
|
|
assert "question" in kinds
|
|
assert "reply" in kinds
|
|
reply_event = next(event for event in events if event.kind == "reply")
|
|
assert reply_event.text == "I am here."
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_anomalies_attune_then_produce_fragments(sync_client):
|
|
_login(sync_client, "listener")
|
|
|
|
with _ws_connect(sync_client, sync_client.cookies.get("qm_session")) as ws:
|
|
_read_until(ws, "session")
|
|
for i in range(3):
|
|
ws.send_json(
|
|
{"type": "anomaly", "source": "radio", "frequency": 101.1 + i, "magnitude": 6.5}
|
|
)
|
|
entity_frame = _read_until(ws, "entity")
|
|
assert entity_frame["is_new"] is True
|
|
|
|
ws.send_json({"type": "anomaly", "source": "radio", "frequency": 104.0, "magnitude": 7.1})
|
|
fragment = _read_until(ws, "utterance", kind="fragment")
|
|
assert fragment["text"] == "listen"
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_same_signature_recontacts_same_entity(sync_client):
|
|
_login(sync_client, "mediumx")
|
|
anomalies = [
|
|
{"type": "anomaly", "source": "radio", "frequency": 101.0 + i, "magnitude": 5.0 + i}
|
|
for i in range(4)
|
|
]
|
|
|
|
with _ws_connect(sync_client, sync_client.cookies.get("qm_session")) as ws:
|
|
_read_until(ws, "session")
|
|
for anomaly in anomalies:
|
|
ws.send_json(anomaly)
|
|
first = _read_until(ws, "entity")["entity"]["name"]
|
|
|
|
with _ws_connect(sync_client, sync_client.cookies.get("qm_session")) as ws:
|
|
_read_until(ws, "session")
|
|
for anomaly in anomalies:
|
|
ws.send_json(anomaly)
|
|
second_frame = _read_until(ws, "entity")
|
|
assert second_frame["entity"]["name"] == first
|
|
assert second_frame["is_new"] is False
|
|
assert second_frame["entity"]["contact_count"] == 2
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_summon_rate_limited_per_account(sync_client, monkeypatch):
|
|
# Swap in a tight, test-scoped limiter so this doesn't depend on (or
|
|
# pollute) the shared module-level budget other tests draw from.
|
|
monkeypatch.setattr(
|
|
app.ws, "summon_limiter", RateLimiter(max_requests=2, window_seconds=60)
|
|
)
|
|
_login(sync_client, "account-limited")
|
|
|
|
with _ws_connect(sync_client, sync_client.cookies.get("qm_session")) as ws:
|
|
_read_until(ws, "session")
|
|
for _ in range(2):
|
|
ws.send_json({"type": "summon"})
|
|
_read_until(ws, "entity")
|
|
_read_until(ws, "utterance", kind="greeting")
|
|
|
|
ws.send_json({"type": "summon"})
|
|
rejection = _read_until(ws, "error")
|
|
assert rejection["code"] == "rate_limited"
|
|
assert rejection["message"] == (
|
|
"The veil is crowded. The spirits need a moment before another summoning."
|
|
)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_summon_rate_limited_per_ip_even_with_fresh_account(
|
|
sync_client, monkeypatch
|
|
):
|
|
# Starve only the IP bucket; the per-account limiter stays at its
|
|
# production default so each account below has plenty of its own budget
|
|
# left. This proves the IP limiter alone can reject a request — the
|
|
# gap the per-account-only limiters left open.
|
|
monkeypatch.setattr(
|
|
app.ws, "summon_ip_limiter", RateLimiter(max_requests=1, window_seconds=60)
|
|
)
|
|
|
|
_login(sync_client, "ip-limited-a")
|
|
with _ws_connect(sync_client, sync_client.cookies.get("qm_session")) as ws:
|
|
_read_until(ws, "session")
|
|
ws.send_json({"type": "summon"})
|
|
_read_until(ws, "entity") # spends the single per-IP slot
|
|
|
|
# A different account — its own per-account budget is untouched — but
|
|
# every connection in this test shares the same (simulated) source IP,
|
|
# which is already spent.
|
|
_login(sync_client, "ip-limited-b")
|
|
with _ws_connect(sync_client, sync_client.cookies.get("qm_session")) as ws:
|
|
_read_until(ws, "session")
|
|
ws.send_json({"type": "summon"})
|
|
rejection = _read_until(ws, "error")
|
|
assert rejection["code"] == "rate_limited"
|
|
assert rejection["message"] == (
|
|
"The veil is crowded. The spirits need a moment before another summoning."
|
|
)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_summon_per_ip_bucket_follows_cf_connecting_ip_not_socket_peer(
|
|
sync_client, monkeypatch
|
|
):
|
|
# Every connection in this test suite shares the same simulated socket
|
|
# peer (TestClient has no real network). Without preferring
|
|
# CF-Connecting-IP, distinct visitors behind the Cloudflare Tunnel would
|
|
# collapse into one shared per-IP bucket — this proves they don't.
|
|
monkeypatch.setattr(
|
|
app.ws, "summon_ip_limiter", RateLimiter(max_requests=1, window_seconds=60)
|
|
)
|
|
|
|
token_a = _login(sync_client, "cf-ip-a")
|
|
with sync_client.websocket_connect(
|
|
"/ws/session",
|
|
headers={"cookie": f"qm_session={token_a}", "cf-connecting-ip": "203.0.113.1"},
|
|
) as ws:
|
|
_read_until(ws, "session")
|
|
ws.send_json({"type": "summon"})
|
|
_read_until(ws, "entity") # spends visitor A's per-IP slot only
|
|
|
|
token_b = _login(sync_client, "cf-ip-b")
|
|
with sync_client.websocket_connect(
|
|
"/ws/session",
|
|
headers={"cookie": f"qm_session={token_b}", "cf-connecting-ip": "203.0.113.2"},
|
|
) as ws:
|
|
_read_until(ws, "session")
|
|
ws.send_json({"type": "summon"})
|
|
# A different visitor IP behind the same tunnel — must not be
|
|
# rejected by visitor A's already-spent bucket.
|
|
_read_until(ws, "entity")
|