tigrbl-tests 0.3.0__py3-none-any.whl

tests/i9n/test_iospec_attributes.py

@@ -0,0 +1,368 @@
+import pytest
+from tigrbl.types import App, SimpleNamespace
+from fastapi.testclient import TestClient
+from sqlalchemy import create_engine
+from sqlalchemy.orm import Mapped, sessionmaker
+from sqlalchemy.pool import StaticPool
+
+from tigrbl import TigrblApp
+from tigrbl.engine.shortcuts import engine as engine_factory, mem
+from tigrbl.bindings.model import bind
+from tigrbl.bindings.rest.router import _build_router
+from tigrbl.bindings.rpc import register_and_attach
+from tigrbl.op import OpSpec
+from tigrbl.runtime.atoms.resolve import assemble
+from tigrbl.runtime.atoms.schema import collect_in, collect_out
+from tigrbl.runtime.kernel import _default_kernel as K, build_phase_chains
+from tigrbl.specs import F, IO, S, acol, vcol
+from tigrbl.orm.tables import Base
+from tigrbl.orm.mixins import GUIDPk
+from tigrbl.types import Integer as IntType, String as StrType
+
+
+@pytest.mark.i9n
+def test_request_and_response_schemas_respect_iospec_aliases():
+    class Thing(Base):
+        __tablename__ = "iospec_schema_i9n"
+        __allow_unmapped__ = True
+
+        id = acol(
+            storage=S(type_=IntType, primary_key=True, autoincrement=True),
+            io=IO(out_verbs=("read",)),
+        )
+        name = acol(
+            storage=S(type_=StrType, nullable=False),
+            io=IO(
+                in_verbs=("create",),
+                out_verbs=("read",),
+                alias_in="first_name",
+                alias_out="firstName",
+            ),
+        )
+
+    bind(Thing)
+    specs = Thing.__tigrbl_cols__
+    ctx_in = SimpleNamespace(
+        opview=K._compile_opview_from_specs(specs, SimpleNamespace(alias="create")),
+        op="create",
+        temp={},
+    )
+    collect_in.run(None, ctx_in)
+    schema_in = ctx_in.temp["schema_in"]
+    assert "id" not in schema_in["by_field"]
+    assert schema_in["by_field"]["name"]["alias_in"] == "first_name"
+
+    ctx_out = SimpleNamespace(
+        opview=K._compile_opview_from_specs(specs, SimpleNamespace(alias="read")),
+        op="read",
+        temp={},
+    )
+    collect_out.run(None, ctx_out)
+    schema_out = ctx_out.temp["schema_out"]
+    assert "id" in schema_out["by_field"]
+    assert schema_out["by_field"]["name"]["alias_out"] == "firstName"
+
+
+@pytest.mark.i9n
+def test_columns_materialized_for_acol():
+    class Thing(Base):
+        __tablename__ = "iospec_columns_i9n"
+        __allow_unmapped__ = True
+
+        id = acol(
+            storage=S(type_=IntType, primary_key=True), io=IO(out_verbs=("read",))
+        )
+        nick: Mapped[str] = vcol(field=F(py_type=str), io=IO(out_verbs=("read",)))
+
+    bind(Thing)
+    assert "id" in Thing.__table__.c
+    assert "nick" in Thing.__table__.c
+
+
+@pytest.mark.i9n
+def test_default_factory_resolves_missing_value():
+    class Thing(Base):
+        __tablename__ = "iospec_defaults_i9n"
+        __allow_unmapped__ = True
+
+        id = acol(
+            storage=S(type_=IntType, primary_key=True, autoincrement=True),
+            io=IO(out_verbs=("read",)),
+        )
+        created = acol(
+            storage=S(type_=StrType, nullable=False),
+            io=IO(in_verbs=("create",)),
+            default_factory=lambda ctx: "now",
+        )
+
+    bind(Thing)
+    specs = Thing.__tigrbl_cols__
+    ctx = SimpleNamespace(
+        opview=K._compile_opview_from_specs(specs, SimpleNamespace(alias="create")),
+        op="create",
+        temp={"in_values": {}},
+        persist=True,
+    )
+    assemble.run(None, ctx)
+    assembled = ctx.temp["assembled_values"]
+    assert assembled["created"] == "now"
+    assert "created" in ctx.temp["used_default_factory"]
+
+
+@pytest.mark.i9n
+def test_binding_attaches_internal_model_namespaces():
+    class Thing(Base):
+        __tablename__ = "iospec_internal_i9n"
+        __allow_unmapped__ = True
+
+        id = acol(
+            storage=S(type_=IntType, primary_key=True), io=IO(out_verbs=("read",))
+        )
+        name = acol(
+            storage=S(type_=StrType, nullable=False),
+            io=IO(in_verbs=("create",), out_verbs=("read",)),
+        )
+
+    api = TigrblApp()
+    api.include_model(Thing, mount_router=False)
+    assert "Thing" in api.models
+    assert hasattr(api.schemas, "Thing")
+    assert "name" in Thing.__tigrbl_cols__
+
+
+@pytest.mark.i9n
+def test_openapi_reflects_io_verbs():
+    class Widget(Base, GUIDPk):
+        __tablename__ = "iospec_openapi_i9n"
+        __allow_unmapped__ = True
+
+        name = acol(
+            storage=S(type_=StrType, nullable=False),
+            io=IO(in_verbs=("create",), out_verbs=("read",)),
+        )
+
+    sp_create = OpSpec(alias="create", target="create")
+    sp_read = OpSpec(alias="read", target="read")
+    router = _build_router(Widget, [sp_create, sp_read])
+    app = App()
+    app.include_router(router)
+    spec = app.openapi()
+
+    props_create = spec["components"]["schemas"]["WidgetCreateRequest"]["properties"]
+    assert "name" in props_create
+    assert "id" not in props_create
+
+    props_read = spec["components"]["schemas"]["WidgetReadResponse"]["properties"]
+    assert "name" in props_read
+    assert "id" in props_read
+
+
+@pytest.mark.i9n
+def test_storage_and_sqlalchemy_integration():
+    engine = create_engine(
+        "sqlite:///:memory:",
+        connect_args={"check_same_thread": False},
+        poolclass=StaticPool,
+    )
+    SessionLocal = sessionmaker(bind=engine, expire_on_commit=False)
+    Base.metadata.clear()
+
+    class Thing(Base):
+        __tablename__ = "iospec_storage_i9n"
+        __allow_unmapped__ = True
+
+        id = acol(
+            storage=S(type_=IntType, primary_key=True, autoincrement=True),
+            io=IO(out_verbs=("read",)),
+        )
+        name = acol(
+            storage=S(type_=StrType, nullable=False),
+            io=IO(in_verbs=("create",), out_verbs=("read",)),
+        )
+
+    bind(Thing)
+    Base.metadata.create_all(engine)
+
+    with SessionLocal() as session:
+        obj = Thing(name="foo")
+        session.add(obj)
+        session.commit()
+        session.refresh(obj)
+        assert obj.id is not None
+        stored = session.get(Thing, obj.id)
+        assert stored.name == "foo"
+
+
+@pytest.mark.i9n
+def test_rest_call_respects_aliases():
+    eng = engine_factory(mem(async_=False))
+
+    class Thing(Base):
+        __tablename__ = "iospec_rest_i9n"
+        __allow_unmapped__ = True
+
+        id = acol(
+            storage=S(type_=IntType, primary_key=True, autoincrement=True),
+            io=IO(out_verbs=("read",)),
+        )
+        name = acol(
+            storage=S(type_=StrType, nullable=False),
+            io=IO(in_verbs=("create",), out_verbs=("read",)),
+        )
+
+    api = TigrblApp(engine=eng)
+    api.include_model(Thing)
+    Base.metadata.create_all(eng.raw()[0])
+    client = TestClient(api)
+
+    resp = client.post("/thing", json={"name": "Ada"})
+    data = resp.json()
+    assert data["name"] == "Ada"
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+async def test_rpc_call_uses_schemas():
+    engine = create_engine(
+        "sqlite:///:memory:",
+        connect_args={"check_same_thread": False},
+        poolclass=StaticPool,
+    )
+    SessionLocal = sessionmaker(bind=engine, expire_on_commit=False)
+    Base.metadata.clear()
+
+    class Thing(Base):
+        __tablename__ = "iospec_rpc_i9n"
+        __allow_unmapped__ = True
+
+        id = acol(
+            storage=S(type_=IntType, primary_key=True, autoincrement=True),
+            io=IO(out_verbs=("read",)),
+        )
+        name = acol(
+            storage=S(type_=StrType, nullable=False),
+            io=IO(in_verbs=("create",), out_verbs=("read",)),
+        )
+
+    bind(Thing)
+    register_and_attach(Thing, [OpSpec(alias="create", target="create")])
+    Base.metadata.create_all(engine)
+
+    with SessionLocal() as session:
+        result = await Thing.rpc.create({"name": "Bob"}, db=session)
+    assert result["name"] == "Bob"
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+async def test_core_crud_helpers_operate():
+    eng = engine_factory(mem(async_=False))
+
+    class Thing(Base):
+        __tablename__ = "iospec_core_i9n"
+        __allow_unmapped__ = True
+
+        id = acol(
+            storage=S(type_=IntType, primary_key=True, autoincrement=True),
+            io=IO(out_verbs=("read",)),
+        )
+        name = acol(
+            storage=S(type_=StrType, nullable=False),
+            io=IO(in_verbs=("create",), out_verbs=("read",)),
+        )
+
+    api = TigrblApp(engine=eng)
+    api.include_model(Thing)
+    Base.metadata.create_all(eng.raw()[0])
+
+    with eng.session() as session:
+        created = await api.core.Thing.create({"name": "Zed"}, db=session)
+        obj = await api.core.Thing.read({"id": created["id"]}, db=session)
+    assert obj["name"] == "Zed"
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+async def test_hooks_trigger_with_iospec():
+    engine = create_engine(
+        "sqlite:///:memory:",
+        connect_args={"check_same_thread": False},
+        poolclass=StaticPool,
+    )
+    SessionLocal = sessionmaker(bind=engine, expire_on_commit=False)
+
+    called = {}
+
+    async def before(ctx):
+        called["hit"] = True
+
+    class Thing(Base):
+        __tablename__ = "iospec_hooks_i9n"
+        __allow_unmapped__ = True
+
+        id = acol(
+            storage=S(type_=IntType, primary_key=True, autoincrement=True),
+            io=IO(out_verbs=("read",)),
+        )
+        name = acol(
+            storage=S(type_=StrType, nullable=False),
+            io=IO(in_verbs=("create",), out_verbs=("read",)),
+        )
+        __tigrbl_hooks__ = {"create": {"PRE_HANDLER": [before]}}
+
+    bind(Thing)
+    register_and_attach(Thing, [OpSpec(alias="create", target="create")])
+    Base.metadata.create_all(engine)
+
+    with SessionLocal() as session:
+        await Thing.rpc.create({"name": "hi"}, db=session)
+    assert called.get("hit") is True
+
+
+@pytest.mark.i9n
+def test_atoms_execute_with_iospec():
+    class Thing(Base):
+        __tablename__ = "iospec_atoms_i9n"
+        __allow_unmapped__ = True
+
+        id = acol(
+            storage=S(type_=IntType, primary_key=True, autoincrement=True),
+            io=IO(out_verbs=("read",)),
+        )
+        name = acol(
+            storage=S(type_=StrType, nullable=False),
+            io=IO(in_verbs=("create",), out_verbs=("read",)),
+        )
+
+    bind(Thing)
+    specs = Thing.__tigrbl_cols__
+    ctx = SimpleNamespace(
+        opview=K._compile_opview_from_specs(specs, SimpleNamespace(alias="create")),
+        op="create",
+        temp={"in_values": {"name": "x"}},
+        persist=True,
+    )
+    collect_in.run(None, ctx)
+    assemble.run(None, ctx)
+    collect_out.run(None, ctx)
+    assert ctx.temp["assembled_values"]["name"] == "x"
+
+
+@pytest.mark.i9n
+def test_system_phase_chain_includes_system_steps():
+    class Thing(Base):
+        __tablename__ = "iospec_system_i9n"
+        __allow_unmapped__ = True
+
+        id = acol(
+            storage=S(type_=IntType, primary_key=True), io=IO(out_verbs=("read",))
+        )
+        name = acol(
+            storage=S(type_=StrType, nullable=False),
+            io=IO(in_verbs=("create",), out_verbs=("read",)),
+        )
+
+    bind(Thing)
+    chains = build_phase_chains(Thing, "create")
+    assert "HANDLER" in chains
+    assert any(chains[ph] for ph in chains)

