tigrbl_tests 0.3.10.dev2__tar.gz → 0.3.11__tar.gz

{tigrbl_tests-0.3.10.dev2 → tigrbl_tests-0.3.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tigrbl_tests
-Version: 0.3.10.dev2
+Version: 0.3.11
 Summary: Test suite and fixtures for the Tigrbl framework.
 License-Expression: Apache-2.0
 License-File: LICENSE

{tigrbl_tests-0.3.10.dev2 → tigrbl_tests-0.3.11}/pyproject.toml

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

{tigrbl_tests-0.3.10.dev2 → tigrbl_tests-0.3.11}/tests/conftest.py

@@ -45,7 +45,7 @@ def _run_coro_sync(coro):
     return result.get("value")
 
 
-def _patch_httpx_asgi_transport_sync_api() -> None:
+def _patch_httpx_asgi_transport_sync_router() -> None:
     """Bridge HTTPX ASGITransport async-only API for sync httpx.Client tests."""
 
     if not hasattr(ASGITransport, "close"):
@@ -75,7 +75,7 @@ def _patch_httpx_asgi_transport_sync_api() -> None:
         ASGITransport.handle_request = handle_request
 
 
-_patch_httpx_asgi_transport_sync_api()
+_patch_httpx_asgi_transport_sync_router()
 
 
 def _reset_tigrbl_state() -> None:
@@ -174,31 +174,45 @@ async def async_db_session():
 
 
 @pytest.fixture
-def create_test_api():
+def create_test_app():
+    """Factory fixture to create initialized app instances for single-model tests."""
+
+    def _create_app(model_class):
+        Base.metadata.clear()
+        app = TigrblApp(engine=mem(async_=False))
+        app.include_table(model_class)
+        app.initialize()
+        return app
+
+    return _create_app
+
+
+@pytest.fixture
+def create_test_router():
     """Factory fixture to create Tigrbl instances for testing individual models."""
 
-    def _create_api(model_class):
+    def _create_router(model_class):
         """Create Tigrbl instance with a single model for testing."""
         Base.metadata.clear()
-        api = TigrblApp(engine=mem(async_=False))
-        api.include_model(model_class)
-        api.initialize()
-        return api
+        app = TigrblApp(engine=mem(async_=False))
+        app.include_table(model_class)
+        app.initialize()
+        return app.router
 
-    return _create_api
+    return _create_router
 
 
 @pytest_asyncio.fixture
-async def create_test_api_async():
+async def create_test_router_async():
     """Factory fixture to create async Tigrbl instances for testing individual models."""
 
-    def _create_api_async(model_class):
+    def _create_app_async(model_class):
         Base.metadata.clear()
-        api = TigrblApp(engine=mem())
-        api.include_model(model_class)
-        return api
+        app = TigrblApp(engine=mem())
+        app.include_table(model_class)
+        return app
 
-    return _create_api_async
+    return _create_app_async
 
 
 @pytest.fixture
@@ -226,7 +240,7 @@ def test_models():
 
 
 @pytest_asyncio.fixture()
-async def api_client(db_mode):
+async def router_client(db_mode):
     """Main fixture for integration tests with Tenant and Item models."""
     Base.metadata.clear()
 
@@ -252,24 +266,29 @@ async def api_client(db_mode):
         def __tigrbl_nested_paths__(cls):
             return "/tenant/{tenant_id}/item"
 
-    fastapi_app = TigrblApp()
+    app = TigrblApp()
 
     if db_mode == "async":
-        api = TigrblApp(engine=mem())
-        api.include_models([Tenant, Item])
-        await api.initialize()
+        app = TigrblApp(engine=mem())
+        app.include_tables([Tenant, Item])
+        await app.initialize()
 
     else:
-        api = TigrblApp(engine=mem(async_=False))
-        api.include_models([Tenant, Item])
-        api.initialize()
+        app = TigrblApp(engine=mem(async_=False))
+        app.include_tables([Tenant, Item])
+        app.initialize()
 
-    api.mount_jsonrpc()
-    fastapi_app.include_router(api.router)
-    transport = ASGITransport(app=fastapi_app)
+    app.mount_jsonrpc()
+    transport = ASGITransport(app=app)
 
     client = AsyncClient(transport=transport, base_url="http://test")
-    return client, api, Item
+    return client, app, Item
+
+
+@pytest_asyncio.fixture()
+async def app_client(router_client):
+    """Backwards-compatible alias for integration tests expecting app_client."""
+    return router_client
 
 
 @pytest.fixture
@@ -289,7 +308,7 @@ def sample_item_data():
 
 
 @pytest_asyncio.fixture()
-async def api_client_v3():
+async def router_client_v3():
     Base.metadata.clear()
 
     class Widget(Base):
@@ -332,15 +351,13 @@ async def api_client_v3():
         }
 
     cfg = mem()
