simple-module-test 0.0.37__tar.gz → 0.0.39__tar.gz

{simple_module_test-0.0.37 → simple_module_test-0.0.39}/.gitignore

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

{simple_module_test-0.0.37 → simple_module_test-0.0.39}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: simple_module_test
-Version: 0.0.37
+Version: 0.0.39
 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,14 +21,14 @@ 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: httpx>=0.27
-Requires-Dist: pytest-asyncio>=0.24
-Requires-Dist: pytest>=8.0
-Requires-Dist: simple-module-core==0.0.37
-Requires-Dist: simple-module-db==0.0.37
-Requires-Dist: simple-module-hosting==0.0.37
-Requires-Dist: sqlalchemy>=2.0
+Requires-Dist: fastapi<0.157,>=0.140
+Requires-Dist: httpx<0.29,>=0.27
+Requires-Dist: pytest-asyncio<2,>=0.24
+Requires-Dist: pytest<10,>=8.0
+Requires-Dist: simple-module-core==0.0.39
+Requires-Dist: simple-module-db==0.0.39
+Requires-Dist: simple-module-hosting==0.0.39
+Requires-Dist: sqlalchemy<3,>=2.0
 Description-Content-Type: text/markdown
 
 # simple_module_test

{simple_module_test-0.0.37 → simple_module_test-0.0.39}/pyproject.toml

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

{simple_module_test-0.0.37 → simple_module_test-0.0.39}/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.37 → simple_module_test-0.0.39}/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.39/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.37 → simple_module_test-0.0.39}/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.37 → simple_module_test-0.0.39}/simple_module_test/fixtures.py

@@ -161,6 +161,9 @@ async def _seed_setup_admin(application) -> None:
 async def _build_app(settings: Settings, *, seed_admin: bool):
     from simple_module_hosting.app_builder import create_app
 
+    # Process-wide state is reset per test by the autouse fixture in
+    # ``process_state``, not here: a second app built inside one test must not
+    # reset the live first app's mail sender or lease backend.
     application = create_app(settings)
 
     await _create_all_tables(application.state.sm.db.engine)

simple_module_test-0.0.39/simple_module_test/mail.py

@@ -0,0 +1,40 @@
+"""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.mail import MailMessage, install_mail_sender
+
+
+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
+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()
+    install_mail_sender(captured)
+    yield captured

{simple_module_test-0.0.37 → simple_module_test-0.0.39}/simple_module_test/plugin.py

@@ -33,6 +33,8 @@ from simple_module_test.fixtures import (  # noqa: F401
     settings,
     setup_pending_app,
 )
+from simple_module_test.mail import captured_mail  # noqa: F401
+from simple_module_test.process_state import _reset_process_state  # noqa: F401
 from simple_module_test.redis_server import redis_server  # noqa: F401
 from simple_module_test.tenant_client import tenant_client  # noqa: F401
 
@@ -42,15 +44,19 @@ def pytest_configure(config: pytest.Config) -> None:
         "markers",
         "postgres: needs a PostgreSQL test database (SM_TEST_DATABASE_URL=postgresql+...)",
     )
-    from simple_module_test.database import database_is_postgres
 
-    # Every Postgres test drops and recreates ``public`` in the one database, so
-    # xdist workers would wipe each other's schema mid-test.
-    if database_is_postgres() and getattr(config.option, "numprocesses", None):
-        raise pytest.UsageError(
-            "SM_TEST_DATABASE_URL is Postgres, whose schema every test drops: run "
-            "serially with `make test-py-pg` or `-n 0` (`PYTEST_WORKERS=0 make test-py`)"
-        )
+
+@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:
@@ -132,7 +138,7 @@ def _cheap_password_hashing() -> None:
             )
         original_init(self, password_hash)
 
-    PasswordHelper.__init__ = _init  # type: ignore[method-assign]
+    PasswordHelper.__init__ = _init
 
 
 _cheap_password_hashing()

simple_module_test-0.0.39/simple_module_test/process_state.py

@@ -0,0 +1,24 @@
+"""Reset process services between tests and apps built by the test plugin."""
+
+from collections.abc import Iterator
+
+import pytest
+from simple_module_core.leases import reset_lease_backend
+from simple_module_core.mail import reset_mail_sender
+from simple_module_hosting.sentry import reset_sentry
+
+
+def reset_process_state() -> None:
+    """Restore unconfigured services without retaining another app's resources."""
+    reset_mail_sender()
+    reset_lease_backend()
+    reset_sentry()
+
+
+@pytest.fixture(autouse=True)
+def _reset_process_state() -> Iterator[None]:
+    reset_process_state()
+    try:
+        yield
+    finally:
+        reset_process_state()

