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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: simple_module_test
-Version: 0.0.32
+Version: 0.0.34
 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.32
-Requires-Dist: simple-module-db==0.0.32
-Requires-Dist: simple-module-hosting==0.0.32
+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: sqlalchemy>=2.0
 Description-Content-Type: text/markdown
 

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

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

simple_module_test-0.0.34/simple_module_test/_schema.py

@@ -0,0 +1,77 @@
+"""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
+
+    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},
+                )

{simple_module_test-0.0.32 → simple_module_test-0.0.34}/simple_module_test/fixtures.py

@@ -20,20 +20,17 @@ 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.session_cookie import forge_session_cookie
 
 _AUTH_PROVIDER_ENV = "SM_AUTH_PROVIDER"
@@ -107,76 +104,56 @@ 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_head() -> str | None:
-    """Cached head revision — cannot change within a pytest run."""
-    from simple_module_hosting.migrations import resolve_head_revision
-
-    return resolve_head_revision()
-
-
-async def _create_all_tables(engine) -> None:
-    """Create all module tables in a single connection.
+@pytest.fixture
+async def db_session(db_state: DatabaseState) -> AsyncGenerator[AsyncSession, None]:
+    """Yield an async session backed by in-memory SQLite."""
+    await _create_all_tables(db_state.engine)
 
-    Also stamps the alembic_version table at head 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
+    async with db_state.session_factory() as session:
+        yield session
 
-    bases = _ensure_models_imported()
-    head = _alembic_head()
 
-    async with engine.begin() as conn:
+SETUP_ADMIN_EMAIL = "admin@test"
+SETUP_ADMIN_PASSWORD = "test-password"
 
-        def _sync_create_all(sync_conn):
-            for base in bases:
-                base.metadata.create_all(sync_conn)
 
-        await conn.run_sync(_sync_create_all)
+async def _seed_setup_admin(application) -> None:
+    """Make the ``app`` fixture model a *configured* install.
 
-        if head:
-            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"))
-            await conn.execute(
-                text("INSERT INTO alembic_version (version_num) VALUES (:v)"),
-                {"v": head},
-            )
+    ``SetupMiddleware`` redirects every request to ``/setup`` until an
+    administrator exists. That is right for a fresh deployment and wrong for a
+    suite asserting on ordinary pages — without this, every test using ``app``
+    gets a 302.
 
+    Seeds the same admin ``authenticated_client`` uses, so that fixture's own
+    ``create_admin`` call stays idempotent rather than creating a second one.
 
-@pytest.fixture
-async def db_session(db_state: DatabaseState) -> AsyncGenerator[AsyncSession, None]:
-    """Yield an async session backed by in-memory SQLite."""
-    await _create_all_tables(db_state.engine)
+    Skipped when the ``users`` module isn't installed: an install with no
+    local-accounts provider registers no setup step and is never gated, so
+    there is nothing to satisfy. Use ``setup_pending_app`` to exercise the gate.
+    """
+    try:
+        from users.bootstrap import create_admin
+    except ImportError:
+        return
 
-    async with db_state.session_factory() as session:
-        yield session
+    async with application.state.sm.db.session_factory() as session:
+        await create_admin(
+            session,
+            email=SETUP_ADMIN_EMAIL,
+            password=SETUP_ADMIN_PASSWORD,
+            full_name="Test Admin",
+        )
 
 
-@pytest.fixture
-async def app(settings: Settings):
-    """Create a FastAPI app with tables pre-created and lifespan triggered."""
+async def _build_app(settings: Settings, *, seed_admin: bool):
     from simple_module_hosting.app_builder import create_app
 
     application = create_app(settings)
 
     await _create_all_tables(application.state.sm.db.engine)
+    if seed_admin:
+        await _seed_setup_admin(application)
 
     # Trigger lifespan startup so app.state.migration is populated
     ctx = application.router.lifespan_context(application)
@@ -188,6 +165,49 @@ async def app(settings: Settings):
     await ctx.__aexit__(None, None, None)
 
 
+@pytest.fixture
+async def app(settings: Settings):
+    """A configured app: tables created, an admin seeded, lifespan triggered."""
+    async for application in _build_app(settings, seed_admin=True):
+        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, 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
+
+
 @pytest.fixture
 async def client(app) -> AsyncGenerator[httpx.AsyncClient, None]:
     """Unauthenticated async HTTP client."""
@@ -211,10 +231,12 @@ async def authenticated_client(app) -> AsyncGenerator[httpx.AsyncClient, None]:
     from users.bootstrap import create_admin
 
     async with app.state.sm.db.session_factory() as session:
+        # Idempotent: the `app` fixture already seeded this same admin so the
+        # setup gate would release. This resolves its id for the cookie.
         result = await create_admin(
             session,
-            email="admin@test",
-            password="test-password",
+            email=SETUP_ADMIN_EMAIL,
+            password=SETUP_ADMIN_PASSWORD,
             full_name="Test Admin",
         )
         user_id = str(result.user.id)

{simple_module_test-0.0.32 → simple_module_test-0.0.34}/simple_module_test/plugin.py

@@ -29,6 +29,7 @@ from simple_module_test.fixtures import (  # noqa: F401
     engine,
     pinned_auth_provider,
     settings,
+    setup_pending_app,
 )