davideandClaude Sonnet 5
6a857f0e07
Balance display: place_bet/request_withdrawal spend whole UTXOs and mark them spent at broadcast time, well before confirmation, so the confirmed-only balance could drop by far more than the amount actually moving. Add compute_pending_balance() (app/wallet/balance.py) to fold the unconfirmed change from in-flight bet/withdrawal PendingTransactions back in; GET /users/me now returns pending_balance_sats + has_pending, and the frontend shows it colored green (settled) or amber (still pending) instead of the confirmed-only figure. Round outcome display: the win/lose reveal and the "pagamento al vincitore in corso" status were fighting over the same UI slot, and the reveal broke across a page refresh. Now: - The round-status box (generic phase progress) and the personal win/lose box are independent and can both be visible at once. - The win/lose box only renders for users who actually played in that round (new user_played field on GET /rounds/current, via a new optional-auth dependency so the endpoint stays usable logged-out). - The reveal delay is anchored to the round's server-provided closes_at instead of a client-side "first seen" timestamp, so repeated reloads can't reset it, and the revealed result is persisted in localStorage so it survives a refresh even after the round has fully closed. - GET /users/me/last-round-result is a durable DB-backed backstop for players who miss the live window entirely (backgrounded tab, offline). Also hardens the frontend polling loop: call() now times out instead of hanging forever, and a session-epoch counter stops an in-flight request from a previous login from resurrecting a duplicate poll loop after logout. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
97 lines
3.4 KiB
Python
97 lines
3.4 KiB
Python
import pytest
|
|
from cryptography.fernet import Fernet
|
|
from httpx import ASGITransport, AsyncClient
|
|
|
|
from app.config import settings
|
|
|
|
|
|
@pytest.fixture
|
|
async def client(monkeypatch, tmp_path):
|
|
monkeypatch.setattr(settings, "database_url", f"sqlite+aiosqlite:///{tmp_path}/test.db")
|
|
monkeypatch.setattr(settings, "jwt_secret", "test-jwt-secret")
|
|
monkeypatch.setattr(settings, "xprv_encryption_key", Fernet.generate_key().decode())
|
|
monkeypatch.setattr(settings, "master_key_path", str(tmp_path / "master.xprv.enc"))
|
|
|
|
import app.wallet.hd as hd
|
|
|
|
hd._account_key = None
|
|
hd.generate_master_key()
|
|
|
|
from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
|
|
|
|
from app.db import base as db_base
|
|
|
|
import app.db.models # noqa: F401
|
|
|
|
db_base.engine = create_async_engine(settings.database_url)
|
|
db_base.AsyncSessionLocal = async_sessionmaker(db_base.engine, expire_on_commit=False)
|
|
|
|
from app.db import session as db_session
|
|
|
|
db_session.AsyncSessionLocal = db_base.AsyncSessionLocal
|
|
|
|
async with db_base.engine.begin() as conn:
|
|
await conn.run_sync(db_base.Base.metadata.create_all)
|
|
|
|
from fastapi import FastAPI
|
|
|
|
from app.api.routes.rounds import router as rounds_router
|
|
from app.auth.routes import router as auth_router
|
|
from app.electrum.listener import ElectrumListener
|
|
|
|
app = FastAPI()
|
|
app.include_router(auth_router)
|
|
app.include_router(rounds_router)
|
|
app.state.electrum_listener = ElectrumListener(lambda: None, db_base.AsyncSessionLocal)
|
|
|
|
transport = ASGITransport(app=app)
|
|
async with AsyncClient(transport=transport, base_url="http://test") as ac:
|
|
yield ac, db_base.AsyncSessionLocal
|
|
|
|
await db_base.engine.dispose()
|
|
|
|
|
|
async def _register(ac, username):
|
|
resp = await ac.post("/auth/register", json={"username": username, "password": "hunter2hunter"})
|
|
assert resp.status_code == 201
|
|
data = resp.json()
|
|
return data["access_token"], data["user_id"] if "user_id" in data else None
|
|
|
|
|
|
async def test_user_played_true_only_for_participants(client):
|
|
ac, session_factory = client
|
|
from app.db.models import Round, RoundConfig, RoundParticipant, User
|
|
|
|
player_token, _ = await _register(ac, "player")
|
|
spectator_token, _ = await _register(ac, "spectator")
|
|
|
|
async with session_factory() as session:
|
|
from sqlalchemy import select
|
|
|
|
session.add(RoundConfig(fee_address="pool-fee-address"))
|
|
player = (await session.scalars(select(User).where(User.username == "player"))).one()
|
|
round_ = Round(status="paying_out", winner_user_id=player.id, winner_amount_sats=123)
|
|
session.add(round_)
|
|
await session.flush()
|
|
session.add(
|
|
RoundParticipant(
|
|
round_id=round_.id,
|
|
user_id=player.id,
|
|
bet_amount_sats=1_000_000_000,
|
|
bet_txid="a" * 64,
|
|
)
|
|
)
|
|
await session.commit()
|
|
|
|
resp = await ac.get("/rounds/current", headers={"Authorization": f"Bearer {player_token}"})
|
|
assert resp.status_code == 200
|
|
assert resp.json()["user_played"] is True
|
|
|
|
resp = await ac.get("/rounds/current", headers={"Authorization": f"Bearer {spectator_token}"})
|
|
assert resp.status_code == 200
|
|
assert resp.json()["user_played"] is False
|
|
|
|
resp = await ac.get("/rounds/current") # no auth at all — logged-out chain-only view
|
|
assert resp.status_code == 200
|
|
assert resp.json()["user_played"] is False
|