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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: simple_module_test
-Version: 0.0.34
+Version: 0.0.36
 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.36
+Requires-Dist: simple-module-db==0.0.36
+Requires-Dist: simple-module-hosting==0.0.36
 Requires-Dist: sqlalchemy>=2.0
 Description-Content-Type: text/markdown
 
@@ -56,6 +56,7 @@ All fixtures below are auto-registered via the `pytest11` entry point — instal
 - `app` — a `create_app(settings)` instance with `lifespan` started and stopped.
 - `client` — an `httpx.AsyncClient` bound to the test app.
 - `authenticated_client` — same but with an admin user seeded and a forged session cookie attached. **Requires the `users` module** to be installed (it seeds the admin via `users.bootstrap`); apps scaffolded by `smpy` include it.
+- `tenant_client` — factory: `async with tenant_client("member") as (client, tenant_id, user_id)` signs in a fresh user who is an `owner` / `admin` / `member` (default `owner`) of a new tenant — or of `tenant_id=` when given — with that tenant active. **Requires the `users` and `tenants` modules.**
 
 ## Usage
 

{simple_module_test-0.0.34 → simple_module_test-0.0.36}/README.md

@@ -23,6 +23,7 @@ All fixtures below are auto-registered via the `pytest11` entry point — instal
 - `app` — a `create_app(settings)` instance with `lifespan` started and stopped.
 - `client` — an `httpx.AsyncClient` bound to the test app.
 - `authenticated_client` — same but with an admin user seeded and a forged session cookie attached. **Requires the `users` module** to be installed (it seeds the admin via `users.bootstrap`); apps scaffolded by `smpy` include it.
+- `tenant_client` — factory: `async with tenant_client("member") as (client, tenant_id, user_id)` signs in a fresh user who is an `owner` / `admin` / `member` (default `owner`) of a new tenant — or of `tenant_id=` when given — with that tenant active. **Requires the `users` and `tenants` modules.**
 
 ## Usage
 

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

@@ -1,6 +1,6 @@
 [project]
 name = "simple_module_test"
-version = "0.0.34"
+version = "0.0.36"
 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.36",
+    "simple_module_db==0.0.36",
+    "simple_module_hosting==0.0.36",
     "sqlalchemy>=2.0",
 ]
 

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

@@ -15,19 +15,26 @@ 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``.
+``tenant_client`` (``users`` + ``tenants``) is a factory yielding a client signed
+in as an ``owner``/``admin``/``member`` of a real tenant — see
+``simple_module_test.tenant_client``.
 """
 
 from simple_module_test.app_factory import build_test_app
 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
 
 __all__ = [
     "FakeEventBus",
     "RecordedEvent",
+    "TenantClient",
     "build_test_app",
     "effective_route_paths",
     "forge_session_cookie",

{simple_module_test-0.0.34 → simple_module_test-0.0.36}/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.36/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.36}/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.36}/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,13 @@ 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
+from simple_module_test.tenant_client import tenant_client  # noqa: F401
 
 
 def _bootstrap_eager_celery() -> None:
@@ -40,7 +44,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.36/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()

simple_module_test-0.0.36/simple_module_test/setup_wizard.py

@@ -0,0 +1,37 @@
+"""Helpers for driving the ``/setup`` wizard from tests.
+
+Every wizard mutation carries the session-bound CSRF token, so a test has to
+do what the page does: load the wizard (which mints the token into the
+session cookie and hands it out as the ``csrfToken`` prop) and echo it back
+as ``X-CSRF-Token``.
+"""
+
+from __future__ import annotations
+
+import httpx
+from simple_module_hosting.csrf import CSRF_HEADER
+
+
+def wizard_client(app) -> httpx.AsyncClient:
+    """An anonymous client for *app*; it keeps the session cookie between calls."""
+    return httpx.AsyncClient(transport=httpx.ASGITransport(app=app), base_url="http://testserver")
+
+
+async def wizard_headers(client: httpx.AsyncClient) -> dict[str, str]:
+    """Load the wizard as Inertia would and return the headers its forms send.
+
+    Raises ``AssertionError`` when the wizard is closed (404) — a test that
+    expected to post into it would otherwise fail with a confusing 403.
+    """
+    resp = await client.get("/setup", headers={"X-Inertia": "true"})
+    assert resp.status_code == 200, f"wizard not open: {resp.status_code}"
+    token = resp.json()["props"]["csrfToken"]
+    return {CSRF_HEADER: token, "Accept": "application/json"}
+
+
+async def post_step(
+    client: httpx.AsyncClient, step_id: str, data: dict | None = None
+) -> httpx.Response:
+    """Submit *step_id*'s wizard form, CSRF token included."""
+    headers = await wizard_headers(client)
+    return await client.post(f"/setup/steps/{step_id}", json=data or {}, headers=headers)

simple_module_test-0.0.36/simple_module_test/tenant_client.py

