simple-module-test 0.0.33__tar.gz → 0.0.35__tar.gz

{simple_module_test-0.0.33 → simple_module_test-0.0.35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: simple_module_test
-Version: 0.0.33
+Version: 0.0.35
 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
@@ -25,9 +25,9 @@ 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.33
-Requires-Dist: simple-module-db==0.0.33
-Requires-Dist: simple-module-hosting==0.0.33
+Requires-Dist: simple-module-core==0.0.35
+Requires-Dist: simple-module-db==0.0.35
+Requires-Dist: simple-module-hosting==0.0.35
 Requires-Dist: sqlalchemy>=2.0
 Description-Content-Type: text/markdown
 

{simple_module_test-0.0.33 → simple_module_test-0.0.35}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "simple_module_test"
-version = "0.0.33"
+version = "0.0.35"
 description = "Shared pytest fixtures (app, client, db_session, authenticated_client) for writing simple_module module tests"
 readme = "README.md"
 license = "MIT"
@@ -25,9 +25,9 @@ dependencies = [
     "httpx>=0.27",
     "pytest>=8.0",
     "pytest-asyncio>=0.24",
-    "simple_module_core==0.0.33",
-    "simple_module_db==0.0.33",
-    "simple_module_hosting==0.0.33",
+    "simple_module_core==0.0.35",
+    "simple_module_db==0.0.35",
+    "simple_module_hosting==0.0.35",
     "sqlalchemy>=2.0",
 ]
 

{simple_module_test-0.0.33 → simple_module_test-0.0.35}/simple_module_test/__init__.py

@@ -15,6 +15,8 @@ Primary exports:
 The pytest plugin auto-registers these fixtures (no imports needed):
 ``fake_event_bus``, ``build_test_app``, ``settings``, ``db_state``,
 ``engine``, ``db_session``, ``app``, ``client``, and ``authenticated_client``.
+``redis_server`` starts a throwaway ``redis-server`` for the tests that need a
+real broker (cross-worker cache invalidation) and skips when the binary is absent.
 See ``simple_module_test.plugin`` (and ``simple_module_test.fixtures``) for
 their definitions. ``authenticated_client`` additionally requires the ``users``
 module to be installed — it seeds an admin via ``users.bootstrap``.

simple_module_test-0.0.35/simple_module_test/_schema.py

@@ -0,0 +1,80 @@
+"""Schema construction for the plugin's app fixtures.
+
+Split out of :mod:`simple_module_test.fixtures` so that module declares
+fixtures and this one holds the machinery underneath them: importing every
+installed module's models, resolving the migration heads, creating the tables
+and stamping ``alembic_version`` so the boot-time migration check passes.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import importlib
+from functools import lru_cache
+
+from simple_module_core.discovery import discover_modules
+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)."""
+    for mod in discover_modules():
+        pkg = type(mod).__module__.split(".")[0]
+        with contextlib.suppress(ModuleNotFoundError):
+            importlib.import_module(f"{pkg}.models")
+    return list(all_module_bases)
+
+
+@lru_cache(maxsize=1)
+def _alembic_heads() -> tuple[str, ...]:
+    """Cached head revisions — cannot change within a pytest run.
+
+    Plural: each module's first migration sets its own ``branch_labels``, so
+    the history has one head per module and a real upgraded database carries
+    an ``alembic_version`` row for each. Stamping only one leaves the rest
+    looking un-applied, which now reads as a behind-head schema and puts every
+    test app behind the setup gate.
+    """
+    from simple_module_hosting.migrations import resolve_head_revisions
+
+    return resolve_head_revisions()
+
+
+async def _create_all_tables(engine) -> None:
+    """Create all module tables in a single connection.
+
+    Also stamps the alembic_version table at heads so the app's startup
+    migration check (``check_migrations``) treats the test DB as current.
+    Without the stamp the check would raise because ``create_all`` doesn't
+    touch alembic_version.
+    """
+    from sqlalchemy import text
+
+    from simple_module_test.database import reset_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:
+
+        def _sync_create_all(sync_conn):
+            for base in bases:
+                base.metadata.create_all(sync_conn)
+
+        await conn.run_sync(_sync_create_all)
+
+        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(
+                    text("INSERT INTO alembic_version (version_num) VALUES (:v)"),
+                    {"v": head},
+                )

simple_module_test-0.0.35/simple_module_test/database.py

@@ -0,0 +1,78 @@
+"""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",
+]

{simple_module_test-0.0.33 → simple_module_test-0.0.35}/simple_module_test/fixtures.py

@@ -20,20 +20,18 @@ which soft-imports ``background_tasks``).
 
 from __future__ import annotations
 
-import contextlib
-import importlib
 import os
 from collections.abc import AsyncGenerator, Iterator
-from functools import lru_cache
 
 import httpx
 import pytest
-from simple_module_core.discovery import DEFAULT_AUTH_PROVIDER, discover_modules
-from simple_module_db.base import all_module_bases
+from simple_module_core.discovery import DEFAULT_AUTH_PROVIDER
 from simple_module_db.session import DatabaseState, init_db
 from simple_module_hosting.settings import Settings
 from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession
 
+from simple_module_test._schema import _create_all_tables
+from simple_module_test.database import begin_test, database_url_for_tests, init_db_kwargs
 from simple_module_test.session_cookie import forge_session_cookie
 
 _AUTH_PROVIDER_ENV = "SM_AUTH_PROVIDER"
@@ -66,6 +64,16 @@ def pinned_auth_provider() -> Iterator[str]:
             os.environ[_AUTH_PROVIDER_ENV] = previous
 
 
+@pytest.fixture(autouse=True)
+def fresh_test_database(request: pytest.FixtureRequest) -> None:
+    """Let the first fixture of each test empty the Postgres schema, and no later one.
+
+    A no-op on the default in-memory SQLite, where every engine is already
+    its own empty database (see ``simple_module_test.database``).
+    """
+    begin_test(request.node)
+
+
 @pytest.fixture
 def settings() -> Settings:
     """Settings configured for testing with in-memory SQLite.
@@ -81,7 +89,7 @@ def settings() -> Settings:
     that expects ``/users/login``.
     """
     return Settings(
-        database_url="sqlite+aiosqlite:///:memory:",
+        database_url=database_url_for_tests(),
         environment="testing",
         secret_key="test-secret-key",
         multi_tenant=True,
@@ -95,7 +103,8 @@ async def db_state() -> AsyncGenerator[DatabaseState, None]:
     """Create a fresh in-memory DatabaseState with listeners registered."""
     from simple_module_db.listeners import register_listeners
 
-    state = init_db("sqlite+aiosqlite:///:memory:")
+    url = database_url_for_tests()
+    state = init_db(url, **init_db_kwargs(url))
     register_listeners(state)
     yield state
     await state.engine.dispose()
@@ -107,67 +116,6 @@ async def engine(db_state: DatabaseState) -> AsyncEngine:
     return db_state.engine
 
 
-@lru_cache(maxsize=1)
-def _ensure_models_imported() -> list:
-    """Import all module models so all_module_bases is populated (cached)."""
-    for mod in discover_modules():
-        pkg = type(mod).__module__.split(".")[0]
-        with contextlib.suppress(ModuleNotFoundError):
-            importlib.import_module(f"{pkg}.models")
-    return list(all_module_bases)
-
-
-@lru_cache(maxsize=1)
-def _alembic_heads() -> tuple[str, ...]:
-    """Cached head revisions — cannot change within a pytest run.
-
-    Plural: each module's first migration sets its own ``branch_labels``, so
-    the history has one head per module and a real upgraded database carries
-    an ``alembic_version`` row for each. Stamping only one leaves the rest
-    looking un-applied, which now reads as a behind-head schema and puts every
-    test app behind the setup gate.
-    """
-    from simple_module_hosting.migrations import resolve_head_revisions
-
-    return resolve_head_revisions()
-
-
-async def _create_all_tables(engine) -> None:
-    """Create all module tables in a single connection.
-
-    Also stamps the alembic_version table at heads so the app's startup
-    migration check (``check_migrations``) treats the test DB as current.
-    Without the stamp the check would raise because ``create_all`` doesn't
-    touch alembic_version.
-    """
-    from sqlalchemy import text
-
-    bases = _ensure_models_imported()
-    heads = _alembic_heads()
-
-    async with engine.begin() as conn:
-
-        def _sync_create_all(sync_conn):
-            for base in bases:
-                base.metadata.create_all(sync_conn)
-
-        await conn.run_sync(_sync_create_all)
-
-        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(
-                    text("INSERT INTO alembic_version (version_num) VALUES (:v)"),
-                    {"v": head},
-                )
-
-
 @pytest.fixture
 async def db_session(db_state: DatabaseState) -> AsyncGenerator[AsyncSession, None]:
     """Yield an async session backed by in-memory SQLite."""
@@ -236,12 +184,38 @@ async def app(settings: Settings):
         yield application
 
 
+def _disable_env_bootstrap(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Stop ``bootstrap_admin_from_env`` seeding the app being built.
+
+    ``UsersModule.on_startup`` creates an administrator from
+    ``SM_USERS_BOOTSTRAP_*``, read from the environment *and* from a ``.env`` on
+    disk. A developer who followed ``.env.example`` has those set, so every app
+    this plugin builds gets an admin whether the fixture asked for one or not.
+    For ``setup_pending_app`` that is not a nuisance but the opposite of its
+    contract: the setup gate releases the moment an administrator exists, so the
+    wizard routes 404 and every test using it fails.
+
+    They fail *locally only* — CI has no ``.env`` — which is the worst shape for
+    a fixture to be wrong in, and left the failure looking like test-ordering
+    noise rather than a fixture that does not do what it says.
+    """
+    for key in list(os.environ):
+        if key.startswith("SM_USERS_BOOTSTRAP_"):
+            monkeypatch.delenv(key, raising=False)
+    try:
+        from users import bootstrap as bootstrap_module
+    except ImportError:
+        return  # No local-accounts provider installed; nothing bootstraps.
+    monkeypatch.setattr(bootstrap_module, "_read_dotenv_bootstrap_vars", dict)
+
+
 @pytest.fixture
-async def setup_pending_app(settings: Settings):
+async def setup_pending_app(settings: Settings, monkeypatch: pytest.MonkeyPatch):
     """An app with no administrator, so the first-run setup gate is engaged.
 
     The counterpart to ``app``: use this to assert on setup-mode behaviour.
     """
+    _disable_env_bootstrap(monkeypatch)
     async for application in _build_app(settings, seed_admin=False):
         yield application
 

{simple_module_test-0.0.33 → simple_module_test-0.0.35}/simple_module_test/plugin.py

@@ -9,6 +9,7 @@ test suites — treat the fixture surface like a public API.
 from __future__ import annotations
 
 import contextlib
+import os
 
 import pytest
 
@@ -27,10 +28,12 @@ from simple_module_test.fixtures import (  # noqa: F401
     db_session,
     db_state,
     engine,
+    fresh_test_database,
     pinned_auth_provider,
     settings,
     setup_pending_app,
 )
+from simple_module_test.redis_server import redis_server  # noqa: F401
 
 
 def _bootstrap_eager_celery() -> None:
@@ -40,7 +43,17 @@ def _bootstrap_eager_celery() -> None:
     so the host's ``build_celery`` call never runs and ``task.delay()``
     falls through to the broker. Skipped silently when ``background_tasks``
     isn't installed.
+
+    Also switches off the cross-worker invalidation transport. ``on_startup``
+    would otherwise open a Redis pub/sub listener per app fixture — against a
+    broker no test environment runs — leaving a reconnect loop in the
+    background of every suite. ``setdefault``, so a test that wants the transport
+    can set the variable and get it — though the tests that exercise the transport
+    build ``RedisInvalidationTransport`` directly instead, against either a fake
+    client (``test_bg_invalidation.py``) or a throwaway ``redis-server`` (the
+    ``redis_server`` fixture, used by ``test_bg_invalidation_redis.py``).
     """
+    os.environ.setdefault("SM_BG_TASKS_BROADCAST_INVALIDATIONS", "false")
     with contextlib.suppress(ImportError):
         from background_tasks.celery_app import build_celery
         from background_tasks.settings import BackgroundTasksSettings

simple_module_test-0.0.35/simple_module_test/redis_server.py

@@ -0,0 +1,145 @@
+"""A throwaway ``redis-server`` for tests that need a real broker.
+
+The cross-worker invalidation transport is the one piece of this framework whose
+whole job happens *between* processes, and a fake client cannot show that it
+works — it can only show that this repo's own retry and teardown logic behaves.
+So the tests that matter start a real server.
+
+Deliberately a subprocess rather than a Docker service or the shared
+``dev-services`` stack: a unit-test job that runs ``make install-py`` and nothing
+else must be able to run these, and a developer must not have to bring anything
+up first. The server is ephemeral — a free port, no persistence
+(``--save '' --appendonly no``), killed on teardown — so it cannot collide with
+the real ``dev-services`` Redis on 6379 or leave state behind.
+
+``SM_TEST_REDIS_URL`` overrides all of this and is used as-is, which is how CI
+supplies a Redis **service container** instead of a binary: GitHub's
+``ubuntu-latest`` image does not ship ``redis-server``, contrary to what this
+docstring first claimed — the ``CI`` guard below caught that on the first run,
+which is the whole reason it exists.
+
+Absent both the variable and the binary the fixture skips — except under ``CI``,
+where it **fails**.
+A skip is right on a developer's machine and wrong on a build: the whole point of
+these tests is to cover what the fake client cannot, and a runner image that
+stopped shipping ``redis-server`` would silently shed every one of them while the
+build stayed green. That is the same "passes while testing nothing" failure the
+tests themselves exist to rule out, so it gets an explicit guard rather than a
+sentence in a plan.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import os
+import shutil
+import socket
+import subprocess
+import time
+from collections.abc import Iterator
+
+import pytest
+
+__all__ = ["redis_server"]
+
+_STARTUP_TIMEOUT_SECONDS = 10.0
+_POLL_INTERVAL_SECONDS = 0.05
+
+
+def _free_port() -> int:
+    """A port nothing is listening on, as of a moment ago.
+
+    Inherently racy — the port could be taken between the probe and the bind —
+    but the alternative is a fixed port, which collides with a developer's own
+    Redis and with a parallel test run. ``redis-server`` fails loudly on a taken
+    port, and :func:`_wait_until_ready` turns that into a clear timeout rather
+    than a hang.
+    """
+    with socket.socket() as sock:
+        sock.bind(("127.0.0.1", 0))
+        return int(sock.getsockname()[1])
+
+
+def _wait_until_ready(process: subprocess.Popen, port: int) -> None:
+    """Block until the server accepts a connection, or fail with its output.
+
+    Polls a TCP connect rather than shelling out to ``redis-cli``: one less
+    binary to require, and the thing under test is whether a socket opens.
+    """
+    deadline = time.monotonic() + _STARTUP_TIMEOUT_SECONDS
+    while time.monotonic() < deadline:
+        if process.poll() is not None:
+            output = (process.stdout.read() if process.stdout else "") or "(no output)"
+            raise RuntimeError(f"redis-server exited during startup: {output}")
+        with contextlib.suppress(OSError), socket.create_connection(("127.0.0.1", port), 0.2):
+            return
+        time.sleep(_POLL_INTERVAL_SECONDS)
+    process.kill()
+    raise RuntimeError(f"redis-server did not accept connections on {port} in time")
+
+
+@pytest.fixture(scope="session")
+def redis_server() -> Iterator[str]:
+    """A URL for a usable Redis. Session-scoped — a local start costs ~50ms.
+
+    Session scope means tests share one server, so anything that would leave a
+    subscription or a key behind must clean up after itself. Pub/sub carries no
+    state between messages, which is why sharing is safe for the invalidation
+    tests; a test that wrote keys would want its own database index.
+
+    With ``SM_TEST_REDIS_URL`` set the server is somebody else's — a CI service
+    container — so it is neither private nor guaranteed empty, and this fixture
+    neither starts nor stops it.
+    """
+    external = os.environ.get("SM_TEST_REDIS_URL")
+    if external:
+        yield external
+        return
+
+    binary = shutil.which("redis-server")
+    if binary is None:
+        message = (
+            "no redis-server binary and no SM_TEST_REDIS_URL, so the real-transport "
+            "and cross-process tests cannot run"
+        )
+        if os.environ.get("CI"):
+            pytest.fail(
+                f"{message}. On CI this is a failure, not a skip: silently dropping "
+                "these tests would leave the cross-process claim untested while the "
+                "build stayed green. Give the job a redis service and point "
+                "SM_TEST_REDIS_URL at it, or install redis-server on the runner."
+            )
+        pytest.skip(message)
+
+    port = _free_port()
+    process = subprocess.Popen(
+        [
+            binary,
+            "--port",
+            str(port),
+            "--bind",
+            "127.0.0.1",
+            # No persistence: nothing to write, nothing to load, no dump.rdb
+            # dropped into whatever directory pytest happened to run from.
+            "--save",
+            "",
+            "--appendonly",
+            "no",
+            "--databases",
+            "1",
+        ],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        text=True,
+    )
+    try:
+        _wait_until_ready(process, port)
+        yield f"redis://127.0.0.1:{port}/0"
+    finally:
+        process.terminate()
+        with contextlib.suppress(subprocess.TimeoutExpired):
+            process.wait(timeout=5)
+        if process.poll() is None:
+            process.kill()
+        if process.stdout is not None:
+            process.stdout.close()