tigrbl-tests 0.3.0__py3-none-any.whl

tests/unit/test_response_parity.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+from types import SimpleNamespace
+import pytest
+from tigrbl.types import App
+from fastapi.testclient import TestClient
+
+from tigrbl.bindings import rpc_call
+from .response_utils import build_ping_model
+
+
+@pytest.mark.asyncio
+async def test_response_rest_rpc_parity():
+    Widget = build_ping_model()
+    app = App()
+    app.include_router(Widget.rest.router)
+    client = TestClient(app)
+    rest_result = client.post("/widget/ping", json={}).json()
+    api = SimpleNamespace(models={"Widget": Widget})
+    rpc_result = await rpc_call(api, Widget, "ping", {}, db=SimpleNamespace())
+    assert rest_result == rpc_result == {"pong": True}

tests/unit/test_response_rest.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+import pytest
+from tigrbl.types import App
+from fastapi.testclient import TestClient
+
+from .response_utils import (
+    RESPONSE_KINDS,
+    build_model_for_response,
+    build_model_for_response_non_alias,
+    build_ping_model,
+    build_model_for_jinja_response,
+)
+
+
+def test_response_rest_call():
+    Widget = build_ping_model()
+    app = App()
+    app.include_router(Widget.rest.router)
+    client = TestClient(app)
+    r = client.post("/widget/ping", json={})
+    assert r.status_code == 200
+    assert r.json() == {"pong": True}
+
+
+@pytest.mark.parametrize("kind", RESPONSE_KINDS)
+def test_response_rest_alias_table(kind, tmp_path):
+    Widget, file_path = build_model_for_response(kind, tmp_path)
+    app = App()
+    app.include_router(Widget.rest.router)
+    client = TestClient(app)
+    kwargs = {"json": {}}
+    if kind == "redirect":
+        kwargs["follow_redirects"] = False
+    r = client.post("/widget/download", **kwargs)
+    if kind == "auto":
+        assert r.json() == {"data": {"pong": True}, "ok": True}
+    elif kind == "json":
+        assert r.json() == {"pong": True}
+    elif kind == "html":
+        assert r.text == "<h1>pong</h1>"
+    elif kind == "text":
+        assert r.text == "pong"
+    elif kind == "file":
+        assert r.content == file_path.read_bytes()
+    elif kind == "stream":
+        assert r.content == b"pong"
+    elif kind == "redirect":
+        assert r.status_code == 307
+        assert r.headers["location"] == "/redirected"
+        return
+    assert r.status_code == 200
+
+
+@pytest.mark.parametrize("kind", RESPONSE_KINDS)
+def test_response_rest_non_alias_table(kind, tmp_path):
+    Widget, file_path = build_model_for_response_non_alias(kind, tmp_path)
+    app = App()
+    app.include_router(Widget.rest.router)
+    client = TestClient(app)
+    kwargs = {"json": {}}
+    if kind == "redirect":
+        kwargs["follow_redirects"] = False
+    r = client.post("/widget/download", **kwargs)
+    if kind == "auto":
+        assert r.json() == {"data": {"pong": True}, "ok": True}
+    elif kind == "json":
+        assert r.json() == {"pong": True}
+    elif kind == "html":
+        assert r.text == "<h1>pong</h1>"
+    elif kind == "text":
+        assert r.text == "pong"
+    elif kind == "file":
+        assert r.content == file_path.read_bytes()
+    elif kind == "stream":
+        assert r.content == b"pong"
+    elif kind == "redirect":
+        assert r.status_code == 307
+        assert r.headers["location"] == "/redirected"
+        return
+    assert r.status_code == 200
+
+
+def test_response_rest_alias_table_jinja(tmp_path):
+    pytest.importorskip("jinja2")
+    Widget = build_model_for_jinja_response(tmp_path)
+    app = App()
+    app.include_router(Widget.rest.router)
+    client = TestClient(app)
+    r = client.post("/widget/download", json={})
+    assert r.status_code == 200
+    assert r.text == "<h1>World</h1>"

