tigrbl_tests 0.3.12.dev6__tar.gz → 0.3.12.dev7__tar.gz

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "tigrbl_tests"
-version = "0.3.12.dev6"
+version = "0.3.12.dev7"
 description = "Test suite and fixtures for the Tigrbl framework."
 license = "Apache-2.0"
 readme = "README.md"

tigrbl_tests-0.3.12.dev7/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.dev7/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.dev7/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"]

tigrbl_tests-0.3.12.dev7/tests/unit/test_op_ctx_parameter_matrix.py

@@ -0,0 +1,88 @@
+from itertools import product
+
+import pytest
+
+from tigrbl import op_ctx
+from tigrbl.mapping.op_mro_collect import mro_collect_decorated_ops
+from tigrbl.types import BaseModel
+
+
+class StatusSchema(BaseModel):
+    ok: bool
+
+
+TARGET_VARIANTS = ("custom", "create", "read", "update", "delete", "list")
+ARITY_VARIANTS = ("collection", "member")
+RESPONSE_SCHEMA_VARIANTS = (None, StatusSchema)
+PERSIST_VARIANTS = ("default", "append", "prepend", "override", "skip")
+
+
+def _normalize_persist(persist: str) -> str:
+    if persist in {"none", "read", "skip"}:
+        return "skip"
+    if persist in {"write", "default", "persist"}:
+        return "default"
+    return persist
+
+
+@pytest.mark.parametrize(
+    "target,arity,response_schema,persist",
+    list(
+        product(
+            TARGET_VARIANTS,
+            ARITY_VARIANTS,
+            RESPONSE_SCHEMA_VARIANTS,
+            PERSIST_VARIANTS,
+        )
+    ),
+    ids=lambda v: getattr(v, "__name__", str(v)),
+)
+def test_op_ctx_parameter_matrix(target, arity, response_schema, persist):
+    class MatrixModel:
+        @op_ctx(
+            alias="probe",
+            target=target,
+            arity=arity,
+            response_schema=response_schema,
+            persist=persist,
+        )
+        def probe(cls, ctx):  # pragma: no cover - declaration-only test
+            return {"ok": True}
+
+    spec = mro_collect_decorated_ops(MatrixModel)[0]
+
+    assert spec.alias == "probe"
+    assert spec.target == target
+    assert spec.arity == arity
+    assert spec.response_model is response_schema
+    assert spec.persist == _normalize_persist(persist)
+
+
+@pytest.mark.parametrize(
+    "target, response_schema, persist",
+    list(product(TARGET_VARIANTS, RESPONSE_SCHEMA_VARIANTS, PERSIST_VARIANTS)),
+    ids=lambda v: getattr(v, "__name__", str(v)),
+)
+def test_op_ctx_parameter_matrix_infers_arity_when_omitted(
+    target, response_schema, persist
+):
+    class MatrixModel:
+        @op_ctx(
+            alias="probe",
+            target=target,
+            response_schema=response_schema,
+            persist=persist,
+        )
+        def probe(cls, ctx):  # pragma: no cover - declaration-only test
+            return {"ok": True}
+
+    spec = mro_collect_decorated_ops(MatrixModel)[0]
+
+    expected_arity = (
+        "collection" if target in {"custom", "create", "list"} else "member"
+    )
+    assert spec.alias == "probe"
+    assert spec.target == target
+    assert spec.arity == expected_arity
+    assert spec.response_model is response_schema
+    assert spec.persist == _normalize_persist(persist)

tigrbl_tests-0.3.12.dev7/tests/unit/test_openapi_documentation_security_behavior.py

