cuneus 0.2.6__tar.gz → 0.2.7__tar.gz

{cuneus-0.2.6 → cuneus-0.2.7}/.gitignore

@@ -5,7 +5,12 @@ build/
 dist/
 wheels/
 *.egg-info
+.*_cache
+
+# coverage
 .coverage
+htmlcov
+
 
 # Virtual environments
 .venv

{cuneus-0.2.6 → cuneus-0.2.7}/Makefile

@@ -25,7 +25,7 @@ help: ## Help is on the way
 	@grep '^[a-zA-Z]' $(MAKEFILE_LIST) | awk -F ':.*?## ' 'NF==2 {printf "   %-20s%s\n", $$1, $$2}' | sort
 
 # export env vars in order to be used in commands
-export PYTHONPATH ?= ./
+export PYTHONPATH ?= ./src
 
 # uv creates the venv automatically, but this tracks if sync has been run
 $(MARKER): $(PYPROJECT) $(UV_LOCK)

{cuneus-0.2.6 → cuneus-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cuneus
-Version: 0.2.6
+Version: 0.2.7
 Summary: ASGI application wrapper
 Project-URL: Homepage, https://github.com/rmyers/cuneus
 Project-URL: Documentation, https://github.com/rmyers/cuneus#readme
@@ -31,6 +31,7 @@ Requires-Dist: httpx>=0.27; extra == 'dev'
 Requires-Dist: mypy>=1.8; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
 Requires-Dist: pytest-cov>=4.0; extra == 'dev'
+Requires-Dist: pytest-mock; extra == 'dev'
 Requires-Dist: pytest>=8.0; extra == 'dev'
 Requires-Dist: redis>=5.0; extra == 'dev'
 Requires-Dist: ruff>=0.3; extra == 'dev'

{cuneus-0.2.6 → cuneus-0.2.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cuneus"
-version = "0.2.6"
+version = "0.2.7"
 description = "ASGI application wrapper"
 readme = "README.md"
 authors = [{ name = "Robert Myers", email = "robert@julython.org" }]
@@ -26,6 +26,7 @@ dev = [
     "pytest>=8.0",
     "pytest-asyncio>=0.23",
     "pytest-cov>=4.0",
+    "pytest-mock",
     "httpx>=0.27",
     "asgi-lifespan>=2.1.0",
     "ruff>=0.3",
@@ -63,7 +64,28 @@ warn_unused_ignores = true
 [tool.pytest.ini_options]
 asyncio_mode = "auto"
 testpaths = ["tests"]
+addopts = [
+    # "--test-alembic",
+    "--log-cli-level=warning",
+    "--cov=cuneus",
+    "--cov-branch",
+    "--cov-report=term-missing:skip-covered",
+    "--cov-report=html",
+    "--strict-markers",
+    "--strict-config",
+    "--verbose",
+]
 
 [tool.coverage.run]
 source = ["src/cuneus"]
 branch = true
+
+[tool.coverage.report]
+exclude_lines = [
+    "pragma: no cover",
+    "def __repr__",
+    "raise AssertionError",
+    "raise NotImplementedError",
+    "if __name__ == .__main__.:",
+    "if TYPE_CHECKING:",
+]

{cuneus-0.2.6 → cuneus-0.2.7}/src/cuneus/__init__.py

@@ -16,19 +16,21 @@ Example:
 """
 
 from .core.application import build_app
-from .core.execptions import (
+from .core.exceptions import (
     AppException,
     BadRequest,
-    Unauthorized,
+    Conflict,
+    DatabaseError,
+    ErrorResponse,
+    ExceptionExtension,
+    ExternalServiceError,
     Forbidden,
     NotFound,
-    Conflict,
     RateLimited,
-    ServiceUnavailable,
-    DatabaseError,
     RedisError,
-    ExternalServiceError,
-    ExceptionExtension,
+    ServiceUnavailable,
+    Unauthorized,
+    error_responses,
 )
 from .core.extensions import BaseExtension, Extension
 from .core.settings import Settings
@@ -46,14 +48,16 @@ __all__ = [
     # Exceptions
     "AppException",
     "BadRequest",
-    "Unauthorized",
+    "Conflict",
+    "DatabaseError",
+    "ErrorResponse",
+    "ExceptionExtension",
+    "ExternalServiceError",
     "Forbidden",
     "NotFound",
-    "Conflict",
     "RateLimited",
-    "ServiceUnavailable",
-    "DatabaseError",
     "RedisError",
-    "ExternalServiceError",
-    "ExceptionExtension",
+    "ServiceUnavailable",
+    "Unauthorized",
+    "error_responses",
 ]

{cuneus-0.2.6 → cuneus-0.2.7}/src/cuneus/cli.py

@@ -44,7 +44,7 @@ def get_user_cli() -> click.Group | None:
 
 @click.group()
 @click.pass_context
-def cli(ctx: click.Context) -> None:
+def cli(ctx: click.Context) -> None:  # pragma: no cover
     """Cuneus CLI - FastAPI application framework."""
     ctx.ensure_object(dict)
 
@@ -95,7 +95,7 @@ def routes() -> None:
     app = import_from_string(config.app_module)
 
     for route in app.routes:
-        if hasattr(route, "methods"):
+        if hasattr(route, "methods"):  # pragma: no branch
             methods = ",".join(route.methods - {"HEAD", "OPTIONS"})
             click.echo(f"{methods:8} {route.path}")
 

{cuneus-0.2.6 → cuneus-0.2.7}/src/cuneus/core/application.py

@@ -17,40 +17,37 @@ from fastapi import FastAPI
 from starlette.middleware import Middleware
 
 from .settings import Settings
-from .execptions import ExceptionExtension
+from .exceptions import ExceptionExtension
 from .logging import LoggingExtension
-from .extensions import Extension, HasCLI, HasMiddleware
+from .extensions import Extension, HasCLI, HasExceptionHandler, HasMiddleware
 from ..ext.health import HealthExtension
 
 logger = structlog.stdlib.get_logger("cuneus")
 
 type ExtensionInput = Extension | Callable[..., Extension]
 
-DEFAULT_EXTENSIONS = (
+DEFAULTS = (
     LoggingExtension,
     HealthExtension,
     ExceptionExtension,
 )
 
 
+class ExtensionConflictError(Exception):
+    """Raised when extensions have conflicting state keys."""
+
+    pass
+
+
 def _instantiate_extension(
     ext: ExtensionInput, settings: Settings | None = None
 ) -> Extension:
     if isinstance(ext, type) or callable(ext):
-        sig = inspect.signature(ext)
-
-        # Check if it accepts a 'settings' parameter
-        if "settings" in sig.parameters:
-            return ext(settings=settings)
-
-        # Check if it accepts **kwargs
-        has_var_keyword = any(
-            p.kind == inspect.Parameter.VAR_KEYWORD for p in sig.parameters.values()
-        )
-        if has_var_keyword:
+        try:
             return ext(settings=settings)
+        except TypeError:
+            return ext()
 
-        return ext()
     return ext
 
 
@@ -92,13 +89,7 @@ def build_app(
 
     settings = settings or Settings()
 
-    if include_defaults:
-        # Allow users to override a default extension
-        user_types = {type(ext) for ext in extensions}
-        defaults = [ext for ext in DEFAULT_EXTENSIONS if type(ext) not in user_types]
-        all_inputs = (*defaults, *extensions)
-    else:
-        all_inputs = extensions
+    all_inputs = (*DEFAULTS, *extensions) if include_defaults else extensions
 
     all_extensions = [_instantiate_extension(ext, settings) for ext in all_inputs]
 
@@ -117,10 +108,13 @@ def build_app(
             state: dict[str, Any] = {}
 
             for ext in all_extensions:
+                ext_name = ext.__class__.__name__
                 ext_state = await stack.enter_async_context(ext.register(registry, app))
                 if ext_state:
                     if overlap := state.keys() & ext_state.keys():
-                        raise ValueError(f"Extension state key collision: {overlap}")
+                        msg = f"Extension {ext_name} state key collision: {overlap}"
+                        logger.error(msg, ext=ext_name, overlap=overlap)
+                        raise ExtensionConflictError(msg).with_traceback(None) from None
                     state.update(ext_state)
 
             yield state
@@ -129,12 +123,21 @@ def build_app(
     middleware: list[Middleware] = []
 
     for ext in all_extensions:
+        ext_name = ext.__class__.__name__
         if isinstance(ext, HasMiddleware):
-            logger.debug(f"Loading middleware from {ext.__class__.__name__}")
+            logger.debug(f"Loading middleware from {ext_name}")
             middleware.extend(ext.middleware())
         if isinstance(ext, HasCLI):
-            logger.debug(f"Adding cli commands from {ext.__class__.__name__}")
+            logger.debug(f"Adding cli commands from {ext_name}")
             ext.register_cli(app_cli)
 
     app = FastAPI(lifespan=lifespan, middleware=middleware, **fastapi_kwargs)
+
+    # Preform post app initialization extension customization
+    for ext in all_extensions:
+        ext_name = ext.__class__.__name__
+        if isinstance(ext, HasExceptionHandler):
+            logger.debug(f"Loading exception handlers from {ext_name}")
+            ext.add_exception_handler(app)
+
     return app, app_cli

cuneus-0.2.6/src/cuneus/core/execptions.py → cuneus-0.2.7/src/cuneus/core/exceptions.py

@@ -7,7 +7,6 @@ from __future__ import annotations
 from typing import Any
 
 import structlog
-import svcs
 from fastapi import FastAPI, Request
 from fastapi.responses import JSONResponse
 from pydantic import BaseModel
@@ -152,24 +151,14 @@ class ExceptionExtension(BaseExtension):
 
     Catches AppException subclasses and converts to JSON responses.
     Catches unexpected exceptions and returns generic 500s.
-
-    Usage:
-        from qtip import build_app
-        from qtip.core.exceptions import ExceptionExtension, ExceptionSettings
-
-        app = build_app(
-            settings,
-            extensions=[ExceptionExtension(settings)],
-        )
     """
 
     def __init__(self, settings: Settings | None = None) -> None:
         self.settings = settings or Settings()
 
-    async def startup(self, registry: svcs.Registry, app: FastAPI) -> dict[str, Any]:
+    def add_exception_handler(self, app: FastAPI) -> None:
         app.add_exception_handler(AppException, self._handle_app_exception)  # type: ignore[arg-type]
         app.add_exception_handler(Exception, self._handle_unexpected_exception)
-        return {}
 
     def _handle_app_exception(
         self, request: Request, exc: AppException
@@ -179,7 +168,7 @@ class ExceptionExtension(BaseExtension):
         else:
             log.warning("client_error", error_code=exc.error_code, message=exc.message)
 
-        response = exc.to_response(request.state.get("request_id", None))
+        response = exc.to_response(getattr(request.state, "request_id", None))
 
         headers = {}
         if isinstance(exc, RateLimited) and exc.retry_after:
@@ -194,8 +183,7 @@ class ExceptionExtension(BaseExtension):
     def _handle_unexpected_exception(
         self, request: Request, exc: Exception
     ) -> JSONResponse:
-        log.exception("unexpected_error")
-
+        log.exception("unexpected_error", exc_info=exc)
         response: dict[str, Any] = {
             "error": {
                 "code": "internal_error",
@@ -203,7 +191,7 @@ class ExceptionExtension(BaseExtension):
             }
         }
 
-        if hasattr(request.state, "request_id"):
+        if hasattr(request.state, "request_id"):  # pragma: no branch
             response["error"]["request_id"] = request.state.request_id
 
         if self.settings.debug:

{cuneus-0.2.6 → cuneus-0.2.7}/src/cuneus/core/extensions.py

@@ -35,7 +35,7 @@ class Extension(Protocol):
 
     def register(
         self, registry: svcs.Registry, app: FastAPI
-    ) -> AsyncContextManager[dict[str, Any]]:
+    ) -> AsyncContextManager[dict[str, Any]]:  # pragma: no cover
         """
         Async context manager for lifecycle.
 
@@ -50,14 +50,21 @@ class Extension(Protocol):
 class HasMiddleware(Protocol):
     """Extension that provides middleware."""
 
-    def middleware(self) -> list[Middleware]: ...
+    def middleware(self) -> list[Middleware]: ...  # pragma: no cover
 
 
 @runtime_checkable
 class HasCLI(Protocol):
     """Extension that provides CLI commands."""
 
-    def register_cli(self, cli_group: Group) -> None: ...
+    def register_cli(self, cli_group: Group) -> None: ...  # pragma: no cover
+
+
+@runtime_checkable
+class HasExceptionHandler(Protocol):
+    """Extension that provides exception handlers."""
+
+    def add_exception_handler(self, app: FastAPI) -> None: ...  # pragma: no cover
 
 
 class BaseExtension:

{cuneus-0.2.6 → cuneus-0.2.7}/src/cuneus/core/logging.py

@@ -4,18 +4,17 @@ Structured logging with structlog and request context.
 
 from __future__ import annotations
 
-from contextvars import ContextVar
 import logging
 import time
 import uuid
-from typing import Any, Awaitable, Callable, MutableMapping
+from typing import Any, Awaitable, Callable
 
 import structlog
 import svcs
 from fastapi import FastAPI, Request, Response
 from starlette.middleware.base import BaseHTTPMiddleware
 from starlette.middleware import Middleware
-from starlette.types import ASGIApp, Scope, Send, Receive
+from starlette.types import ASGIApp
 
 from .extensions import BaseExtension
 from .settings import Settings
@@ -38,7 +37,7 @@ def configure_structlog(settings: Settings | None = None) -> None:
     ]
 
     renderer: structlog.types.Processor = structlog.dev.ConsoleRenderer(colors=True)
-    if log_settings.log_json:
+    if log_settings.log_json:  # pragma: no cover
         renderer = structlog.processors.JSONRenderer()
 
     # Configure structlog
@@ -79,15 +78,6 @@ class LoggingExtension(BaseExtension):
 
     Integrates with stdlib logging so uvicorn and other libraries
     also output through structlog.
-
-    Usage:
-        from qtip import build_app
-        from qtip.middleware.logging import LoggingExtension, LoggingSettings
-
-        app = build_app(
-            settings,
-            extensions=[LoggingExtension(settings)],
-        )
     """
 
     def __init__(self, settings: Settings | None = None) -> None:
@@ -160,71 +150,3 @@ class LoggingMiddleware(BaseHTTPMiddleware):
             raise
         finally:
             structlog.contextvars.clear_contextvars()
-
-
-# Used by httpx for request ID propagation
-request_id_ctx: ContextVar[str | None] = ContextVar("request_id", default=None)
-
-
-class RequestIDMiddleware:
-    def __init__(self, app: ASGIApp, header_name: str = "X-Request-ID") -> None:
-        self.app = app
-        self.header_name = header_name
-
-    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
-        if scope["type"] != "http":
-            await self.app(scope, receive, send)
-            return
-
-        headers = dict(scope.get("headers", []))
-        request_id = headers.get(
-            self.header_name.lower().encode(), str(uuid.uuid4())[:8].encode()
-        ).decode()
-
-        if "state" not in scope:
-            scope["state"] = {}
-        scope["state"]["request_id"] = request_id
-
-        # Set contextvar for use in HTTP clients
-        token = request_id_ctx.set(request_id)
-
-        async def send_with_request_id(message: MutableMapping[str, Any]) -> None:
-            if message["type"] == "http.response.start":
-                headers = list(message.get("headers", []))
-                headers.append((self.header_name.encode(), request_id.encode()))
-                message["headers"] = headers
-            await send(message)
-
-        try:
-            await self.app(scope, receive, send_with_request_id)
-        finally:
-            request_id_ctx.reset(token)
-
-
-# === Public API ===
-
-
-def get_logger(**initial_context: Any) -> structlog.stdlib.BoundLogger:
-    """
-    Get a logger with optional initial context.
-
-    Usage:
-        log = get_logger()
-        log.info("user logged in", user_id=123)
-    """
-    log = structlog.stdlib.get_logger()
-    if initial_context:
-        log = log.bind(**initial_context)
-    return log
-
-
-def bind_contextvars(**context: Any) -> None:
-    """
-    Bind additional context that will appear in all subsequent logs.
-    """
-    structlog.contextvars.bind_contextvars(**context)
-
-
-def get_request_id(request: Request) -> str:
-    """Get request ID from request state."""
-    return getattr(request.state, "request_id", "-")

cuneus-0.2.7/tests/test_cli.py

@@ -0,0 +1,252 @@
+import pytest
+from click.testing import CliRunner
+from unittest.mock import patch, MagicMock
+
+from cuneus.cli import (
+    import_from_string,
+    get_user_cli,
+    cli,
+    dev,
+    prod,
+    routes,
+    CuneusCLI,
+    main,
+)
+
+
+class TestImportFromString:
+    def test_imports_module_attribute(self):
+        result = import_from_string("os.path:join")
+        from os.path import join
+
+        assert result is join
+
+    def test_raises_on_missing_colon(self):
+        with pytest.raises(ValueError, match="missing function"):
+            import_from_string("os.path.join")
+
+    def test_raises_on_invalid_module(self):
+        with pytest.raises(ModuleNotFoundError):
+            import_from_string("nonexistent.module:func")
+
+    def test_raises_on_invalid_attribute(self):
+        with pytest.raises(AttributeError):
+            import_from_string("os.path:nonexistent_func")
+
+    def test_adds_cwd_to_path(self, tmp_path, monkeypatch):
+        monkeypatch.chdir(tmp_path)
+
+        # Create a temp module
+        (tmp_path / "temp_module.py").write_text("my_var = 42")
+
+        result = import_from_string("temp_module:my_var")
+        assert result == 42
+
+
+class TestGetUserCli:
+    def test_returns_none_on_import_error(self):
+        with patch("cuneus.cli.Settings") as mock_settings:
+            mock_settings.return_value.cli_module = "nonexistent:cli"
+            result = get_user_cli()
+            assert result is None
+
+    def test_returns_cli_on_success(self):
+        import click
+
+        @click.group()
+        def user_cli():
+            pass
+
+        with (
+            patch("cuneus.cli.Settings") as mock_settings,
+            patch("cuneus.cli.import_from_string", return_value=user_cli),
+        ):
+            mock_settings.return_value.cli_module = "myapp:cli"
+            result = get_user_cli()
+            assert result is user_cli
+
+
+class TestCliCommands:
+    @pytest.fixture
+    def runner(self):
+        return CliRunner()
+
+    def test_cli_help(self, runner):
+        result = runner.invoke(cli, ["--help"])
+        assert result.exit_code == 0
+        assert "Cuneus CLI" in result.output
+
+    def test_dev_command(self, runner):
+        with (
+            patch("cuneus.cli.Settings") as mock_settings,
+            patch("uvicorn.run") as mock_run,
+        ):
+            mock_settings.return_value.app_module = "myapp:app"
+
+            result = runner.invoke(dev, ["--host", "127.0.0.1", "--port", "3000"])
+
+            assert result.exit_code == 0
+            mock_run.assert_called_once_with(
+                "myapp:app",
+                host="127.0.0.1",
+                port=3000,
+                reload=True,
+                log_config=None,
+                server_header=False,
+            )
+
+    def test_dev_command_defaults(self, runner):
+        with (
+            patch("cuneus.cli.Settings") as mock_settings,
+            patch("uvicorn.run") as mock_run,
+        ):
+            mock_settings.return_value.app_module = "myapp:app"
+
+            result = runner.invoke(dev)
+
+            assert result.exit_code == 0
+            mock_run.assert_called_once_with(
+                "myapp:app",
+                host="0.0.0.0",
+                port=8000,
+                reload=True,
+                log_config=None,
+                server_header=False,
+            )
+
+    def test_prod_command(self, runner):
+        with (
+            patch("cuneus.cli.Settings") as mock_settings,
+            patch("uvicorn.run") as mock_run,
+        ):
+            mock_settings.return_value.app_module = "myapp:app"
+
+            result = runner.invoke(prod, ["--workers", "4"])
+
+            assert result.exit_code == 0
+            mock_run.assert_called_once_with(
+                "myapp:app",
+                host="0.0.0.0",
+                port=8000,
+                workers=4,
+                log_config=None,
+                server_header=False,
+            )
+
+    def test_routes_command(self, runner):
+        mock_app = MagicMock()
+        mock_route = MagicMock()
+        mock_route.methods = {"GET", "HEAD", "OPTIONS"}
+        mock_route.path = "/users"
+        mock_app.routes = [mock_route]
+
+        with (
+            patch("cuneus.cli.Settings") as mock_settings,
+            patch("cuneus.cli.import_from_string", return_value=mock_app),
+        ):
+            mock_settings.return_value.app_module = "myapp:app"
+
+            result = runner.invoke(routes)
+
+            assert result.exit_code == 0
+            assert "GET" in result.output
+            assert "/users" in result.output
+            assert "HEAD" not in result.output
+
+
+class TestCuneusCLI:
+    @pytest.fixture
+    def runner(self):
+        return CliRunner()
+
+    def test_has_base_commands(self):
+        cli = CuneusCLI()
+        commands = cli.list_commands(None)  # type: ignore
+        assert "dev" in commands
+        assert "prod" in commands
+        assert "routes" in commands
+
+    def test_merges_user_commands(self):
+        import click
+
+        @click.group()
+        def user_cli():
+            pass
+
+        @user_cli.command()
+        def custom():
+            click.echo("custom command")
+
+        cli = CuneusCLI()
+        cli._user_cli = user_cli
+        cli._user_cli_loaded = True
+
+        commands = cli.list_commands(None)  # type: ignore
+        assert "dev" in commands
+        assert "custom" in commands
+
+    def test_user_cli_takes_priority(self):
+        import click
+
+        @click.group()
+        def user_cli():
+            pass
+
+        @user_cli.command()
+        def dev():
+            click.echo("user dev")
+
+        cli = CuneusCLI()
+        cli._user_cli = user_cli
+        cli._user_cli_loaded = True
+
+        ctx = click.Context(cli)
+        cmd = cli.get_command(ctx, "dev")
+        assert cmd is not None
+
+        # Should get user's dev, not base dev
+        runner = CliRunner()
+        result = runner.invoke(cmd)
+        assert "user dev" in result.output
+
+    def test_falls_back_to_base_command(self):
+        import click
+
+        @click.group()
+        def user_cli():
+            pass
+
+        cli = CuneusCLI()
+        cli._user_cli = user_cli
+        cli._user_cli_loaded = True
+
+        ctx = click.Context(cli)
+        cmd = cli.get_command(ctx, "routes")
+
+        assert cmd is not None
+        assert cmd.name == "routes"
+
+    def test_lazy_loads_user_cli(self):
+        cli = CuneusCLI()
+        assert cli._user_cli_loaded is False
+
+        with patch("cuneus.cli.get_user_cli", return_value=None) as mock_get:
+            _ = cli.user_cli
+            mock_get.assert_called_once()
+            assert cli._user_cli_loaded is True
+
+            # Second access doesn't reload
+            _ = cli.user_cli
+            mock_get.assert_called_once()
+
+
+class TestMain:
+    def test_main_is_cuneus_cli(self):
+        assert isinstance(main, CuneusCLI)
+
+    def test_main_help(self):
+        runner = CliRunner()
+        with patch.object(CuneusCLI, "user_cli", None):
+            result = runner.invoke(main, ["--help"])
+            assert result.exit_code == 0
+            assert "Cuneus CLI" in result.output

cuneus-0.2.7/tests/test_exceptions.py

@@ -0,0 +1,178 @@
+import pytest
+from fastapi import FastAPI
+from starlette.testclient import TestClient
+
+from cuneus import (
+    AppException,
+    BadRequest,
+    Conflict,
+    DatabaseError,
+    ErrorResponse,
+    ExceptionExtension,
+    ExternalServiceError,
+    Forbidden,
+    NotFound,
+    RateLimited,
+    RedisError,
+    ServiceUnavailable,
+    Settings,
+    Unauthorized,
+    build_app,
+    error_responses,
+)
+
+
+class TestAppException:
+    def test_defaults(self):
+        exc = AppException()
+        assert exc.status_code == 500
+        assert exc.error_code == "internal_error"
+        assert exc.message == "An unexpected error occurred"
+        assert exc.details == {}
+
+    def test_custom_values(self):
+        exc = AppException(
+            "Something broke",
+            error_code="custom_error",
+            status_code=418,
+            details={"foo": "bar"},
+        )
+        assert exc.message == "Something broke"
+        assert exc.error_code == "custom_error"
+        assert exc.status_code == 418
+        assert exc.details == {"foo": "bar"}
+
+    def test_to_response(self):
+        exc = AppException("Test error", error_code="test", details={"key": "value"})
+        response = exc.to_response(request_id="req-123")
+
+        assert isinstance(response, ErrorResponse)
+        assert response.error.status == 500
+        assert response.error.code == "test"
+        assert response.error.message == "Test error"
+        assert response.error.request_id == "req-123"
+        assert response.error.details == {"key": "value"}
+
+    def test_to_response_no_request_id(self):
+        exc = AppException()
+        response = exc.to_response()
+        assert response.error.request_id is None
+
+
+class TestHttpExceptions:
+    @pytest.mark.parametrize(
+        "exc_class,status,code",
+        [
+            (BadRequest, 400, "bad_request"),
+            (Unauthorized, 401, "unauthorized"),
+            (Forbidden, 403, "forbidden"),
+            (NotFound, 404, "not_found"),
+            (Conflict, 409, "conflict"),
+            (RateLimited, 429, "rate_limited"),
+            (ServiceUnavailable, 503, "service_unavailable"),
+        ],
+    )
+    def test_http_exception_defaults(self, exc_class, status, code):
+        exc = exc_class()
+        assert exc.status_code == status
+        assert exc.error_code == code
+        assert isinstance(exc, AppException)
+
+    def test_rate_limited_retry_after(self):
+        exc = RateLimited(retry_after=60)
+        assert exc.retry_after == 60
+
+
+class TestInfrastructureExceptions:
+    @pytest.mark.parametrize(
+        "exc_class,status,code",
+        [
+            (DatabaseError, 503, "database_error"),
+            (RedisError, 503, "cache_error"),
+            (ExternalServiceError, 502, "external_service_error"),
+        ],
+    )
+    def test_infra_exception_defaults(self, exc_class, status, code):
+        exc = exc_class()
+        assert exc.status_code == status
+        assert exc.error_code == code
+
+
+class TestErrorResponses:
+    def test_single_exception(self):
+        responses = error_responses(NotFound())
+        assert 404 in responses
+        assert responses[404]["model"] == ErrorResponse
+
+    def test_multiple_exceptions(self):
+        responses = error_responses(NotFound(), BadRequest(), Forbidden())
+        assert set(responses.keys()) == {400, 403, 404}
+
+
+class TestExceptionExtension:
+    @pytest.fixture
+    def app(self, request):
+        params = getattr(request, "param", {})
+        settings = Settings(**params)
+        app, _ = build_app(settings=settings)
+
+        @app.get("/app-error")
+        async def raise_app_error():
+            raise NotFound("Item not found", details={"id": 123})
+
+        @app.get("/unexpected")
+        async def raise_unexpected():
+            raise RuntimeError("Boom")
+
+        @app.get("/server-error")
+        async def raise_server_error():
+            raise AppException("Boom")
+
+        @app.get("/rate-limited")
+        async def raise_rate_limited():
+            raise RateLimited(retry_after=30)
+
+        return app
+
+    @pytest.fixture
+    def client(self, app):
+        with TestClient(app, raise_server_exceptions=False) as client:
+            yield client
+
+    def test_handles_app_exception(self, client):
+        resp = client.get("/app-error")
+        assert resp.status_code == 404, resp.text
+        body = resp.json()
+        assert body["error"]["code"] == "not_found"
+        assert body["error"]["message"] == "Item not found"
+        assert body["error"]["details"] == {"id": 123}
+
+    @pytest.mark.parametrize("app", [{"debug": False}], indirect=True)
+    def test_handles_unexpected_exception(self, client):
+        resp = client.get("/unexpected")
+        assert resp.status_code == 500, resp.text
+        body = resp.json()
+        assert body["error"]["code"] == "internal_error"
+        assert body["error"]["message"] == "An unexpected error occurred"
+        assert "details" not in body["error"]
+
+    @pytest.mark.parametrize("app", [{"debug": True}], indirect=True)
+    def test_debug_mode_includes_exception_details(self, client):
+        resp = client.get("/unexpected")
+        assert resp.status_code == 500, resp.text
+        body = resp.json()
+        assert body["error"]["details"]["exception"] == "RuntimeError"
+        assert body["error"]["details"]["message"] == "Boom"
+
+    @pytest.mark.parametrize("app", [{"log_server_errors": True}], indirect=True)
+    def test_log_server_errors(self, client):
+        resp = client.get("/server-error")
+        assert resp.status_code == 500, resp.text
+        body = resp.json()
+        assert body["error"]["code"] == "internal_error"
+        assert body["error"]["message"] == "Boom"
+
+    def test_rate_limited_includes_retry_after_header(self, client):
+        resp = client.get("/rate-limited")
+        assert resp.status_code == 429, resp.text
+        assert resp.headers["Retry-After"] == "30"

cuneus-0.2.7/tests/test_extensions.py

@@ -0,0 +1,7 @@
+from cuneus.core.extensions import BaseExtension
+
+
+async def test_base_extension(mocker):
+    b = BaseExtension()
+    state = await b.startup(mocker.Mock(), mocker.Mock())
+    assert state == {}

cuneus-0.2.7/tests/test_integration.py

@@ -0,0 +1,111 @@
+from typing import Any
+
+import pytest
+from click.testing import CliRunner
+from fastapi import FastAPI, Request
+from starlette.testclient import TestClient
+from svcs import Registry
+
+from cuneus import build_app, BaseExtension
+from cuneus.ext import health
+
+
+class MyParamLessExtension(BaseExtension):
+
+    def __init__(self):
+        pass
+
+
+class MyExtraSettings(BaseExtension):
+
+    def __init__(self, debug: bool):
+        self.debug = debug
+
+    async def startup(self, registry: Registry, app: FastAPI) -> dict[str, Any]:
+        await super().startup(registry, app)
+        return {"my_ext": {"debug": self.debug}}
+
+
+class MyConflictState(BaseExtension):
+
+    def __init__(self, debug: bool):
+        self.debug = debug
+
+    async def startup(self, registry: Registry, app: FastAPI) -> dict[str, Any]:
+        await super().startup(registry, app)
+        return {"my_ext": {"debug": self.debug}}
+
+
+async def test_cuneus_defaults():
+    app, _ = build_app()
+
+    @app.get("/some_path")
+    async def something():
+        return {"it": "works"}
+
+    with TestClient(app) as client:
+        resp = client.get("/healthz")
+        assert resp.status_code == 200
+        assert resp.headers.get("X-Request-ID") is None
+        assert resp.json()["status"] == health.HealthStatus.HEALTHY
+
+        # Test other health routes
+        resp = client.get("/healthz/live")
+        assert resp.status_code == 200
+        resp = client.get("/healthz/ready")
+        assert resp.status_code == 200
+
+        resp = client.get("/some_path")
+        assert resp.status_code == 200
+        assert resp.headers["X-Request-ID"] is not None
+
+
+async def test_cuneus_custom_extension():
+    app, _ = build_app(MyParamLessExtension, MyExtraSettings(debug=True))
+
+    @app.get("/some_path")
+    async def something(request: Request):
+        return request.state.my_ext
+
+    with TestClient(app) as client:
+        resp = client.get("/healthz")
+        assert resp.status_code == 200
+        assert resp.headers.get("X-Request-ID") is None
+
+        assert resp.json()["status"] == health.HealthStatus.HEALTHY
+
+        resp = client.get("/some_path")
+        assert resp.status_code == 200
+        assert resp.headers["X-Request-ID"] is not None
+        assert resp.json() == {"debug": True}
+
+
+async def test_cuneus_conflict():
+    app, _ = build_app(MyExtraSettings(debug=True), MyConflictState(False))
+
+    @app.get("/some_path")
+    async def something():
+        return {"it": "works"}
+
+    with pytest.raises(Exception):
+        with TestClient(app) as client:
+            resp = client.get("/healthz")
+            assert resp.status_code == 200
+            assert resp.headers.get("X-Request-ID") is None
+
+
+def test_build_app_setup():
+    with pytest.raises(AttributeError):
+        build_app(lifespan={"lifespan": "this is not allowed"})
+
+    with pytest.raises(AttributeError):
+        build_app(middleware=[{"not": "allowed"}])
+
+
+def test_cli():
+    _, cli = build_app(MyParamLessExtension, MyExtraSettings(debug=True))
+    runner = CliRunner()
+    result = runner.invoke(cli, ["--help"])
+
+    assert result.exit_code == 0
+    assert "Usage:" in result.output

{cuneus-0.2.6 → cuneus-0.2.7}/uv.lock

@@ -249,7 +249,7 @@ toml = [
 
 [[package]]
 name = "cuneus"
-version = "0.2.5"
+version = "0.2.7"
 source = { editable = "." }
 dependencies = [
     { name = "click" },
@@ -282,6 +282,7 @@ dev = [
     { name = "pytest" },
     { name = "pytest-asyncio" },
     { name = "pytest-cov" },
+    { name = "pytest-mock" },
     { name = "redis" },
     { name = "ruff" },
     { name = "sqlalchemy", extra = ["asyncio"] },
@@ -306,6 +307,7 @@ requires-dist = [
     { name = "pytest", marker = "extra == 'dev'", specifier = ">=8.0" },
     { name = "pytest-asyncio", marker = "extra == 'dev'", specifier = ">=0.23" },
     { name = "pytest-cov", marker = "extra == 'dev'", specifier = ">=4.0" },
+    { name = "pytest-mock", marker = "extra == 'dev'" },
     { name = "redis", marker = "extra == 'redis'", specifier = ">=5.0" },
     { name = "ruff", marker = "extra == 'dev'", specifier = ">=0.3" },
     { name = "sqlalchemy", extras = ["asyncio"], marker = "extra == 'database'", specifier = ">=2.0" },
@@ -870,6 +872,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/ee/49/1377b49de7d0c1ce41292161ea0f721913fa8722c19fb9c1e3aa0367eecb/pytest_cov-7.0.0-py3-none-any.whl", hash = "sha256:3b8e9558b16cc1479da72058bdecf8073661c7f57f7d3c5f22a1c23507f2d861", size = 22424, upload-time = "2025-09-09T10:57:00.695Z" },
 ]
 
+[[package]]
+name = "pytest-mock"
+version = "3.15.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/68/14/eb014d26be205d38ad5ad20d9a80f7d201472e08167f0bb4361e251084a9/pytest_mock-3.15.1.tar.gz", hash = "sha256:1849a238f6f396da19762269de72cb1814ab44416fa73a8686deac10b0d87a0f", size = 34036, upload-time = "2025-09-16T16:37:27.081Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5a/cc/06253936f4a7fa2e0f48dfe6d851d9c56df896a9ab09ac019d70b760619c/pytest_mock-3.15.1-py3-none-any.whl", hash = "sha256:0a25e2eb88fe5168d535041d09a4529a188176ae608a6d249ee65abc0949630d", size = 10095, upload-time = "2025-09-16T16:37:25.734Z" },
+]
+
 [[package]]
 name = "python-dotenv"
 version = "1.2.1"

cuneus-0.2.6/tests/test_integration.py

@@ -1,14 +0,0 @@
-from starlette.testclient import TestClient
-
-from cuneus import build_app
-from cuneus.ext import health
-
-
-async def test_cuneus():
-    app, _ = build_app()
-
-    with TestClient(app) as client:
-        resp = client.get("/healthz")
-        assert resp.status_code == 201
-
-        assert resp.json()["status"] == health.HealthStatus.HEALTHY