tests/unit/test_response_rpc.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+from types import SimpleNamespace
+import json
+import pytest
+
+from tigrbl.bindings import rpc_call
+
+from .response_utils import (
+    RESPONSE_KINDS,
+    build_model_for_response,
+    build_model_for_response_non_alias,
+    build_ping_model,
+    build_model_for_jinja_response,
+)
+
+
+@pytest.mark.asyncio
+async def test_response_rpc_call():
+    Widget = build_ping_model()
+    api = SimpleNamespace(models={"Widget": Widget})
+    result = await rpc_call(api, Widget, "ping", {}, db=SimpleNamespace())
+    assert result == {"pong": True}
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("kind", RESPONSE_KINDS)
+async def test_response_rpc_alias_table(kind, tmp_path):
+    Widget, file_path = build_model_for_response(kind, tmp_path)
+    api = SimpleNamespace(models={"Widget": Widget})
+    result = await rpc_call(api, Widget, "download", {}, db=SimpleNamespace())
+    if kind == "auto":
+        assert json.loads(result["body"]) == {"data": {"pong": True}, "ok": True}
+    elif kind == "json":
+        assert json.loads(result["body"]) == {"pong": True}
+    elif kind == "html":
+        assert result["body"] == b"<h1>pong</h1>"
+    elif kind == "text":
+        assert result["body"] == b"pong"
+    elif kind == "file":
+        assert result["path"] == str(file_path)
+    elif kind == "stream":
+        content = b"".join([chunk async for chunk in result["body_iterator"]])
+        assert content == b"pong"
+    elif kind == "redirect":
+        assert result["status_code"] == 307
+        headers = dict(result["raw_headers"])
+        assert headers[b"location"].decode() == "/redirected"
+        return
+    if kind not in {"auto", "json"}:
+        assert result["status_code"] == 200
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("kind", RESPONSE_KINDS)
+async def test_response_rpc_non_alias_table(kind, tmp_path):
+    Widget, file_path = build_model_for_response_non_alias(kind, tmp_path)
+    api = SimpleNamespace(models={"Widget": Widget})
+    result = await rpc_call(api, Widget, "download", {}, db=SimpleNamespace())
+    if kind == "auto":
+        assert json.loads(result["body"]) == {"data": {"pong": True}, "ok": True}
+    elif kind == "json":
+        assert json.loads(result["body"]) == {"pong": True}
+    elif kind == "html":
+        assert result["body"] == b"<h1>pong</h1>"
+    elif kind == "text":
+        assert result["body"] == b"pong"
+    elif kind == "file":
+        assert result["path"] == str(file_path)
+    elif kind == "stream":
+        content = b"".join([chunk async for chunk in result["body_iterator"]])
+        assert content == b"pong"
+    elif kind == "redirect":
+        assert result["status_code"] == 307
+        headers = dict(result["raw_headers"])
+        assert headers[b"location"].decode() == "/redirected"
+        return
+    if kind not in {"auto", "json"}:
+        assert result["status_code"] == 200
+
+
+@pytest.mark.asyncio
+async def test_response_rpc_alias_table_jinja(tmp_path):
+    pytest.importorskip("jinja2")
+    Widget = build_model_for_jinja_response(tmp_path)
+    api = SimpleNamespace(models={"Widget": Widget})
+    result = await rpc_call(api, Widget, "download", {}, db=SimpleNamespace())
+    assert result["status_code"] == 200
+    assert result["body"] == b"<h1>World</h1>"

tests/unit/test_response_template.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+import pytest
+
+from tigrbl.response import render_template
+
+pytest.importorskip("jinja2")
+
+
+@pytest.mark.asyncio
+async def test_render_template_j2_html(tmp_path):
+    tpl = tmp_path / "hello.j2.html"
+    tpl.write_text("<h1>{{ name }}</h1>")
+    html = await render_template(
+        name="hello.j2.html",
+        context={"name": "World"},
+        search_paths=[str(tmp_path)],
+    )
+    assert "<h1>World</h1>" in html
+
+
+@pytest.mark.asyncio
+async def test_render_template_html(tmp_path):
+    tpl = tmp_path / "plain.html"
+    tpl.write_text("<h1>{{ name }}</h1>")
+    html = await render_template(
+        name="plain.html",
+        context={"name": "World"},
+        search_paths=[str(tmp_path)],
+    )
+    assert "<h1>World</h1>" in html