@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+from httpx import ASGITransport, Client
+from sqlalchemy import Column, String
+
+from tigrbl import (
+    APIKey,
+    HTTPBearer,
+    MutualTLS,
+    OAuth2,
+    OpenIdConnect,
+    TigrblApp,
+    TigrblRouter,
+)
+from tigrbl._spec import OpSpec
+from tigrbl.orm.mixins import GUIDPk
+from tigrbl.orm.tables import TableBase
+from tigrbl.shortcuts.engine import mem
+from tigrbl.types import Security
+
+
+def _bearer_dep(cred=Security(HTTPBearer(scheme_name="BearerAuth"))):
+    return cred
+
+
+def _api_key_dep(cred=Security(APIKey(scheme_name="ApiKeyAuth", name="X-API-Key"))):
+    return cred
+
+
+def _oauth2_dep(
+    cred=Security(
+        OAuth2(
+            scheme_name="OAuth2Auth",
+            flows={"clientCredentials": {"tokenUrl": "https://issuer.example/token"}},
+        )
+    ),
+):
+    return cred
+
+
+def _openid_dep(
+    cred=Security(
+        OpenIdConnect(
+            scheme_name="OpenIdAuth",
+            openid_connect_url="https://issuer.example/.well-known/openid-configuration",
+        )
+    ),
+):
+    return cred
+
+
+def _mtls_dep(cred=Security(MutualTLS(scheme_name="MutualTLSAuth"))):
+    return cred
+
+
+class AppDocsTable(TableBase, GUIDPk):
+    __tablename__ = "app_docs_table_openapi"
+
+    name = Column(String, nullable=False)
+    __tigrbl_ops__ = (OpSpec(alias="read", target="read", secdeps=(_bearer_dep,)),)
+
+
+class RouterDocsTable(TableBase, GUIDPk):
+    __tablename__ = "router_docs_table_openapi"
+
+    name = Column(String, nullable=False)
+    __tigrbl_ops__ = (OpSpec(alias="read", target="read", secdeps=(_api_key_dep,)),)
+
+
+class TableDocsTable(TableBase, GUIDPk):
+    __tablename__ = "table_docs_table_openapi"
+
+    name = Column(String, nullable=False)
+    __tigrbl_ops__ = (
+        OpSpec(
+            alias="read",
+            target="read",
+            secdeps=(_oauth2_dep, _openid_dep, _mtls_dep),
+        ),
+    )
+
+
+def test_openapi_docs_cover_app_router_table_and_all_security_schemes() -> None:
+    app = TigrblApp(engine=mem(async_=False))
+    app.include_table(AppDocsTable)
+
+    router = TigrblRouter(engine=mem(async_=False))
+    router.include_table(RouterDocsTable)
+    router.include_table(TableDocsTable)
+    app.include_router(router)
+
+    app.initialize()
+
+    transport = ASGITransport(app=app)
+    with Client(transport=transport, base_url="http://test") as client:
+        openapi = client.get("/openapi.json").json()
+
+    documented_security = [
+        security
+        for path_item in openapi["paths"].values()
+        for op in path_item.values()
+        if isinstance(op, dict)
+        for security in op.get("security", [])
+    ]
+
+    assert {"BearerAuth": []} in documented_security
+    assert {"ApiKeyAuth": []} in documented_security
+    assert {"OAuth2Auth": []} in documented_security
+    assert {"OpenIdAuth": []} in documented_security
+    assert {"MutualTLSAuth": []} in documented_security
+
+    security_schemes = openapi["components"].get("securitySchemes", {})
+    assert security_schemes == {
+        "BearerAuth": {"type": "http", "scheme": "bearer"},
+        "ApiKeyAuth": {"type": "apiKey", "name": "X-API-Key", "in": "header"},
+        "OAuth2Auth": {
+            "type": "oauth2",
+            "flows": {
+                "clientCredentials": {"tokenUrl": "https://issuer.example/token"}
+            },
+        },
+        "OpenIdAuth": {
+            "type": "openIdConnect",
+            "openIdConnectUrl": "https://issuer.example/.well-known/openid-configuration",
+        },
+        "MutualTLSAuth": {"type": "mutualTLS"},
+    }

tigrbl_tests-0.3.12.dev7/tests/unit/test_openrpc_documentation_security_behavior.py

