simple-module-test 0.0.7__tar.gz

simple_module_test-0.0.7/.gitignore

@@ -0,0 +1,63 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+.venv/
+*.egg
+
+# UV
+uv.lock
+
+# Node
+node_modules/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Environment
+.env
+
+# Database
+*.db
+*.sqlite3
+
+# Module-managed runtime state (e.g. uploaded dataset files,
+# default storage_dir for SM_DATASETS_STORAGE_DIR).
+var/
+
+# file_storage filesystem backend default root (override via SM_FILE_STORAGE_FS_ROOT_PATH).
+uploads/
+
+# Vite
+host/static/dist/
+
+# VitePress (docs)
+docs/.vitepress/cache/
+docs/.vitepress/dist/
+
+# Auto-generated frontend module manifest (regenerated by the host at boot
+# or via `make gen-pages`).
+host/client_app/modules.manifest.json
+host/client_app/modules.generated.ts
+host/client_app/modules.generated.css
+
+# Worktrees
+.worktrees/
+
+# Performance profiles
+.memray/
+.benchmarks/
+
+# OS
+.DS_Store
+Thumbs.db
+
+.playwright-cli/*
+.playwright-mcp/*
+host/client_app/.playwright-cli/*
+.superpowers/

simple_module_test-0.0.7/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Anto Subash
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

simple_module_test-0.0.7/PKG-INFO

@@ -0,0 +1,84 @@
+Metadata-Version: 2.4
+Name: simple_module_test
+Version: 0.0.7
+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
+Project-URL: Issues, https://github.com/antosubash/simple_module_python/issues
+Project-URL: Changelog, https://github.com/antosubash/simple_module_python/blob/main/CHANGELOG.md
+Author-email: Anto Subash <antosubash@live.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: fixtures,pytest,pytest-plugin,simple-module,testing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: FastAPI
+Classifier: Framework :: Pytest
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Testing
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+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.7
+Requires-Dist: simple-module-db==0.0.7
+Requires-Dist: simple-module-hosting==0.0.7
+Requires-Dist: sqlalchemy>=2.0
+Description-Content-Type: text/markdown
+
+# simple_module_test
+
+Shared pytest fixtures and helpers for writing tests against [simple_module](https://github.com/antosubash/simple_module_python) apps and modules.
+
+Fixtures are exposed via a `pytest11` entry point, so installing the package is enough — no `conftest.py` import needed.
+
+## Install
+
+```bash
+pip install simple_module_test
+# or, if you already pulled in the framework:
+pip install "simple_module_hosting[dev]"
+```
+
+## What it provides
+
+- `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.
+
+## Usage
+
+In a module's `tests/test_something.py`:
+
+```python
+import pytest
+
+pytestmark = pytest.mark.asyncio
+
+
+async def test_create_order(authenticated_client):
+    resp = await authenticated_client.post(
+        "/api/orders",
+        json={"customer_id": 1, "total_cents": 9900},
+    )
+    assert resp.status_code == 201
+    assert resp.json()["total_cents"] == 9900
+```
+
+No fixture imports, no `conftest.py` — the `pytest11` entry point auto-loads them.
+
+## Depends on
+
+- `simple_module_core`, `simple_module_db`, `simple_module_hosting`
+- `pytest`, `pytest-asyncio`, `httpx`, `sqlalchemy`
+
+## License
+
+MIT — see [LICENSE](https://github.com/antosubash/simple_module_python/blob/main/LICENSE).

simple_module_test-0.0.7/README.md

@@ -0,0 +1,51 @@
+# simple_module_test
+
+Shared pytest fixtures and helpers for writing tests against [simple_module](https://github.com/antosubash/simple_module_python) apps and modules.
+
+Fixtures are exposed via a `pytest11` entry point, so installing the package is enough — no `conftest.py` import needed.
+
+## Install
+
+```bash
+pip install simple_module_test
+# or, if you already pulled in the framework:
+pip install "simple_module_hosting[dev]"
+```
+
+## What it provides
+
+- `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.
+
+## Usage
+
+In a module's `tests/test_something.py`:
+
+```python
+import pytest
+
+pytestmark = pytest.mark.asyncio
+
+
+async def test_create_order(authenticated_client):
+    resp = await authenticated_client.post(
+        "/api/orders",
+        json={"customer_id": 1, "total_cents": 9900},
+    )
+    assert resp.status_code == 201
+    assert resp.json()["total_cents"] == 9900
+```
+
+No fixture imports, no `conftest.py` — the `pytest11` entry point auto-loads them.
+
+## Depends on
+
+- `simple_module_core`, `simple_module_db`, `simple_module_hosting`
+- `pytest`, `pytest-asyncio`, `httpx`, `sqlalchemy`
+
+## License
+
+MIT — see [LICENSE](https://github.com/antosubash/simple_module_python/blob/main/LICENSE).

simple_module_test-0.0.7/pyproject.toml

@@ -0,0 +1,53 @@
+[project]
+name = "simple_module_test"
+version = "0.0.7"
+description = "Shared pytest fixtures (app, client, db_session, authenticated_client) for writing simple_module module tests"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.12"
+authors = [{ name = "Anto Subash", email = "antosubash@live.com" }]
+keywords = ["simple-module", "pytest", "pytest-plugin", "fixtures", "testing"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Framework :: FastAPI",
+    "Framework :: Pytest",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Testing",
+    "Typing :: Typed",
+]
+dependencies = [
+    "fastapi>=0.115",
+    "httpx>=0.27",
+    "pytest>=8.0",
+    "pytest-asyncio>=0.24",
+    "simple_module_core==0.0.7",
+    "simple_module_db==0.0.7",
+    "simple_module_hosting==0.0.7",
+    "sqlalchemy>=2.0",
+]
+
+[project.entry-points.pytest11]
+simple_module_test = "simple_module_test.plugin"
+
+[project.urls]
+Homepage = "https://github.com/antosubash/simple_module_python"
+Repository = "https://github.com/antosubash/simple_module_python"
+Issues = "https://github.com/antosubash/simple_module_python/issues"
+Changelog = "https://github.com/antosubash/simple_module_python/blob/main/CHANGELOG.md"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["simple_module_test"]
+
+[tool.uv.sources]
+simple_module_core = { workspace = true }
+simple_module_db = { workspace = true }
+simple_module_hosting = { workspace = true }

simple_module_test-0.0.7/simple_module_test/__init__.py

@@ -0,0 +1,29 @@
+"""Shared pytest fixtures and helpers for SimpleModule module authors.
+
+Install with ``pip install simple_module_test[dev]`` (or add it to
+``[project.optional-dependencies].dev`` of your module). The pytest plugin
+registers its fixtures automatically via the ``pytest11`` entry_point — no
+imports needed in your test files.
+
+Primary exports:
+
+* :class:`FakeEventBus` — records every ``publish``/``publish_nowait`` call
+  so tests can assert on emitted events without wiring real subscribers.
+* :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.
+"""
+
+from simple_module_test.app_factory import build_test_app
+from simple_module_test.fake_events import FakeEventBus, RecordedEvent
+from simple_module_test.session_cookie import forge_session_cookie
+
+__all__ = [
+    "FakeEventBus",
+    "RecordedEvent",
+    "build_test_app",
+    "forge_session_cookie",
+]

simple_module_test-0.0.7/simple_module_test/app_factory.py

@@ -0,0 +1,23 @@
+"""Build a minimal FastAPI app wrapping a single module for isolated testing."""
+
+from __future__ import annotations
+
+from fastapi import FastAPI
+from simple_module_core import ModuleBase
+from simple_module_hosting.app_builder import wire_module_routes
+
+
+def build_test_app(module: ModuleBase | type[ModuleBase]) -> FastAPI:
+    """Return a FastAPI app that registers only the given module's routes.
+
+    Accepts either a module class (instantiated lazily) or a pre-built
+    instance. The resulting app has the module's registered routes and
+    empty framework registries so tests don't need the full
+    :func:`simple_module_hosting.create_app` machinery.
+    """
+    instance = module() if isinstance(module, type) else module
+
+    app = FastAPI()
+    app.state.module = instance
+    wire_module_routes(app, instance)
+    return app

simple_module_test-0.0.7/simple_module_test/fake_events.py

@@ -0,0 +1,59 @@
+"""A recording EventBus for tests.
+
+Subclasses the real :class:`simple_module_core.EventBus` so any handlers
+subscribed during a test still run — ``FakeEventBus`` just *additionally*
+records every publish for later assertion. This keeps the surface area
+test-behaves-like-real-behaves small: there's no chance of a test passing
+against the fake but failing against the real bus.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from simple_module_core import Event, EventBus
+
+
+@dataclass(frozen=True)
+class RecordedEvent[E: Event]:
+    """An event observed by the :class:`FakeEventBus` in test order.
+
+    Wrapping the raw event lets us extend this later (e.g. capture timestamp,
+    source module, or stack frame) without changing the ``bus.events`` shape.
+    """
+
+    event: E
+
+
+class FakeEventBus(EventBus):
+    """An EventBus subclass that records every published event."""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.events: list[RecordedEvent] = []
+
+    async def publish(self, event: Event) -> None:  # type: ignore[override]
+        self.events.append(RecordedEvent(event=event))
+        return await super().publish(event)
+
+    def publish_nowait(self, event: Event) -> None:
+        self.events.append(RecordedEvent(event=event))
+        super().publish_nowait(event)
+
+    # ── Assertion helpers ──────────────────────────────────────────
+
+    def clear(self) -> None:
+        """Discard every recorded event (for resetting state between phases)."""
+        self.events.clear()
+
+    def find_by_type[E: Event](self, event_type: type[E]) -> list[E]:
+        """Return every recorded event whose type is exactly ``event_type``."""
+        return [r.event for r in self.events if type(r.event) is event_type]
+
+    def assert_published[E: Event](self, event_type: type[E]) -> list[E]:
+        """Assert at least one event of ``event_type`` was published and return them."""
+        matches = self.find_by_type(event_type)
+        if not matches:
+            seen = ", ".join(sorted({type(r.event).__name__ for r in self.events})) or "<nothing>"
+            raise AssertionError(f"Expected at least one {event_type.__name__} event; saw: {seen}")
+        return matches

simple_module_test-0.0.7/simple_module_test/plugin.py

@@ -0,0 +1,50 @@
+"""Pytest plugin — registered via the ``pytest11`` entry_point in pyproject.toml.
+
+Fixtures declared here are available to every test run in any environment
+that has ``simple_module_test`` installed, without a ``conftest.py``
+import. Delete a fixture from this file and you break external modules'
+test suites — treat the fixture surface like a public API.
+"""
+
+from __future__ import annotations
+
+import contextlib
+
+import pytest
+
+from simple_module_test.app_factory import build_test_app as _build_test_app
+from simple_module_test.fake_events import FakeEventBus
+
+
+def _bootstrap_eager_celery() -> None:
+    """Register a process-wide eager Celery app before any test runs.
+
+    Tests that don't use the ``client`` fixture never trigger the lifespan,
+    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.
+    """
+    with contextlib.suppress(ImportError):
+        from background_tasks.celery_app import build_celery
+        from background_tasks.settings import BackgroundTasksSettings
+
+        build_celery(BackgroundTasksSettings(task_always_eager=True, task_eager_propagates=True))
+
+
+_bootstrap_eager_celery()
+
+
+@pytest.fixture
+def fake_event_bus() -> FakeEventBus:
+    """Fresh recording EventBus for each test."""
+    return FakeEventBus()
+
+
+@pytest.fixture
+def build_test_app():
+    """Callable that wraps a module class in a minimal FastAPI app.
+
+    Exposed as a fixture (not a direct import) so tests can compose it with
+    other fixtures via pytest's dependency resolution.
+    """
+    return _build_test_app

simple_module_test-0.0.7/simple_module_test/session_cookie.py

@@ -0,0 +1,26 @@
+"""Helpers for forging signed Starlette session cookies in tests.
+
+Starlette's ``SessionMiddleware`` encodes sessions as base64-encoded JSON
+signed with an ``itsdangerous`` ``TimestampSigner``. Tests that want to
+skip the HTTP flow (login / locale-switcher / etc.) to establish a session
+can call :func:`forge_session_cookie` to build the exact cookie value the
+middleware would emit, then inject it via ``httpx.AsyncClient(cookies=...)``.
+"""
+
+from __future__ import annotations
+
+import json
+from base64 import b64encode
+
+from itsdangerous import TimestampSigner
+
+
+def forge_session_cookie(secret_key: str, session_data: dict) -> str:
+    """Return the signed cookie value Starlette's SessionMiddleware would emit.
+
+    The encoding (``b64(json)`` signed with ``TimestampSigner``) must match
+    Starlette exactly — otherwise the middleware rejects the cookie and the
+    test request arrives with an empty session.
+    """
+    data = b64encode(json.dumps(session_data).encode())
+    return TimestampSigner(str(secret_key)).sign(data).decode("utf-8")

simple_module_test-0.0.7/tests/test_app_factory.py

@@ -0,0 +1,88 @@
+"""Tests for build_test_app + the bundled pytest fixtures."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from fastapi import APIRouter, FastAPI
+from simple_module_core import Event, ModuleBase, ModuleMeta
+
+
+@dataclass
+class _PingSent(Event):
+    target: str = ""
+
+
+class _EchoModule(ModuleBase):
+    """A toy module used to exercise build_test_app — defines a single GET /ping route."""
+
+    meta = ModuleMeta(
+        name="Echo",
+        route_prefix="/api/echo",
+        view_prefix="/echo",
+        requires_framework=">=1.0,<2.0",
+    )
+
+    def register_routes(self, api_router: APIRouter, view_router: APIRouter) -> None:
+        @api_router.get("/ping")
+        async def ping() -> dict:
+            return {"pong": True}
+
+
+class TestBuildTestApp:
+    async def test_returns_fastapi_instance_from_class(self):
+        """Passing a ModuleBase subclass instantiates it and returns a FastAPI app."""
+        from simple_module_test import build_test_app
+
+        app = build_test_app(_EchoModule)
+        assert isinstance(app, FastAPI)
+
+    async def test_returns_fastapi_instance_from_instance(self):
+        """Accepts an already-instantiated module too."""
+        from simple_module_test import build_test_app
+
+        app = build_test_app(_EchoModule())
+        assert isinstance(app, FastAPI)
+
+    async def test_registers_module_routes_with_prefix(self):
+        """The module's register_routes() runs and its api routes appear under the prefix."""
+        from simple_module_test import build_test_app
+
+        app = build_test_app(_EchoModule)
+        paths = {getattr(r, "path", None) for r in app.routes}
+        assert "/api/echo/ping" in paths
+
+    async def test_module_accessible_on_app_state(self):
+        """The instance is stored on app.state.module so tests can poke at it."""
+        from simple_module_test import build_test_app
+
+        app = build_test_app(_EchoModule)
+        assert isinstance(app.state.module, _EchoModule)
+
+    async def test_isolates_from_other_installed_modules(self):
+        """build_test_app only mounts the given module — Products/Auth routes are absent."""
+        from simple_module_test import build_test_app
+
+        app = build_test_app(_EchoModule)
+        paths = {getattr(r, "path", None) for r in app.routes}
+        assert not any(p and p.startswith("/api/products") for p in paths)
+        assert not any(p and p.startswith("/auth") for p in paths)
+
+
+# ── pytest plugin fixtures ──────────────────────────────────────────
+
+
+class TestPluginFixtures:
+    async def test_fake_event_bus_fixture_is_fresh_each_test_part1(self, fake_event_bus):
+        """First of a pair: publish an event and verify recording."""
+        await fake_event_bus.publish(_PingSent(target="first"))
+        assert len(fake_event_bus.events) == 1
+
+    async def test_fake_event_bus_fixture_is_fresh_each_test_part2(self, fake_event_bus):
+        """Second of the pair: if the fixture leaked state, we'd see the previous event."""
+        assert fake_event_bus.events == []
+
+    async def test_build_test_app_fixture_returns_callable(self, build_test_app):
+        """The fixture exposes the helper as a callable, composable with other fixtures."""
+        app = build_test_app(_EchoModule)
+        assert isinstance(app, FastAPI)

simple_module_test-0.0.7/tests/test_fake_events.py

@@ -0,0 +1,103 @@
+"""Tests for FakeEventBus — the event bus test double."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import pytest
+from simple_module_core import Event
+
+
+@dataclass
+class OrderCreated(Event):
+    order_id: int = 0
+
+
+@dataclass
+class OrderShipped(Event):
+    order_id: int = 0
+    tracking: str = ""
+
+
+class TestFakeEventBus:
+    async def test_records_publish(self):
+        """publish() records the event for later assertion."""
+        from simple_module_test import FakeEventBus
+
+        bus = FakeEventBus()
+        await bus.publish(OrderCreated(order_id=42))
+
+        assert len(bus.events) == 1
+        assert bus.events[0].event.order_id == 42
+        assert type(bus.events[0].event) is OrderCreated
+
+    async def test_records_publish_nowait(self):
+        """publish_nowait() also records without awaiting."""
+        from simple_module_test import FakeEventBus
+
+        bus = FakeEventBus()
+        bus.publish_nowait(OrderCreated(order_id=7))
+        assert len(bus.events) == 1
+
+    async def test_find_by_type(self):
+        """find_by_type filters the recorded log to a single event class."""
+        from simple_module_test import FakeEventBus
+
+        bus = FakeEventBus()
+        await bus.publish(OrderCreated(order_id=1))
+        await bus.publish(OrderShipped(order_id=1, tracking="ABC"))
+        await bus.publish(OrderCreated(order_id=2))
+
+        created = bus.find_by_type(OrderCreated)
+        shipped = bus.find_by_type(OrderShipped)
+        assert len(created) == 2
+        assert len(shipped) == 1
+        assert shipped[0].tracking == "ABC"
+
+    async def test_clear_resets_log(self):
+        """clear() empties the recorded events so test phases can isolate state."""
+        from simple_module_test import FakeEventBus
+
+        bus = FakeEventBus()
+        await bus.publish(OrderCreated())
+        bus.clear()
+        assert bus.events == []
+
+    async def test_subscribed_handlers_still_fire(self):
+        """FakeEventBus is a real EventBus — subscribers still run; recording is additive."""
+        from simple_module_test import FakeEventBus
+
+        bus = FakeEventBus()
+        received: list[int] = []
+
+        async def handler(event: OrderCreated) -> None:
+            received.append(event.order_id)
+
+        bus.subscribe(OrderCreated, handler)
+        await bus.publish(OrderCreated(order_id=99))
+
+        # Handler fired AND event recorded.
+        assert received == [99]
+        assert len(bus.events) == 1
+
+    async def test_assert_published_raises_when_missing(self):
+        """assert_published raises AssertionError when no matching event was recorded."""
+        from simple_module_test import FakeEventBus
+
+        bus = FakeEventBus()
+        await bus.publish(OrderCreated(order_id=1))
+
+        with pytest.raises(AssertionError) as exc_info:
+            bus.assert_published(OrderShipped)
+        assert "OrderShipped" in str(exc_info.value)
+
+    async def test_assert_published_succeeds_when_present(self):
+        """assert_published returns the matching events when at least one is found."""
+        from simple_module_test import FakeEventBus
+
+        bus = FakeEventBus()
+        await bus.publish(OrderCreated(order_id=1))
+        await bus.publish(OrderCreated(order_id=2))
+
+        matches = bus.assert_published(OrderCreated)
+        assert len(matches) == 2