tigrbl_tests 0.3.12.dev6__tar.gz → 0.3.12.dev8__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tigrbl_tests
-Version: 0.3.12.dev6
+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.dev6 → tigrbl_tests-0.3.12.dev8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tigrbl_tests"
-version = "0.3.12.dev6"
+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.dev6 → 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_op_ctx_uvicorn_scopes.py

@@ -0,0 +1,170 @@
+import uuid
+from itertools import product
+
+import httpx
+import pytest
+
+from tigrbl import TigrblApp, TigrblRouter, op_ctx
+from tigrbl.orm.mixins import GUIDPk
+from tigrbl.orm.tables import TableBase
+from tigrbl.shortcuts.engine import mem
+from tigrbl.types import BaseModel, Column, String
+
+from .uvicorn_utils import run_uvicorn_in_task, stop_uvicorn_server
+
+
+class TokenInventorySchema(BaseModel):
+    access_tokens: int
+    refresh_tokens: int
+
+
+PERSIST_VARIANTS = (
+    "default",
+    "write",
+    "append",
+    "prepend",
+    "override",
+    "skip",
+    "none",
+    "read",
+)
+ARITY_VARIANTS = ("collection", "member")
+RESPONSE_SCHEMA_VARIANTS = (None, TokenInventorySchema)
+SCOPE_VARIANTS = ("table", "router", "app")
+
+
+def _op_payload() -> dict[str, int]:
+    return {"access_tokens": 3, "refresh_tokens": 1}
+
+
+def _member_path(resource: str, alias: str) -> str:
+    return f"/{resource}/{uuid.uuid4()}/{alias}"
+
+
+def _collection_path(resource: str, alias: str) -> str:
+    return f"/{resource}/{alias}"
+
+
+def _build_table_app(
+    arity: str, response_schema, persist: str
+) -> tuple[TigrblApp, str]:
+    TableBase.metadata.clear()
+    schema_tag = "with_schema" if response_schema is not None else "no_schema"
+
+    class InventoryTable(TableBase, GUIDPk):
+        __tablename__ = f"inventory_table_op_ctx_uvicorn_{arity}_{persist}_{schema_tag}"
+        __resource__ = "inventory"
+        name = Column(String)
+
+        @op_ctx(
+            alias="token_inventory",
+            target="custom",
+            arity=arity,
+            response_schema=response_schema,
+            persist=persist,
+        )
+        def token_inventory(cls, ctx):
+            return _op_payload()
+
+    app = TigrblApp(engine=mem(async_=False))
+    app.include_table(InventoryTable, prefix="")
+    path = (
+        _collection_path("inventory", "token_inventory")
+        if arity == "collection"
+        else _member_path("inventory", "token_inventory")
+    )
+    return app, path
+
+
+async def _build_router_app(
+    arity: str, response_schema, persist: str
+) -> tuple[TigrblApp, str]:
+    TableBase.metadata.clear()
+    schema_tag = "with_schema" if response_schema is not None else "no_schema"
+
+    class InventoryTable(TableBase, GUIDPk):
+        __tablename__ = (
+            f"inventory_router_op_ctx_uvicorn_{arity}_{persist}_{schema_tag}"
+        )
+        __resource__ = "inventory"
+        name = Column(String)
+
+        @op_ctx(
+            alias="token_inventory",
+            target="custom",
+            arity=arity,
+            response_schema=response_schema,
+            persist=persist,
+        )
+        def token_inventory(cls, ctx):
+            return _op_payload()
+
+    router = TigrblRouter(engine=mem(async_=False))
+    router.include_table(InventoryTable, prefix="")
+    await router.initialize()
+
+    app = TigrblApp(engine=mem(async_=False))
+    app.include_router(router)
+    path = (
+        _collection_path("inventory", "token_inventory")
+        if arity == "collection"
+        else _member_path("inventory", "token_inventory")
+    )
+    return app, path
+
+
+def _build_app_local_op(
+    arity: str, response_schema, persist: str
+) -> tuple[TigrblApp, str]:
+    TableBase.metadata.clear()
+
+    class InventoryApp(TigrblApp):
+        @op_ctx(
+            alias="token_inventory",
+            target="custom",
+            arity=arity,
+            response_schema=response_schema,
+            persist=persist,
+        )
+        def token_inventory(cls, ctx):
+            return _op_payload()
+
+    app = InventoryApp(engine=mem(async_=False))
+    path = (
+        _collection_path("inventoryapp", "token_inventory")
+        if arity == "collection"
+        else _member_path("inventoryapp", "token_inventory")
+    )
+    return app, path
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "scope,arity,response_schema,persist",
+    list(
+        product(
+            SCOPE_VARIANTS, ARITY_VARIANTS, RESPONSE_SCHEMA_VARIANTS, PERSIST_VARIANTS
+        )
+    ),
+    ids=lambda v: getattr(v, "__name__", str(v)),
+)
+async def test_uvicorn_client_call_with_op_ctx_parameter_combinations(
+    scope: str, arity: str, response_schema, persist: str
+) -> None:
+    if scope == "table":
+        app, path = _build_table_app(arity, response_schema, persist)
+    elif scope == "router":
+        app, path = await _build_router_app(arity, response_schema, persist)
+    else:
+        app, path = _build_app_local_op(arity, response_schema, persist)
+
+    base_url, server, task = await run_uvicorn_in_task(app)
+    try:
+        async with httpx.AsyncClient() as client:
+            response = await client.post(f"{base_url}{path}", json={})
+
+        assert response.status_code == 200
+        assert response.json() == _op_payload()
+    finally:
+        await stop_uvicorn_server(server, task)

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.dev8/tests/unit/test_engine_session_database_availability.py