-    fastapi_app = TigrblApp()
-    api = TigrblApp(engine=cfg)
-    api.include_model(Widget, prefix="")
-    api.mount_jsonrpc()
-    api.attach_diagnostics()
-    await api.initialize()
+    app = TigrblApp(engine=cfg)
+    app.include_table(Widget, prefix="")
+    app.mount_jsonrpc()
+    app.attach_diagnostics()
+    await app.initialize()
     prov = _resolver.resolve_provider()
     _, session_maker = prov.ensure()
-    fastapi_app.include_router(api.router)
-    transport = ASGITransport(app=fastapi_app)
+    transport = ASGITransport(app=app)
     client = AsyncClient(transport=transport, base_url="http://test")
-    return client, api, Widget, session_maker
+    return client, app, Widget, session_maker

{tigrbl_tests-0.3.10.dev2 → tigrbl_tests-0.3.11}/tests/i9n/test_acronym_route_name.py

@@ -5,12 +5,12 @@ from tigrbl.types import Column, String
 
 
 @pytest.mark.i9n
-def test_acronym_model_route(create_test_api):
+def test_acronym_model_route(create_test_router):
     class GPGKey(Base, GUIDPk):
         __tablename__ = "gpg_keys"
         key = Column(String, nullable=False)
 
-    api = create_test_api(GPGKey)
-    paths = {route.path for route in api.router.routes}
+    router = create_test_router(GPGKey)
+    paths = {route.path for route in router.routes}
     assert "/gpgkey" in paths
     assert all("g_p_g_key" not in p for p in paths)

{tigrbl_tests-0.3.10.dev2 → tigrbl_tests-0.3.11}/tests/i9n/test_allow_anon.py

@@ -1,10 +1,12 @@
 from httpx import ASGITransport, Client
-from tigrbl.security import HTTPAuthorizationCredentials, HTTPBearer
+from tigrbl.security import HTTPAuthorizationCredentials, HTTPBearer, Security
+from tigrbl.requests import Request
+from tigrbl.runtime.status import HTTPException
 from tigrbl.engine import resolver as _resolver
 from tigrbl.engine.shortcuts import mem
 from sqlalchemy.orm import sessionmaker
 
-from tigrbl import TigrblApp
+from tigrbl import TigrblApp, TigrblRouter
 from tigrbl.orm.mixins import GUIDPk
 from tigrbl.orm.tables import Base
 from tigrbl.config.constants import TIGRBL_AUTH_CONTEXT_ATTR
@@ -13,10 +15,7 @@ from tigrbl.types import (
     AuthNProvider,
     Column,
     ForeignKey,
-    HTTPException,
     PgUUID,
-    Request,
-    Security,
     String,
     uuid4,
 )
@@ -61,12 +60,12 @@ def _build_client():
 
     cfg = mem(async_=False)
     auth = DummyAuth()
-    api = TigrblApp(engine=cfg)
-    api.set_auth(authn=auth.get_principal)
-    api.include_models([Tenant, Item])
-    api.initialize()
+    router = TigrblRouter(engine=cfg)
+    router.set_auth(authn=auth.get_principal)
+    router.include_tables([Tenant, Item])
+    router.initialize()
     app = TigrblApp()
