create-caspian-app 1.0.0 → 1.0.2

package/dist/tests/conftest.py

@@ -1,89 +1,89 @@
-"""Shared pytest setup for the app-level test suite.
-
-Ensures the project root is importable so `import main` and `from src...`
-resolve the same way they do when Caspian boots the app.
-"""
-
-import asyncio
-import os
-import sys
-from collections.abc import Coroutine
-from pathlib import Path
-from types import SimpleNamespace
-from typing import Optional, TypeVar
-
-import pytest
-
-PROJECT_ROOT = Path(__file__).resolve().parents[1]
-if str(PROJECT_ROOT) not in sys.path:
-    sys.path.insert(0, str(PROJECT_ROOT))
-
-_T = TypeVar("_T")
-
-
-def run_async(coro: Coroutine[object, object, _T]) -> _T:
-    """Run a coroutine to completion and return its result.
-
-    Shared helper so synchronous tests can exercise async runtime code
-    (component compilation, streaming) without a full async test harness.
-    """
-    return asyncio.run(coro)
-
-
-@pytest.fixture
-def fake_request():
-    """Factory for a minimal Starlette-like request stand-in.
-
-    Casp's ``Auth`` reads ``request.session`` while ``StateManager`` reads
-    ``request.state.session`` and ``request.headers``. The factory shares a
-    single session dict between ``request.session`` and ``request.state.session``
-    so both runtimes observe the same store, and exposes ``url``/``method``/
-    ``query_params`` defaults that the auth request-flow helpers touch.
-    """
-
-    def _make(
-        session: Optional[dict] = None,
-        headers: Optional[dict] = None,
-        method: str = "GET",
-        path: str = "/",
-        query_params: Optional[dict] = None,
-    ) -> SimpleNamespace:
-        store: dict = session if session is not None else {}
-        return SimpleNamespace(
-            session=store,
-            state=SimpleNamespace(session=store),
-            headers=headers if headers is not None else {},
-            method=method,
-            url=SimpleNamespace(path=path),
-            query_params=query_params if query_params is not None else {},
-        )
-
-    return _make
-
-
-@pytest.fixture
-def component_fixture_dir():
-    """A throwaway directory for writing component modules a test then imports.
-
-    Tests write ``.py`` component files here and pass the path as ``base_dir``
-    to ``transform_components`` so relative ``@import`` paths resolve against a
-    clean, per-test directory. The compiler only loads components from inside a
-    configured ``componentScanDirs`` root (``src`` here), so the directory must
-    live under ``src`` rather than an arbitrary ``tmp_path``.
-    """
-    import shutil
-    import uuid
-
-    scan_root = PROJECT_ROOT / "src" / "__test_components__"
-    fixture_dir = scan_root / uuid.uuid4().hex
-    fixture_dir.mkdir(parents=True, exist_ok=True)
-    try:
-        yield fixture_dir
-    finally:
-        shutil.rmtree(scan_root, ignore_errors=True)
-
-# Keep the app in its non-production code paths during tests (dev security
-# headers, readable error messages, no HTTPS-only cookies).
-os.environ.setdefault("APP_ENV", "development")
-# Deterministic session secret so importing main.py never raises in dev.
-os.environ.setdefault("AUTH_SECRET", "test-secret-not-for-production")
+"""Shared pytest setup for the app-level test suite.
+
+Ensures the project root is importable so `import main` and `from src...`
+resolve the same way they do when Caspian boots the app.
+"""
+
+import asyncio
+import os
+import sys
+from collections.abc import Coroutine
+from pathlib import Path
+from types import SimpleNamespace
+from typing import Optional, TypeVar
+
+import pytest
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+if str(PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(PROJECT_ROOT))
+
+_T = TypeVar("_T")
+
+
+def run_async(coro: Coroutine[object, object, _T]) -> _T:
+    """Run a coroutine to completion and return its result.
+
+    Shared helper so synchronous tests can exercise async runtime code
+    (component compilation, streaming) without a full async test harness.
+    """
+    return asyncio.run(coro)
+
+
+@pytest.fixture
+def fake_request():
+    """Factory for a minimal Starlette-like request stand-in.
+
+    Casp's ``Auth`` reads ``request.session`` while ``StateManager`` reads
+    ``request.state.session`` and ``request.headers``. The factory shares a
+    single session dict between ``request.session`` and ``request.state.session``
+    so both runtimes observe the same store, and exposes ``url``/``method``/
+    ``query_params`` defaults that the auth request-flow helpers touch.
+    """
+
+    def _make(
+        session: Optional[dict] = None,
+        headers: Optional[dict] = None,
+        method: str = "GET",
+        path: str = "/",
+        query_params: Optional[dict] = None,
+    ) -> SimpleNamespace:
+        store: dict = session if session is not None else {}
+        return SimpleNamespace(
+            session=store,
+            state=SimpleNamespace(session=store),
+            headers=headers if headers is not None else {},
+            method=method,
+            url=SimpleNamespace(path=path),
+            query_params=query_params if query_params is not None else {},
+        )
+
+    return _make
+
+
+@pytest.fixture
+def component_fixture_dir():
+    """A throwaway directory for writing component modules a test then imports.
+
+    Tests write ``.py`` component files here and pass the path as ``base_dir``
+    to ``transform_components`` so relative ``@import`` paths resolve against a
+    clean, per-test directory. The compiler only loads components from inside a
+    configured ``componentScanDirs`` root (``src`` here), so the directory must
+    live under ``src`` rather than an arbitrary ``tmp_path``.
+    """
+    import shutil
+    import uuid
+
+    scan_root = PROJECT_ROOT / "src" / "__test_components__"
+    fixture_dir = scan_root / uuid.uuid4().hex
+    fixture_dir.mkdir(parents=True, exist_ok=True)
+    try:
+        yield fixture_dir
+    finally:
+        shutil.rmtree(scan_root, ignore_errors=True)
+
+# Keep the app in its non-production code paths during tests (dev security
+# headers, readable error messages, no HTTPS-only cookies).
+os.environ.setdefault("APP_ENV", "development")
+# Deterministic session secret so importing main.py never raises in dev.
+os.environ.setdefault("AUTH_SECRET", "test-secret-not-for-production")

