tigrbl-tests 0.3.0__py3-none-any.whl

tests/i9n/test_op_ctx_alias_examples.py

@@ -0,0 +1,62 @@
+import pytest
+from pydantic import BaseModel
+from tigrbl import op_alias, op_ctx
+from tigrbl.orm.mixins import GUIDPk
+from tigrbl.orm.tables import Base
+from tigrbl.specs import F, S, acol
+from tigrbl.types import Column, Mapped, String
+from .test_op_ctx_behavior import setup_api
+
+
+@pytest.mark.i9n
+def test_op_ctx_alias_create_examples(sync_db_session):
+    _, get_db = sync_db_session
+
+    class Person(Base, GUIDPk):
+        __tablename__ = "people"
+        __resource__ = "person"
+        name: Mapped[str] = acol(
+            storage=S(String), field=F(constraints={"examples": ["Alice"]})
+        )
+
+        @op_ctx(alias="register", target="create", arity="collection")
+        def register(cls, ctx):  # pragma: no cover - logic irrelevant
+            pass
+
+    app, _ = setup_api(Person, get_db)
+    spec = app.openapi()
+    _ = spec["paths"]["/person/register"]["post"]
+    req_props = spec["components"]["schemas"]["PersonRegisterRequest"]["properties"]
+    resp_props = spec["components"]["schemas"]["PersonRegisterResponse"]["properties"]
+    assert req_props["name"]["examples"][0] == "Alice"
+    assert resp_props["name"]["examples"][0] == "Alice"
+
+
+@pytest.mark.i9n
+def test_op_ctx_alias_inherits_canonical_schemas(sync_db_session):
+    _, get_db = sync_db_session
+
+    class CreateReq(BaseModel):
+        info: str
+
+    class CreateResp(BaseModel):
+        info: str
+
+    @op_alias(
+        alias="create",
+        target="create",
+        request_model=CreateReq,
+        response_model=CreateResp,
+    )
+    class Person(Base, GUIDPk):
+        __tablename__ = "people2"
+        __resource__ = "person2"
+        name: Mapped[str] = Column(String)
+
+        @op_ctx(alias="register", target="create", arity="collection")
+        def register(cls, ctx):  # pragma: no cover - logic irrelevant
+            pass
+
+    setup_api(Person, get_db)
+    assert set(Person.schemas.register.in_.model_fields) == {"info"}
+    assert set(Person.schemas.register.out.model_fields) == {"info"}

tests/i9n/test_op_ctx_behavior.py