@@ -0,0 +1,51 @@
+from sqlalchemy import text
+
+from tigrbl import TableBase, TigrblApp, resolver
+from tigrbl.orm.mixins import GUIDPk
+from tigrbl.shortcuts.engine import engine, mem
+from tigrbl.types import Column, String
+
+
+class AvailabilityRecord(TableBase, GUIDPk):
+    __tablename__ = "availability_records"
+    name = Column(String(100), nullable=False)
+
+
+def test_engine_availability_via_shortcut():
+    eng = engine(mem(async_=False))
+    sql_engine, session_factory = eng.raw()
+
+    assert sql_engine is not None
+    assert callable(session_factory)
+
+
+def test_session_availability_via_engine_context_manager():
+    eng = engine(mem(async_=False))
+
+    with eng.session() as db:
+        assert db.execute(text("SELECT 1")).scalar_one() == 1
+
+
+def test_database_availability_after_app_initialize():
+    app = TigrblApp(engine=mem(async_=False))
+    app.include_table(AvailabilityRecord)
+    app.initialize()
+
+    provider = resolver.resolve_provider(router=app)
+    assert provider is not None
+
+    _, session_factory = provider.ensure()
+
+    with session_factory() as db:
+        assert db.execute(text("SELECT 1")).scalar_one() == 1
+        db.execute(
+            text(
+                "CREATE TABLE IF NOT EXISTS availability_probe "
+                "(id INTEGER PRIMARY KEY, note TEXT)"
+            )
+        )
+        db.commit()
+        names = db.execute(
+            text("SELECT name FROM sqlite_master WHERE type='table'")
+        ).scalars()
+        assert "availability_probe" in set(names)

{tigrbl_tests-0.3.12.dev6 → 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"

tigrbl_tests-0.3.12.dev8/tests/unit/test_op_ctx_custom_target_persist.py

@@ -0,0 +1,79 @@
+from itertools import product
+from types import SimpleNamespace
+
+import pytest
+
+from tigrbl import op_ctx
+from tigrbl.mapping import handlers
+from tigrbl.mapping.op_mro_collect import mro_collect_decorated_ops
+from tigrbl.types import BaseModel
+
+
+class TokenInventorySchema(BaseModel):
+    access_tokens: int
+    refresh_tokens: int
+
+
+PERSIST_VARIANTS = (
+    "default",
+    "write",
+    "append",
+    "prepend",
+    "override",
+    "skip",
+    "none",
+    "read",
+)
+ARITY_VARIANTS = ("collection", "member")
+RESPONSE_SCHEMA_VARIANTS = (None, TokenInventorySchema)
+
+
+def _normalize_persist(persist: str) -> str:
+    if persist in {"none", "read", "skip"}:
+        return "skip"
+    if persist in {"write", "default", "persist"}:
+        return "default"
+    return persist
+
+
+def _build_custom_model(arity: str, response_schema, persist: str):
+    class Model:
+        __name__ = "Model"
+
+        @op_ctx(
+            alias="token_inventory",
+            target="custom",
+            arity=arity,
+            response_schema=response_schema,
+            persist=persist,
+        )
+        def token_inventory(
+            cls, ctx
+        ):  # pragma: no cover - runtime execution not needed
+            return TokenInventorySchema(access_tokens=1, refresh_tokens=2)
+
+    specs = mro_collect_decorated_ops(Model)
+    Model.opspecs = SimpleNamespace(all=tuple(specs))
+    handlers.build_and_attach(Model, specs)
+    return Model, specs[0]
+
+
+@pytest.mark.parametrize(
+    "arity,response_schema,persist",
+    list(product(ARITY_VARIANTS, RESPONSE_SCHEMA_VARIANTS, PERSIST_VARIANTS)),
+    ids=lambda v: getattr(v, "__name__", str(v)),
+)
+def test_op_ctx_custom_target_parameter_cross_product(
+    arity: str, response_schema, persist: str
+) -> None:
+    model, spec = _build_custom_model(arity, response_schema, persist)
+
+    assert spec.alias == "token_inventory"
+    assert spec.target == "custom"
+    assert spec.arity == arity
+    assert spec.response_model is response_schema
+    assert spec.persist == _normalize_persist(persist)
+
+    # For custom targets, persist controls transaction behavior elsewhere, not handler order.
+    handler_names = [fn.__name__ for fn in model.hooks.token_inventory.HANDLER]
+    assert handler_names == ["token_inventory"]