davideandClaude Sonnet 5.5
7ba8e22bb4
pysqlite's legacy mode emitted BEGIN only at the first DML, so every read before it ran outside any transaction and a lock wait surfaced as "database is locked" at an arbitrary later statement; place_bet also mistook that error for a write-snapshot conflict, which SQLite cannot produce. - _register_sqlite_pragmas: synchronous=FULL, isolation_level=None and a `begin` event that emits BEGIN / BEGIN IMMEDIATE. - begin_immediate(session): takes the write lock before the first read; called first thing in place_bet, request_withdrawal, the scheduler transitions, _trigger_payout, the confirmation poller, the reconciler, bump_fee's persist phase, deposit crediting / external-spend marking / reinstating, and the derivation-index allocation at registration. - A lock not granted before a broadcast answers service_busy (503, all seven languages), nothing built or sent; after a broadcast nothing is undone, the rows stay `building` for the reconciler. - Spec, storico, BUGS.md and CLAUDE.md updated; 37 new tests on a real file DB. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
62 lines
2.3 KiB
Python
62 lines
2.3 KiB
Python
"""Regression tests for B-39: SQLite must run in WAL mode with a busy_timeout,
|
|
since this app has five concurrent background tasks plus every HTTP handler
|
|
sharing one database file, and the default rollback-journal mode lets a writer
|
|
block every reader and fails a second writer immediately instead of waiting."""
|
|
|
|
import pytest
|
|
from sqlalchemy.ext.asyncio import create_async_engine
|
|
|
|
from app.db.base import _SQLITE_BUSY_TIMEOUT_MS, _register_sqlite_pragmas
|
|
|
|
|
|
@pytest.fixture
|
|
async def sqlite_engine(tmp_path):
|
|
# WAL needs a real file (it writes a companion -wal/-shm file alongside it) —
|
|
# ":memory:" wouldn't exercise the same path.
|
|
engine = create_async_engine(f"sqlite+aiosqlite:///{tmp_path}/test.db")
|
|
yield engine
|
|
await engine.dispose()
|
|
|
|
|
|
async def _pragma(engine, name: str):
|
|
async with engine.connect() as conn:
|
|
result = await conn.exec_driver_sql(f"PRAGMA {name}")
|
|
return result.fetchone()[0]
|
|
|
|
|
|
async def test_register_sqlite_pragmas_enables_wal_and_busy_timeout(sqlite_engine):
|
|
_register_sqlite_pragmas(sqlite_engine)
|
|
|
|
assert (await _pragma(sqlite_engine, "journal_mode")).lower() == "wal"
|
|
assert await _pragma(sqlite_engine, "busy_timeout") == _SQLITE_BUSY_TIMEOUT_MS
|
|
assert await _pragma(sqlite_engine, "synchronous") == 2 # FULL (B-88, DAT-52)
|
|
|
|
|
|
async def test_register_sqlite_pragmas_applies_to_every_new_connection(sqlite_engine):
|
|
"""The pool can open more than one underlying DBAPI connection over the
|
|
engine's lifetime — the pragmas must be re-applied to each one, not just
|
|
the first, or a later connection would silently fall back to SQLite's
|
|
defaults."""
|
|
_register_sqlite_pragmas(sqlite_engine)
|
|
|
|
async with sqlite_engine.connect() as first:
|
|
await first.exec_driver_sql("PRAGMA journal_mode")
|
|
|
|
async with sqlite_engine.connect() as second:
|
|
result = await second.exec_driver_sql("PRAGMA busy_timeout")
|
|
assert result.fetchone()[0] == _SQLITE_BUSY_TIMEOUT_MS
|
|
|
|
|
|
def test_register_sqlite_pragmas_is_a_noop_for_other_dialects():
|
|
"""Must not touch (or crash on) a non-sqlite engine — e.g. a future
|
|
PostgreSQL DATABASE_URL, which neither needs nor understands these
|
|
pragmas."""
|
|
|
|
class _FakeDialect:
|
|
name = "postgresql"
|
|
|
|
class _FakeEngine:
|
|
dialect = _FakeDialect()
|
|
|
|
_register_sqlite_pragmas(_FakeEngine()) # must not raise
|