@@ -0,0 +1,395 @@
+import pytest
+from httpx import ASGITransport, AsyncClient
+from tigrbl.types import App, BaseModel, Column, String, UUID
+
+from tigrbl import TigrblApp, op_ctx, schema_ctx, hook_ctx
+from tigrbl.orm.tables import Base
+from tigrbl.orm.mixins import GUIDPk
+from tigrbl.runtime.kernel import build_phase_chains
+
+
+# helper to set up Tigrbl with sync DB from fixture
+
+
+def setup_api(model_cls, get_db):
+    Base.metadata.clear()
+    app = App()
+    api = TigrblApp(get_db=get_db)
+    api.include_model(model_cls, prefix="")
+    api.initialize()
+    app.include_router(api.router)
+    return app, api
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+async def test_op_ctx_request_response_schemas(sync_db_session):
+    _, get_sync_db = sync_db_session
+
+    class Widget(Base, GUIDPk):
+        __tablename__ = "widgets"
+        __resource__ = "widget"
+        name = Column(String)
+
+        @schema_ctx(alias="Echo", kind="in")
+        class EchoIn(BaseModel):
+            text: str
+
+        @schema_ctx(alias="Echo", kind="out")
+        class EchoOut(BaseModel):
+            text: str
+
+        @op_ctx(
+            alias="echo",
+            target="custom",
+            arity="collection",
+            request_schema="Echo.in",
+            response_schema="Echo.out",
+        )
+        def echo(cls, ctx):
+            payload = ctx.get("payload") or {}
+            return {"text": str(payload.get("text"))}
+
+    app, api = setup_api(Widget, get_sync_db)
+
+    async with AsyncClient(
+        transport=ASGITransport(app=app), base_url="http://test"
+    ) as client:
+        res = await client.post("/widget/echo", json={"text": "123"})
+    assert res.status_code == 200
+    assert res.json() == {"text": "123"}
+
+
+@pytest.mark.i9n
+def test_op_ctx_columns(sync_db_session):
+    _, get_sync_db = sync_db_session
+
+    class Gadget(Base, GUIDPk):
+        __tablename__ = "gadgets"
+        __resource__ = "gadget"
+        name = Column(String)
+        flag = Column(String)
+
+        @op_ctx(alias="ping", target="custom", arity="collection")
+        def ping(cls, ctx):
+            return {}
+
+    _, api = setup_api(Gadget, get_sync_db)
+    assert set(api.columns["Gadget"]) == {"id", "name", "flag"}
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+async def test_op_ctx_defaults_value_resolution(sync_db_session):
+    _, get_sync_db = sync_db_session
+
+    class Thing(Base, GUIDPk):
+        __tablename__ = "things"
+        __resource__ = "thing"
+        name = Column(String)
+        status = Column(String, default="new")
+
+        @op_ctx(alias="make", target="create")
+        def make(cls, ctx):
+            pass
+
+    app, api = setup_api(Thing, get_sync_db)
+
+    async with AsyncClient(
+        transport=ASGITransport(app=app), base_url="http://test"
+    ) as client:
+        res = await client.post("/thing", json={"name": "a"})
+    assert res.status_code == 201
+    item_id = UUID(res.json()["id"])
+    assert res.json()["status"] == "new"
+
+    gen = get_sync_db()
+    session = next(gen)
+    obj = session.get(Thing, item_id)
+    assert obj.status == "new"
+    try:
+        next(gen)
+    except StopIteration:
+        pass
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+async def test_op_ctx_internal_orm_models(sync_db_session):
+    _, get_sync_db = sync_db_session
+
+    class Item(Base, GUIDPk):
+        __tablename__ = "items"
+        __resource__ = "item"
+        name = Column(String)
+
+        @op_ctx(alias="seed", target="create")
+        def seed(cls, ctx):
+            pass
+
+    app, api = setup_api(Item, get_sync_db)
+
+    async with AsyncClient(
+        transport=ASGITransport(app=app), base_url="http://test"
+    ) as client:
+        res = await client.post("/item", json={"name": "a"})
+    assert res.status_code == 201
+    item_id = UUID(res.json()["id"])
+
+    assert api.models["Item"] is Item
+    gen = get_sync_db()
+    session = next(gen)
+    assert isinstance(session.get(Item, item_id), Item)
+    try:
+        next(gen)
+    except StopIteration:
+        pass
+
+
+@pytest.mark.i9n
+def test_op_ctx_openapi_json(sync_db_session):
+    _, get_sync_db = sync_db_session
+
+    class Widget(Base, GUIDPk):
+        __tablename__ = "widgets"
+        __resource__ = "widget"
+        name = Column(String)
+
+        @op_ctx(alias="ping", target="custom", arity="collection")
+        def ping(cls, ctx):
+            return {}
+
+    app, _ = setup_api(Widget, get_sync_db)
+    spec = app.openapi()
+    assert "/widget/ping" in spec["paths"]
+    assert "post" in spec["paths"]["/widget/ping"]
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+async def test_op_ctx_preserves_canon_schemas(sync_db_session):
+    _, get_sync_db = sync_db_session
+
+    class RegisterIn(BaseModel):
+        name: str
+
+    class TokenPair(BaseModel):
+        access: str
+
+    class Widget(Base, GUIDPk):
+        __tablename__ = "widgets"
+        __resource__ = "widget"
+        name = Column(String)
+
+        @op_ctx(
+            alias="register",
+            target="custom",
+            arity="collection",
+            request_schema=RegisterIn,
+            response_schema=TokenPair,
+        )
+        def register(cls, ctx):
+            return TokenPair(access="x")
+
+    app, _ = setup_api(Widget, get_sync_db)
+    spec = app.openapi()
+    schemas = spec["components"]["schemas"].keys()
+    assert "WidgetCreateRequest" in schemas
+    assert "WidgetCreateResponse" in schemas
+    assert "WidgetRegisterRequest" in schemas
+    assert "WidgetRegisterResponse" in schemas
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+async def test_op_ctx_storage_sqlalchemy(sync_db_session):
+    _, get_sync_db = sync_db_session
+
+    class Widget(Base, GUIDPk):
+        __tablename__ = "widgets"
+        __resource__ = "widget"
+        name = Column(String)
+
+        @op_ctx(alias="make", target="create")
+        def make(cls, ctx):
+            pass
+
+    app, _ = setup_api(Widget, get_sync_db)
+
+    async with AsyncClient(
+        transport=ASGITransport(app=app), base_url="http://test"
+    ) as client:
+        res = await client.post("/widget", json={"name": "w"})
+    assert res.status_code == 201
+    item_id = UUID(res.json()["id"])
+
+    gen = get_sync_db()
+    session = next(gen)
+    obj = session.get(Widget, item_id)
+    assert obj is not None
+    try:
+        next(gen)
+    except StopIteration:
+        pass
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+async def test_op_ctx_rest_call(sync_db_session):
+    _, get_sync_db = sync_db_session
+
+    class Gadget(Base, GUIDPk):
+        __tablename__ = "gadgets"
+        __resource__ = "gadget"
+        name = Column(String)
+
+        @schema_ctx(alias="Ping", kind="out")
+        class PingOut(BaseModel):
+            msg: str
+
+        @op_ctx(
+            alias="ping",
+            target="custom",
+            arity="collection",
+            response_schema="Ping.out",
+        )
+        def ping(cls, ctx):
+            return {"msg": "ok"}
+
+    app, _ = setup_api(Gadget, get_sync_db)
+
+    async with AsyncClient(
+        transport=ASGITransport(app=app), base_url="http://test"
+    ) as client:
+        res = await client.post("/gadget/ping", json={})
+    assert res.status_code == 200
+    assert res.json() == {"msg": "ok"}
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+async def test_op_ctx_rpc_method(sync_db_session):
+    _, get_sync_db = sync_db_session
+
+    class Widget(Base, GUIDPk):
+        __tablename__ = "widgets"
+        __resource__ = "widget"
+        name = Column(String)
+
+        @op_ctx(alias="ping", target="custom", arity="collection")
+        def ping(cls, ctx):
+            return {"ok": True}
+
+    app, api = setup_api(Widget, get_sync_db)
+    api.mount_jsonrpc(prefix="/rpc")
+    app.include_router(api.router)
+
+    async with AsyncClient(
+        transport=ASGITransport(app=app), base_url="http://test"
+    ) as client:
+        payload = {"jsonrpc": "2.0", "method": "Widget.ping", "params": {}, "id": 1}
+        res = await client.post("/rpc", json=payload, follow_redirects=True)
+    assert res.status_code == 200
+    assert res.json()["result"] == {"ok": True}
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+async def test_op_ctx_core_crud(sync_db_session):
+    _, get_sync_db = sync_db_session
+
+    class Widget(Base, GUIDPk):
+        __tablename__ = "widgets"
+        __resource__ = "widget"
+        name = Column(String)
+
+        @op_ctx(alias="fetch", target="read", arity="member")
+        def fetch(cls, ctx, obj):
+            return obj
+
+    app, _ = setup_api(Widget, get_sync_db)
+
+    async with AsyncClient(
+        transport=ASGITransport(app=app), base_url="http://test"
+    ) as client:
+        r1 = await client.post("/widget", json={"name": "w"})
+        wid = UUID(r1.json()["id"])  # capture id as UUID
+        r2 = await client.get(f"/widget/{wid}")
+    assert r2.status_code == 200
+    assert r2.json()["name"] == "w"
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+async def test_op_ctx_hookz(sync_db_session):
+    _, get_sync_db = sync_db_session
+    calls = []
+
+    class Widget(Base, GUIDPk):
+        __tablename__ = "widgets"
+        __resource__ = "widget"
+        name = Column(String)
+
+        @schema_ctx(alias="Echo", kind="out")
+        class EchoOut(BaseModel):
+            msg: str
+
+        @op_ctx(
+            alias="echo",
+            target="custom",
+            arity="collection",
+            response_schema="Echo.out",
+        )
+        def echo(cls, ctx):
+            return {"msg": "hi"}
+
+        @hook_ctx(ops="echo", phase="POST_HANDLER")
+        async def record(cls, ctx):
+            calls.append("hooked")
+
+    app, _ = setup_api(Widget, get_sync_db)
+
+    async with AsyncClient(
+        transport=ASGITransport(app=app), base_url="http://test"
+    ) as client:
+        await client.post("/widget/echo", json={})
+    assert calls.count("hooked") >= 1
+
+
+@pytest.mark.i9n
+def test_op_ctx_atom_plan(sync_db_session):
+    _, get_sync_db = sync_db_session
+
+    class Widget(Base, GUIDPk):
+        __tablename__ = "widgets"
+        __resource__ = "widget"
+        name = Column(String)
+
+        @op_ctx(alias="make", target="create")
+        def make(cls, ctx):
+            pass
+
+    _, api = setup_api(Widget, get_sync_db)
+    chains = build_phase_chains(Widget, "make")
+    names = [fn.__name__ for funcs in chains.values() for fn in funcs]
+    assert "create" in names
+
+
+@pytest.mark.i9n
+def test_op_ctx_system_steps(sync_db_session):
+    _, get_sync_db = sync_db_session
+
+    class Widget(Base, GUIDPk):
+        __tablename__ = "widgets"
+        __resource__ = "widget"
+        name = Column(String)
+
+        @op_ctx(alias="ping", target="custom", arity="collection")
+        def ping(cls, ctx):
+            return {}
+
+    _, api = setup_api(Widget, get_sync_db)
+    chains = build_phase_chains(Widget, "ping")
+
+    assert chains["START_TX"]
+    assert chains["END_TX"]