@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+from httpx import ASGITransport, Client
+from sqlalchemy import Column, String
+
+from tigrbl import (
+    APIKey,
+    HTTPBearer,
+    MutualTLS,
+    OAuth2,
+    OpenIdConnect,
+    TigrblApp,
+    TigrblRouter,
+)
+from tigrbl._spec import OpSpec
+from tigrbl.orm.mixins import GUIDPk
+from tigrbl.orm.tables import TableBase
+from tigrbl.shortcuts.engine import mem
+from tigrbl.types import Security
+
+
+def _bearer_dep(cred=Security(HTTPBearer(scheme_name="BearerAuth"))):
+    return cred
+
+
+def _api_key_dep(cred=Security(APIKey(scheme_name="ApiKeyAuth", name="X-API-Key"))):
+    return cred
+
+
+def _oauth2_dep(
+    cred=Security(
+        OAuth2(
+            scheme_name="OAuth2Auth",
+            flows={"clientCredentials": {"tokenUrl": "https://issuer.example/token"}},
+        )
+    ),
+):
+    return cred
+
+
+def _openid_dep(
+    cred=Security(
+        OpenIdConnect(
+            scheme_name="OpenIdAuth",
+            openid_connect_url="https://issuer.example/.well-known/openid-configuration",
+        )
+    ),
+):
+    return cred
+
+
+def _mtls_dep(cred=Security(MutualTLS(scheme_name="MutualTLSAuth"))):
+    return cred
+
+
+class AppDocsTable(TableBase, GUIDPk):
+    __tablename__ = "app_docs_table_openrpc"
+
+    name = Column(String, nullable=False)
+    __tigrbl_ops__ = (OpSpec(alias="read", target="read", secdeps=(_bearer_dep,)),)
+
+
+class RouterDocsTable(TableBase, GUIDPk):
+    __tablename__ = "router_docs_table_openrpc"
+
+    name = Column(String, nullable=False)
+    __tigrbl_ops__ = (OpSpec(alias="read", target="read", secdeps=(_api_key_dep,)),)
+
+
+class TableDocsTable(TableBase, GUIDPk):
+    __tablename__ = "table_docs_table_openrpc"
+
+    name = Column(String, nullable=False)
+    __tigrbl_ops__ = (
+        OpSpec(
+            alias="read",
+            target="read",
+            secdeps=(_oauth2_dep, _openid_dep, _mtls_dep),
+        ),
+    )
+
+
+def test_openrpc_docs_cover_app_router_table_and_all_security_schemes() -> None:
+    app = TigrblApp(engine=mem(async_=False))
+    app.include_table(AppDocsTable)
+
+    router = TigrblRouter(engine=mem(async_=False))
+    router.include_table(RouterDocsTable)
+    router.include_table(TableDocsTable)
+    app.include_router(router)
+
+    app.initialize()
+    app.mount_jsonrpc()
+    app.mount_openrpc()
+
+    transport = ASGITransport(app=app)
+    with Client(transport=transport, base_url="http://test") as client:
+        openrpc = client.get("/openrpc.json").json()
+
+    method_map = {method["name"]: method for method in openrpc["methods"]}
+    assert "AppDocsTable.read" in method_map
+    assert "RouterDocsTable.read" in method_map
+    assert "TableDocsTable.read" in method_map
+
+    assert method_map["AppDocsTable.read"]["security"] == [{"BearerAuth": []}]
+    assert method_map["RouterDocsTable.read"]["security"] == [{"ApiKeyAuth": []}]
+    assert method_map["TableDocsTable.read"]["security"] == [
+        {"OAuth2Auth": []},
+        {"OpenIdAuth": []},
+        {"MutualTLSAuth": []},
+    ]
+
+    assert openrpc["components"]["securitySchemes"] == {
+        "BearerAuth": {"type": "http", "scheme": "bearer"},
+        "ApiKeyAuth": {"type": "apiKey", "name": "X-API-Key", "in": "header"},
+        "OAuth2Auth": {
+            "type": "oauth2",
+            "flows": {
+                "clientCredentials": {"tokenUrl": "https://issuer.example/token"}
+            },
+        },
+        "OpenIdAuth": {
+            "type": "openIdConnect",
+            "openIdConnectUrl": "https://issuer.example/.well-known/openid-configuration",
+        },
+        "MutualTLSAuth": {"type": "mutualTLS"},
+    }