-    app.include_router(api.router)
+    app.include_router(router)
     prov = _resolver.resolve_provider()
     engine, maker = prov.ensure()
     SessionLocal = sessionmaker(bind=engine, expire_on_commit=False)
@@ -93,12 +92,12 @@ def _build_client_attr():
 
     cfg = mem(async_=False)
     auth = DummyAuth()
-    api = TigrblApp(engine=cfg)
-    api.set_auth(authn=auth.get_principal)
-    api.include_models([Tenant, Item])
-    api.initialize()
+    router = TigrblRouter(engine=cfg)
+    router.set_auth(authn=auth.get_principal)
+    router.include_tables([Tenant, Item])
+    router.initialize()
     app = TigrblApp()
-    app.include_router(api.router)
+    app.include_router(router)
     prov = _resolver.resolve_provider()
     engine, maker = prov.ensure()
     SessionLocal = sessionmaker(bind=engine, expire_on_commit=False)
@@ -162,11 +161,12 @@ def _build_client_create_noauth():
             return {"create", "bulk_create"}
 
     cfg = mem(async_=False)
-    api = TigrblApp(engine=cfg)
-    api.include_models([Tenant, Item])
-    api.initialize()
+    router = TigrblRouter(engine=cfg)
+    router.include_tables([Tenant, Item])
+    router.initialize()
+
     app = TigrblApp()
-    app.include_router(api.router)
+    app.include_router(router)
     prov = _resolver.resolve_provider()
     engine, maker = prov.ensure()
     SessionLocal = sessionmaker(bind=engine, expire_on_commit=False)
@@ -192,11 +192,12 @@ def _build_client_create_attr_noauth():
         __tigrbl_allow_anon__ = {"create", "bulk_create"}
 
     cfg = mem(async_=False)
-    api = TigrblApp(engine=cfg)
-    api.include_models([Tenant, Item])
-    api.initialize()
+    router = TigrblRouter(engine=cfg)
+    router.include_tables([Tenant, Item])
+    router.initialize()
+
     app = TigrblApp()
-    app.include_router(api.router)
+    app.include_router(router)
     prov = _resolver.resolve_provider()
     engine, maker = prov.ensure()
     SessionLocal = sessionmaker(bind=engine, expire_on_commit=False)

{tigrbl_tests-0.3.10.dev2 → tigrbl_tests-0.3.11}/tests/i9n/test_apikey_generation.py

@@ -1,5 +1,6 @@
 import pytest
 from tigrbl import TigrblApp
+from tigrbl.engine.shortcuts import mem
 from tigrbl.types import Mapped, String
 from httpx import ASGITransport, AsyncClient
 
@@ -30,15 +31,13 @@ class ConcreteApiKey(Base, GUIDPk, Created, LastUsed, ValidityWindow, KeyDigest)
 
 @pytest.mark.i9n
 @pytest.mark.asyncio
-async def test_api_key_creation_requires_valid_payload(sync_db_session):
+async def test_router_key_creation_requires_valid_payload(sync_db_session):
     """Posting without required fields yields an unprocessable entity response."""
-    _, get_sync_db = sync_db_session
+    cfg, _ = sync_db_session
 
-    app = TigrblApp()
-    api = TigrblApp(get_db=get_sync_db)
-    api.include_models([ConcreteApiKey])
-    api.initialize()
-    app.include_router(api.router)
+    app = TigrblApp(engine=mem(async_=False))
+    app.include_tables([ConcreteApiKey])
+    app.initialize()
     transport = ASGITransport(app=app)
 
     async with AsyncClient(transport=transport, base_url="http://test") as client:

{tigrbl_tests-0.3.10.dev2 → tigrbl_tests-0.3.11}/tests/i9n/test_authn_provider_integration.py