tests/i9n/test_op_ctx_core_crud_order.py

@@ -0,0 +1,219 @@
+import pytest
+from tigrbl.types import App
+from httpx import ASGITransport, AsyncClient
+from sqlalchemy import Column, String
+
+from tigrbl import TigrblApp, op_ctx
+from tigrbl.orm.tables import Base
+from tigrbl.orm.mixins import GUIDPk
+from tigrbl.core import crud
+from tigrbl import core as _core
+from tigrbl.engine.shortcuts import mem
+from tigrbl.engine.engine_spec import EngineSpec
+from tigrbl.engine._engine import Engine
+
+
+def setup_api(model_cls):
+    Base.metadata.clear()
+    spec = EngineSpec.from_any(mem(async_=False))
+    engine = Engine(spec)
+    app = App(engine=engine)
+    api = TigrblApp(engine=engine)
+    api.include_model(model_cls, prefix="")
+    api.initialize()
+    app.include_router(api.router)
+    return app, engine
+
+
+async def fetch_inspection(client):
+    openapi = (await client.get("/openapi.json")).json()
+    hookz = (await client.get("/hookz")).json()
+    kernelz = (await client.get("/kernelz")).json()
+    return openapi, hookz, kernelz
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "verb,alias,http_method,arity,needs_id,expected_status",
+    [
+        ("create", "make", "post", None, False, 201),
+        ("read", "fetch", "get", "member", True, 404),
+        ("update", "change", "patch", "member", True, 404),
+        ("delete", "remove", "delete", "member", True, 404),
+        ("list", "browse", "get", "collection", False, 400),
+        ("clear", "purge", "delete", "collection", False, 400),
+    ],
+)
+async def test_op_ctx_alias(
+    monkeypatch,
+    verb,
+    alias,
+    http_method,
+    arity,
+    needs_id,
+    expected_status,
+):
+    calls: list[str] = []
+    orig = getattr(_core, verb)
+
+    async def wrapped(*args, **kwargs):
+        calls.append("core")
+        return await orig(*args, **kwargs)
+
+    # Patch both the re-exported core function and the underlying crud module
+    monkeypatch.setattr(_core, verb, wrapped)
+    monkeypatch.setattr(crud, verb, wrapped)
+
+    class Widget(Base, GUIDPk):
+        __tablename__ = "widgets"
+        __resource__ = "widget"
+        name = Column(String)
+
+        @op_ctx(alias=alias, target=verb, arity=arity)
+        def _(cls, ctx):  # pragma: no cover - handler not invoked
+            calls.append("op")
+            if verb == "update" and ctx.get("obj"):
+                ctx["obj"].name = "b"
+            if verb == "clear":
+                ctx["result"] = {"cleared": True}
+            return ctx.get("obj") or ctx.get("result")
+
+    app, engine = setup_api(Widget)
+    get_sync_db = engine.get_db
+
+    async with AsyncClient(
+        transport=ASGITransport(app=app), base_url="http://test"
+    ) as client:
+        wid = None
+        if needs_id or verb in {"update", "delete", "list", "clear"}:
+            r = await client.post("/widget", json={"name": "a"})
+            wid = r.json()["id"]
+        path = f"/widget/{wid}/{alias}" if needs_id else f"/widget/{alias}"
+        body = (
+            {"name": "b"}
+            if verb == "update"
+            else {"name": "a"}
+            if verb == "create"
+            else None
+        )
+        if http_method == "post":
+            res = await client.post(path, json=body)
+        elif http_method == "get":
+            res = await client.get(path)
+        elif http_method == "patch":
+            res = await client.patch(path, json=body)
+        elif http_method == "put":
+            res = await client.put(path, json=body)
+        else:
+            res = await client.delete(path)
+        assert res.status_code == expected_status
+
+        gen = get_sync_db()
+        session = next(gen)
+        count = session.query(Widget).count()
+        obj = session.query(Widget).first()
+        if verb == "create":
+            assert count == 1
+        elif verb == "update":
+            assert obj.name == "a"
+        elif verb == "delete":
+            assert count == 1
+        elif verb == "clear":
+            assert count == 1
+        else:
+            assert count == 1
+        try:
+            next(gen)
+        except StopIteration:
+            pass
+
+        openapi, _, _ = await fetch_inspection(client)
+        assert path not in openapi["paths"]
+
+    if verb == "create":
+        # Creating via alias still invokes the core creator
+        assert calls == ["op", "core"]
+    else:
+        assert calls == []
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "verb,http_method,arity,needs_id",
+    [
+        ("create", "post", None, False),
+        ("read", "get", "member", True),
+        ("update", "patch", "member", True),
+        ("delete", "delete", "member", True),
+        ("list", "get", "collection", False),
+        ("clear", "delete", "collection", False),
+    ],
+)
+async def test_op_ctx_override(verb, http_method, arity, needs_id):
+    class Widget(Base, GUIDPk):
+        __tablename__ = "widgets"
+        __resource__ = "widget"
+        name = Column(String)
+
+        @op_ctx(target=verb, arity=arity)
+        def _(cls, ctx):  # pragma: no cover - handler not invoked
+            ctx["result"] = {"custom": True}
+            return ctx["result"]
+
+    app, engine = setup_api(Widget)
+    get_sync_db = engine.get_db
+
+    async with AsyncClient(
+        transport=ASGITransport(app=app), base_url="http://test"
+    ) as client:
+        wid = None
+        if needs_id or verb in {"update", "delete", "list", "clear"}:
+            r = await client.post("/widget", json={"name": "a"})
+            wid = r.json()["id"]
+        path = f"/widget/{wid}" if needs_id else "/widget"
+        body = (
+            {"name": "b"}
+            if verb == "update"
+            else {"name": "a"}
+            if verb == "create"
+            else None
+        )
+        if http_method == "post":
+            res = await client.post(path, json=body)
+        elif http_method == "get":
+            res = await client.get(path)
+        elif http_method == "patch":
+            res = await client.patch(path, json=body)
+        elif http_method == "put":
+            res = await client.put(path, json=body)
+        else:
+            res = await client.delete(path)
+        assert res.status_code in {200, 201}
+
+        gen = get_sync_db()
+        session = next(gen)
+        count = session.query(Widget).count()
+        if verb == "create":
+            assert count == 1
+        elif verb == "read":
+            assert count == 1 if wid else 0
+        elif verb == "update":
+            obj = session.query(Widget).first()
+            # Overriding the update target bypasses the core updater
+            assert obj.name == "a"
+        elif verb == "delete":
+            assert count == 0
+        elif verb == "list":
+            assert count == 1
+        elif verb == "clear":
+            assert count == 0
+        try:
+            next(gen)
+        except StopIteration:
+            pass
+
+        openapi, _, _ = await fetch_inspection(client)
+        template = "/widget/{item_id}" if needs_id else "/widget"
+        assert template in openapi["paths"]

