tigrbl_tests 0.3.12.dev7__tar.gz → 0.3.12.dev8__tar.gz

{tigrbl_tests-0.3.12.dev7 → tigrbl_tests-0.3.12.dev8}/PKG-INFO

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

{tigrbl_tests-0.3.12.dev7 → tigrbl_tests-0.3.12.dev8}/pyproject.toml

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

{tigrbl_tests-0.3.12.dev7 → tigrbl_tests-0.3.12.dev8}/tests/architecture/test_transport_dispatch_convergence.py

@@ -29,6 +29,13 @@ def test_gateway_invoke_invokes_runtime_kernel_plan_and_executor():
     assert "await _invoke(" in source
 
 
+def test_gateway_invoke_uses_runtime_atoms_for_fallback_and_errors():
+    source = _source("runtime/gw/invoke.py")
+    assert "_runtime_route_handler" in source
+    assert "_error_to_transport" in source
+    assert "except Exception" not in source
+
+
 def test_mapping_does_not_import_dispatch_modules():
     rest_collection = ROOT / "mapping" / "rest" / "collection.py"
     rest_member = ROOT / "mapping" / "rest" / "member.py"

tigrbl_tests-0.3.12.dev8/tests/harness_v3/test_route_runtime_fallback_atoms.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+import re
+
+import pytest
+from types import SimpleNamespace
+
+from tigrbl.runtime.atoms.route import jsonrpc_batch_intercept, op_resolve
+
+
+def _ctx_for_route(*, method: str, path: str, routes: list[object]):
+    request = SimpleNamespace(method=method, path=path, url=SimpleNamespace(path=path))
+    return SimpleNamespace(
+        temp={"route": {}},
+        request=request,
+        app=SimpleNamespace(routes=routes),
+    )
+
+
+def test_op_resolve_discovers_runtime_route_handler() -> None:
+    captured = {"ok": True}
+
+    def handler() -> dict[str, bool]:
+        return captured
+
+    route = SimpleNamespace(
+        pattern=re.compile(r"^/items/(?P<item_id>[^/]+)$"),
+        methods={"GET"},
+        handler=handler,
+    )
+    ctx = _ctx_for_route(method="GET", path="/items/abc", routes=[route])
+
+    op_resolve.run(None, ctx)
+
+    route_ns = ctx.temp["route"]
+    assert route_ns["handler"] is handler
+    assert route_ns["path_params"] == {"item_id": "abc"}
+    assert route_ns.get("method_not_allowed") is None
+
+
+def test_op_resolve_marks_method_not_allowed_for_runtime_route() -> None:
+    route = SimpleNamespace(
+        pattern=re.compile(r"^/items/(?P<item_id>[^/]+)$"),
+        methods={"GET"},
+        handler=lambda: {"ok": True},
+    )
+    ctx = _ctx_for_route(method="POST", path="/items/abc", routes=[route])
+
+    op_resolve.run(None, ctx)
+
+    route_ns = ctx.temp["route"]
+    assert route_ns.get("handler") is None
+    assert route_ns["method_not_allowed"] is True
+
+
+def test_op_resolve_finds_opmeta_index_from_proto_and_selector() -> None:
+    ctx = SimpleNamespace(
+        temp={"route": {}},
+        proto="http.jsonrpc",
+        selector="Widget.create",
+        kernel_plan=SimpleNamespace(
+            opmeta=[SimpleNamespace(alias="create", model=object, target="create")],
+            opkey_to_meta={},
+        ),
+    )
+
+    # SimpleNamespace is unhashable; use tiny hashable opkey object.
+    class _OpKey:
+        def __init__(self, proto: str, selector: str) -> None:
+            self.proto = proto
+            self.selector = selector
+
+        def __hash__(self) -> int:
+            return hash((self.proto, self.selector))
+
+        def __eq__(self, other: object) -> bool:
+            return (
+                isinstance(other, _OpKey)
+                and other.proto == self.proto
+                and other.selector == self.selector
+            )
+
+    ctx.kernel_plan.opkey_to_meta = {_OpKey("http.jsonrpc", "Widget.create"): 0}
+
+    op_resolve.run(None, ctx)
+
+    assert ctx.temp["route"]["opmeta_index"] == 0
+
+
+@pytest.mark.asyncio
+async def test_jsonrpc_batch_intercept_short_circuits_response() -> None:
+    class _App:
+        jsonrpc_prefix = "/rpc"
+
+        async def rpc_call(self, model: str, op: str, params: dict, **_: object):
+            return {"model": model, "op": op, "params": params}
+
+    payload = [
+        {"jsonrpc": "2.0", "method": "Widget.create", "params": {"name": "x"}, "id": 1}
+    ]
+    ctx = SimpleNamespace(
+        payload=payload,
+        app=_App(),
+        raw=SimpleNamespace(scope={"path": "/rpc"}),
+        temp={"route": {}},
+    )
+
+    await jsonrpc_batch_intercept.run(None, ctx)
+
+    route = ctx.temp["route"]
+    response = ctx.temp["egress"]["transport_response"]
+    assert route["short_circuit"] is True
+    assert response["status_code"] == 200
+    assert response["body"][0]["result"]["op"] == "create"

