tigrbl-tests 0.3.0__py3-none-any.whl

tests/i9n/test_openapi_schema_examples_presence.py

@@ -0,0 +1,81 @@
+import pytest
+from tigrbl import TigrblApp, Base
+from tigrbl.engine.shortcuts import mem
+from tigrbl.orm.mixins import GUIDPk
+from tigrbl.specs import F, S, acol
+from tigrbl.types import App, Mapped, String
+from httpx import ASGITransport, AsyncClient
+
+
+class Widget(Base, GUIDPk):
+    __tablename__ = "widgets_example_presence"
+    name: Mapped[str] = acol(
+        storage=S(String, nullable=False), field=F(constraints={"examples": ["foo"]})
+    )
+
+
+def _resolve_schema(spec, schema):
+    if "$ref" in schema:
+        ref = schema["$ref"].split("/")[-1]
+        return spec["components"]["schemas"][ref]
+    if "anyOf" in schema:
+        return _resolve_schema(spec, schema["anyOf"][0])
+    if "items" in schema:
+        item = _resolve_schema(spec, schema["items"])
+        schema["items"] = item
+        if "examples" not in schema and "examples" in item:
+            schema["examples"] = [item["examples"][0]]
+    return schema
+
+
+@pytest.mark.asyncio
+@pytest.mark.i9n
+async def test_openapi_examples_and_schemas_present(db_mode):
+    fastapi_app = App()
+    engine = mem() if db_mode == "async" else mem(async_=False)
+    api = TigrblApp(engine=engine)
+    api.include_model(Widget)
+    if db_mode == "async":
+        await api.initialize()
+    else:
+        api.initialize()
+    api.mount_jsonrpc()
+    fastapi_app.include_router(api.router)
+
+    transport = ASGITransport(app=fastapi_app)
+    async with AsyncClient(transport=transport, base_url="http://test") as client:
+        spec = (await client.get("/openapi.json")).json()
+
+    path = f"/{Widget.__name__.lower()}"
+    create_req = spec["paths"][path]["post"]["requestBody"]["content"][
+        "application/json"
+    ]["schema"]
+    create_resp = spec["paths"][path]["post"]["responses"]["201"]["content"][
+        "application/json"
+    ]["schema"]
+    create_req = _resolve_schema(spec, create_req)
+    create_resp = _resolve_schema(spec, create_resp)
+    assert create_req["properties"]["name"]["examples"][0] == "foo"
+    assert create_resp["properties"]["name"]["examples"][0] == "foo"
+
+    expected = {
+        "WidgetClearResponse",
+        "WidgetCreateRequest",
+        "WidgetCreateResponse",
+        "WidgetDeleteResponse",
+        "WidgetListResponse",
+        "WidgetReadResponse",
+        "WidgetReplaceRequest",
+        "WidgetReplaceResponse",
+        "WidgetUpdateRequest",
+        "WidgetUpdateResponse",
+    }
+    assert expected <= set(spec["components"]["schemas"])
+
+    assert hasattr(api.schemas, "Widget")
+    widget_ns = getattr(api.schemas, "Widget")
+    for alias in ["create", "read", "update", "replace", "delete", "list", "clear"]:
+        assert hasattr(widget_ns, alias)
+        op_ns = getattr(widget_ns, alias)
+        assert hasattr(op_ns, "in_")
+        assert hasattr(op_ns, "out")

tests/i9n/test_opspec_effects_i9n_test.py