simple_module_test-0.0.39/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.39/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.39/tests/test_testing_process_state.py

@@ -0,0 +1,94 @@
+"""Process services are isolated between plugin-built apps and tests."""
+
+from unittest.mock import Mock
+
+from simple_module_core.leases import (
+    InProcessLeaseBackend,
+    configure_leases,
+    get_leases,
+    reset_lease_backend,
+)
+from simple_module_core.mail import (
+    ConsoleMailSender,
+    current_mail_sender,
+    install_mail_resolver,
+    install_mail_sender,
+    mail_transport_installed,
+    reset_mail_sender,
+    resolve_mail_sender,
+)
+from simple_module_hosting import sentry
+from simple_module_test.mail import CapturedMail
+from simple_module_test.process_state import reset_process_state
+
+
+async def test_reset_mail_clears_sender_and_worker_resolver() -> None:
+    sender = CapturedMail()
+
+    async def resolver(db):
+        return sender
+
+    install_mail_sender(sender)
+    install_mail_resolver(resolver)
+    reset_mail_sender()
+    assert not mail_transport_installed()
+    assert isinstance(current_mail_sender(), ConsoleMailSender)
+    assert isinstance(await resolve_mail_sender(object()), ConsoleMailSender)
+    assert current_mail_sender().include_body is False
+
+
+async def test_reset_leases_discards_configuration_and_held_names() -> None:
+    original = InProcessLeaseBackend()
+    configure_leases(original)
+    assert await original.acquire("held", "previous-app", 60) == 1
+    reset_lease_backend()
+    replacement = get_leases()
+    assert replacement is not original
+    assert isinstance(replacement, InProcessLeaseBackend)
+    assert await replacement.acquire("held", "next-app", 60) == 1
+
+
+def test_reset_sentry_closes_and_unbinds_client(monkeypatch) -> None:
+    import pytest
+
+    sdk = pytest.importorskip("sentry_sdk")
+    scope = Mock()
+    monkeypatch.setattr(sdk, "get_global_scope", lambda: scope)
+    monkeypatch.setattr(sentry, "_enabled", True)
+    sentry._request_scope.set({"type": "http"})
+    sentry.reset_sentry()
+    scope.client.close.assert_called_once_with()
+    scope.set_client.assert_called_once_with(None)
+    assert not sentry.is_enabled()
+    assert sentry._request_scope.get() is None
+    sentry.reset_sentry()
+    scope.client.close.assert_called_once_with()
+
+
+async def test_plugin_second_app_keeps_first_apps_services(settings, monkeypatch) -> None:
+    """Resets are per test (autouse fixture), so a second app in one test must not
+    wipe the first app's installed mail sender."""
+    from fastapi import FastAPI
+    from simple_module_hosting import app_builder
+    from simple_module_test import fixtures
+
+    def create_app(settings):
+        app = FastAPI()
+        app.state.sm = Mock()
+        return app
+
+    async def create_tables(engine):
+        pass
+
+    monkeypatch.setattr(app_builder, "create_app", create_app)
+    monkeypatch.setattr(fixtures, "_create_all_tables", create_tables)
+    install_mail_sender(CapturedMail())
+    async for _app in fixtures._build_app(settings, seed_admin=False):
+        assert mail_transport_installed()
+    reset_process_state()
+
+
+def test_autouse_reset_clears_state_left_by_a_previous_test() -> None:
+    # The autouse ``_reset_process_state`` fixture ran before this test.
+    assert not mail_transport_installed()
+    assert not sentry.is_enabled()

simple_module_test-0.0.39/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.39/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.37/simple_module_test/database.py

@@ -1,92 +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 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}
-
-
-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 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
-
-
-__all__ = [
-    "SQLITE_MEMORY",
-    "TEST_DATABASE_ENV",
-    "begin_test",
-    "database_is_postgres",
-    "database_url_for_tests",
-    "init_db_kwargs",
-    "is_sqlite",
-    "reset_schema",
-    "reset_schema_once",
-]