tests/unit/test_response_uuid.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import base64
+import importlib
+import json
+import sys
+import types
+from uuid import uuid4
+
+
+from tigrbl.response.shortcuts import as_json
+
+
+def test_as_json_serializes_uuid() -> None:
+    uid = uuid4()
+    resp = as_json({"id": uid}, envelope=False)
+    assert resp.media_type == "application/json"
+    assert json.loads(resp.body) == {"id": str(uid)}
+
+
+def test_as_json_serializes_bytes() -> None:
+    payload = b"\x00\x01bytes"
+    resp = as_json({"blob": payload}, envelope=False)
+    assert resp.media_type == "application/json"
+    body = json.loads(resp.body)
+    assert body == {"blob": base64.b64encode(payload).decode("ascii")}
+
+
+def test_as_json_fallbacks_when_orjson_unsupported(monkeypatch) -> None:
+    import tigrbl.response.shortcuts as shortcuts
+
+    original_orjson = sys.modules.get("orjson")
+    fake_orjson = types.SimpleNamespace(
+        OPT_NON_STR_KEYS=0,
+        OPT_SERIALIZE_NUMPY=0,
+        OPT_SERIALIZE_BYTES=0,
+        dumps=lambda *args, **kwargs: (_ for _ in ()).throw(
+            TypeError("unsupported option")
+        ),
+    )
+
+    monkeypatch.setitem(sys.modules, "orjson", fake_orjson)
+    reloaded = importlib.reload(shortcuts)
+
+    try:
+        payload = {"blob": b"\x00\x98bytes"}
+        resp = reloaded.as_json(payload, envelope=False)
+
+        assert resp.media_type == "application/json"
+        assert json.loads(resp.body) == {
+            "blob": base64.b64encode(payload["blob"]).decode("ascii")
+        }
+    finally:
+        if original_orjson is not None:
+            monkeypatch.setitem(sys.modules, "orjson", original_orjson)
+        else:
+            monkeypatch.delitem(sys.modules, "orjson", raising=False)
+        importlib.reload(shortcuts)

tests/unit/test_rest_all_default_op_verbs.py

@@ -0,0 +1,58 @@
+import pytest
+from tigrbl.bindings.rest import build_router_and_attach
+from tigrbl.orm.mixins import GUIDPk
+from tigrbl.op import OpSpec
+from tigrbl.orm.tables import Base
+from tigrbl.types import Column, String
+
+
+def _route_map(router) -> dict[str, tuple[str, set[str]]]:
+    out: dict[str, tuple[str, set[str]]] = {}
+    for r in getattr(router, "routes", []):
+        if hasattr(r, "name"):
+            name = getattr(r, "name")
+            path = getattr(r, "path")
+            methods = set(getattr(r, "methods", []) or [])
+        else:  # pragma: no cover - fallback when FastAPI is missing
+            path, methods, _, opts = r
+            name = opts.get("name")
+            methods = set(methods)
+        if name and "." in name:
+            alias = name.split(".", 1)[1]
+            out[alias] = (path, methods)
+    return out
+
+
+@pytest.mark.parametrize(
+    "alias,target,path,methods",
+    [
+        ("create", "create", "/item", {"POST"}),
+        ("read", "read", "/item/{item_id}", {"GET"}),
+        ("update", "update", "/item/{item_id}", {"PATCH"}),
+        ("replace", "replace", "/item/{item_id}", {"PUT"}),
+        ("delete", "delete", "/item/{item_id}", {"DELETE"}),
+        ("list", "list", "/item", {"GET"}),
+        ("clear", "clear", "/item", {"DELETE"}),
+        ("merge", "merge", "/item/{item_id}", {"PATCH"}),
+        ("bulk_create", "bulk_create", "/item", {"POST"}),
+        ("bulk_update", "bulk_update", "/item", {"PATCH"}),
+        ("bulk_replace", "bulk_replace", "/item", {"PUT"}),
+        ("bulk_merge", "bulk_merge", "/item", {"PATCH"}),
+        ("bulk_delete", "bulk_delete", "/item", {"DELETE"}),
+        ("custom_op", "custom", "/item/custom_op", {"POST"}),
+    ],
+)
+def test_rest_default_op_verbs(alias, target, path, methods):
+    Base.metadata.clear()
+
+    class Item(Base, GUIDPk):
+        __tablename__ = "items"
+        name = Column(String, nullable=False)
+
+    build_router_and_attach(Item, [OpSpec(alias=alias, target=target)])
+
+    routes = _route_map(Item.rest.router)
+    assert alias in routes
+    got_path, got_methods = routes[alias]
+    assert got_path.lower() == path.lower()
+    assert got_methods == methods

tests/unit/test_rest_bulk_delete_suppresses_clear.py