@@ -0,0 +1,193 @@
+import asyncio
+
+import pytest
+from tigrbl.types import App
+from sqlalchemy import String, create_engine
+from sqlalchemy.orm import sessionmaker
+
+from tigrbl import core as _core
+from tigrbl.bindings.model import bind
+from tigrbl.hook import hook_ctx
+from tigrbl.op.types import PHASES
+from tigrbl.runtime import system as runtime_system
+from tigrbl.runtime.kernel import build_phase_chains
+from tigrbl.specs import IO, S, acol
+from tigrbl.orm.tables import Base
+from tigrbl.orm.mixins import GUIDPk
+
+
+# --- models --------------------------------------------------------------------
+
+
+# NOTE:
+# Historically this test called ``Base.metadata.clear()`` at import time to
+# ensure a pristine declarative registry.  When the test module is imported as
+# part of the full suite, clearing the global metadata wipes out tables defined
+# by earlier tests which still rely on the shared ``Base``.  Subsequent tests
+# would then fail with missing table/column errors (manifesting as HTTP 503
+# responses) because their models lost their metadata.  The table names used in
+# this module are unique, so we can simply avoid clearing the global metadata to
+# preserve isolation without impacting other tests.
+
+
+class Gadget(Base, GUIDPk):
+    __tablename__ = "gadgets_opspec"
+    __allow_unmapped__ = True
+
+    name = acol(
+        storage=S(type_=String, nullable=False, default="anon"),
+        io=IO(in_verbs=("create",), out_verbs=("read",)),
+    )
+
+
+class Hooked(Base, GUIDPk):
+    __tablename__ = "hooked_opspec"
+    __allow_unmapped__ = True
+
+    name = acol(
+        storage=S(type_=String, nullable=False),
+        io=IO(in_verbs=("create",), out_verbs=("read",)),
+    )
+
+    @hook_ctx(ops="create", phase="PRE_HANDLER")
+    def inject_name(cls, ctx):
+        payload = dict(ctx.get("payload") or {})
+        payload.setdefault("name", "hooked")
+        ctx["payload"] = payload
+
+
+# --- helpers -------------------------------------------------------------------
+
+GADGET_TABLE = Gadget.__table__
+HOOKED_TABLE = Hooked.__table__
+
+
+def _ensure_tables():
+    for model, table in ((Gadget, GADGET_TABLE), (Hooked, HOOKED_TABLE)):
+        if not hasattr(model, "__table__"):
+            model.__table__ = table  # type: ignore[attr-defined]
+        if table.key not in Base.metadata.tables:
+            Base.metadata._add_table(table.name, table.schema, table)
+        if not hasattr(model, "__mapper__"):
+            Base.registry.map_imperatively(model, table)
+
+
+def _fresh_session():
+    engine = create_engine("sqlite:///:memory:")
+    _ensure_tables()
+    Base.metadata.create_all(bind=engine, tables=[Gadget.__table__, Hooked.__table__])
+    return sessionmaker(bind=engine)()
+
+
+# --- tests ---------------------------------------------------------------------
+
+
+@pytest.mark.i9n
+def test_request_and_response_schemas():
+    _ensure_tables()
+    bind(Gadget)
+    assert hasattr(Gadget.schemas, "create")
+    assert hasattr(Gadget.schemas.create, "in_")
+    assert hasattr(Gadget.schemas, "read")
+    assert hasattr(Gadget.schemas.read, "out")
+
+
+@pytest.mark.i9n
+def test_columns_bound():
+    _ensure_tables()
+    bind(Gadget)
+    assert "name" in Gadget.__table__.c
+    assert "name" in Gadget.__tigrbl_cols__
+
+
+@pytest.mark.i9n
+def test_defaults_value_resolution():
+    _ensure_tables()
+    bind(Gadget)
+    db = _fresh_session()
+    obj = asyncio.run(_core.create(Gadget, db=db, data={}))
+    assert obj.name == "anon"
+
+
+@pytest.mark.i9n
+def test_internal_model_opspec_binding():
+    _ensure_tables()
+    bind(Gadget)
+    sp = Gadget.opspecs.by_alias["create"][0]
+    assert sp.table is Gadget
+
+
+@pytest.mark.i9n
+def test_openapi_includes_path():
+    _ensure_tables()
+    bind(Gadget)
+    app = App()
+    app.include_router(Gadget.rest.router)
+    schema = app.openapi()
+    assert "/gadget" in schema["paths"]
+
+
+@pytest.mark.i9n
+def test_storage_and_sqlalchemy_persist():
+    _ensure_tables()
+    bind(Gadget)
+    db = _fresh_session()
+    asyncio.run(_core.create(Gadget, db=db, data={"name": "stored"}))
+    fetched = db.query(Gadget).one()
+    assert fetched.name == "stored"
+
+
+@pytest.mark.i9n
+def test_rest_routes_bound():
+    _ensure_tables()
+    session = _fresh_session()
+
+    def get_db():
+        return session
+
+    Gadget.__tigrbl_get_db__ = staticmethod(get_db)  # type: ignore[attr-defined]
+    bind(Gadget)
+    app = App()
+    app.include_router(Gadget.rest.router)
+    paths = {route.path for route in app.router.routes}
+    assert "/gadget" in paths
+
+
+@pytest.mark.i9n
+def test_rpc_method_bound():
+    _ensure_tables()
+    bind(Gadget)
+    assert hasattr(Gadget.rpc, "create")
+
+
+@pytest.mark.i9n
+def test_core_crud_handler_used():
+    _ensure_tables()
+    bind(Gadget)
+    step = Gadget.hooks.create.HANDLER[0]
+    assert step.__qualname__ == _core.create.__qualname__
+
+
+@pytest.mark.i9n
+def test_hook_execution():
+    _ensure_tables()
+    bind(Hooked)
+    assert Hooked.hooks.create.PRE_HANDLER
+
+
+@pytest.mark.i9n
+def test_atom_injection():
+    _ensure_tables()
+    bind(Gadget)
+    chains = build_phase_chains(Gadget, "create")
+    non_handler = [ph for ph in PHASES if ph != "HANDLER" and chains.get(ph)]
+    # atom discovery injects steps into additional phases beyond the handler
+    assert non_handler
+
+
+@pytest.mark.i9n
+def test_system_step_registry():
+    subjects = runtime_system.subjects()
+    assert ("txn", "begin") in subjects
+    assert ("handler", "crud") in subjects
+    assert ("txn", "commit") in subjects