tigrbl_tests-0.3.12.dev8/tests/i9n/test_uvicorn_transport_behavior.py

@@ -0,0 +1,150 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import ssl
+from typing import Any
+
+import httpx
+import pytest
+from tigrbl import Request
+from tigrbl import TigrblApp
+from tigrbl import TigrblRouter
+from tigrbl_tests.examples._support import pick_unique_port, start_uvicorn, stop_uvicorn
+
+
+async def _probe_http3_over_quic(host: str, port: int) -> dict[str, Any]:
+    try:
+        from aioquic.asyncio.client import connect
+        from aioquic.quic.configuration import QuicConfiguration
+    except Exception:
+        return {
+            "supported": False,
+            "status": 0,
+            "error": "aioquic-not-installed",
+        }
+
+    configuration = QuicConfiguration(
+        is_client=True,
+        alpn_protocols=["h3"],
+        verify_mode=ssl.CERT_NONE,
+    )
+
+    try:
+        async with asyncio.timeout(2.0):
+            async with connect(
+                host,
+                port,
+                configuration=configuration,
+                wait_connected=True,
+            ):
+                return {"supported": True, "status": 200, "error": None}
+    except Exception as exc:
+        return {
+            "supported": False,
+            "status": 0,
+            "error": type(exc).__name__,
+        }
+
+
+@pytest.mark.asyncio
+async def test_tigrblapp_uvicorn_h1_h2_h3_behavior() -> None:
+    app = TigrblApp()
+
+    router = TigrblRouter()
+
+    @router.get("/echo")
+    async def echo(request: Request) -> dict[str, Any]:
+        return {
+            "method": request.method,
+            "x_test": request.headers.get("x-test"),
+            "http_version": request.scope.get("http_version"),
+        }
+
+    @router.post("/jsonrpc")
+    async def jsonrpc(request: Request) -> dict[str, Any]:
+        payload = json.loads(request.body.decode("utf-8") or "{}")
+        return {
+            "jsonrpc": "2.0",
+            "id": payload.get("id"),
+            "result": payload.get("params"),
+        }
+
+    app.include_router(router)
+    app.attach_diagnostics(prefix="")
+
+    port = pick_unique_port()
+    base_url, server, task = await start_uvicorn(app, port=port)
+
+    try:
+        async with httpx.AsyncClient(base_url=base_url, timeout=5.0) as client:
+            h1 = await client.get("/echo", headers={"x-test": "h1"})
+
+        h2: httpx.Response | None = None
+        h2_error: str | None = None
+        try:
+            async with httpx.AsyncClient(
+                base_url=base_url,
+                timeout=5.0,
+                http2=True,
+            ) as client:
+                h2 = await client.get("/echo", headers={"x-test": "h2"})
+        except ImportError as exc:
+            h2_error = type(exc).__name__
+
+        async with httpx.AsyncClient(base_url=base_url, timeout=5.0) as client:
+            rpc = await client.post(
+                "/jsonrpc",
+                json={
+                    "jsonrpc": "2.0",
+                    "method": "echo",
+                    "params": {"msg": "hi"},
+                    "id": 1,
+                },
+            )
+
+        h3 = await _probe_http3_over_quic("127.0.0.1", port)
+
+        out = {
+            "http1": {
+                "status": h1.status_code,
+                "http_version": h1.http_version,
+                "body": h1.json(),
+            },
+            "http2": {
+                "status": h2.status_code if h2 else 0,
+                "http_version": h2.http_version if h2 else None,
+                "body": h2.json() if h2 else None,
+                "error": h2_error,
+            },
+            "jsonrpc": {
+                "status": rpc.status_code,
+                "http_version": rpc.http_version,
+                "body": rpc.json(),
+            },
+            "http3": h3,
+        }
+
+        assert out["http1"]["status"] == 200
+        assert out["http1"]["http_version"] == "HTTP/1.1"
+        assert out["http1"]["body"]["x_test"] == "h1"
+
+        if h2 is not None:
+            assert out["http2"]["status"] == 200
+            assert out["http2"]["http_version"] == "HTTP/1.1"
+            assert out["http2"]["body"]["x_test"] == "h2"
+            assert out["http2"]["error"] is None
+        else:
+            assert out["http2"]["status"] == 0
+            assert out["http2"]["error"] == "ImportError"
+
+        assert out["jsonrpc"]["status"] == 200
+        assert out["jsonrpc"]["body"] == {
+            "jsonrpc": "2.0",
+            "id": 1,
+            "result": {"msg": "hi"},
+        }
+
+        assert out["http3"]["supported"] is False
+    finally:
+        await stop_uvicorn(server, task)