package/dist/tests/test_health_route.py

@@ -1,44 +1,44 @@
-"""Integration test for the app's HTTP surface via httpx2's ASGI transport.
-
-`/health` is the simplest always-on route and exercises the full middleware
-stack (session, CSRF, security headers, auth) end to end. We drive the ASGI
-app directly with httpx2's AsyncClient over its ASGITransport rather than
-Starlette's TestClient.
-"""
-
-import asyncio
-
-import httpx2
-
-import main
-
-
-async def _get(path: str) -> httpx2.Response:
-    # ASGITransport speaks to the app in-process; no server/socket required.
-    transport = httpx2.ASGITransport(app=main.app)
-    async with httpx2.AsyncClient(
-        transport=transport, base_url="http://testserver"
-    ) as client:
-        return await client.get(path)
-
-
-def _get_sync(path: str) -> httpx2.Response:
-    # Run the async request from a plain sync test (no pytest-asyncio needed).
-    return asyncio.run(_get(path))
-
-
-def test_health_returns_ok():
-    response = _get_sync("/health")
-    assert response.status_code == 200
-    assert response.json() == {"status": "ok"}
-
-
-def test_health_carries_security_headers():
-    response = _get_sync("/health")
-    # SecurityHeadersMiddleware attaches baseline browser headers.
-    assert response.headers.get("x-content-type-options") == "nosniff"
-
-
-def test_unknown_route_is_404():
-    response = _get_sync("/definitely-not-a-real-route")
-    assert response.status_code == 404
+"""Integration test for the app's HTTP surface via httpx2's ASGI transport.
+
+`/health` is the simplest always-on route and exercises the full middleware
+stack (session, CSRF, security headers, auth) end to end. We drive the ASGI
+app directly with httpx2's AsyncClient over its ASGITransport rather than
+Starlette's TestClient.
+"""
+
+import asyncio
+
+import httpx2
+
+import main
+
+
+async def _get(path: str) -> httpx2.Response:
+    # ASGITransport speaks to the app in-process; no server/socket required.
+    transport = httpx2.ASGITransport(app=main.app)
+    async with httpx2.AsyncClient(
+        transport=transport, base_url="http://testserver"
+    ) as client:
+        return await client.get(path)
+
+
+def _get_sync(path: str) -> httpx2.Response:
+    # Run the async request from a plain sync test (no pytest-asyncio needed).
+    return asyncio.run(_get(path))
+
+
+def test_health_returns_ok():
+    response = _get_sync("/health")
+    assert response.status_code == 200
+    assert response.json() == {"status": "ok"}
+
+
+def test_health_carries_security_headers():
+    response = _get_sync("/health")
+    # SecurityHeadersMiddleware attaches baseline browser headers.
+    assert response.headers.get("x-content-type-options") == "nosniff"
+
+
+def test_unknown_route_is_404():
+    response = _get_sync("/definitely-not-a-real-route")
+    assert response.status_code == 404