tests/i9n/test_owner_tenant_policy.py

@@ -0,0 +1,173 @@
+from tigrbl.types import App, HTTPException, Request, Security
+from typing import Iterable
+
+from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
+from fastapi.testclient import TestClient
+import pytest
+import uuid
+from sqlalchemy import Column, String
+
+from tigrbl import TigrblApp, Base
+from tigrbl.orm.mixins import GUIDPk
+from tigrbl.orm.mixins.ownable import Ownable, OwnerPolicy
+from tigrbl.orm.mixins.tenant_bound import TenantBound, TenantPolicy
+from tigrbl.config.constants import TIGRBL_AUTH_CONTEXT_ATTR
+from tigrbl.types.authn_abc import AuthNProvider
+
+
+class DummyAuth(AuthNProvider):
+    def __init__(self, user_id: uuid.UUID, tenant_id: uuid.UUID):
+        self.user_id = user_id
+        self.tenant_id = tenant_id
+
+    async def get_principal(
+        self,
+        request: Request,
+        creds: HTTPAuthorizationCredentials = Security(HTTPBearer()),
+    ):
+        if creds.credentials != "secret":
+            raise HTTPException(status_code=401)
+        principal = {"user_id": self.user_id, "tenant_id": self.tenant_id}
+        request.state.principal = principal
+        setattr(request.state, TIGRBL_AUTH_CONTEXT_ATTR, principal)
+        return principal
+
+
+def _client_for_owner(
+    policy: OwnerPolicy,
+    user_id: uuid.UUID,
+    tenant_id: uuid.UUID,
+    extra_user_ids: Iterable[uuid.UUID] | None = None,
+) -> TestClient:
+    Base.metadata.clear()
+
+    class User(Base, GUIDPk):
+        __tablename__ = "users"
+        __table_args__ = {"schema": "main"}
+        name = Column(String, nullable=False)
+
+    class Item(Base, GUIDPk, Ownable):
+        __tablename__ = "items"
+        __table_args__ = {"schema": "main"}
+        name = Column(String, nullable=False)
+        __tigrbl_owner_policy__ = policy
+
+    from tigrbl.engine.shortcuts import mem
+    from tigrbl.engine.engine_spec import EngineSpec
+    from tigrbl.engine._engine import Engine
+
+    engine = Engine(EngineSpec.from_any(mem(async_=False)))
+    db_engine, _ = engine.raw()
+    Base.metadata.create_all(bind=db_engine)
+
+    with engine.session() as session:
+        session.execute(User.__table__.insert().values(id=user_id, name="owner"))
+        for extra in extra_user_ids or []:
+            session.execute(User.__table__.insert().values(id=extra, name="extra"))
+        session.commit()
+
+    authn = DummyAuth(user_id, tenant_id)
+    api = TigrblApp(engine=engine)
+    api.set_auth(authn=authn.get_principal)
+    api.include_models([User, Item])
+    app = App()
+    app.include_router(api.router)
+    api.initialize()
+    return TestClient(app)
+
+
+@pytest.mark.i9n
+def test_owner_policy_runtime_switch():
+    user_id = uuid.uuid4()
+    tenant_id = uuid.uuid4()
+    headers = {"Authorization": "Bearer secret"}
+
+    client = _client_for_owner(OwnerPolicy.STRICT_SERVER, user_id, tenant_id)
+    res = client.post(
+        "/item",
+        json={"name": "one", "owner_id": str(user_id)},
+        headers=headers,
+    )
+    assert res.status_code == 400
+
+    supplied = uuid.uuid4()
+    client = _client_for_owner(
+        OwnerPolicy.CLIENT_SET, user_id, tenant_id, extra_user_ids=[supplied]
+    )
+    res = client.post(
+        "/item",
+        json={"name": "two", "owner_id": str(supplied)},
+        headers=headers,
+    )
+    assert res.status_code == 201
+    assert res.json()["owner_id"] == str(supplied)
+
+
+def _client_for_tenant(
+    policy: TenantPolicy,
+    user_id: uuid.UUID,
+    tenant_id: uuid.UUID,
+    extra_tenant_ids: Iterable[uuid.UUID] | None = None,
+) -> TestClient:
+    Base.metadata.clear()
+
+    class Tenant(Base, GUIDPk):
+        __tablename__ = "tenants"
+        __table_args__ = {"schema": "main"}
+        name = Column(String, nullable=False)
+
+    class Item(Base, GUIDPk, TenantBound):
+        __tablename__ = "items"
+        __table_args__ = {"schema": "main"}
+        name = Column(String, nullable=False)
+        __tigrbl_tenant_policy__ = policy
+
+    from tigrbl.engine.shortcuts import mem
+    from tigrbl.engine.engine_spec import EngineSpec
+    from tigrbl.engine._engine import Engine
+
+    engine = Engine(EngineSpec.from_any(mem(async_=False)))
+    db_engine, _ = engine.raw()
+    Base.metadata.create_all(bind=db_engine)
+
+    with engine.session() as session:
+        session.execute(Tenant.__table__.insert().values(id=tenant_id, name="acme"))
+        for extra in extra_tenant_ids or []:
+            session.execute(Tenant.__table__.insert().values(id=extra, name="extra"))
+        session.commit()
+
+    authn = DummyAuth(user_id, tenant_id)
+    api = TigrblApp(engine=engine)
+    api.set_auth(authn=authn.get_principal)
+    api.include_models([Tenant, Item])
+    app = App()
+    app.include_router(api.router)
+    api.initialize()
+    return TestClient(app)
+
+
+@pytest.mark.i9n
+def test_tenant_policy_runtime_switch():
+    user_id = uuid.uuid4()
+    tenant_id = uuid.uuid4()
+    headers = {"Authorization": "Bearer secret"}
+
+    client = _client_for_tenant(TenantPolicy.STRICT_SERVER, user_id, tenant_id)
+    res = client.post(
+        "/item",
+        json={"name": "one", "tenant_id": str(tenant_id)},
+        headers=headers,
+    )
+    assert res.status_code == 400
+
+    supplied = uuid.uuid4()
+    client = _client_for_tenant(
+        TenantPolicy.CLIENT_SET, user_id, tenant_id, extra_tenant_ids=[supplied]
+    )
+    res = client.post(
+        "/item",
+        json={"name": "two", "tenant_id": str(supplied)},
+        headers=headers,
+    )
+    assert res.status_code == 201
+    assert res.json()["tenant_id"] == str(supplied)

