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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: simple_module_test
-Version: 0.0.34
+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.34
-Requires-Dist: simple-module-db==0.0.34
-Requires-Dist: simple-module-hosting==0.0.34
+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.34 → simple_module_test-0.0.35}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "simple_module_test"
-version = "0.0.34"
+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.34",
-    "simple_module_db==0.0.34",
-    "simple_module_hosting==0.0.34",
+    "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.34 → 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.34 → simple_module_test-0.0.35}/simple_module_test/_schema.py

@@ -51,8 +51,11 @@ async def _create_all_tables(engine) -> None:
     """
     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:
 

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.34 → simple_module_test-0.0.35}/simple_module_test/fixtures.py

@@ -31,6 +31,7 @@ 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"
@@ -63,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.
@@ -78,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,
@@ -92,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()

{simple_module_test-0.0.34 → 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()