@@ -2,7 +2,6 @@ from httpx import ASGITransport, Client
 
 from tigrbl.security import HTTPAuthorizationCredentials, HTTPBearer
 from tigrbl.engine.shortcuts import mem
-from tigrbl.types import HTTPException, Request, Security
 
 from tigrbl import TigrblApp, Base, hook_ctx
 from tigrbl.config.constants import TIGRBL_AUTH_CONTEXT_ATTR
@@ -10,6 +9,11 @@ from tigrbl.orm.mixins import GUIDPk
 from tigrbl.types.authn_abc import AuthNProvider
 
 
+from tigrbl.runtime.status import HTTPException
+from tigrbl.requests import Request
+from tigrbl.security import Security
+
+
 class HookedAuth(AuthNProvider):
     """Simple AuthN provider that records context via hooks."""
 
@@ -40,11 +44,11 @@ def _build_client_with_auth():
         async def capture(cls, ctx):
             auth.ctx_principal = ctx.get("auth_context")
 
-    api = TigrblApp(engine=mem(async_=False))
-    api.set_auth(authn=auth.get_principal)
-    api.include_model(Tenant)
-    api.initialize()
-    transport = ASGITransport(app=api)
+    app = TigrblApp(engine=mem(async_=False))
+    app.set_auth(authn=auth.get_principal)
+    app.include_table(Tenant)
+    app.initialize()
+    transport = ASGITransport(app=app)
     return Client(transport=transport, base_url="http://test"), auth
 
 

{tigrbl_tests-0.3.10.dev2 → tigrbl_tests-0.3.11}/tests/i9n/test_bindings_integration.py

@@ -12,8 +12,8 @@ from tigrbl.orm.mixins import GUIDPk
 from tigrbl.specs import IO, S, acol
 from tigrbl.bindings import (
     bind,
-    include_model,
-    include_models,
+    include_table,
+    include_tables,
     rpc_call,
     rebind,
 )
@@ -55,24 +55,24 @@ def _make_db():
     return engine, db
 
 
-def test_include_model_and_rpc_call():
+def test_include_table_and_rpc_call():
     engine, db = _make_db()
-    api = SimpleNamespace(engine=engine)
-    _resolver.register_api(api, engine)
-
-    include_model(api, Widget, mount_router=False)
-
-    # api facade populated
-    assert api.models["Widget"] is Widget
-    assert hasattr(api.schemas, "Widget")
-    assert hasattr(api.handlers, "Widget")
-    assert hasattr(api.hooks, "Widget")
-    assert hasattr(api.rpc, "Widget")
-    assert hasattr(api.rest, "Widget")
-    assert "Widget" in api.routers
-    assert "Widget" in api.columns
-    assert "Widget" in api.table_config
-    assert hasattr(api.core, "Widget")
+    router = SimpleNamespace(engine=engine)
+    _resolver.register_router(router, engine)
+
+    include_table(router, Widget, mount_router=False)
+
+    # router facade populated
+    assert router.models["Widget"] is Widget
+    assert hasattr(router.schemas, "Widget")
+    assert hasattr(router.handlers, "Widget")
+    assert hasattr(router.hooks, "Widget")
+    assert hasattr(router.rpc, "Widget")
+    assert hasattr(router.rest, "Widget")
+    assert "Widget" in router.routers
+    assert "Widget" in router.columns
+    assert "Widget" in router.table_config
+    assert hasattr(router.core, "Widget")
 
     # model namespaces
     assert hasattr(Widget, TIGRBL_GET_DB_ATTR)
@@ -82,21 +82,21 @@ def test_include_model_and_rpc_call():
     phases = build_phase_chains(Widget, "create")
     assert phases["HANDLER"], "phase lifecycle must contain handler step"
 
