simple-module-test 0.0.36__tar.gz → 0.0.38__tar.gz

{simple_module_test-0.0.36 → simple_module_test-0.0.38}/.gitignore

@@ -7,8 +7,6 @@ build/
 .venv/
 *.egg
 
-# UV
-uv.lock
 
 # Node
 node_modules/
@@ -64,3 +62,5 @@ host/client_app/.playwright-cli/*
 .superpowers/
 .qa/
 .verify/
+/openapi.json
+qa-shots/

{simple_module_test-0.0.36 → simple_module_test-0.0.38}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: simple_module_test
-Version: 0.0.36
+Version: 0.0.38
 Summary: Shared pytest fixtures (app, client, db_session, authenticated_client) for writing simple_module module tests
 Project-URL: Homepage, https://github.com/antosubash/simple_module_python
 Project-URL: Repository, https://github.com/antosubash/simple_module_python
@@ -21,13 +21,13 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Testing
 Classifier: Typing :: Typed
 Requires-Python: >=3.12
-Requires-Dist: fastapi>=0.115
+Requires-Dist: fastapi<0.157,>=0.140
 Requires-Dist: httpx>=0.27
 Requires-Dist: pytest-asyncio>=0.24
 Requires-Dist: pytest>=8.0
-Requires-Dist: simple-module-core==0.0.36
-Requires-Dist: simple-module-db==0.0.36
-Requires-Dist: simple-module-hosting==0.0.36
+Requires-Dist: simple-module-core==0.0.38
+Requires-Dist: simple-module-db==0.0.38
+Requires-Dist: simple-module-hosting==0.0.38
 Requires-Dist: sqlalchemy>=2.0
 Description-Content-Type: text/markdown
 

{simple_module_test-0.0.36 → simple_module_test-0.0.38}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "simple_module_test"
-version = "0.0.36"
+version = "0.0.38"
 description = "Shared pytest fixtures (app, client, db_session, authenticated_client) for writing simple_module module tests"
 readme = "README.md"
 license = "MIT"
@@ -21,13 +21,13 @@ classifiers = [
     "Typing :: Typed",
 ]
 dependencies = [
-    "fastapi>=0.115",
+    "fastapi>=0.140,<0.157",
     "httpx>=0.27",
     "pytest>=8.0",
     "pytest-asyncio>=0.24",
-    "simple_module_core==0.0.36",
-    "simple_module_db==0.0.36",
-    "simple_module_hosting==0.0.36",
+    "simple_module_core==0.0.38",
+    "simple_module_db==0.0.38",
+    "simple_module_hosting==0.0.38",
     "sqlalchemy>=2.0",
 ]
 

{simple_module_test-0.0.36 → simple_module_test-0.0.38}/simple_module_test/__init__.py

@@ -30,6 +30,7 @@ from simple_module_test.fake_events import FakeEventBus, RecordedEvent
 from simple_module_test.routes import effective_route_paths
 from simple_module_test.session_cookie import forge_session_cookie
 from simple_module_test.tenant_client import TenantClient
+from simple_module_test.waiting import wait_for, wait_for_sync
 
 __all__ = [
     "FakeEventBus",
@@ -38,4 +39,6 @@ __all__ = [
     "build_test_app",
     "effective_route_paths",
     "forge_session_cookie",
+    "wait_for",
+    "wait_for_sync",
 ]

{simple_module_test-0.0.36 → simple_module_test-0.0.38}/simple_module_test/_schema.py

@@ -19,6 +19,9 @@ from simple_module_db.base import all_module_bases
 @lru_cache(maxsize=1)
 def _ensure_models_imported() -> list:
     """Import all module models so all_module_bases is populated (cached)."""
+    import simple_module_db.leases  # framework-owned table (#539)
+    import simple_module_db.stored_settings  # noqa: F401  framework-owned table (#500)
+
     for mod in discover_modules():
         pkg = type(mod).__module__.split(".")[0]
         with contextlib.suppress(ModuleNotFoundError):
@@ -51,27 +54,34 @@ async def _create_all_tables(engine) -> None:
     """
     from sqlalchemy import text
 
-    from simple_module_test.database import reset_schema_once
+    from simple_module_test.database import prepare_schema_once
 
     bases = _ensure_models_imported()
     heads = _alembic_heads()
-    await reset_schema_once(engine)  # Postgres: start empty; SQLite memory already is
 
-    async with engine.begin() as conn:
+    async def _build(engine) -> None:
+        async with engine.begin() as conn:
 
-        def _sync_create_all(sync_conn):
-            for base in bases:
-                base.metadata.create_all(sync_conn)
+            def _sync_create_all(sync_conn):
+                for base in bases:
+                    base.metadata.create_all(sync_conn)
 
-        await conn.run_sync(_sync_create_all)
+            await conn.run_sync(_sync_create_all)
+            # Part of the build, so a reused Postgres schema's fingerprint covers it.
+            if heads:
+                await conn.execute(
+                    text(
+                        "CREATE TABLE IF NOT EXISTS alembic_version "
+                        "(version_num VARCHAR(32) NOT NULL PRIMARY KEY)"
+                    )
+                )
 
+    tables = [table for base in bases for table in base.metadata.tables.values()]
+    # Postgres reuses the schema built for an earlier test, emptied of rows.
+    await prepare_schema_once(engine, tables, _build)
+
+    async with engine.begin() as conn:
         if heads:
-            await conn.execute(
-                text(
-                    "CREATE TABLE IF NOT EXISTS alembic_version "
-                    "(version_num VARCHAR(32) NOT NULL PRIMARY KEY)"
-                )
-            )
             await conn.execute(text("DELETE FROM alembic_version"))
             for head in heads:
                 await conn.execute(

simple_module_test-0.0.38/simple_module_test/database.py

@@ -0,0 +1,199 @@
+"""Which database the test fixtures run on (#343).
+
+In-memory SQLite by default. Set ``SM_TEST_DATABASE_URL`` to an async URL
+(``postgresql+asyncpg://postgres@localhost:5432/sm_test``) to run the same
+suites on Postgres — what SQLite cannot show: real concurrent transactions,
+row locks, stricter types, and SQL that SQLite happens to accept.
+
+On Postgres every test starts with empty tables, so tests stay independent:
+the schema is built once per process and emptied of rows between tests, and
+dropped and rebuilt only when it changed (``prepare_schema_once``). Pooled
+connections are disabled because pytest-asyncio
+gives each test its own event loop. Under pytest-xdist each worker gets its
+own database (``<name>_gw0``, ...), so workers never drop each other's schema.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from typing import Any
+
+from sqlalchemy import text
+from sqlalchemy.engine import make_url
+from sqlalchemy.pool import NullPool
+
+TEST_DATABASE_ENV = "SM_TEST_DATABASE_URL"
+SQLITE_MEMORY = "sqlite+aiosqlite:///:memory:"
+XDIST_WORKER_ENV = "PYTEST_XDIST_WORKER"
+
+
+def database_url_for_tests() -> str:
+    return os.environ.get(TEST_DATABASE_ENV) or SQLITE_MEMORY
+
+
+def database_is_postgres() -> bool:
+    return database_url_for_tests().startswith("postgresql")
+
+
+def is_sqlite(url: str) -> bool:
+    return url.startswith("sqlite")
+
+
+def init_db_kwargs(url: str) -> dict[str, Any]:
+    return {} if is_sqlite(url) else {"poolclass": NullPool}
+
+
+def isolate_worker_database() -> None:
+    """Point this xdist worker at its own Postgres database, creating it if needed.
+
+    Rewrites ``SM_TEST_DATABASE_URL`` rather than wrapping it, so tests that read
+    the variable directly and subprocesses that inherit it land on the same
+    database. A no-op on SQLite and outside xdist workers. The role needs
+    ``CREATEDB`` the first time.
+    """
+    worker = os.environ.get(XDIST_WORKER_ENV)
+    if not worker or not database_is_postgres():
+        return
+    base = make_url(database_url_for_tests())
+    url = base.set(database=f"{base.database}_{worker}")
+    asyncio.run(_create_database_if_missing(base, url.database or ""))
+    os.environ[TEST_DATABASE_ENV] = url.render_as_string(hide_password=False)
+
+
+async def _create_database_if_missing(server_url: Any, name: str) -> None:
+    from sqlalchemy.ext.asyncio import create_async_engine
+
+    engine = create_async_engine(server_url, poolclass=NullPool, isolation_level="AUTOCOMMIT")
+    try:
+        async with engine.connect() as conn:
+            exists = await conn.scalar(
+                text("SELECT 1 FROM pg_database WHERE datname = :n"), {"n": name}
+            )
+            if not exists:
+                quoted = conn.dialect.identifier_preparer.quote_identifier(name)
+                await conn.execute(text(f"CREATE DATABASE {quoted}"))
+    finally:
+        await engine.dispose()
+
+
+async def reset_schema(engine: Any) -> None:
+    """Empty the database before a test (Postgres); a no-op on SQLite."""
+    global _built_schema
+    if engine.dialect.name == "sqlite":
+        return
+    _built_schema = None  # whatever was built before is gone
+    async with engine.begin() as conn:
+        await conn.execute(text("DROP SCHEMA IF EXISTS public CASCADE"))
+        await conn.execute(text("CREATE SCHEMA public"))
+        # The drop took the installed extensions with it; modules' models need them.
+        await conn.run_sync(_create_declared_extensions)
+
+
+def _create_declared_extensions(sync_conn: Any) -> None:
+    from simple_module_core.discovery import discover_modules
+    from simple_module_db.extensions import ensure_db_extensions
+
+    ensure_db_extensions(sync_conn, discover_modules())
+
+
+# The test the schema was last emptied for. On SQLite every engine is its own
+# in-memory database; on Postgres the ``app`` and ``db_session`` fixtures share
+# one, so a second reset inside the same test would wipe the first fixture's
+# rows (the seeded admin, say) from under it.
+_current_test: object | None = None
+_reset_for: object | None = None
+
+
+def begin_test(token: object) -> None:
+    """Mark the start of a test; the next ``reset_schema_once`` resets."""
+    global _current_test
+    _current_test = token
+
+
+async def reset_schema_once(engine: Any) -> None:
+    """``reset_schema`` at most once per test (see ``begin_test``)."""
+    global _reset_for
+    if _current_test is not None and _reset_for is _current_test:
+        return
+    await reset_schema(engine)
+    _reset_for = _current_test
+
+
+# The tables this process last built and the catalog fingerprint after the
+# build (Postgres only); reused only while both still match.
+_built_schema: tuple[frozenset[str], str] | None = None
+
+_FINGERPRINT = text(
+    "SELECT md5(coalesce(string_agg(item, ',' ORDER BY item), '')) FROM ("
+    " SELECT c.relname || ':' || c.relkind::text || ':' || coalesce(a.attname || ':'"
+    "  || a.atttypid::text || ':' || a.attnotnull::text, '') AS item"
+    " FROM pg_class c LEFT JOIN pg_attribute a"
+    "  ON a.attrelid = c.oid AND a.attnum > 0 AND NOT a.attisdropped"
+    " WHERE c.relnamespace = 'public'::regnamespace"
+    " UNION ALL SELECT 'con:' || conname FROM pg_constraint"
+    "  WHERE connamespace = 'public'::regnamespace"
+    " UNION ALL SELECT 'type:' || typname FROM pg_type"
+    "  WHERE typnamespace = 'public'::regnamespace"
+    " UNION ALL SELECT 'ext:' || extname FROM pg_extension) AS s"
+)
+_RESTART_SEQUENCES = text(
+    "SELECT setval(c.oid::regclass, 1, false) FROM pg_class c"
+    " WHERE c.relkind = 'S' AND c.relnamespace = 'public'::regnamespace"
+)
+
+
+async def prepare_schema_once(engine: Any, tables: list[Any], build: Any) -> None:
+    """Give this test empty ``tables``, at most once per test (see ``begin_test``).
+
+    SQLite: ``build(engine)``, since every engine is a fresh in-memory database.
+    Postgres: when this process already built the schema and the catalog still
+    matches it, delete every row and restart the sequences (~0.03 s) instead of
+    dropping and rebuilding it (~0.25 s). Anything else (the first test, a
+    direct ``reset_schema`` call, a test's own DDL) resets and rebuilds.
+    """
+    global _reset_for, _built_schema
+    if engine.dialect.name == "sqlite":
+        await build(engine)
+        return
+    if _current_test is not None and _reset_for is _current_test:
+        return
+    _reset_for = _current_test
+    names = frozenset(table.fullname for table in tables)
+    if _built_schema is not None and _built_schema == (names, await _fingerprint(engine)):
+        await _empty_tables(engine, tables)
+        return
+    await reset_schema(engine)
+    await build(engine)
+    _built_schema = (names, await _fingerprint(engine))
+
+
+async def _fingerprint(engine: Any) -> str:
+    async with engine.connect() as conn:
+        return await conn.scalar(_FINGERPRINT)
+
+
+async def _empty_tables(engine: Any, tables: list[Any]) -> None:
+    from sqlalchemy.schema import sort_tables
+
+    async with engine.begin() as conn:
+        quote = conn.dialect.identifier_preparer.format_table
+        # Children first, so no foreign key refuses a parent's delete.
+        for table in reversed(sort_tables(tables)):
+            await conn.execute(text(f"DELETE FROM {quote(table)}"))
+        await conn.execute(_RESTART_SEQUENCES)
+
+
+__all__ = [
+    "SQLITE_MEMORY",
+    "TEST_DATABASE_ENV",
+    "begin_test",
+    "database_is_postgres",
+    "database_url_for_tests",
+    "init_db_kwargs",
+    "is_sqlite",
+    "isolate_worker_database",
+    "prepare_schema_once",
+    "reset_schema",
+    "reset_schema_once",
+]

{simple_module_test-0.0.36 → simple_module_test-0.0.38}/simple_module_test/fake_events.py

@@ -32,7 +32,7 @@ class FakeEventBus(EventBus):
         super().__init__()
         self.events: list[RecordedEvent] = []
 
-    async def publish(self, event: Event) -> None:  # type: ignore[override]
+    async def publish(self, event: Event) -> None:
         self.events.append(RecordedEvent(event=event))
         return await super().publish(event)
 

simple_module_test-0.0.38/simple_module_test/mail.py

@@ -0,0 +1,49 @@
+"""Mail fixtures: capture what the app sends, and never leak a sender between tests.
+
+The process mail sender (``simple_module_core.mail``) is module-level state that
+an app's ``mail`` module installs on startup, so a test that boots an app would
+otherwise hand its SMTP sender to the next test in the same worker.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+
+import pytest
+from simple_module_core import mail as core_mail
+from simple_module_core.mail import MailMessage
+
+
+class CapturedMail:
+    """A sender that records every message instead of sending it."""
+
+    def __init__(self, *, delivers_email: bool = True) -> None:
+        self.delivers_email = delivers_email
+        self.messages: list[MailMessage] = []
+
+    async def send(self, message: MailMessage) -> None:
+        self.messages.append(message)
+
+    def to(self, address: str) -> list[MailMessage]:
+        return [m for m in self.messages if m.to == address]
+
+
+@pytest.fixture(autouse=True)
+def _reset_process_mail_sender() -> Iterator[None]:
+    sender, resolver = core_mail._sender, core_mail._resolver
+    yield
+    core_mail.install_mail_sender(sender)
+    core_mail.install_mail_resolver(resolver)
+
+
+@pytest.fixture
+def captured_mail() -> Iterator[CapturedMail]:
+    """Install a recording sender that claims to deliver; yields it.
+
+    Installed after any app fixture requested before it has started, so it wins
+    over the ``mail`` module's sender. A ``settings_reloaded`` in the test
+    reinstalls the real one; reinstall with ``install_mail_sender(captured)``.
+    """
+    captured = CapturedMail()
+    core_mail.install_mail_sender(captured)
+    yield captured

{simple_module_test-0.0.36 → simple_module_test-0.0.38}/simple_module_test/plugin.py

@@ -33,10 +33,45 @@ from simple_module_test.fixtures import (  # noqa: F401
     settings,
     setup_pending_app,
 )
+from simple_module_test.mail import _reset_process_mail_sender, captured_mail  # noqa: F401
 from simple_module_test.redis_server import redis_server  # noqa: F401
 from simple_module_test.tenant_client import tenant_client  # noqa: F401
 
 
+def pytest_configure(config: pytest.Config) -> None:
+    config.addinivalue_line(
+        "markers",
+        "postgres: needs a PostgreSQL test database (SM_TEST_DATABASE_URL=postgresql+...)",
+    )
+
+
+@pytest.hookimpl(tryfirst=True)
+def pytest_load_initial_conftests(early_config, parser, args) -> None:
+    """Give each xdist worker its own Postgres database.
+
+    Every Postgres test drops and recreates ``public``. This runs before any
+    conftest is imported (``pytest_configure`` runs after), so a conftest or
+    test helper that reads the URL at import time already sees the worker's.
+    """
+    from simple_module_test.database import isolate_worker_database
+
+    isolate_worker_database()
+
+
+def pytest_collection_modifyitems(config: pytest.Config, items: list[pytest.Item]) -> None:
+    """Skip ``@pytest.mark.postgres`` tests unless the test database is Postgres."""
+    from simple_module_test.database import database_is_postgres
+
+    if database_is_postgres():
+        return
+    skip = pytest.mark.skip(
+        reason="needs Postgres: set SM_TEST_DATABASE_URL=postgresql+asyncpg://..."
+    )
+    for item in items:
+        if "postgres" in item.keywords:
+            item.add_marker(skip)
+
+
 def _bootstrap_eager_celery() -> None:
     """Register a process-wide eager Celery app before any test runs.
 
@@ -65,6 +100,49 @@ def _bootstrap_eager_celery() -> None:
 _bootstrap_eager_celery()
 
 
+def _cheap_password_hashing() -> None:
+    """Make ``PasswordHelper()`` hash with minimal Argon2/bcrypt cost.
+
+    Every ``app`` fixture seeds an admin, and production-cost Argon2 is ~90ms
+    of CPU per hash — over a tenth of each app's setup, paid thousands of times
+    a run. The hashes stay real ``$argon2``/``$2b`` strings that verify and
+    upgrade through the same code paths; only their work factor drops, which is
+    a property of deployment rather than anything a test asserts.
+
+    Patched at import, not in a fixture: test modules build ``PasswordHelper()``
+    at module scope during collection, before any fixture runs. An explicit
+    ``password_hash=`` still wins. Skipped when ``fastapi_users`` is absent, or
+    when ``SM_TEST_REAL_PASSWORD_HASHING`` is set — the opt-out for a consumer
+    suite whose tests depend on production hash parameters.
+    """
+    if os.environ.get("SM_TEST_REAL_PASSWORD_HASHING"):
+        return
+    try:
+        from fastapi_users.password import PasswordHelper
+        from pwdlib import PasswordHash
+        from pwdlib.hashers.argon2 import Argon2Hasher
+        from pwdlib.hashers.bcrypt import BcryptHasher
+    except ImportError:
+        return
+
+    original_init = PasswordHelper.__init__
+
+    def _init(self, password_hash: PasswordHash | None = None) -> None:
+        if password_hash is None:
+            password_hash = PasswordHash(
+                (
+                    Argon2Hasher(time_cost=1, memory_cost=8, parallelism=1),
+                    BcryptHasher(rounds=4),
+                )
+            )
+        original_init(self, password_hash)
+
+    PasswordHelper.__init__ = _init
+
+
+_cheap_password_hashing()
+
+
 @pytest.fixture
 def fake_event_bus() -> FakeEventBus:
     """Fresh recording EventBus for each test."""

simple_module_test-0.0.38/simple_module_test/waiting.py

@@ -0,0 +1,83 @@
+"""Polling helpers that replace fixed ``sleep()`` waits in tests.
+
+A fixed sleep is a bet on timing: too short and the test flakes on a loaded
+runner, too long and the suite is slow on a fast one. ``wait_for`` polls a
+predicate until it is truthy and fails with the last value it saw.
+"""
+
+import asyncio
+import inspect
+import time
+from collections.abc import Awaitable, Callable
+from typing import Any
+
+
+def _timeout_error(
+    predicate: Callable[..., Any], timeout: float, last: Any, error: BaseException | None
+) -> AssertionError:
+    name = getattr(predicate, "__name__", repr(predicate))
+    detail = f"last error: {error!r}" if error is not None else f"last value: {last!r}"
+    return AssertionError(f"wait_for({name}) not satisfied within {timeout}s; {detail}")
+
+
+def _poll_once(predicate: Callable[[], Any]) -> tuple[Any, BaseException | None]:
+    """Call ``predicate`` once; an exception it raises is returned, not raised."""
+    try:
+        return predicate(), None
+    except Exception as exc:
+        return None, exc
+
+
+async def wait_for(
+    predicate: Callable[[], Any] | Callable[[], Awaitable[Any]],
+    timeout: float = 2.0,
+    interval: float = 0.01,
+) -> Any:
+    """Poll ``predicate`` (sync or async) until truthy; return its value.
+
+    Raises ``AssertionError`` with the last value seen on timeout. An exception
+    raised by the predicate counts as "not yet" and is reported if it is the
+    last thing seen.
+    """
+    deadline = time.monotonic() + timeout
+    while True:
+        value, error = _poll_once(predicate)
+        if inspect.isawaitable(value):
+            value, error = await _settle(value, max(deadline - time.monotonic(), 0.001))
+        if value:
+            return value
+        if time.monotonic() >= deadline:
+            raise _timeout_error(predicate, timeout, value, error)
+        await asyncio.sleep(interval)
+
+
+async def _settle(awaitable: Awaitable[Any], budget: float) -> tuple[Any, BaseException | None]:
+    """Await an async predicate's result, with :func:`_poll_once`'s contract.
+
+    ``budget`` bounds the await, so a predicate that hangs fails the wait at its
+    timeout instead of blocking the test forever.
+    """
+    try:
+        return await asyncio.wait_for(awaitable, budget), None
+    except Exception as exc:
+        return None, exc
+
+
+def wait_for_sync(
+    predicate: Callable[[], Any],
+    timeout: float = 2.0,
+    interval: float = 0.01,
+) -> Any:
+    """Blocking twin of :func:`wait_for` for sync tests (sync predicates only)."""
+    deadline = time.monotonic() + timeout
+    while True:
+        value, error = _poll_once(predicate)
+        if inspect.isawaitable(value):
+            if inspect.iscoroutine(value):
+                value.close()  # never awaited: avoid the RuntimeWarning
+            raise TypeError("wait_for_sync takes a sync predicate; use wait_for for async ones")
+        if value:
+            return value
+        if time.monotonic() >= deadline:
+            raise _timeout_error(predicate, timeout, value, error)
+        time.sleep(interval)  # intentional-sleep: the polling interval itself

simple_module_test-0.0.38/tests/test_schema_reuse_pg.py

@@ -0,0 +1,75 @@
+"""Postgres reuses the schema between tests, emptied of rows (``prepare_schema_once``)."""
+
+from __future__ import annotations
+
+import pytest
+from simple_module_test import database
+from sqlalchemy import Column, Integer, MetaData, String, Table, func, select, text
+from sqlalchemy.ext.asyncio import create_async_engine
+
+pytestmark = pytest.mark.postgres
+
+_metadata = MetaData()
+_item = Table(
+    "reuse_probe_item",
+    _metadata,
+    Column("id", Integer, primary_key=True),
+    Column("name", String(20)),
+)
+
+
+@pytest.fixture
+async def engine(monkeypatch):
+    # The probe drives the per-test state itself; put it back afterwards.
+    for attr in ("_current_test", "_reset_for", "_built_schema"):
+        monkeypatch.setattr(database, attr, getattr(database, attr))
+    url = database.database_url_for_tests()
+    engine = create_async_engine(url, **database.init_db_kwargs(url))
+    try:
+        yield engine
+    finally:
+        await database.reset_schema(engine)  # the next test rebuilds the real schema
+        await engine.dispose()
+
+
+async def _next_test(engine, builds: list[int]) -> None:
+    async def build(engine) -> None:
+        builds.append(1)
+        async with engine.begin() as conn:
+            await conn.run_sync(_metadata.create_all)
+
+    database.begin_test(object())
+    await database.prepare_schema_once(engine, [_item], build)
+
+
+async def _insert(engine) -> int:
+    async with engine.begin() as conn:
+        return (
+            await conn.execute(_item.insert().values(name="x").returning(_item.c.id))
+        ).scalar_one()
+
+
+async def test_a_later_test_gets_the_same_schema_without_rows(engine):
+    builds: list[int] = []
+    await _next_test(engine, builds)
+    assert [await _insert(engine), await _insert(engine)] == [1, 2]
+
+    await _next_test(engine, builds)
+
+    assert builds == [1]
+    async with engine.connect() as conn:
+        assert await conn.scalar(select(func.count()).select_from(_item)) == 0
+    assert await _insert(engine) == 1  # sequences restart too
+
+
+async def test_a_test_that_changes_the_schema_forces_a_rebuild(engine):
+    builds: list[int] = []
+    await _next_test(engine, builds)
+    async with engine.begin() as conn:
+        await conn.execute(text("CREATE TABLE reuse_probe_extra (x int)"))
+
+    await _next_test(engine, builds)
+
+    assert builds == [1, 1]
+    async with engine.connect() as conn:
+        assert await conn.scalar(text("SELECT to_regclass('reuse_probe_extra')")) is None

simple_module_test-0.0.38/tests/test_waiting_helpers.py

@@ -0,0 +1,88 @@
+import asyncio
+
+import pytest
+from simple_module_test import wait_for, wait_for_sync
+
+
+async def test_returns_value_when_already_true():
+    assert await wait_for(lambda: "ok") == "ok"
+
+
+async def test_polls_sync_predicate_until_true():
+    calls = {"n": 0}
+
+    def pred():
+        calls["n"] += 1
+        return calls["n"] >= 3
+
+    assert await wait_for(pred, interval=0.001) is True
+    assert calls["n"] == 3
+
+
+async def test_async_predicate():
+    state = {"done": False}
+
+    async def pred():
+        return state["done"]
+
+    async def flip():
+        await asyncio.sleep(0.02)  # intentional-sleep: simulate work finishing later
+        state["done"] = True
+
+    task = asyncio.create_task(flip())
+    assert await wait_for(pred, interval=0.005) is True
+    await task
+
+
+async def test_timeout_reports_last_value():
+    with pytest.raises(AssertionError, match=r"last value: 0"):
+        await wait_for(lambda: 0, timeout=0.05, interval=0.005)
+
+
+async def test_predicate_exception_is_retried_then_reported():
+    calls = {"n": 0}
+
+    def pred():
+        calls["n"] += 1
+        if calls["n"] < 3:
+            raise KeyError("missing")
+        return True
+
+    assert await wait_for(pred, interval=0.001)
+
+    def boom():
+        raise ValueError("x")
+
+    with pytest.raises(AssertionError, match="last error: ValueError"):
+        await wait_for(boom, timeout=0.05, interval=0.005)
+
+
+def test_sync_returns_and_polls():
+    calls = {"n": 0}
+
+    def pred():
+        calls["n"] += 1
+        return calls["n"] >= 2
+
+    assert wait_for_sync(pred, interval=0.001) is True
+
+
+def test_sync_timeout():
+    with pytest.raises(AssertionError, match=r"last value: \[\]"):
+        wait_for_sync(list, timeout=0.05, interval=0.005)
+
+
+async def test_hung_async_predicate_times_out():
+    async def hangs():
+        await asyncio.sleep(30)  # intentional-sleep: never returns on its own
+
+    with pytest.raises(AssertionError, match="not satisfied"):
+        await wait_for(hangs, timeout=0.05, interval=0.005)
+
+
+def test_sync_rejects_an_async_predicate():
+    async def pred():
+        return True
+
+    with pytest.raises(TypeError, match="sync predicate"):
+        wait_for_sync(pred)

simple_module_test-0.0.38/tests/test_worker_database.py

@@ -0,0 +1,51 @@
+"""Each xdist worker gets its own Postgres database (``isolate_worker_database``)."""
+
+from __future__ import annotations
+
+import pytest
+from simple_module_test import database
+
+_PG = "postgresql+asyncpg://postgres:secret@db.local:5432/sm_test"
+
+
+@pytest.fixture
+def created(monkeypatch) -> list[tuple[str, str]]:
+    calls: list[tuple[str, str]] = []
+
+    async def fake_create(server_url, name):
+        calls.append((server_url.database, name))
+
+    monkeypatch.setattr(database, "_create_database_if_missing", fake_create)
+    return calls
+
+
+def test_a_worker_is_pointed_at_its_own_database(monkeypatch, created):
+    monkeypatch.setenv(database.TEST_DATABASE_ENV, _PG)
+    monkeypatch.setenv(database.XDIST_WORKER_ENV, "gw3")
+
+    database.isolate_worker_database()
+
+    assert created == [("sm_test", "sm_test_gw3")]
+    assert database.database_url_for_tests() == (
+        "postgresql+asyncpg://postgres:secret@db.local:5432/sm_test_gw3"
+    )
+
+
+def test_outside_xdist_the_named_database_is_used(monkeypatch, created):
+    monkeypatch.setenv(database.TEST_DATABASE_ENV, _PG)
+    monkeypatch.delenv(database.XDIST_WORKER_ENV, raising=False)
+
+    database.isolate_worker_database()
+
+    assert created == []
+    assert database.database_url_for_tests() == _PG
+
+
+def test_sqlite_workers_are_left_alone(monkeypatch, created):
+    monkeypatch.delenv(database.TEST_DATABASE_ENV, raising=False)
+    monkeypatch.setenv(database.XDIST_WORKER_ENV, "gw0")
+
+    database.isolate_worker_database()
+
+    assert created == []
+    assert database.database_url_for_tests() == database.SQLITE_MEMORY

simple_module_test-0.0.36/simple_module_test/database.py

@@ -1,78 +0,0 @@
-"""Which database the test fixtures run on (#343).
-
-In-memory SQLite by default. Set ``SM_TEST_DATABASE_URL`` to an async URL
-(``postgresql+asyncpg://postgres@localhost:5432/sm_test``) to run the same
-suites on Postgres — what SQLite cannot show: real concurrent transactions,
-row locks, stricter types, and SQL that SQLite happens to accept.
-
-On Postgres every fixture starts from an empty ``public`` schema, so tests
-stay independent; pooled connections are disabled because pytest-asyncio
-gives each test its own event loop.
-"""
-
-from __future__ import annotations
-
-import os
-from typing import Any
-
-from sqlalchemy import text
-from sqlalchemy.pool import NullPool
-
-TEST_DATABASE_ENV = "SM_TEST_DATABASE_URL"
-SQLITE_MEMORY = "sqlite+aiosqlite:///:memory:"
-
-
-def database_url_for_tests() -> str:
-    return os.environ.get(TEST_DATABASE_ENV) or SQLITE_MEMORY
-
-
-def is_sqlite(url: str) -> bool:
-    return url.startswith("sqlite")
-
-
-def init_db_kwargs(url: str) -> dict[str, Any]:
-    return {} if is_sqlite(url) else {"poolclass": NullPool}
-
-
-async def reset_schema(engine: Any) -> None:
-    """Empty the database before a test (Postgres); a no-op on SQLite."""
-    if engine.dialect.name == "sqlite":
-        return
-    async with engine.begin() as conn:
-        await conn.execute(text("DROP SCHEMA IF EXISTS public CASCADE"))
-        await conn.execute(text("CREATE SCHEMA public"))
-
-
-# The test the schema was last emptied for. On SQLite every engine is its own
-# in-memory database; on Postgres the ``app`` and ``db_session`` fixtures share
-# one, so a second reset inside the same test would wipe the first fixture's
-# rows (the seeded admin, say) from under it.
-_current_test: object | None = None
-_reset_for: object | None = None
-
-
-def begin_test(token: object) -> None:
-    """Mark the start of a test; the next ``reset_schema_once`` resets."""
-    global _current_test
-    _current_test = token
-
-
-async def reset_schema_once(engine: Any) -> None:
-    """``reset_schema`` at most once per test (see ``begin_test``)."""
-    global _reset_for
-    if _current_test is not None and _reset_for is _current_test:
-        return
-    await reset_schema(engine)
-    _reset_for = _current_test
-
-
-__all__ = [
-    "SQLITE_MEMORY",
-    "TEST_DATABASE_ENV",
-    "begin_test",
-    "database_url_for_tests",
-    "init_db_kwargs",
-    "is_sqlite",
-    "reset_schema",
-    "reset_schema_once",
-]