tests/i9n/test_request_extras.py

@@ -0,0 +1,74 @@
+import pytest
+import pytest_asyncio
+from tigrbl.types import App
+from httpx import ASGITransport, AsyncClient
+from pydantic import Field
+from sqlalchemy import Column, String
+from uuid import uuid4
+
+from tigrbl import TigrblApp, Base
+from tigrbl.engine.shortcuts import mem
+from tigrbl.schema import _build_schema
+
+
+@pytest_asyncio.fixture()
+async def api_client_with_extras(db_mode):
+    Base.metadata.clear()
+
+    class Widget(Base):
+        __tablename__ = "widgets"
+        id = Column(String, primary_key=True, default=lambda: str(uuid4()))
+        name = Column(String, nullable=False)
+        __tigrbl_request_extras__ = {
+            "*": {"token": (str | None, Field(default=None, exclude=True))},
+            "create": {"create_note": (str | None, Field(default=None, exclude=True))},
+            "update": {"update_flag": (bool | None, Field(default=None, exclude=True))},
+        }
+
+    if db_mode == "async":
+        api = TigrblApp(engine=mem())
+        api.include_model(Widget)
+        await api.initialize()
+    else:
+        api = TigrblApp(engine=mem(async_=False))
+        api.include_model(Widget)
+        api.initialize()
+
+    app = App()
+    app.include_router(api.router)
+    transport = ASGITransport(app=app)
+    client = AsyncClient(transport=transport, base_url="http://test")
+    return client, api, Widget
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+async def test_request_extras_schema(api_client_with_extras):
+    _, _, Widget = api_client_with_extras
+    create_schema = _build_schema(Widget, verb="create")
+    update_schema = _build_schema(Widget, verb="update")
+    assert {"token", "create_note"} <= set(create_schema.model_fields)
+    assert {"token", "update_flag"} <= set(update_schema.model_fields)
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+async def test_request_extras_runtime(api_client_with_extras):
+    client, _, _ = api_client_with_extras
+    res = await client.post(
+        "/widget",
+        json={"name": "w1", "token": "t", "create_note": "note"},
+    )
+    assert res.status_code == 201
+    body = res.json()
+    wid = body["id"]
+    assert "token" not in body and "create_note" not in body
+
+    res = await client.patch(
+        f"/widget/{wid}",
+        json={"name": "w2", "token": "t2", "update_flag": True},
+    )
+    assert res.status_code == 200
+
+    body = res.json()
+    assert "token" not in body and "update_flag" not in body