-    asyncio.run(rpc_call(api, Widget, "create", {"id": uuid4(), "name": "w"}, db=db))
-    rows = asyncio.run(rpc_call(api, Widget, "list", {}, db=db))
+    asyncio.run(rpc_call(router, Widget, "create", {"id": uuid4(), "name": "w"}, db=db))
+    rows = asyncio.run(rpc_call(router, Widget, "list", {}, db=db))
     assert rows and rows[0]["name"] == "w"
 
 
-def test_include_models():
+def test_include_tables():
     engine, db = _make_db()
-    api = SimpleNamespace(engine=engine)
-    _resolver.register_api(api, engine)
+    router = SimpleNamespace(engine=engine)
+    _resolver.register_router(router, engine)
 
-    include_models(api, [Widget, Gizmo], mount_router=False)
+    include_tables(router, [Widget, Gizmo], mount_router=False)
 
-    assert set(api.models) == {"Widget", "Gizmo"}
-    assert hasattr(api.schemas, "Widget")
-    assert hasattr(api.schemas, "Gizmo")
+    assert set(router.models) == {"Widget", "Gizmo"}
+    assert hasattr(router.schemas, "Widget")
+    assert hasattr(router.schemas, "Gizmo")
 
 
 def test_bind_and_rebind():

{tigrbl_tests-0.3.10.dev2 → tigrbl_tests-0.3.11}/tests/i9n/test_bindings_modules.py

@@ -9,15 +9,13 @@ from tigrbl.types import (
     String,
 )
 
-from tigrbl.bindings import (
-    api as api_binding,
-    columns as columns_binding,
-    handlers as handlers_binding,
-    hooks as hooks_binding,
-    model as model_binding,
-    rest as rest_binding,
-    rpc as rpc_binding,
-)
+import tigrbl.bindings.columns as columns_binding
+import tigrbl.bindings.handlers as handlers_binding
+import tigrbl.bindings.hooks as hooks_binding
+import tigrbl.bindings.model as model_binding
+import tigrbl.bindings.rest as rest_binding
+import tigrbl.bindings.router as router_binding
+import tigrbl.bindings.rpc as rpc_binding
 from tigrbl.bindings.schemas import build_and_attach as schemas_build_and_attach
 from tigrbl.specs import ColumnSpec, F, IO, S
 from tigrbl.op import resolve
@@ -117,12 +115,12 @@ def test_model_bind_and_rebind(model_cls):
 
 @pytest.mark.i9n
 @pytest.mark.asyncio
-async def test_api_include_and_rpc_call(monkeypatch, model_cls):
+async def test_router_include_and_rpc_call(monkeypatch, model_cls):
     model_binding.bind(model_cls)
