simple-module-test 0.0.17__tar.gz → 0.0.19__tar.gz

{simple_module_test-0.0.17 → simple_module_test-0.0.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simple_module_test
-Version: 0.0.17
+Version: 0.0.19
 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.17
-Requires-Dist: simple-module-db==0.0.17
-Requires-Dist: simple-module-hosting==0.0.17
+Requires-Dist: simple-module-core==0.0.19
+Requires-Dist: simple-module-db==0.0.19
+Requires-Dist: simple-module-hosting==0.0.19
 Requires-Dist: sqlalchemy>=2.0
 Description-Content-Type: text/markdown
 
@@ -47,11 +47,15 @@ pip install "simple_module_hosting[dev]"
 
 ## What it provides
 
+All fixtures below are auto-registered via the `pytest11` entry point — installing the package is enough.
+
+- `fake_event_bus` — a fresh recording `EventBus` per test that captures every `publish`/`publish_nowait` call.
+- `build_test_app` — callable returning a minimal FastAPI app that loads exactly one module.
 - `settings` — a ready-to-use `Settings` instance with an in-memory SQLite database and multi-tenancy enabled.
 - `db_state`, `engine`, `db_session` — fresh `DatabaseState` per test; `db_session` also creates all module tables and stamps `alembic_version` at head so the boot-time migration check passes.
 - `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.
+- `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.
 
 ## Usage
 

{simple_module_test-0.0.17 → simple_module_test-0.0.19}/README.md

@@ -14,11 +14,15 @@ pip install "simple_module_hosting[dev]"
 
 ## What it provides
 
+All fixtures below are auto-registered via the `pytest11` entry point — installing the package is enough.
+
+- `fake_event_bus` — a fresh recording `EventBus` per test that captures every `publish`/`publish_nowait` call.
+- `build_test_app` — callable returning a minimal FastAPI app that loads exactly one module.
 - `settings` — a ready-to-use `Settings` instance with an in-memory SQLite database and multi-tenancy enabled.
 - `db_state`, `engine`, `db_session` — fresh `DatabaseState` per test; `db_session` also creates all module tables and stamps `alembic_version` at head so the boot-time migration check passes.
 - `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.
+- `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.
 
 ## Usage
 

{simple_module_test-0.0.17 → simple_module_test-0.0.19}/pyproject.toml

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

{simple_module_test-0.0.17 → simple_module_test-0.0.19}/simple_module_test/__init__.py

@@ -12,9 +12,12 @@ Primary exports:
 * :func:`build_test_app` — return a minimal FastAPI app loading exactly
   one module, with an in-memory SQLite DB.
 
-The corresponding pytest fixtures are ``fake_event_bus``, ``test_app``,
-``test_client``, and ``test_db_session``. See ``simple_module_test.plugin``
-for their definitions.
+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``.
+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``.
 """
 
 from simple_module_test.app_factory import build_test_app

simple_module_test-0.0.19/simple_module_test/fixtures.py

@@ -0,0 +1,197 @@
+"""Headline app/db/client fixtures shipped by the pytest plugin.
+
+These are the fixtures the README advertises — ``settings``, ``db_state``,
+``engine``, ``db_session``, ``app``, ``client``, ``authenticated_client`` —
+made available to any test run in an environment that installs
+``simple_module_test`` (the ``pytest11`` entry point re-exports them from
+:mod:`simple_module_test.plugin`). They build a real ``create_app`` against an
+in-memory SQLite DB with every installed module's tables created and the
+``alembic_version`` row stamped at head, so the boot-time migration check
+passes.
+
+Module-scope imports here reference only framework packages
+(``simple_module_core`` / ``simple_module_db`` / ``simple_module_hosting``),
+which are this package's declared dependencies. The one plugin-module coupling
+— ``authenticated_client`` seeding an admin via ``users.bootstrap`` — is a lazy
+import inside the fixture body, so importing this module never requires the
+``users`` module to be installed (mirroring ``plugin._bootstrap_eager_celery``,
+which soft-imports ``background_tasks``).
+"""
+
+from __future__ import annotations
+
+import contextlib
+import importlib
+from collections.abc import AsyncGenerator
+from functools import lru_cache
+
+import httpx
+import pytest
+from simple_module_core.discovery import discover_modules
+from simple_module_db.base import all_module_bases
+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.session_cookie import forge_session_cookie
+
+
+@pytest.fixture
+def settings() -> Settings:
+    """Settings configured for testing with in-memory SQLite.
+
+    Multi-tenancy stays on so the existing ``TenantMiddleware`` tests
+    (and the ``X-Tenant-ID`` header paths they rely on) keep working.
+    Individual tests that want the tenant middleware absent construct
+    their own ``Settings(multi_tenant=False, ...)`` in the test body.
+    """
+    return Settings(
+        database_url="sqlite+aiosqlite:///:memory:",
+        environment="testing",
+        secret_key="test-secret-key",
+        multi_tenant=True,
+        tenant_header="X-Tenant-ID",
+    )
+
+
+@pytest.fixture
+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:")
+    register_listeners(state)
+    yield state
+    await state.engine.dispose()
+
+
+@pytest.fixture
+async def engine(db_state: DatabaseState) -> AsyncEngine:
+    """Return the engine from the test DatabaseState."""
+    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.
+
+    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
+
+    bases = _ensure_models_imported()
+    head = _alembic_head()
+
+    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 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},
+            )
+
+
+@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)
+
+    async with db_state.session_factory() as session:
+        yield session
+
+
+@pytest.fixture
+async def app(settings: Settings):
+    """Create a FastAPI app with tables pre-created and lifespan triggered."""
+    from simple_module_hosting.app_builder import create_app
+
+    application = create_app(settings)
+
+    await _create_all_tables(application.state.sm.db.engine)
+
+    # Trigger lifespan startup so app.state.migration is populated
+    ctx = application.router.lifespan_context(application)
+    await ctx.__aenter__()
+
+    yield application
+
+    # Lifespan shutdown disposes the engine
+    await ctx.__aexit__(None, None, None)
+
+
+@pytest.fixture
+async def client(app) -> AsyncGenerator[httpx.AsyncClient, None]:
+    """Unauthenticated async HTTP client."""
+    transport = httpx.ASGITransport(app=app)
+    async with httpx.AsyncClient(
+        transport=transport,
+        base_url="http://testserver",
+    ) as c:
+        yield c
+
+
+@pytest.fixture
+async def authenticated_client(app) -> AsyncGenerator[httpx.AsyncClient, None]:
+    """HTTPX client with a signed session cookie carrying a seeded admin user's id.
+
+    Requires the ``users`` module to be installed — it seeds the admin via
+    ``users.bootstrap.create_admin``. The import is deferred to here (not module
+    scope) so this plugin imports cleanly without ``users``; a consumer app that
+    uses this fixture without ``users`` gets a clear ImportError naming it.
+    """
+    from users.bootstrap import create_admin
+
+    async with app.state.sm.db.session_factory() as session:
+        result = await create_admin(
+            session,
+            email="admin@test",
+            password="test-password",
+            full_name="Test Admin",
+        )
+        user_id = str(result.user.id)
+
+    signed = forge_session_cookie(
+        app.state.sm.settings.secret_key,
+        {"user_id": user_id},
+    )
+
+    transport = httpx.ASGITransport(app=app)
+    async with httpx.AsyncClient(
+        transport=transport,
+        base_url="http://testserver",
+        cookies={"session": signed},
+    ) as c:
+        yield c

{simple_module_test-0.0.17 → simple_module_test-0.0.19}/simple_module_test/plugin.py

@@ -15,6 +15,21 @@ import pytest
 from simple_module_test.app_factory import build_test_app as _build_test_app
 from simple_module_test.fake_events import FakeEventBus
 
+# Re-export the headline app/db/client fixtures the README advertises. pytest
+# collects fixture-decorated attributes of the plugin module, so importing them
+# here registers them for every test run that installs simple_module_test —
+# without a per-consumer conftest. Treat this surface like a public API: deleting
+# one breaks external modules' suites. See GH #200.
+from simple_module_test.fixtures import (  # noqa: F401
+    app,
+    authenticated_client,
+    client,
+    db_session,
+    db_state,
+    engine,
+    settings,
+)
+
 
 def _bootstrap_eager_celery() -> None:
     """Register a process-wide eager Celery app before any test runs.

simple_module_test-0.0.19/tests/test_plugin_fixtures.py

@@ -0,0 +1,62 @@
+"""GH #200: the published ``simple_module_test`` plugin must register the
+headline fixtures its README/``__init__`` advertise — not just ``fake_event_bus``
++ ``build_test_app``. Before the fix those fixtures lived only in the framework
+repo's root ``conftest.py``, so a consumer that installed the plugin (but wasn't
+the framework repo) got "fixture not found".
+"""
+
+from __future__ import annotations
+
+# The fixtures the plugin promises. Treat this set as the public fixture
+# surface — dropping one breaks external modules' suites.
+_HEADLINE_FIXTURES = (
+    "fake_event_bus",
+    "build_test_app",
+    "settings",
+    "db_state",
+    "engine",
+    "db_session",
+    "app",
+    "client",
+    "authenticated_client",
+)
+
+
+def _is_pytest_fixture(obj) -> bool:
+    """True if ``obj`` was produced by ``@pytest.fixture`` (version-robust).
+
+    pytest >=8.4 returns a ``FixtureFunctionDefinition`` instance; older
+    versions left the function in place with a ``_pytestfixturefunction``
+    marker attribute. Cover both so this test doesn't pin a pytest version.
+    """
+    return hasattr(obj, "_pytestfixturefunction") or (
+        type(obj).__name__ == "FixtureFunctionDefinition"
+    )
+
+
+def test_plugin_module_exports_every_headline_fixture():
+    """Each advertised fixture is a real ``@pytest.fixture`` on the plugin module."""
+    import simple_module_test.plugin as plugin
+
+    for name in _HEADLINE_FIXTURES:
+        obj = getattr(plugin, name, None)
+        assert obj is not None, f"{name!r} is not exported by simple_module_test.plugin"
+        # A plain function imported by mistake would not satisfy this.
+        assert _is_pytest_fixture(obj), f"{name!r} is not a pytest fixture"
+
+
+def test_plugin_is_registered_via_pytest11_entry_point(pytestconfig):
+    """pytest discovered the plugin through its ``pytest11`` entry point, so a
+    consumer gets the fixtures by installing the package alone."""
+    assert pytestconfig.pluginmanager.hasplugin("simple_module_test")
+
+
+async def test_db_session_fixture_injects_without_a_local_conftest(db_session):
+    """``db_session`` resolves in this test dir, which has no conftest defining
+    it — it can only come from the installed plugin (root conftest no longer
+    provides it). Proves the moved fixture is genuinely shipped, not just
+    re-exported on paper."""
+    from sqlalchemy import text
+
+    result = await db_session.execute(text("SELECT 1"))
+    assert result.scalar_one() == 1