@@ -0,0 +1,25 @@
+from tigrbl.bindings.rest import build_router_and_attach
+from tigrbl.orm.mixins import GUIDPk
+from tigrbl.op import OpSpec
+from tigrbl.orm.tables import Base
+from tigrbl.types import Column, String
+
+
+def test_bulk_delete_suppresses_clear_route():
+    Base.metadata.clear()
+
+    class Item(Base, GUIDPk):
+        __tablename__ = "items_bulk_delete_route"
+        name = Column(String, nullable=False)
+
+    build_router_and_attach(
+        Item,
+        [
+            OpSpec(alias="clear", target="clear"),
+            OpSpec(alias="bulk_delete", target="bulk_delete"),
+        ],
+    )
+
+    aliases = {route.name.split(".", 1)[1] for route in Item.rest.router.routes}
+    assert "bulk_delete" in aliases
+    assert "clear" not in aliases

tests/unit/test_rest_no_schema_jsonable.py

@@ -0,0 +1,68 @@
+import pytest
+from fastapi.testclient import TestClient
+from sqlalchemy import Integer, String
+from sqlalchemy.orm import Mapped
+
+from tigrbl import TigrblApp as Tigrblv3
+from tigrbl.engine.shortcuts import mem
+from tigrbl.specs import F, IO, S, acol
+from tigrbl.orm.tables import Base as Base3
+
+
+@pytest.fixture()
+def client_and_model():
+    Base3.metadata.clear()
+
+    class Gadget(Base3):
+        __tablename__ = "gadgets"
+        __allow_unmapped__ = True
+
+        id: Mapped[int] = acol(
+            storage=S(type_=Integer, primary_key=True, autoincrement=True)
+        )
+        name: Mapped[str] = acol(
+            storage=S(type_=String, nullable=False),
+            field=F(required_in=("create",)),
+            io=IO(
+                in_verbs=("create", "update", "replace"),
+                out_verbs=("read", "list"),
+            ),
+        )
+        age: Mapped[int] = acol(
+            storage=S(type_=Integer, nullable=False, default=0),
+            io=IO(
+                in_verbs=("create", "update", "replace"),
+                out_verbs=("read", "list"),
+            ),
+        )
+
+        __tigrbl_cols__ = {"id": id, "name": name, "age": age}
+
+    api = Tigrblv3(engine=mem(async_=False))
+    api.include_model(Gadget, prefix="")
+    api.initialize()
+
+    # Remove generated out schemas to exercise jsonable fallback
+    Gadget.schemas.read.out = None  # type: ignore[attr-defined]
+    Gadget.schemas.list.out = None  # type: ignore[attr-defined]
+
+    client = TestClient(api)
+    try:
+        yield client, Gadget
+    finally:
+        client.close()
+
+
+def test_rest_read_and_list_without_schema(client_and_model):
+    client, _ = client_and_model
+    created = client.post("/gadget", json={"name": "A", "age": 1})
+    item_id = created.json()["id"]
+
+    resp = client.get(f"/gadget/{item_id}")
+    assert resp.status_code == 200
+    assert resp.json()["id"] == item_id
+
+    resp_list = client.get("/gadget")
+    assert resp_list.status_code == 200
+    ids = {item["id"] for item in resp_list.json()}
+    assert item_id in ids

tests/unit/test_rest_operation_id_uniqueness.py

@@ -0,0 +1,36 @@
+from fastapi import FastAPI
+
+from tigrbl.bindings.rest.router import _build_router
+from tigrbl.op import OpSpec
+from tigrbl.orm.mixins import GUIDPk
+from tigrbl.orm.tables import Base
+
+
+class Item(Base, GUIDPk):
+    __tablename__ = "items_operation_id"
+
+
+def _collect_operation_ids(schema: dict) -> list[str]:
+    ids: list[str] = []
+    for path in schema["paths"].values():
+        for method in path.values():
+            operation_id = method.get("operationId")
+            if operation_id:
+                ids.append(operation_id)
+    return ids
+
+
+def test_operation_ids_are_unique():
+    Base.metadata.clear()
+    router = _build_router(
+        Item,
+        [
+            OpSpec(alias="dup", target="custom", arity="collection"),
+            OpSpec(alias="dup", target="custom", arity="member"),
+        ],
+    )
+    app = FastAPI()
+    app.include_router(router)
+    schema = app.openapi()
+    operation_ids = _collect_operation_ids(schema)
+    assert len(operation_ids) == len(set(operation_ids))

tests/unit/test_rest_rpc_parity_default_ops.py