tests/i9n/test_iospec_integration.py

@@ -0,0 +1,181 @@
+import pytest
+import pytest_asyncio
+from httpx import ASGITransport, AsyncClient
+from sqlalchemy import select
+from types import SimpleNamespace
+
+from tigrbl import TigrblApp
+from tigrbl.engine import resolver as _resolver
+from tigrbl.engine.shortcuts import mem
+from tigrbl.orm.tables import Base
+from tigrbl.orm.mixins import GUIDPk
+from tigrbl.specs import IO, S, acol
+from tigrbl.types import App, String, UUID
+from tigrbl.core import crud
+from tigrbl.runtime.atoms.resolve import assemble
+
+
+class Widget(Base, GUIDPk):
+    __tablename__ = "widgets"
+
+    name = acol(
+        storage=S(type_=String, nullable=False),
+        io=IO(in_verbs=("create",), out_verbs=("read",)),
+    )
+    secret = acol(
+        storage=S(type_=String, nullable=True),
+        io=IO(in_verbs=("create",), out_verbs=(), allow_out=False),
+    )
+    created_at = acol(
+        storage=S(type_=String, nullable=False),
+        io=IO(in_verbs=("create",), out_verbs=("read",)),
+        default_factory=lambda ctx: "now",
+    )
+
+
+@pytest_asyncio.fixture
+async def widget_setup():
+    app = App()
+    api = TigrblApp(engine=mem(async_=False))
+    api.include_model(Widget, prefix="/widget")
+    api.mount_jsonrpc(prefix="/rpc")
+    api.attach_diagnostics(prefix="/system")
+    api.initialize()
+    app.include_router(api.router)
+
+    prov = _resolver.resolve_provider()
+    SessionLocal = prov.session
+
+    transport = ASGITransport(app=app)
+    client = AsyncClient(transport=transport, base_url="http://test")
+    yield client, api, SessionLocal
+    await client.aclose()
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+async def test_request_schema_reflects_io_spec(widget_setup):
+    _, api, _ = widget_setup
+    schema = api.schemas.Widget.create.in_.model_json_schema()
+    assert set(schema["properties"]) == {"name", "secret", "created_at"}
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+async def test_response_schema_reflects_io_spec(widget_setup):
+    _, api, _ = widget_setup
+    schema = api.schemas.Widget.read.out.model_json_schema()
+    assert set(schema["properties"]) == {"id", "name", "created_at", "secret"}
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+async def test_columns_store_io_spec(widget_setup):
+    _, _, _ = widget_setup
+    spec = Widget.__tigrbl_cols__["secret"].io
+    assert spec.allow_out is False
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+async def test_default_factory_resolution(widget_setup):
+    _, _, _ = widget_setup
+    specs = Widget.__tigrbl_cols__
+    ctx = SimpleNamespace(
+        specs=specs, op="create", temp={"in_values": {}}, persist=True
+    )
+    assemble.run(None, ctx)
+    assert ctx.temp["assembled_values"]["created_at"] == "now"
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+async def test_orm_model_carries_io_spec(widget_setup):
+    _, _, _ = widget_setup
+    assert "name" in Widget.__tigrbl_cols__
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+async def test_openapi_reflects_io_spec(widget_setup):
+    client, _, _ = widget_setup
+    spec = (await client.get("/openapi.json")).json()
+    props = spec["components"]["schemas"]["WidgetReadResponse"]["properties"]
+    assert "secret" in props
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+async def test_storage_persists_data(widget_setup):
+    client, _, SessionLocal = widget_setup
+    payload = {
+        "name": "hi",
+        "secret": "s",
+        "created_at": "now",
+    }
+    resp = await client.post("/widget/widget", json=payload)
+    wid = UUID(resp.json()["id"])
+    with SessionLocal() as session:
+        obj = session.execute(select(Widget).where(Widget.id == wid)).scalar_one()
+    assert obj.name == "hi"
+    assert obj.secret == "s"
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+async def test_rest_calls_honor_io_spec(widget_setup):
+    client, _, _ = widget_setup
+    payload = {
+        "name": "hi",
+        "secret": "s",
+        "created_at": "now",
+    }
+    resp = await client.post("/widget/widget", json=payload)
+    wid = resp.json()["id"]
+    data = (await client.get(f"/widget/widget/{wid}")).json()
+    assert data["secret"] == "s"
+    assert data["name"] == "hi"
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+async def test_rpc_methods_honor_io_spec(widget_setup):
+    client, _, _ = widget_setup
+    payload = {
+        "jsonrpc": "2.0",
+        "method": "Widget.create",
+        "params": {
+            "name": "rpc",
+            "secret": "x",
+            "created_at": "now",
+        },
+        "id": 1,
+    }
+    result = (await client.post("/rpc/", json=payload)).json()["result"]
+    assert result["secret"] == "x"
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+async def test_core_crud_binding(widget_setup):
+    _, _, _ = widget_setup
+    assert Widget.hooks.create.HANDLER[0].__qualname__ == crud.create.__qualname__
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+async def test_hookz_reports_operations(widget_setup):
+    client, _, _ = widget_setup
+    data = (await client.get("/system/hookz")).json()
+    assert "Widget" in data
+    assert "create" in data["Widget"]
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+async def test_kernelz_lists_atoms_and_steps(widget_setup):
+    client, _, _ = widget_setup
+    data = (await client.get("/system/kernelz")).json()
+    steps = data["Widget"]["create"]
+    assert "HANDLER:hook:wire:tigrbl:core:crud:ops:create@HANDLER" in steps
+    assert any("hook:sys:txn:begin@START_TX" in s for s in steps)

