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

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

@@ -64,3 +64,4 @@ host/client_app/.playwright-cli/*
 .superpowers/
 .qa/
 .verify/
+/openapi.json

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "simple_module_test"
-version = "0.0.35"
+version = "0.0.37"
 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.35",
-    "simple_module_db==0.0.35",
-    "simple_module_hosting==0.0.35",
+    "simple_module_core==0.0.37",
+    "simple_module_db==0.0.37",
+    "simple_module_hosting==0.0.37",
     "sqlalchemy>=2.0",
 ]
 

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

@@ -20,16 +20,21 @@ real broker (cross-worker cache invalidation) and skips when the binary is absen
 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.35 → simple_module_test-0.0.37}/simple_module_test/database.py

@@ -26,6 +26,10 @@ 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")
 
@@ -41,6 +45,15 @@ async def reset_schema(engine: Any) -> None:
     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
@@ -70,6 +83,7 @@ __all__ = [
     "SQLITE_MEMORY",
     "TEST_DATABASE_ENV",
     "begin_test",
+    "database_is_postgres",
     "database_url_for_tests",
     "init_db_kwargs",
     "is_sqlite",

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

@@ -34,6 +34,37 @@ from simple_module_test.fixtures import (  # noqa: F401
     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 pytest_configure(config: pytest.Config) -> None:
+    config.addinivalue_line(
+        "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`)"
+        )
+
+
+def pytest_collection_modifyitems(config: pytest.Config, items: list[pytest.Item]) -> None:
+    """Skip ``@pytest.mark.postgres`` tests unless the test database is Postgres."""
+    from simple_module_test.database import database_is_postgres
+
+    if database_is_postgres():
+        return
+    skip = pytest.mark.skip(
+        reason="needs Postgres: set SM_TEST_DATABASE_URL=postgresql+asyncpg://..."
+    )
+    for item in items:
+        if "postgres" in item.keywords:
+            item.add_marker(skip)
 
 
 def _bootstrap_eager_celery() -> None:
@@ -64,6 +95,49 @@ def _bootstrap_eager_celery() -> None:
 _bootstrap_eager_celery()
 
 
+def _cheap_password_hashing() -> None:
+    """Make ``PasswordHelper()`` hash with minimal Argon2/bcrypt cost.
+
+    Every ``app`` fixture seeds an admin, and production-cost Argon2 is ~90ms
+    of CPU per hash — over a tenth of each app's setup, paid thousands of times
+    a run. The hashes stay real ``$argon2``/``$2b`` strings that verify and
+    upgrade through the same code paths; only their work factor drops, which is
+    a property of deployment rather than anything a test asserts.
+
+    Patched at import, not in a fixture: test modules build ``PasswordHelper()``
+    at module scope during collection, before any fixture runs. An explicit
+    ``password_hash=`` still wins. Skipped when ``fastapi_users`` is absent, or
+    when ``SM_TEST_REAL_PASSWORD_HASHING`` is set — the opt-out for a consumer
+    suite whose tests depend on production hash parameters.
+    """
+    if os.environ.get("SM_TEST_REAL_PASSWORD_HASHING"):
+        return
+    try:
+        from fastapi_users.password import PasswordHelper
+        from pwdlib import PasswordHash
+        from pwdlib.hashers.argon2 import Argon2Hasher
+        from pwdlib.hashers.bcrypt import BcryptHasher
+    except ImportError:
+        return
+
+    original_init = PasswordHelper.__init__
+
+    def _init(self, password_hash: PasswordHash | None = None) -> None:
+        if password_hash is None:
+            password_hash = PasswordHash(
+                (
+                    Argon2Hasher(time_cost=1, memory_cost=8, parallelism=1),
+                    BcryptHasher(rounds=4),
+                )
+            )
+        original_init(self, password_hash)
+
+    PasswordHelper.__init__ = _init  # type: ignore[method-assign]
+
+
+_cheap_password_hashing()
+
+
 @pytest.fixture
 def fake_event_bus() -> FakeEventBus:
     """Fresh recording EventBus for each test."""

simple_module_test-0.0.37/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.37/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"]