simple-module-db 0.0.40__tar.gz → 0.0.42__tar.gz

{simple_module_db-0.0.40 → simple_module_db-0.0.42}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: simple_module_db
-Version: 0.0.40
+Version: 0.0.42
 Summary: Per-module SQLModel Base, async session, standard mixins (Audit, SoftDelete, MultiTenant, Versioned) for simple_module
 Project-URL: Homepage, https://github.com/antosubash/simple_module_python
 Project-URL: Repository, https://github.com/antosubash/simple_module_python
@@ -25,7 +25,7 @@ Requires-Dist: aiosqlite<0.23,>=0.20
 Requires-Dist: alembic<2,>=1.14
 Requires-Dist: asyncpg<0.33,>=0.30
 Requires-Dist: psycopg2-binary<3,>=2.9
-Requires-Dist: simple-module-core==0.0.40
+Requires-Dist: simple-module-core==0.0.42
 Requires-Dist: sqlalchemy[asyncio]<3,>=2.0
 Requires-Dist: sqlmodel<0.1,>=0.0.22
 Description-Content-Type: text/markdown

{simple_module_db-0.0.40 → simple_module_db-0.0.42}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "simple_module_db"
-version = "0.0.40"
+version = "0.0.42"
 description = "Per-module SQLModel Base, async session, standard mixins (Audit, SoftDelete, MultiTenant, Versioned) for simple_module"
 readme = "README.md"
 license = "MIT"
@@ -28,7 +28,7 @@ dependencies = [
     # The async app code goes through asyncpg; migration env.py rewrites the
     # URL to +psycopg2 because Alembic's online migrations are sync-only.
     "psycopg2-binary>=2.9,<3",
-    "simple_module_core==0.0.40",
+    "simple_module_core==0.0.42",
     "sqlalchemy[asyncio]>=2.0,<3",
     "sqlmodel>=0.0.22,<0.1",
 ]

simple_module_db-0.0.42/simple_module_db/data_compatibility.py

@@ -0,0 +1,83 @@
+"""Database-backed Doctor diagnostics, separate from core's static checks."""
+
+from collections.abc import Sequence
+from pathlib import Path
+
+from alembic.runtime.migration import MigrationContext
+from simple_module_core.data_compatibility import collect_data_compatibility
+from simple_module_core.diagnostics import Diagnostic, DiagnosticLevel
+from simple_module_core.module import ModuleBase
+from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
+
+DATA_COMPATIBILITY_CODE = "SM033"
+
+
+async def database_compatibility_diagnostics(
+    modules: Sequence[ModuleBase], database_url: str
+) -> list[Diagnostic]:
+    try:
+        if not _database_exists(database_url):
+            return []  # Nothing migrated yet; opening it would create an empty SQLite file.
+        engine = create_async_engine(database_url)
+    except Exception:
+        # A malformed or non-async URL must be a finding, not a traceback; the URL can
+        # carry credentials, so it is not echoed.
+        return [_problem(DiagnosticLevel.WARNING, "Could not open the database URL.")]
+    try:
+        try:
+            async with engine.connect() as conn:
+                migrated = await conn.run_sync(
+                    lambda sync: bool(MigrationContext.configure(sync).get_current_heads())
+                )
+        except Exception:
+            # Unreachable is a warning: doctor also runs where no database is up
+            # (CI, a laptop without the stack); boot is where errors are refused.
+            # Connection errors can carry credentials, so the cause is not shown.
+            return [_problem(DiagnosticLevel.WARNING, "Could not reach the database.")]
+        if not migrated:
+            return []
+        try:
+            async with async_sessionmaker(engine)() as db:
+                issues = await collect_data_compatibility(modules, db)
+        except Exception as exc:
+            # A check that crashes is a bug to fix, not a pass: doctor must fail.
+            return [
+                _problem(
+                    DiagnosticLevel.ERROR,
+                    f"A module data compatibility check failed ({type(exc).__name__}).",
+                )
+            ]
+        return [
+            Diagnostic(
+                level=DiagnosticLevel(issue.severity),
+                code=DATA_COMPATIBILITY_CODE,
+                module_name=issue.upgrade_id.split(".", 1)[0],
+                message=f"{issue.upgrade_id}: {issue.message}",
+                suggestion=issue.remediation(),
+            )
+            for issue in issues
+        ]
+    finally:
+        await engine.dispose()
+
+
+def _problem(level: DiagnosticLevel, message: str) -> Diagnostic:
+    return Diagnostic(
+        level=level,
+        code=DATA_COMPATIBILITY_CODE,
+        module_name="<database>",
+        message=message,
+        suggestion="Check database connectivity and apply pending host schema migrations, "
+        "then rerun doctor.",
+    )
+
+
+def _database_exists(database_url: str) -> bool:
+    """False for a SQLite file that isn't there yet; every other URL is tried."""
+    from sqlalchemy.engine import make_url
+
+    url = make_url(database_url)
+    if not url.get_backend_name().startswith("sqlite"):
+        return True
+    database = url.database or ""
+    return database in ("", ":memory:") or Path(database).exists()