tests/i9n/test_request_extras_provider.py

@@ -0,0 +1,27 @@
+import pytest
+
+from tigrbl import Base
+from tigrbl.orm.mixins import GUIDPk
+from tigrbl.schema import _build_schema
+from tigrbl.types import Column, Field, RequestExtrasProvider, String
+from tigrbl.types.request_extras_provider import list_request_extras_providers
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+async def test_request_extras_provider_in_schema():
+    Base.metadata.clear()
+
+    class Widget(Base, GUIDPk, RequestExtrasProvider):
+        __tablename__ = "widgets"
+        name = Column(String, nullable=False)
+        __tigrbl_request_extras__ = {
+            "create": {"extra": (int | None, Field(None, exclude=True))}
+        }
+
+    SCreate = _build_schema(Widget, verb="create")
+    SRead = _build_schema(Widget, verb="read")
+
+    assert "extra" in SCreate.model_fields
+    assert "extra" not in SRead.model_fields
+    assert Widget in list_request_extras_providers()

tests/i9n/test_response_extras_provider.py

@@ -0,0 +1,22 @@
+import pytest
+
+from tigrbl import Base
+from tigrbl.orm.mixins import GUIDPk
+from tigrbl.schema import _build_schema
+from tigrbl.types import Column, Field, ResponseExtrasProvider, String
+from tigrbl.types.response_extras_provider import list_response_extras_providers
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+async def test_response_extras_provider_in_schema():
+    Base.metadata.clear()
+
+    class Widget(Base, GUIDPk, ResponseExtrasProvider):
+        __tablename__ = "widgets"
+        name = Column(String, nullable=False)
+        __tigrbl_response_extras__ = {"read": {"extra": (int | None, Field(None))}}
+
+    SRead = _build_schema(Widget, verb="read")
+    assert "extra" in SRead.model_fields
+    assert Widget in list_response_extras_providers()

tests/i9n/test_rest_fallback_serialization.py

@@ -0,0 +1,66 @@
+import pytest
+import pytest_asyncio
+from tigrbl.types import App
+from httpx import ASGITransport, AsyncClient
+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_asyncio.fixture()
+async def client_and_model():
+    Base3.metadata.clear()
+
+    class Widget(Base3):
+        __tablename__ = "widgets"
+        __allow_unmapped__ = True
+
+        id: Mapped[int] = acol(
+            storage=S(type_=Integer, primary_key=True, autoincrement=True),
+            io=IO(out_verbs=("read", "list")),
+        )
+        name: Mapped[str] = acol(
+            storage=S(type_=String, nullable=False),
+            field=F(required_in=("create",)),
+            io=IO(in_verbs=("create", "update")),
+        )
+
+        __tigrbl_cols__ = {"id": id, "name": name}
+
+    app = App()
+    api = Tigrblv3(engine=mem())
+    api.include_model(Widget, prefix="")
+    await api.initialize()
+    # Remove output schemas to trigger fallback serialization
+    Widget.schemas.read.out = None
+    Widget.schemas.list.out = None
+
+    app.include_router(api.router)
+    transport = ASGITransport(app=app)
+    client = AsyncClient(transport=transport, base_url="http://test")
+    try:
+        yield client, Widget
+    finally:
+        await client.aclose()
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+async def test_rest_read_and_list_without_out_schema(client_and_model):
+    client, _ = client_and_model
+    created = await client.post("/widget", json={"name": "A"})
+    item_id = created.json()["id"]
+
+    resp = await client.get(f"/widget/{item_id}")
+    assert resp.status_code == 200
+    assert resp.json()["id"] == item_id
+
+    resp_list = await client.get("/widget")
+    assert resp_list.status_code == 200
+    data = resp_list.json()
+    assert isinstance(data, list)
+    assert data[0]["id"] == item_id