@@ -0,0 +1,86 @@
+import pytest
+
+
+from tigrbl import TigrblApp
+from tigrbl.orm.mixins import GUIDPk, BulkCapable, Mergeable
+from tigrbl.orm.tables import Base
+from tigrbl.op.types import CANON
+from tigrbl.types import Column, String
+
+
+def _route_map(router) -> dict[str, tuple[str, set[str]]]:
+    out: dict[str, tuple[str, set[str]]] = {}
+    for r in getattr(router, "routes", []):
+        if hasattr(r, "name"):
+            name = getattr(r, "name")
+            path = getattr(r, "path")
+            methods = set(getattr(r, "methods", []) or [])
+        else:  # pragma: no cover - fallback when FastAPI is missing
+            path, methods, _, opts = r
+            name = opts.get("name")
+            methods = set(methods)
+        if name and "." in name:
+            alias = name.split(".", 1)[1]
+            out[alias] = (path, methods)
+    return out
+
+
+@pytest.mark.parametrize(
+    "alias,target,path,methods",
+    [
+        ("create", "create", "/item", {"POST"}),
+        ("read", "read", "/item/{item_id}", {"GET"}),
+        ("update", "update", "/item/{item_id}", {"PATCH"}),
+        ("replace", "replace", "/item/{item_id}", {"PUT"}),
+        ("delete", "delete", "/item/{item_id}", {"DELETE"}),
+        ("list", "list", "/item", {"GET"}),
+        ("clear", "clear", "/item", {"DELETE"}),
+        ("merge", "merge", "/item/{item_id}", {"PATCH"}),
+        ("bulk_create", "bulk_create", "/item", {"POST"}),
+        ("bulk_update", "bulk_update", "/item", {"PATCH"}),
+        ("bulk_replace", "bulk_replace", "/item", {"PUT"}),
+        ("bulk_merge", "bulk_merge", "/item", {"PATCH"}),
+        ("bulk_delete", "bulk_delete", "/item", {"DELETE"}),
+    ],
+)
+def test_rest_rpc_parity_for_default_verbs(alias, target, path, methods):
+    Base.metadata.clear()
+
+    class Item(Base, GUIDPk, BulkCapable, Mergeable):
+        __tablename__ = "items"
+        name = Column(String, nullable=False)
+
+    Item.__tigrbl_ops__ = {verb: {"target": verb} for verb in CANON if verb != "custom"}
+
+    api = TigrblApp()
+    api.include_model(Item, mount_router=False)
+
+    routes = _route_map(Item.rest.router)
+    if alias == "clear" and "bulk_delete" in routes:
+        assert alias not in routes
+    elif alias == "create" and "bulk_create" in routes:
+        assert alias not in routes
+    else:
+        assert alias in routes
+        got_path, got_methods = routes[alias]
+        assert got_path.lower() == path.lower()
+        assert got_methods == methods
+
+    assert hasattr(api.rpc.Item, alias)
+
+
+def test_non_bulkcapable_prefers_create() -> None:
+    Base.metadata.clear()
+
+    class Item(Base, GUIDPk, Mergeable):
+        __tablename__ = "items"
+        name = Column(String, nullable=False)
+
+    api = TigrblApp()
+    api.include_model(Item, mount_router=False)
+
+    routes = _route_map(Item.rest.router)
+    assert "bulk_create" not in routes
+    assert "create" in routes
+    assert hasattr(api.rpc.Item, "create")
+    assert not hasattr(api.rpc.Item, "bulk_create")

tests/unit/test_rest_rpc_prefixes.py

@@ -0,0 +1,40 @@
+from tigrbl import TigrblApp
+from tigrbl.orm.tables import Base
+from tigrbl.orm.mixins import GUIDPk
+from tigrbl.types import Column, String
+
+
+def _router_paths(api, name: str) -> set[str]:
+    router = api.routers.get(name)
+    return {r.path for r in getattr(router, "routes", [])}
+
+
+def test_default_resource_and_rpc_prefixes():
+    Base.metadata.clear()
+
+    class Item(Base, GUIDPk):
+        __tablename__ = "items"
+        name = Column(String, nullable=False)
+
+    api = TigrblApp()
+    api.include_model(Item, mount_router=False)
+
+    paths = {p.lower() for p in _router_paths(api, "Item")}
+    assert "/item" in paths
+    assert hasattr(api.rpc, "Item")
+
+
+def test_resource_override_affects_prefixes():
+    Base.metadata.clear()
+
+    class Item(Base, GUIDPk):
+        __tablename__ = "items"
+        __resource__ = "test"
+        name = Column(String, nullable=False)
+
+    api = TigrblApp()
+    api.include_model(Item, mount_router=False)
+
+    paths = {p.lower() for p in _router_paths(api, "Item")}
+    assert "/test" in paths
+    assert hasattr(api.rpc, "Test")