@@ -0,0 +1,125 @@
+"""``tenant_client``: a signed-in member of a real tenant, with a chosen role.
+
+For a module adopting ``MultiTenantMixin``: its tests need requests that act
+for one tenant, as an ``owner``, ``admin`` or ``member`` there — the role that
+reaches the principal as ``tenant:<role>``::
+
+    async def test_members_can_read(tenant_client):
+        async with tenant_client("member") as (client, tenant_id, user_id):
+            resp = await client.get("/api/things")
+
+    async def test_isolation(tenant_client):
+        async with tenant_client() as a, tenant_client() as b:
+            ...  # two tenants, two owners
+
+    async with tenant_client("owner") as owner, tenant_client(
+        "member", tenant_id=owner.tenant_id
+    ) as member:
+        ...  # two users of the same tenant
+
+Requires the ``users`` and ``tenants`` modules. Both are imported inside the
+fixture body, never at module scope, so this plugin still imports cleanly in
+an app that has neither — the same rule ``authenticated_client`` follows.
+"""
+
+from __future__ import annotations
+
+import uuid
+from collections.abc import AsyncGenerator, Callable
+from contextlib import AbstractAsyncContextManager, asynccontextmanager
+from typing import Any, NamedTuple
+
+import httpx
+import pytest
+from simple_module_core.tenancy import TenantRole
+
+from simple_module_test.session_cookie import forge_session_cookie
+
+
+class TenantClient(NamedTuple):
+    client: httpx.AsyncClient
+    tenant_id: str
+    user_id: str
+
+
+async def create_user(app: Any, email: str) -> str:
+    """A real, active, non-superuser ``users`` row with the ``user`` role; its id."""
+    from users.bootstrap import ensure_user_role
+    from users.models import User, UserRole
+
+    async with app.state.sm.db.session_factory() as session:
+        user = User(
+            id=uuid.uuid4(),
+            email=email,
+            hashed_password="x",
+            is_active=True,
+            is_superuser=False,
+            is_verified=True,
+        )
+        session.add(user)
+        await session.flush()
+        # Seeded lazily: test schemas come from ``create_all`` with no seed rows,
+        # and a missing role must not silently leave the user role-less.
+        role = await ensure_user_role(session)
+        session.add(UserRole(user_id=user.id, role_id=role.id))
+        await session.commit()
+        return str(user.id)
+
+
+async def _join(app: Any, user_id: str, email: str, role: TenantRole, tenant_id: str | None) -> str:
+    from tenants.models import Membership, Tenant
+    from tenants.resolver import forget
+
+    async with app.state.sm.db.session_factory() as session:
+        if tenant_id is None:
+            tenant = Tenant(slug=f"t-{uuid.uuid4().hex[:12]}", name="Test Org")
+            session.add(tenant)
+            await session.flush()
+            tenant_id = tenant.id
+        session.add(Membership(tenant_id=tenant_id, user_id=user_id, role=role, email=email))
+        await session.commit()
+    forget(user_id)  # the resolver caches memberships per user
+    return tenant_id
+
+
+@asynccontextmanager
+async def session_client(app: Any, data: dict[str, Any]) -> AsyncGenerator[httpx.AsyncClient]:
+    """An ``httpx`` client for ``app`` whose signed session cookie holds ``data``."""
+    cookie = forge_session_cookie(app.state.sm.settings.secret_key, data)
+    async with httpx.AsyncClient(
+        transport=httpx.ASGITransport(app=app),
+        base_url="http://testserver",
+        cookies={"session": cookie},
+    ) as client:
+        yield client
+
+
+@pytest.fixture
+def tenant_client(app: Any) -> Callable[..., AbstractAsyncContextManager[TenantClient]]:
+    """Factory: ``tenant_client(role="owner", *, tenant_id=None, email=None)``.
+
+    Creates a user and a membership with ``role`` — in a new tenant, or in
+    ``tenant_id`` when given — and yields a :class:`TenantClient` whose session
+    has that tenant active.
+    """
+    from tenants.constants import SESSION_ACTIVE_TENANT
+
+    @asynccontextmanager
+    async def factory(
+        role: str = TenantRole.OWNER,
+        *,
+        tenant_id: str | None = None,
+        email: str | None = None,
+    ) -> AsyncGenerator[TenantClient]:
+        member_role = TenantRole(role)
+        email = email or f"{member_role}-{uuid.uuid4().hex[:8]}@example.com"
+        user_id = await create_user(app, email)
+        tenant_id = await _join(app, user_id, email, member_role, tenant_id)
+        data = {"user_id": user_id, SESSION_ACTIVE_TENANT: tenant_id}
+        async with session_client(app, data) as client:
+            yield TenantClient(client, tenant_id, user_id)
+
+    return factory
+
+
+__all__ = ["TenantClient", "create_user", "session_client", "tenant_client"]