{simple_module_db-0.0.40 → simple_module_db-0.0.42}/simple_module_db/insert_guard.py

@@ -10,7 +10,9 @@ from __future__ import annotations
 
 from typing import Any
 
+from sqlalchemy import literal, select
 from sqlalchemy.orm import ORMExecuteState
+from sqlalchemy.sql.elements import BindParameter, Label
 
 from simple_module_db import model_registry as registry
 from simple_module_db.tenancy import (
@@ -77,6 +79,8 @@ def guard_insert(
     bound = current_tenant_id.get()
     tenant_id = None if bypass else bound
     stamp = bound or fallback
+    if getattr(execute_state.statement, "select", None) is not None:
+        return _guard_from_select(execute_state, tenant_id, stamp, mappers[0], strict)
     if getattr(execute_state.statement, "_multi_values", None):
         return _guard_multi_values(execute_state, tenant_id, stamp, mappers[0], strict)
     for value in assigned_tenant_ids(execute_state):
@@ -100,6 +104,46 @@ def guard_insert(
     return None
 
 
+def _guard_from_select(
+    execute_state: ORMExecuteState, tenant_id: str | None, stamp: str, entity: str, strict: bool
+) -> None:
+    stmt = execute_state.statement
+    if tenant_id is None and strict:
+        raise missing_tenant_error(entity, "INSERT")
+    names = list(stmt._select_names)
+    if TENANT_COLUMN in names:
+        if tenant_id is None:
+            return
+        # SQL expressions cannot be validated as Python values; require a bound
+        # literal, or an explicit all_tenants bypass for cross-tenant copies.
+        params = _param_rows(execute_state)
+        bind_names = stmt.compile().bind_names if params else {}
+        sources = [stmt.select]
+        while sources:
+            source = sources.pop()
+            if hasattr(source, "selects"):
+                sources.extend(source.selects)
+                continue
+            value = list(source.selected_columns)[names.index(TENANT_COLUMN)]
+            while isinstance(value, Label):
+                value = value.element
+            if not isinstance(value, BindParameter) or value.callable is not None:
+                raise TenantIsolationError("INSERT ... SELECT tenant_id must be a bound literal")
+            for row in params or [{}]:
+                assigned = row.get(
+                    value.key, row.get(bind_names.get(value, value.key), value.value)
+                )
+                if assigned != tenant_id:
+                    raise _foreign_insert(assigned, tenant_id)
+        return
+    source = stmt.select.subquery()
+    execute_state.statement = stmt.from_select(
+        [*names, TENANT_COLUMN],
+        select(*source.c, literal(stamp)),
+        include_defaults=stmt.include_insert_from_select_defaults,
+    )
+
+
 def _guard_multi_values(
     execute_state: ORMExecuteState, tenant_id: str | None, stamp: str, entity: str, strict: bool
 ) -> Any:

{simple_module_db-0.0.40 → simple_module_db-0.0.42}/simple_module_db/leases.py

@@ -106,19 +106,40 @@ class DbLeaseBackend:
                 await conn.execute(_SQLITE_WRITE_LOCK)
             yield conn, await _db_now(conn)
 
+    async def _locked_now(self, conn: AsyncConnection, *where: Any) -> datetime:
+        """Lock the matching rows on Postgres, then read the clock (#698).
+
+        Postgres computes an UPDATE's new values before it waits on a row lock,
+        so a time read first could grant (or "refresh") a lease that expired
+        during the wait. SQLite holds the database write lock already.
+        """
+        await conn.execute(select(_T.c.slot).where(*where).with_for_update())
+        return await _db_now(conn)
+
     async def _take_slot(
         self,
         conn: AsyncConnection,
         name: str,
         slot: int,
         token: str,
-        expires: datetime,
+        ttl: float,
         now: datetime,
     ) -> int | None:
         """Claim *slot* if free (missing or expired) or already ours; return its fence."""
-        values = {"holder": token, "expires_at": expires}
-        ins = _insert(conn.dialect.name).values(name=name, slot=slot, fence=1, **values)
-        taken = (await conn.execute(ins.on_conflict_do_nothing())).rowcount == 1
+        if self._sqlite:
+            values = {"holder": token, "expires_at": now + timedelta(seconds=ttl)}
+            ins = _insert(conn.dialect.name).values(name=name, slot=slot, fence=1, **values)
+            taken = (await conn.execute(ins.on_conflict_do_nothing())).rowcount == 1
+        else:
+            # An expired placeholder gives a missing slot a row to lock; the
+            # UPDATE below then claims it exactly like an expired lease (fence 1).
+            placeholder = _insert(conn.dialect.name).values(
+                name=name, slot=slot, holder=_FREE, fence=0, expires_at=_EPOCH
+            )
+            await conn.execute(placeholder.on_conflict_do_nothing())
+            now = await self._locked_now(conn, _row(name, slot))
+            values = {"holder": token, "expires_at": now + timedelta(seconds=ttl)}
+            taken = False
         if not taken:
             stmt = (
                 update(_T)
@@ -144,15 +165,14 @@ class DbLeaseBackend:
 
     async def acquire(self, name: str, token: str, ttl: float) -> int | None:
         async with self._tx() as (conn, now):
-            return await self._take_slot(conn, name, 0, token, now + timedelta(seconds=ttl), now)
+            return await self._take_slot(conn, name, 0, token, ttl, now)
 
     async def semaphore_acquire(self, name: str, token: str, slots: int, ttl: float) -> int | None:
         async with self._tx() as (conn, now):
-            expires = now + timedelta(seconds=ttl)
             mine = await self._slot_of(conn, name, token, now)
             order = [mine] if mine is not None else range(slots)
             for slot in order:
-                if await self._take_slot(conn, name, slot, token, expires, now) is not None:
+                if await self._take_slot(conn, name, slot, token, ttl, now) is not None:
                     return await self._next_counter(conn, name)
             return None
 
@@ -169,8 +189,11 @@ class DbLeaseBackend:
     ) -> bool:
         """Extend (``ttl``) or end (``None``) *token*'s unexpired hold."""
         async with self._tx() as (conn, now):
-            where = [_T.c.name == name, _T.c.holder == token, _T.c.expires_at > now]
+            where = [_T.c.name == name, _T.c.holder == token]
             where.append(_T.c.slot >= 0 if any_slot else _T.c.slot == 0)
+            if not self._sqlite:
+                now = await self._locked_now(conn, *where)
+            where.append(_T.c.expires_at > now)
             expires = now if ttl is None else now + timedelta(seconds=ttl)
             result = await conn.execute(update(_T).where(*where).values(expires_at=expires))
             return result.rowcount > 0

{simple_module_db-0.0.40 → simple_module_db-0.0.42}/simple_module_db/session.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+import sqlite3
+import time
 from collections.abc import Callable
 from dataclasses import dataclass, field
 
@@ -153,6 +155,34 @@ def _is_file_database(database_url: str) -> bool:
     return bool(path) and path != ":memory:"
 
 
+def _ensure_wal(cursor, timeout_ms: int = 5000) -> None:
+    """Switch the file to WAL unless it already is.
+
+    Switching needs an exclusive lock, and SQLite fails it with "database is
+    locked" at once, without waiting out ``busy_timeout``, when another
+    connection holds a lock. That happens when two connections open a fresh
+    file together. So read the mode first (WAL persists in the file, so later
+    connections skip the switch), and retry a lost switch until the winner has
+    finished or ``timeout_ms`` has passed. On aiosqlite the sleep blocks the
+    event loop, but only while a fresh file is being switched.
+    """
+    deadline = time.monotonic() + timeout_ms / 1000
+    while _journal_mode(cursor) != "wal":
+        try:
+            cursor.execute("PRAGMA journal_mode=WAL")
+            return
+        except sqlite3.OperationalError:
+            if time.monotonic() >= deadline:
+                raise
+            time.sleep(0.02)
+
+
+def _journal_mode(cursor) -> str:
+    # The aiosqlite adapter's ``execute`` returns None, so fetch from the cursor.
+    cursor.execute("PRAGMA journal_mode")
+    return cursor.fetchone()[0].lower()
+
+
 def _configure_sqlite(
     engine: AsyncEngine,
     database_url: str,
@@ -166,7 +196,7 @@ def _configure_sqlite(
     Registered on the *sync* engine's ``connect`` event — the async engine is a
     facade, and ``connect`` fires on the DBAPI connection underneath it. All
     three PRAGMAs must be re-issued per connection except ``journal_mode``,
-    which is a property of the file; re-issuing it is cheap and idempotent.
+    which is a property of the file (see :func:`_ensure_wal`).
 
     Also registers a ``savepoint`` listener that opens the transaction before an
     outermost SAVEPOINT (pysqlite would otherwise let its RELEASE commit; GH #350).
@@ -182,7 +212,7 @@ def _configure_sqlite(
             if busy_timeout_ms is not None:
                 cursor.execute(f"PRAGMA busy_timeout={int(busy_timeout_ms)}")
             if apply_wal:
-                cursor.execute("PRAGMA journal_mode=WAL")
+                _ensure_wal(cursor, busy_timeout_ms or 0)
         finally:
             cursor.close()
 

simple_module_db-0.0.42/tests/test_db_data_compatibility_doctor.py

@@ -0,0 +1,91 @@
+"""Doctor checks semantic upgrades without importing host code (#711)."""
+
+import pytest
+from simple_module_core.data_compatibility import DataCompatibilityIssue
+from simple_module_core.module import ModuleBase, ModuleMeta
+from sqlalchemy import text
+from sqlalchemy.ext.asyncio import create_async_engine
+
+
+@pytest.mark.parametrize(
+    ("migrated", "severity", "expected"),
+    [
+        (True, "error", "error"),
+        (True, "warning", "warning"),
+        (False, "error", None),
+    ],
+)
+async def test_db_doctor_data_findings(tmp_path, migrated, severity, expected):
+    from simple_module_db.data_compatibility import database_compatibility_diagnostics
+
+    url = f"sqlite+aiosqlite:///{tmp_path / 'doctor.db'}"
+    engine = create_async_engine(url)
+    try:
+        async with engine.begin() as conn:
+            if migrated:
+                await conn.execute(text("CREATE TABLE alembic_version (version_num VARCHAR(32))"))
+                await conn.execute(
+                    text("INSERT INTO alembic_version VALUES ('host_local_revision')")
+                )
+    finally:
+        await engine.dispose()
+
+    class Module(ModuleBase):
+        meta = ModuleMeta(name="Example")
+
+        async def check_data_compatibility(self, db):
+            return [
+                DataCompatibilityIssue(
+                    upgrade_id="example.v1", message="Upgrade required", severity=severity
+                )
+            ]
+
+    findings = await database_compatibility_diagnostics([Module()], url)
+    if expected:
+        assert len(findings) == 1
+        assert findings[0].level == expected
+        assert "example.v1" in findings[0].message
+        assert "smpy migrations prepare example.v1" in findings[0].suggestion
+    else:
+        assert findings == []
+
+
+async def test_db_doctor_skips_a_sqlite_file_that_does_not_exist(tmp_path):
+    from simple_module_db.data_compatibility import database_compatibility_diagnostics
+
+    path = tmp_path / "app.db"
+    assert await database_compatibility_diagnostics([], f"sqlite+aiosqlite:///{path}") == []
+    # Doctor must not leave an empty database behind.
+    assert not path.exists()
+
+
+async def test_db_doctor_warns_on_unreachable_database(tmp_path):
+    from simple_module_db.data_compatibility import database_compatibility_diagnostics
+
+    # A directory exists but cannot be opened as a SQLite database.
+    findings = await database_compatibility_diagnostics([], f"sqlite+aiosqlite:///{tmp_path}")
+    assert len(findings) == 1
+    assert findings[0].level == "warning"
+    assert "could not reach" in findings[0].message.lower()
+
+
+async def test_db_doctor_fails_when_a_module_check_crashes(tmp_path):
+    from simple_module_core.module import ModuleBase
+    from simple_module_core.module_meta import ModuleMeta
+    from simple_module_db.data_compatibility import database_compatibility_diagnostics
+    from sqlalchemy import create_engine, text
+
+    path = tmp_path / "app.db"
+    with create_engine(f"sqlite:///{path}").begin() as conn:
+        conn.execute(text("CREATE TABLE alembic_version (version_num VARCHAR(32))"))
+        conn.execute(text("INSERT INTO alembic_version VALUES ('abc')"))
+
+    class Broken(ModuleBase):
+        meta = ModuleMeta(name="Broken")
+
+        async def check_data_compatibility(self, db):
+            raise KeyError("bug")
+
+    findings = await database_compatibility_diagnostics([Broken()], f"sqlite+aiosqlite:///{path}")
+    assert [f.level for f in findings] == ["error"]
+    assert "KeyError" in findings[0].message

simple_module_db-0.0.42/tests/test_db_insert_select_tenant.py

@@ -0,0 +1,129 @@
+"""Tenant destinations for INSERT ... SELECT (#693)."""
+
+import pytest
+from _core_scope_models import Tag, _Base, tag
+from simple_module_db.listeners import attach_session_listeners
+from simple_module_db.query_filter import EngineTenancy, bind_engine_policy
+from simple_module_db.tenancy import (
+    TenantIsolationError,
+    current_tenant_id,
+    no_tenant,
+    tenant_context,
+)
+from sqlalchemy import bindparam, create_engine, insert, literal, select, union_all
+from sqlalchemy.orm import Session, configure_mappers
+
+
+@pytest.fixture
+def seeded():
+    configure_mappers()
+    engine = create_engine("sqlite://")
+    _Base.metadata.create_all(engine)
+    with engine.begin() as conn:
+        conn.execute(
+            insert(tag),
+            [
+                {"id": 1, "name": "used", "tenant_id": "A"},
+                {"id": 2, "name": "unused", "tenant_id": "A"},
+                {"id": 3, "name": "b-tag", "tenant_id": "B"},
+            ],
+        )
+
+    class TenantSession(Session):
+        pass
+
+    attach_session_listeners(TenantSession)
+    bind_engine_policy(engine, EngineTenancy(tenant_strict=False))
+    try:
+        with TenantSession(engine) as session, tenant_context("A"):
+            yield session
+    finally:
+        engine.dispose()
+
+
+def _rows(session, stmt, **options):
+    return sorted(session.execute(stmt.execution_options(**options)).all(), key=repr)
+
+
+@pytest.mark.parametrize("compound", [False, True])
+@pytest.mark.parametrize("target", [tag, Tag])
+def test_insert_select_stamps_tenant_and_scopes_source(seeded, compound, target):
+    source = select((tag.c.id + 100).label("id"), literal("copy").label("name"))
+    if compound:
+        source = union_all(source.where(tag.c.id == 1), source.where(tag.c.id == 2))
+    seeded.execute(insert(target).from_select(["id", "name"], source))
+    assert _rows(
+        seeded, select(tag.c.id, tag.c.tenant_id).where(tag.c.id >= 100), all_tenants=True
+    ) == [(101, "A"), (102, "A")]
+
+
+def test_insert_select_accepts_matching_explicit_tenant(seeded):
+    source = select(literal(101), literal("copy"), literal("A"))
+    seeded.execute(insert(tag).from_select(["id", "name", "tenant_id"], source))
+    assert _rows(seeded, select(tag.c.id).where(tag.c.id == 101)) == [(101,)]
+
+
+def test_insert_select_refuses_foreign_explicit_tenant(seeded):
+    source = select(literal(101), literal("copy"), literal("B"))
+    with pytest.raises(TenantIsolationError):
+        seeded.execute(insert(tag).from_select(["id", "name", "tenant_id"], source))
+
+
+@pytest.mark.parametrize("explicit", [False, True])
+def test_strict_insert_select_requires_tenant_even_for_plain_source(seeded, explicit):
+    bind_engine_policy(seeded.bind, EngineTenancy(tenant_strict=True))
+    current_tenant_id.set(None)
+    columns, values = ["id", "name"], [literal(101), literal("copy")]
+    if explicit:
+        columns.append("tenant_id")
+        values.append(literal("A"))
+    with pytest.raises(TenantIsolationError):
+        seeded.execute(insert(tag).from_select(columns, select(*values)))
+
+
+def test_unbound_insert_select_uses_fallback_tenant(seeded):
+    with no_tenant():
+        seeded.execute(
+            insert(tag).from_select(["id", "name"], select(literal(101), literal("copy")))
+        )
+    assert _rows(seeded, select(tag.c.tenant_id).where(tag.c.id == 101), all_tenants=True) == [
+        ("default",)
+    ]
+
+
+@pytest.mark.parametrize("strict", [False, True])
+def test_insert_select_bypass_preserves_explicit_tenant(seeded, strict):
+    bind_engine_policy(seeded.bind, EngineTenancy(tenant_strict=strict))
+    stmt = insert(tag).from_select(
+        ["id", "name", "tenant_id"], select(literal(101), literal("copy"), literal("B"))
+    )
+    seeded.execute(stmt.execution_options(all_tenants=True))
+    assert _rows(seeded, select(tag.c.tenant_id).where(tag.c.id == 101), all_tenants=True) == [
+        ("B",)
+    ]
+
+
+def test_insert_select_refuses_unverifiable_tenant_expression(seeded):
+    source = select(tag.c.id + 100, tag.c.name, tag.c.tenant_id)
+    with pytest.raises(TenantIsolationError):
+        seeded.execute(insert(tag).from_select(["id", "name", "tenant_id"], source))
+
+
+def test_insert_select_checks_every_compound_branch(seeded):
+    source = union_all(
+        select(literal(101), literal("copy"), literal("A")),
+        select(literal(102), literal("copy"), literal("B")),
+    )
+    with pytest.raises(TenantIsolationError):
+        seeded.execute(insert(tag).from_select(["id", "name", "tenant_id"], source))
+
+
+@pytest.mark.parametrize("anonymous", [False, True])
+def test_insert_select_checks_execution_parameter_override(seeded, anonymous):
+    tenant = literal("A") if anonymous else bindparam("tenant", "A")
+    source = select(literal(101), literal("copy"), tenant)
+    parameter = "param_3" if anonymous else "tenant"
+    with pytest.raises(TenantIsolationError):
+        seeded.execute(
+            insert(tag).from_select(["id", "name", "tenant_id"], source), {parameter: "B"}
+        )

simple_module_db-0.0.42/tests/test_db_lease_lock_wait.py

@@ -0,0 +1,39 @@
+"""A lease taken after waiting on a row lock is still valid when granted (#698)."""
+
+import asyncio
+import uuid
+
+import pytest
+from simple_module_db.leases import DbLeaseBackend, LeaseRow
+from sqlalchemy import func, select
+
+_T = LeaseRow.__table__
+
+
+@pytest.mark.postgres
+@pytest.mark.parametrize("operation", ["acquire", "refresh"])
+async def test_postgres_lock_wait_does_not_consume_ttl(engine, operation):
+    async with engine.begin() as conn:
+        await conn.run_sync(LeaseRow.metadata.create_all)
+    backend = DbLeaseBackend(engine)
+    name = f"lockwait-{uuid.uuid4().hex}"
+    holder = "old" if operation == "acquire" else "me"
+    ttl = 0.01 if operation == "acquire" else 60
+    assert await backend.acquire(name, holder, ttl) is not None
+    await asyncio.sleep(0.05)  # intentional-sleep: let the 10 ms lease expire
+
+    async with engine.connect() as blocker:
+        await blocker.begin()
+        row = (_T.c.name == name) & (_T.c.slot == 0)
+        await blocker.execute(select(_T.c.fence).where(row).with_for_update())
+        if operation == "acquire":
+            pending = asyncio.create_task(backend.acquire(name, "new", 1.0))
+        else:
+            pending = asyncio.create_task(backend.refresh(name, "me", 1.0))
+        await asyncio.sleep(1.5)  # intentional-sleep: hold the lock past the 1 s TTL
+        await blocker.commit()
+    assert await pending
+
+    async with engine.connect() as conn:
+        live = await conn.execute(select(_T.c.expires_at > func.clock_timestamp()).where(row))
+        assert live.scalar_one() is True

simple_module_db-0.0.42/tests/test_db_sqlite_wal_switch.py

@@ -0,0 +1,87 @@
+"""The per-connection WAL switch must tolerate a concurrent opener (fresh file)."""
+
+from __future__ import annotations
+
+import sqlite3
+import threading
+
+import pytest
+from simple_module_db.session import _ensure_wal
+
+
+class _Cursor:
+    """A cursor whose switch loses the race; the winner leaves ``after``."""
+
+    def __init__(self, before: str, after: str) -> None:
+        self.mode = before
+        self.after = after
+        self.switches = 0
+
+    def execute(self, sql: str):
+        if sql == "PRAGMA journal_mode=WAL":
+            self.switches += 1
+            self.mode = self.after
+            raise sqlite3.OperationalError("database is locked")
+        return self
+
+    def fetchone(self):
+        return (self.mode,)
+
+
+def test_already_wal_skips_the_switch():
+    cursor = _Cursor("wal", "wal")
+    _ensure_wal(cursor)
+    assert cursor.switches == 0
+
+
+def test_losing_the_switch_to_another_connection_is_fine():
+    cursor = _Cursor("delete", "wal")
+    _ensure_wal(cursor)
+    assert cursor.switches == 1
+
+
+def test_a_switch_still_in_progress_is_retried():
+    cursor = _Cursor("delete", "delete")
+    original = cursor.execute
+
+    def execute(sql):
+        if sql == "PRAGMA journal_mode=WAL" and cursor.switches == 2:
+            cursor.mode = "wal"
+            return cursor
+        return original(sql)
+
+    cursor.execute = execute
+    _ensure_wal(cursor)
+    assert (cursor.switches, cursor.mode) == (2, "wal")
+
+
+def test_a_switch_that_leaves_the_file_unjournaled_still_raises():
+    with pytest.raises(sqlite3.OperationalError, match="locked"):
+        _ensure_wal(_Cursor("delete", "delete"), timeout_ms=50)
+
+
+def test_fresh_file_waits_for_a_concurrent_switch(tmp_path):
+    """The old one-shot switch failed here at once: the other opener held a lock."""
+    path = tmp_path / "app.db"
+    other = sqlite3.connect(path, check_same_thread=False)
+    other.execute("CREATE TABLE t (x)")
+    other.commit()
+    other.execute("BEGIN IMMEDIATE")
+    other.execute("INSERT INTO t VALUES (1)")
+
+    def finish_and_switch():
+        other.commit()
+        other.execute("PRAGMA journal_mode=WAL")
+
+    timer = threading.Timer(0.2, finish_and_switch)
+    opener = sqlite3.connect(path, timeout=0)
+    try:
+        with pytest.raises(sqlite3.OperationalError, match="locked"):
+            opener.execute("PRAGMA journal_mode=WAL")
+        timer.start()
+        _ensure_wal(opener.cursor(), timeout_ms=5000)
+        assert opener.execute("PRAGMA journal_mode").fetchone()[0] == "wal"
+    finally:
+        timer.join()
+        opener.close()
+        other.close()