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

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

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

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

@@ -34,6 +34,7 @@ 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 _bootstrap_eager_celery() -> None:

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"]