package/dist/tests/test_main_helpers.py

@@ -1,112 +1,112 @@
-"""Unit tests for the pure helper functions in `main.py`.
-
-These cover the app-owned logic that has no external dependencies: env
-parsing, query-param coercion, and the component-deferral HTML transform.
-"""
-
-import inspect
-from typing import Optional
-
-import main
-
-
-class TestEnvParsing:
-    def test_csv_env_splits_and_strips(self, monkeypatch):
-        monkeypatch.setenv("SOME_LIST", " a , b ,, c ")
-        assert main._csv_env("SOME_LIST") == ["a", "b", "c"]
-
-    def test_csv_env_missing_is_empty(self, monkeypatch):
-        monkeypatch.delenv("SOME_LIST", raising=False)
-        assert main._csv_env("SOME_LIST") == []
-
-    def test_bool_env_truthy_values(self, monkeypatch):
-        for raw in ("1", "true", "TRUE", "yes", "on"):
-            monkeypatch.setenv("FLAG", raw)
-            assert main._bool_env("FLAG") is True
-
-    def test_bool_env_falsy_and_default(self, monkeypatch):
-        monkeypatch.setenv("FLAG", "nope")
-        assert main._bool_env("FLAG") is False
-        monkeypatch.delenv("FLAG", raising=False)
-        assert main._bool_env("FLAG", default=True) is True
-
-
-class TestScalarCoercion:
-    def test_int_and_float(self):
-        assert main._coerce_scalar("42", int) == 42
-        assert main._coerce_scalar("3.5", float) == 3.5
-
-    def test_bool_variants(self):
-        assert main._coerce_scalar("yes", bool) is True
-        assert main._coerce_scalar("off", bool) is False
-
-    def test_none_passthrough(self):
-        assert main._coerce_scalar(None, int) is None
-
-    def test_bad_int_falls_back_to_string(self):
-        # Best-effort coercion: unparseable input returns the raw string.
-        assert main._coerce_scalar("not-a-number", int) == "not-a-number"
-
-    def test_optional_is_unwrapped(self):
-        assert main._coerce_scalar("7", Optional[int]) == 7
-
-
-class TestUnwrapOptional:
-    def test_unwraps_optional(self):
-        assert main._unwrap_optional(Optional[int]) is int
-
-    def test_leaves_plain_type(self):
-        assert main._unwrap_optional(str) is str
-
-
-class TestQueryParamCoercion:
-    def _param(self, annotation):
-        return inspect.Parameter(
-            "x", inspect.Parameter.POSITIONAL_OR_KEYWORD, annotation=annotation
-        )
-
-    def test_list_param(self):
-        from starlette.datastructures import QueryParams
-        from starlette.requests import Request
-
-        scope = {
-            "type": "http",
-            "query_string": b"x=1&x=2&x=3",
-            "headers": [],
-        }
-        request = Request(scope)
-        # sanity: the request exposes the multi-value list
-        assert isinstance(request.query_params, QueryParams)
-        result = main._coerce_query_param(request, "x", self._param(list[int]))
-        assert result == [1, 2, 3]
-
-    def test_scalar_param(self):
-        from starlette.requests import Request
-
-        scope = {"type": "http", "query_string": b"x=10", "headers": []}
-        request = Request(scope)
-        result = main._coerce_query_param(request, "x", self._param(int))
-        assert result == 10
-
-
-class TestDeferComponentRoots:
-    def test_no_component_is_untouched(self):
-        html = "<div>hello</div>"
-        assert main.defer_component_roots(html) == html
-
-    def test_component_root_is_wrapped_in_template(self):
-        # The transform operates on a full document body, as in production.
-        html = "<body><div pp-component=\"abc\"><span>x</span></div></body>"
-        out = main.defer_component_roots(html)
-        assert "<template" in out
-        assert 'pp-component="abc"' in out
-
-    def test_finalize_html_defers_and_tags_scripts(self):
-        html = (
-            "<body><div pp-component=\"abc\">"
-            "<script>console.log(1)</script></div></body>"
-        )
-        out = main.finalize_html(html)
-        # transform_scripts retags author scripts before deferral.
-        assert 'type="text/pp"' in out
-        assert "<template" in out
+"""Unit tests for the pure helper functions in `main.py`.
+
+These cover the app-owned logic that has no external dependencies: env
+parsing, query-param coercion, and the component-deferral HTML transform.
+"""
+
+import inspect
+from typing import Optional
+
+import main
+
+
+class TestEnvParsing:
+    def test_csv_env_splits_and_strips(self, monkeypatch):
+        monkeypatch.setenv("SOME_LIST", " a , b ,, c ")
+        assert main._csv_env("SOME_LIST") == ["a", "b", "c"]
+
+    def test_csv_env_missing_is_empty(self, monkeypatch):
+        monkeypatch.delenv("SOME_LIST", raising=False)
+        assert main._csv_env("SOME_LIST") == []
+
+    def test_bool_env_truthy_values(self, monkeypatch):
+        for raw in ("1", "true", "TRUE", "yes", "on"):
+            monkeypatch.setenv("FLAG", raw)
+            assert main._bool_env("FLAG") is True
+
+    def test_bool_env_falsy_and_default(self, monkeypatch):
+        monkeypatch.setenv("FLAG", "nope")
+        assert main._bool_env("FLAG") is False
+        monkeypatch.delenv("FLAG", raising=False)
+        assert main._bool_env("FLAG", default=True) is True
+
+
+class TestScalarCoercion:
+    def test_int_and_float(self):
+        assert main._coerce_scalar("42", int) == 42
+        assert main._coerce_scalar("3.5", float) == 3.5
+
+    def test_bool_variants(self):
+        assert main._coerce_scalar("yes", bool) is True
+        assert main._coerce_scalar("off", bool) is False
+
+    def test_none_passthrough(self):
+        assert main._coerce_scalar(None, int) is None
+
+    def test_bad_int_falls_back_to_string(self):
+        # Best-effort coercion: unparseable input returns the raw string.
+        assert main._coerce_scalar("not-a-number", int) == "not-a-number"
+
+    def test_optional_is_unwrapped(self):
+        assert main._coerce_scalar("7", Optional[int]) == 7
+
+
+class TestUnwrapOptional:
+    def test_unwraps_optional(self):
+        assert main._unwrap_optional(Optional[int]) is int
+
+    def test_leaves_plain_type(self):
+        assert main._unwrap_optional(str) is str
+
+
+class TestQueryParamCoercion:
+    def _param(self, annotation):
+        return inspect.Parameter(
+            "x", inspect.Parameter.POSITIONAL_OR_KEYWORD, annotation=annotation
+        )
+
+    def test_list_param(self):
+        from starlette.datastructures import QueryParams
+        from starlette.requests import Request
+
+        scope = {
+            "type": "http",
+            "query_string": b"x=1&x=2&x=3",
+            "headers": [],
+        }
+        request = Request(scope)
+        # sanity: the request exposes the multi-value list
+        assert isinstance(request.query_params, QueryParams)
+        result = main._coerce_query_param(request, "x", self._param(list[int]))
+        assert result == [1, 2, 3]
+
+    def test_scalar_param(self):
+        from starlette.requests import Request
+
+        scope = {"type": "http", "query_string": b"x=10", "headers": []}
+        request = Request(scope)
+        result = main._coerce_query_param(request, "x", self._param(int))
+        assert result == 10
+
+
+class TestDeferComponentRoots:
+    def test_no_component_is_untouched(self):
+        html = "<div>hello</div>"
+        assert main.defer_component_roots(html) == html
+
+    def test_component_root_is_wrapped_in_template(self):
+        # The transform operates on a full document body, as in production.
+        html = "<body><div pp-component=\"abc\"><span>x</span></div></body>"
+        out = main.defer_component_roots(html)
+        assert "<template" in out
+        assert 'pp-component="abc"' in out
+
+    def test_finalize_html_defers_and_tags_scripts(self):
+        html = (
+            "<body><div pp-component=\"abc\">"
+            "<script>console.log(1)</script></div></body>"
+        )
+        out = main.finalize_html(html)
+        # transform_scripts retags author scripts before deferral.
+        assert 'type="text/pp"' in out
+        assert "<template" in out

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-caspian-app",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Scaffold a new Caspian project (FastAPI-powered reactive Python framework).",
   "main": "dist/index.js",
   "type": "module",