-    api = SimpleNamespace()
-    api_binding.include_model(api, model_cls, mount_router=False)
-    assert model_cls.__name__ in api.models
-    routers = api_binding.include_models(
+    router = SimpleNamespace()
+    router_binding.include_table(router, model_cls, mount_router=False)
+    assert model_cls.__name__ in router.models
+    routers = router_binding.include_tables(
         SimpleNamespace(), [model_cls], mount_router=False
     )
     assert model_cls.__name__ in routers
@@ -132,8 +130,8 @@ async def test_api_include_and_rpc_call(monkeypatch, model_cls):
 
     monkeypatch.setattr(_executor, "_invoke", fake_invoke)
     payload = {"name": "x"}
-    result = await api_binding.rpc_call(
-        api, model_cls, "create", payload=payload, db=object()
+    result = await router_binding.rpc_call(
+        router, model_cls, "create", payload=payload, db=object()
     )
     assert result == payload
 

{tigrbl_tests-0.3.10.dev2 → tigrbl_tests-0.3.11}/tests/i9n/test_core_access.py

@@ -2,13 +2,16 @@ import pytest
 import pytest_asyncio
 from typing import Any, Mapping
 
-from tigrbl.types import HTTPException, UUID, Column, Integer, String, uuid4
+from tigrbl.types import UUID, Column, Integer, String, uuid4
 
 from tigrbl import TigrblApp, Base
 from tigrbl.engine.shortcuts import engine as build_engine, mem
 from tigrbl.orm.mixins import GUIDPk, BulkCapable, Replaceable
 
 
+from tigrbl.runtime.status import HTTPException
+
+
 class CoreTestUser(Base, GUIDPk, BulkCapable, Replaceable):
     __tablename__ = "test_users"
     name = Column(String(100), nullable=True)
@@ -22,32 +25,32 @@ def _get(obj: Any, attr: str) -> Any:
 
 
 @pytest.fixture
-def sync_api():
+def sync_app():
     """Create a sync Tigrbl instance with CoreTestUser."""
     Base.metadata.clear()
     eng = build_engine(mem(async_=False))
-    api = TigrblApp(engine=eng)
-    api.include_model(CoreTestUser)
-    api.initialize()
-    return api, eng
+    app = TigrblApp(engine=eng)
+    app.include_table(CoreTestUser)
+    app.initialize()
+    return app, eng
 
 
 @pytest_asyncio.fixture
-async def async_api():
+async def async_app():
     """Create an async Tigrbl instance with CoreTestUser."""
     Base.metadata.clear()
     eng = build_engine(mem(async_=True))
-    api = TigrblApp(engine=eng)
-    api.include_model(CoreTestUser)
-    await api.initialize()
-    return api, eng
+    app = TigrblApp(engine=eng)
+    app.include_table(CoreTestUser)
+    await app.initialize()
+    return app, eng
 
 
-def test_api_exposes_core_proxies(sync_api):
-    api, _ = sync_api
-    assert hasattr(api.core, "CoreTestUser")
-    assert hasattr(api.core_raw, "CoreTestUser")
-    schema_ns = api.schemas.CoreTestUser
+def test_app_exposes_core_proxies(sync_app):
+    app, _ = sync_app
+    assert hasattr(app.core, "CoreTestUser")
+    assert hasattr(app.core_raw, "CoreTestUser")
+    schema_ns = app.schemas.CoreTestUser
     for name in [
         "create",
         "read",
@@ -64,10 +67,10 @@ def test_api_exposes_core_proxies(sync_api):
 
 
 @pytest.mark.asyncio
-async def test_core_and_core_raw_sync_operations(sync_api):
-    api, eng = sync_api
+async def test_core_and_core_raw_sync_operations(sync_app):
+    app, eng = sync_app
     with eng.session() as db:
-        for proxy in (api.core, api.core_raw):
+        for proxy in (app.core, app.core_raw):
             model = proxy.CoreTestUser
             await model.clear({}, db=db)
 
@@ -148,17 +151,17 @@ async def test_core_and_core_raw_sync_operations(sync_api):
 
 
 @pytest.mark.asyncio
-async def test_core_read_not_found(sync_api):
-    api, eng = sync_api
+async def test_core_read_not_found(sync_app):
+    app, eng = sync_app
     fake_id = "00000000-0000-0000-0000-000000000000"
     with eng.session() as db:
         with pytest.raises(HTTPException):
-            await api.core.CoreTestUser.read({"id": fake_id}, db=db)
+            await app.core.CoreTestUser.read({"id": fake_id}, db=db)
 
 
 @pytest.mark.asyncio
-async def test_async_api_initializes(async_api):
-    api, eng = async_api
-    assert hasattr(api.core, "CoreTestUser")
+async def test_async_app_initializes(async_app):
+    app, eng = async_app
+    assert hasattr(app.core, "CoreTestUser")
     async with eng.asession():
         pass

{tigrbl_tests-0.3.10.dev2 → tigrbl_tests-0.3.11}/tests/i9n/test_engine_install_uvicorn.py

@@ -24,7 +24,7 @@ class EngineWidget(Base, GUIDPk):
 @pytest_asyncio.fixture()
 async def running_engine_app():
     app = TigrblApp(engine=mem(async_=False))
-    app.include_model(EngineWidget)
+    app.include_table(EngineWidget)
     app.mount_jsonrpc(prefix="/rpc")
     app.initialize()