tigrbl_tests 0.3.10.dev1__tar.gz → 0.3.11.dev2__tar.gz

{tigrbl_tests-0.3.10.dev1 → tigrbl_tests-0.3.11.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tigrbl_tests
-Version: 0.3.10.dev1
+Version: 0.3.11.dev2
 Summary: Test suite and fixtures for the Tigrbl framework.
 License-Expression: Apache-2.0
 License-File: LICENSE

{tigrbl_tests-0.3.10.dev1 → tigrbl_tests-0.3.11.dev2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tigrbl_tests"
-version = "0.3.10.dev1"
+version = "0.3.11.dev2"
 description = "Test suite and fixtures for the Tigrbl framework."
 license = "Apache-2.0"
 readme = "README.md"

{tigrbl_tests-0.3.10.dev1 → tigrbl_tests-0.3.11.dev2}/tests/i9n/test_hook_lifecycle.py

@@ -98,6 +98,7 @@ async def test_hook_phases_execution_order(db_mode):
     res = await client.post(
         "/rpc",
         json={
+            "id": "hook-order-check",
             "method": "Item.create",
             "params": {"tenant_id": tid, "name": "test-item"},
         },
@@ -163,6 +164,7 @@ async def test_hook_parity_crud_vs_rpc(db_mode):
     await client.post(
         "/rpc",
         json={
+            "id": "hook-parity-check",
             "method": "Item.create",
             "params": {"tenant_id": tid, "name": "rpc-item"},
         },

{tigrbl_tests-0.3.10.dev1 → tigrbl_tests-0.3.11.dev2}/tests/i9n/test_mountable_lens_uvicorn.py

@@ -26,7 +26,7 @@ async def test_lens_mountable_on_tigrbl_app_uvicorn():
             in response.text
         )
         assert (
-            'href="https://esm.sh/@tigrbljs/tigrbl-lens@latest/dist/tigrbl-lens.css"'
+            'href="https://esm.sh/@tigrbljs/tigrbl-lens@latest/dist/tigrbl-lens.css?css"'
             in response.text
         )
         assert 'import { createRoot } from "react-dom/client";' in response.text

{tigrbl_tests-0.3.10.dev1 → tigrbl_tests-0.3.11.dev2}/tests/i9n/test_v3_default_rpc_ops.py

@@ -140,6 +140,96 @@ async def test_bulk_methods_absent(client_and_model):
         assert not hasattr(Gadget.rpc, name)
 
 
+@pytest_asyncio.fixture()
+async def wrapper_field_client_and_model():
+    Base3.metadata.clear()
+    Base3.registry.dispose()
+
+    class WrapperNamed(Base3):
+        __tablename__ = "wrapper_named"
+        __allow_unmapped__ = True
+
+        id: Mapped[int] = acol(
+            storage=S(type_=Integer, primary_key=True, autoincrement=True)
+        )
+        data: Mapped[str] = acol(
+            storage=S(type_=String, nullable=False),
+            field=F(required_in=("create",)),
+            io=IO(in_verbs=("create", "update"), out_verbs=("read", "list")),
+        )
+
+        __tigrbl_cols__ = {"id": id, "data": data}
+
+    app = Tigrblv3()
+    api = Tigrblv3(engine=mem())
+    api.include_model(WrapperNamed, prefix="")
+    api.mount_jsonrpc(prefix="/rpc")
+    await api.initialize()
+    app.include_router(api.router)
+    transport = ASGITransport(app=app)
+    client = AsyncClient(transport=transport, base_url="http://test")
+    try:
+        yield client, WrapperNamed
+    finally:
+        await client.aclose()
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+async def test_rpc_create_allows_schema_defined_wrapper_like_fields(
+    wrapper_field_client_and_model,
+):
+    client, _ = wrapper_field_client_and_model
+    payload = {
+        "jsonrpc": "2.0",
+        "method": "WrapperNamed.create",
+        "params": {"data": "legit"},
+        "id": 99,
+    }
+
+    response = await client.post("/rpc", json=payload)
+
+    assert response.status_code == 200
+    body = response.json()
+    assert "error" not in body
+    assert body["result"]["data"] == "legit"
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+@pytest.mark.parametrize("wrapper_key", ["data", "payload", "body", "item"])
+async def test_rpc_create_rejects_wrapper_object(wrapper_key, client_and_model):
+    client, _ = client_and_model
+    payload = {
+        "jsonrpc": "2.0",
+        "method": "Gadget.create",
+        "params": {wrapper_key: {"name": "Wrapped", "age": 7}},
+        "id": 11,
+    }
+
+    response = await client.post("/rpc", json=payload)
+
+    assert response.status_code == 200
+    error = response.json()["error"]
+    assert error["code"] == -32602
+    assert error["message"] == "Invalid params"
+    assert error["data"]["disallowed_keys"] == [wrapper_key]
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+@pytest.mark.parametrize("wrapper_key", ["data", "payload", "body", "item"])
+async def test_rest_create_rejects_wrapper_object(wrapper_key, client_and_model):
+    client, _ = client_and_model
+
+    response = await client.post(
+        "/gadget",
+        json={wrapper_key: {"name": "Wrapped", "age": 7}},
+    )
+
+    assert response.status_code == 422
+
+
 @pytest_asyncio.fixture()
 async def bulk_client_and_model():
     Base3.metadata.clear()
@@ -184,6 +274,31 @@ async def bulk_client_and_model():
         await client.aclose()
 
 
+@pytest.mark.i9n
+@pytest.mark.asyncio
+@pytest.mark.parametrize("wrapper_key", ["data", "payload", "body", "item"])
+async def test_rpc_bulk_create_rejects_wrapper_object_items(
+    wrapper_key,
+    bulk_client_and_model,
+):
+    client, _ = bulk_client_and_model
+
+    payload = {
+        "jsonrpc": "2.0",
+        "method": "Gadget.bulk_create",
+        "params": [{wrapper_key: {"name": "Wrapped", "age": 7}}],
+        "id": 20,
+    }
+
+    response = await client.post("/rpc", json=payload)
+
+    assert response.status_code == 200
+    error = response.json()["error"]
+    assert error["code"] == -32602
+    assert error["message"] == "Invalid params"
+    assert error["data"]["disallowed_keys"] == [wrapper_key]
+
+
 @pytest.mark.i9n
 @pytest.mark.asyncio
 async def test_rpc_bulk_ops(bulk_client_and_model):

{tigrbl_tests-0.3.10.dev1 → tigrbl_tests-0.3.11.dev2}/tests/request/test_request_asgi_scope_compat.py

@@ -26,6 +26,8 @@ def test_request_accepts_scope_with_receive_kwarg_for_compatibility() -> None:
     assert request.query == {"a": ["1", "2"], "b": ["3"]}
     assert request.path_params == {"tenant_id": "abc"}
     assert request.headers.authorization == "Bearer test-token"
+    assert request.headers.get("Authorization") == "Bearer test-token"
+    assert request.headers.get("authorization") == "Bearer test-token"
     assert request.bearer_token == "test-token"
     assert request.client.ip == "198.51.100.77"
 

tigrbl_tests-0.3.11.dev2/tests/request/test_request_authn_strip.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from tigrbl.requests import Request
+
+
+def _make_request(*, headers: dict[str, str]) -> Request:
+    return Request(
+        method="GET",
+        path="/authn",
+        headers=headers,
+        query={},
+        path_params={},
+        body=b"",
+    )
+
+
+def test_request_admin_key_is_stripped() -> None:
+    request = _make_request(headers={"X-Admin-Key": "  admin-secret  "})
+
+    assert request.admin_key == "admin-secret"
+
+
+def test_request_bearer_session_token_is_stripped() -> None:
+    request = _make_request(headers={"Authorization": "Bearer   public-token  "})
+
+    assert request.bearer_token == "public-token"
+    assert request.session_token == "public-token"
+
+
+def test_request_cookie_session_token_is_stripped() -> None:
+    request = _make_request(headers={"Cookie": "sid=  session-cookie-token  "})
+
+    assert request.session_token == "session-cookie-token"

{tigrbl_tests-0.3.10.dev1 → tigrbl_tests-0.3.11.dev2}/tests/request/test_request_transport_convenience_dot_notation.py

@@ -32,6 +32,23 @@ def test_request_headers_and_cookies_support_nested_dot_notation_access() -> Non
     assert request.headers.cookie.tenant == "acme"
 
 
+def test_request_cookie_header_supports_many_cookies_with_terse_getters() -> None:
+    request = _make_request(
+        headers={
+            "Cookie": "sid=session-token; tenant=acme; theme=dark; mode=compact",
+        }
+    )
+
+    assert request.headers.get("cookie", "")
+    assert request.headers.cookie.sid == "session-token"
+    assert request.headers.cookie.tenant == "acme"
+    assert request.headers.cookie.theme == "dark"
+    assert request.cookies.get("sid") == "session-token"
+    assert request.cookies.get("tenant") == "acme"
+    assert request.cookies.get("theme") == "dark"
+    assert request.cookies.get("mode") == "compact"
+
+
 @pytest.mark.asyncio()
 async def test_request_exposes_json_and_dot_notation_bearer_conveniences() -> None:
     request = _make_request(

tigrbl_tests-0.3.11.dev2/tests/response/test_response_transport_convenience_dot_notation.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from tigrbl.responses import Response
+
+
+def test_response_supports_instance_json_method_for_body_payload() -> None:
+    response = Response(
+        status_code=200,
+        headers=[("content-type", "application/json; charset=utf-8")],
+        body=b'{"ok":true,"count":1}',
+    )
+
+    assert response.json() == {"ok": True, "count": 1}
+
+
+def test_response_headers_and_cookies_support_dot_notation() -> None:
+    response = Response(
+        status_code=200,
+        headers=[
+            ("x-request-id", "req-123"),
+            ("set-cookie", "sid=session-token; Path=/"),
+        ],
+        body=b"",
+    )
+
+    assert response.headers_map.x_request_id == "req-123"
+    assert response.headers.get("x-request-id") == "req-123"
+    assert "sid" in response.headers.get("set-cookie", "")
+    assert response.cookies.sid == "session-token"
+
+
+def test_response_set_cookie_supports_many_cookies_and_terse_reads() -> None:
+    response = Response(status_code=200, headers=[], body=b"")
+
+    response.set_cookie("sid", "session-token", path="/")
+    response.set_cookie("tenant", "acme", path="/")
+    response.set_cookie("theme", "dark", path="/")
+
+    set_cookie_header = response.headers.get("set-cookie", "")
+    assert "sid=session-token" in set_cookie_header
+    assert "tenant=acme" in set_cookie_header
+    assert "theme=dark" in set_cookie_header
+    assert "session-token" in set_cookie_header.get("sid", "")
+    assert "acme" in set_cookie_header.get("tenant", "")
+    assert "dark" in set_cookie_header.get("theme", "")
+    assert set_cookie_header.get("missing") is None
+
+    assert response.cookies.sid == "session-token"
+    assert response.cookies.tenant == "acme"
+    assert response.cookies.theme == "dark"

tigrbl_tests-0.3.11.dev2/tests/unit/test_jsonrpc_openrpc.py

@@ -0,0 +1,139 @@
+from httpx import ASGITransport, Client
+from sqlalchemy import Column, String
+from tigrbl import Base, TigrblApi, TigrblApp
+from tigrbl.engine.shortcuts import mem
+from tigrbl.orm.mixins import GUIDPk
+
+
+def _build_app():
+    class Widget(Base, GUIDPk):
+        __tablename__ = "widgets_openrpc"
+        name = Column(String, nullable=False)
+
+    app = TigrblApp(engine=mem(async_=False))
+    app.include_model(Widget)
+    app.initialize()
+    app.mount_jsonrpc()
+    return app, Widget
+
+
+def test_openrpc_endpoint_exposed():
+    app, _ = _build_app()
+    transport = ASGITransport(app=app)
+    with Client(transport=transport, base_url="http://test") as client:
+        response = client.get("/openrpc.json")
+
+        assert response.status_code == 200
+        payload = response.json()
+        assert payload["openrpc"] == "1.2.6"
+        assert payload["servers"] == [{"name": app.title, "url": "/rpc"}]
+        assert "methods" in payload
+
+
+def test_openrpc_server_url_respects_jsonrpc_prefix():
+    app, _ = _build_app()
+    app.jsonrpc_prefix = "/rpc/custom"
+    transport = ASGITransport(app=app)
+
+    with Client(transport=transport, base_url="http://test") as client:
+        payload = client.get("/openrpc.json").json()
+
+    assert payload["servers"] == [{"name": app.title, "url": "/rpc/custom"}]
+
+
+def test_openrpc_includes_method_schema():
+    app, model = _build_app()
+    transport = ASGITransport(app=app)
+    with Client(transport=transport, base_url="http://test") as client:
+        payload = client.get("/openrpc.json").json()
+        methods = {method["name"]: method for method in payload["methods"]}
+
+        create_method = methods[f"{model.__name__}.create"]
+        assert create_method["paramStructure"] == "by-name"
+
+        params = create_method["params"][0]["schema"]
+        assert params["title"].startswith(model.__name__)
+        assert "Create" in params["title"]
+
+        result = create_method["result"]["schema"]
+        assert result["title"].startswith(model.__name__)
+        assert "Response" in result["title"]
+
+
+def test_mount_jsonrpc_updates_openrpc_server_url() -> None:
+    app, _ = _build_app()
+    app.mount_jsonrpc(prefix="/jsonrpc")
+    transport = ASGITransport(app=app)
+
+    with Client(transport=transport, base_url="http://test") as client:
+        payload = client.get("/openrpc.json").json()
+
+    assert payload["servers"] == [{"name": app.title, "url": "/jsonrpc"}]
+
+
+def test_jsonrpc_create_accepts_nested_params_mapping() -> None:
+    app, model = _build_app()
+    transport = ASGITransport(app=app)
+
+    request_payload = {
+        "jsonrpc": "2.0",
+        "method": f"{model.__name__}.create",
+        "params": {"params": {"name": "New Widget"}},
+        "id": 1,
+    }
+
+    with Client(transport=transport, base_url="http://test") as client:
+        response = client.post("/rpc", json=request_payload)
+
+    assert response.status_code == 200
+    data = response.json()
+    assert data["id"] == 1
+    assert "error" not in data
+    assert data["result"]["name"] == "New Widget"
+
+
+def test_jsonrpc_notification_without_id_returns_no_content() -> None:
+    app, model = _build_app()
+    transport = ASGITransport(app=app)
+
+    request_payload = {
+        "jsonrpc": "2.0",
+        "method": f"{model.__name__}.create",
+        "params": {"name": "Silent Widget"},
+    }
+
+    with Client(transport=transport, base_url="http://test") as client:
+        response = client.post("/rpc", json=request_payload)
+
+    assert response.status_code == 204
+    assert response.content == b""
+
+
+def test_mount_lens_uses_latest_openrpc_path_by_default() -> None:
+    app, _ = _build_app()
+    app.mount_openrpc(path="/schema/openrpc.json")
+    app.mount_lens(path="/lens-custom")
+
+    transport = ASGITransport(app=app)
+    with Client(transport=transport, base_url="http://test") as client:
+        html = client.get("/lens-custom").text
+
+    assert "/schema/openrpc.json" in html
+
+
+def test_openrpc_server_url_respects_api_mount_jsonrpc_prefix_argument():
+    class Widget(Base, GUIDPk):
+        __tablename__ = "widgets_openrpc_api_mount_prefix"
+        name = Column(String, nullable=False)
+
+    api = TigrblApi(engine=mem(async_=False))
+    api.include_model(Widget)
+    api.initialize()
+    api.mount_jsonrpc(prefix="/jsonrpc")
+    api.mount_openrpc()
+
+    transport = ASGITransport(app=api)
+    with Client(transport=transport, base_url="http://test") as client:
+        payload = client.get("/openrpc.json").json()
+
+    assert payload["servers"] == [{"name": api.title, "url": "/jsonrpc"}]

{tigrbl_tests-0.3.10.dev1 → tigrbl_tests-0.3.11.dev2}/tests/unit/test_openapi_openrpc_schema_separation.py

@@ -48,3 +48,24 @@ def test_openrpc_schema_excludes_openapi_endpoint() -> None:
     method_names = {method["name"].lower() for method in payload["methods"]}
     assert all("openapi" not in name for name in method_names)
     assert all("openrpc" not in name for name in method_names)
+
+
+def test_openapi_schema_excludes_openrpc_even_if_route_is_schema_visible() -> None:
+    app = _build_app()
+
+    def openrpc_override(_request):
+        return {"openrpc": "1.2.6"}
+
+    app.add_api_route(
+        "/openrpc.json",
+        openrpc_override,
+        methods=["GET"],
+        name="openrpc_json",
+        include_in_schema=True,
+    )
+
+    transport = ASGITransport(app=app)
+    with Client(transport=transport, base_url="http://test") as client:
+        payload = client.get("/openapi.json").json()
+
+    assert "/openrpc.json" not in payload["paths"]

tigrbl_tests-0.3.11.dev2/tests/unit/test_rest_request_mapping_access.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+import json
+from collections.abc import Mapping
+from typing import Any
+
+from tigrbl.requests import Request
+from tigrbl.responses import Response
+
+ADMIN_KEY = "admin-secret"
+
+
+def _json_mapping(response: Response) -> Mapping[str, Any]:
+    payload = response.json()
+    if not isinstance(payload, Mapping):
+        raise TypeError("Expected a mapping JSON payload")
+    if isinstance(payload.get("result"), Mapping):
+        return payload["result"]
+    if isinstance(payload.get("data"), Mapping):
+        return payload["data"]
+    return payload
+
+
+def _rest_request(
+    method: str,
+    path: str,
+    payload: dict[str, Any],
+    response_payload: Mapping[str, Any],
+) -> tuple[Request, Response, Mapping[str, Any]]:
+    request = Request(
+        method=method,
+        path=path,
+        headers={"x-admin-key": ADMIN_KEY, "content-type": "application/json"},
+        query={},
+        path_params={},
+        body=json.dumps(payload).encode("utf-8"),
+    )
+    response = Response.json(response_payload)
+    return request, response, _json_mapping(response)
+
+
+def test_rest_request_supports_mapping_access_on_result_payload() -> None:
+    request, response, result = _rest_request(
+        "POST",
+        "/users",
+        {"email": "a@b.com"},
+        {"ok": True, "result": {"id": "u-1", "email": "a@b.com"}},
+    )
+
+    assert request.headers.get("x-admin-key") == ADMIN_KEY
+    assert request.json()["email"] == "a@b.com"
+    assert response.status_code == 200
+    assert isinstance(result, Mapping)
+    assert result["id"] == "u-1"
+    assert result.get("email") == "a@b.com"
+
+
+def test_rest_request_supports_mapping_access_on_data_payload() -> None:
+    request, _, data = _rest_request(
+        "POST",
+        "/users",
+        {"email": "e@f.com"},
+        {"ok": True, "data": {"id": "u-3", "email": "e@f.com"}},
+    )
+
+    assert request.headers.get("x-admin-key") == ADMIN_KEY
+    assert request.json().get("email") == "e@f.com"
+    assert isinstance(data, Mapping)
+    assert data["id"] == "u-3"
+    assert data.get("email") == "e@f.com"
+
+
+def test_rest_request_supports_mapping_access_without_result_envelope() -> None:
+    request, _, data = _rest_request(
+        "GET",
+        "/users/u-2",
+        {},
+        {"id": "u-2", "email": "c@d.com"},
+    )
+
+    assert request.headers.get("x-admin-key") == ADMIN_KEY
+    assert isinstance(data, Mapping)
+    assert data["id"] == "u-2"
+    assert data.get("email") == "c@d.com"
+
+
+def test_response_json_is_mapping_and_supports_data_and_result_access() -> None:
+    response = Response.json(
+        {
+            "ok": True,
+            "data": {"id": "d-1", "name": "data-object"},
+            "result": {"id": "r-1", "name": "result-object"},
+        }
+    )
+
+    payload = response.json()
+    assert isinstance(payload, Mapping)
+    assert payload["data"]["id"] == "d-1"
+    assert payload["result"]["id"] == "r-1"

tigrbl_tests-0.3.10.dev1/tests/response/test_response_transport_convenience_dot_notation.py

@@ -1,27 +0,0 @@
-from __future__ import annotations
-
-from tigrbl.responses import Response
-
-
-def test_response_supports_instance_json_method_for_body_payload() -> None:
-    response = Response(
-        status_code=200,
-        headers=[("content-type", "application/json; charset=utf-8")],
-        body=b'{"ok":true,"count":1}',
-    )
-
-    assert response.json() == {"ok": True, "count": 1}
-
-
-def test_response_headers_and_cookies_support_dot_notation() -> None:
-    response = Response(
-        status_code=200,
-        headers=[
-            ("x-request-id", "req-123"),
-            ("set-cookie", "sid=session-token; Path=/"),
-        ],
-        body=b"",
-    )
-
-    assert response.headers_map.x_request_id == "req-123"
-    assert response.cookies.sid == "session-token"

tigrbl_tests-0.3.10.dev1/tests/unit/test_jsonrpc_openrpc.py

@@ -1,60 +0,0 @@
-from httpx import ASGITransport, Client
-from sqlalchemy import Column, String
-from tigrbl import Base, TigrblApp
-from tigrbl.engine.shortcuts import mem
-from tigrbl.orm.mixins import GUIDPk
-
-
-def _build_app():
-    class Widget(Base, GUIDPk):
-        __tablename__ = "widgets_openrpc"
-        name = Column(String, nullable=False)
-
-    app = TigrblApp(engine=mem(async_=False))
-    app.include_model(Widget)
-    app.initialize()
-    app.mount_jsonrpc()
-    return app, Widget
-
-
-def test_openrpc_endpoint_exposed():
-    app, _ = _build_app()
-    transport = ASGITransport(app=app)
-    with Client(transport=transport, base_url="http://test") as client:
-        response = client.get("/openrpc.json")
-
-        assert response.status_code == 200
-        payload = response.json()
-        assert payload["openrpc"] == "1.2.6"
-        assert payload["servers"] == [{"name": app.title, "url": "/rpc"}]
-        assert "methods" in payload
-
-
-def test_openrpc_server_url_respects_jsonrpc_prefix():
-    app, _ = _build_app()
-    app.jsonrpc_prefix = "/rpc/custom"
-    transport = ASGITransport(app=app)
-
-    with Client(transport=transport, base_url="http://test") as client:
-        payload = client.get("/openrpc.json").json()
-
-    assert payload["servers"] == [{"name": app.title, "url": "/rpc/custom"}]
-
-
-def test_openrpc_includes_method_schema():
-    app, model = _build_app()
-    transport = ASGITransport(app=app)
-    with Client(transport=transport, base_url="http://test") as client:
-        payload = client.get("/openrpc.json").json()
-        methods = {method["name"]: method for method in payload["methods"]}
-
-        create_method = methods[f"{model.__name__}.create"]
-        assert create_method["paramStructure"] == "by-name"
-
-        params = create_method["params"][0]["schema"]
-        assert params["title"].startswith(model.__name__)
-        assert "Create" in params["title"]
-
-        result = create_method["result"]["schema"]
-        assert result["title"].startswith(model.__name__)
-        assert "Response" in result["title"]