tests/i9n/test_key_digest_uvicorn.py

@@ -0,0 +1,151 @@
+from uuid import uuid4
+
+import httpx
+import pytest
+import pytest_asyncio
+
+from tigrbl import TigrblApp
+from tigrbl.orm.mixins import (
+    GUIDPk,
+    Created,
+    LastUsed,
+    ValidityWindow,
+    KeyDigest,
+    tzutcnow,
+    tzutcnow_plus_day,
+)
+from tigrbl.orm.mixins.utils import CRUD_IO
+from tigrbl.orm.tables._base import Base
+from tigrbl.specs import F, S, acol
+from tigrbl.types import App, Mapped, String
+from sqlalchemy import inspect
+
+from .uvicorn_utils import run_uvicorn_in_task, stop_uvicorn_server
+
+
+class ApiKey(Base, GUIDPk, Created, LastUsed, ValidityWindow, KeyDigest):
+    __abstract__ = False
+    __tablename__ = "apikeys_uvicorn"
+    __resource__ = "apikey"
+
+    label: Mapped[str] = acol(
+        storage=S(String, nullable=False),
+        field=F(constraints={"max_length": 120}),
+        io=CRUD_IO,
+    )
+    service_id: Mapped[str] = acol(
+        storage=S(String, nullable=False),
+        field=F(constraints={"max_length": 120}),
+        io=CRUD_IO,
+    )
+
+
+@pytest_asyncio.fixture()
+async def running_app(sync_db_session):
+    engine, get_sync_db = sync_db_session
+
+    app = App()
+    api = TigrblApp(get_db=get_sync_db)
+    api.include_models([ApiKey])
+    await api.initialize()
+    app.include_router(api.router)
+
+    base_url, server, task = await run_uvicorn_in_task(app)
+    try:
+        yield (base_url, engine)
+    finally:
+        await stop_uvicorn_server(server, task)
+
+
+def _payload() -> dict:
+    now = tzutcnow()
+    return {
+        "label": "test",
+        "service_id": str(uuid4()),
+        "valid_from": now.isoformat(),
+        "valid_to": tzutcnow_plus_day().isoformat(),
+    }
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+async def test_create_apikey_success(running_app):
+    base_url, _ = running_app
+    async with httpx.AsyncClient() as client:
+        resp = await client.post(f"{base_url}/apikey", json=_payload())
+    assert resp.status_code == 201
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+async def test_create_response_fields(running_app):
+    base_url, _ = running_app
+    async with httpx.AsyncClient() as client:
+        resp = await client.post(f"{base_url}/apikey", json=_payload())
+    body = resp.json()
+    expected = {
+        "api_key",
+        "label",
+        "service_id",
+        "valid_from",
+        "valid_to",
+        "digest",
+        "last_used_at",
+        "created_at",
+        "id",
+    }
+    assert set(body) == expected
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+async def test_persisted_columns(running_app):
+    base_url, engine = running_app
+    async with httpx.AsyncClient() as client:
+        await client.post(f"{base_url}/apikey", json=_payload())
+    inspector = inspect(engine)
+    cols = {col["name"] for col in inspector.get_columns("apikeys_uvicorn")}
+    expected = {
+        "label",
+        "service_id",
+        "valid_from",
+        "valid_to",
+        "digest",
+        "last_used_at",
+        "created_at",
+        "id",
+    }
+    assert cols == expected
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+async def test_read_excludes_api_key(running_app):
+    base_url, _ = running_app
+    async with httpx.AsyncClient() as client:
+        resp = await client.post(f"{base_url}/apikey", json=_payload())
+        created = resp.json()
+        fetched = await client.get(f"{base_url}/apikey/{created['id']}")
+    body = fetched.json()
+    assert "api_key" not in body
+    assert body["digest"] == created["digest"]
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+async def test_rejects_digest_in_request(running_app):
+    base_url, _ = running_app
+    bad = _payload() | {"digest": "x"}
+    async with httpx.AsyncClient() as client:
+        resp = await client.post(f"{base_url}/apikey", json=bad)
+    assert resp.status_code == 422
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+async def test_rejects_api_key_in_request(running_app):
+    base_url, _ = running_app
+    bad = _payload() | {"api_key": "raw"}
+    async with httpx.AsyncClient() as client:
+        resp = await client.post(f"{base_url}/apikey", json=bad)
+    assert resp.status_code == 422