tigrbl_tests-0.3.12.dev8/tests/unit/runtime/test_payload_select_invalid_rpc_params.py

@@ -0,0 +1,27 @@
+from types import SimpleNamespace
+
+from tigrbl.runtime.atoms.route import payload_select
+
+
+def test_payload_select_invalid_jsonrpc_string_params_returns_invalid_rpc_error():
+    ctx = SimpleNamespace(
+        temp={
+            "route": {
+                "rpc_envelope": {
+                    "jsonrpc": "2.0",
+                    "method": "Widget.create",
+                    "params": "not-a-mapping",
+                    "id": 1,
+                },
+                "params": {},
+            },
+        }
+    )
+
+    payload_select.run(None, ctx)
+
+    assert isinstance(ctx.temp["route"].get("payload"), dict)
+    assert ctx.payload == {}
+    assert ctx.temp.get("rpc_error", {}).get("code") == -32602
+    assert ctx.temp["rpc_error"]["message"] == "Invalid params"
+    assert ctx.temp["rpc_error"]["data"]["value_type"] == "str"

{tigrbl_tests-0.3.12.dev7 → tigrbl_tests-0.3.12.dev8}/tests/unit/test_jsonrpc_openrpc.py

@@ -125,6 +125,54 @@ def test_mount_lens_uses_latest_openrpc_path_by_default() -> None:
     assert "/schema/openrpc.json" in html
 
 
+def test_default_system_docs_endpoints_are_present_and_gettable() -> None:
+    app, _ = _build_app()
+    transport = ASGITransport(app=app)
+
+    with Client(transport=transport, base_url="http://test") as client:
+        docs = client.get("/docs")
+        lens = client.get("/lens")
+        openapi = client.get("/openapi.json")
+        openrpc = client.get("/openrpc.json")
+
+    assert docs.status_code == 200
+    assert "text/html" in docs.headers.get("content-type", "")
+    assert "swagger-ui" in docs.text
+
+    assert lens.status_code == 200
+    assert "text/html" in lens.headers.get("content-type", "")
+    assert 'id="root"' in lens.text
+
+    assert openapi.status_code == 200
+    assert openapi.json()["openapi"] == "3.1.0"
+
+    assert openrpc.status_code == 200
+    assert openrpc.json()["openrpc"] == "1.2.6"
+
+
+def test_docs_lens_openapi_openrpc_are_rest_get_only_and_not_rpc_methods() -> None:
+    app, _ = _build_app()
+    transport = ASGITransport(app=app)
+
+    route_map = {route.path: route for route in app.routes}
+    for path in ("/docs", "/lens", "/openapi.json", "/openrpc.json"):
+        assert path in route_map
+        assert set(route_map[path].methods or []) == {"GET"}
+
+    with Client(transport=transport, base_url="http://test") as client:
+        assert client.post("/docs").status_code == 405
+        assert client.post("/lens").status_code == 405
+        assert client.post("/openapi.json").status_code == 405
+        assert client.post("/openrpc.json").status_code == 405
+
+        method_names = {
+            method["name"] for method in client.get("/openrpc.json").json()["methods"]
+        }
+
+    for forbidden in ("docs", "lens", "openapi", "openrpc"):
+        assert all(forbidden not in name.lower() for name in method_names)
+
+
 def test_openrpc_server_url_respects_router_mount_jsonrpc_prefix_argument():
     class Widget(TableBase, GUIDPk):
         __tablename__ = "widgets_openrpc_router_mount_prefix"