tests/i9n/test_openapi_clear_response_schema.py

@@ -0,0 +1,35 @@
+import pytest
+from httpx import ASGITransport, AsyncClient
+
+from tigrbl import TigrblApp
+from tigrbl.orm.mixins import GUIDPk
+from tigrbl.orm.tables import Base
+from tigrbl.types import App, Column, String
+
+
+@pytest.mark.asyncio()
+async def test_openapi_clear_response_schema() -> None:
+    Base.metadata.clear()
+
+    class Widget(Base, GUIDPk):
+        __tablename__ = "widgets_openapi_clear"
+        name = Column(String, nullable=False)
+
+    app = App()
+    api = TigrblApp()
+    api.include_model(Widget)
+    app.include_router(api.router)
+
+    async with AsyncClient(
+        transport=ASGITransport(app=app), base_url="http://test"
+    ) as client:
+        spec = (await client.get("/openapi.json")).json()
+
+    path = f"/{Widget.__name__.lower()}"
+    schema_ref = spec["paths"][path]["delete"]["responses"]["200"]["content"][
+        "application/json"
+    ]["schema"]["$ref"]
+    assert schema_ref.endswith("WidgetClearResponse")
+    comp = spec["components"]["schemas"]["WidgetClearResponse"]
+    assert "deleted" in comp.get("properties", {})
+    assert comp.get("examples") == [{"deleted": 0}]