tigrbl-tests 0.3.0__py3-none-any.whl

tests/conftest.py

@@ -0,0 +1,285 @@
+import pytest
+import pytest_asyncio
+from tigrbl import TigrblApp, Base
+from tigrbl.types import App
+from tigrbl.orm.mixins import BulkCapable, GUIDPk
+from tigrbl.specs import F, IO, S, acol
+from tigrbl.column.storage_spec import StorageTransform
+from tigrbl.schema import builder as v3_builder
+from tigrbl.runtime import kernel as runtime_kernel
+from tigrbl.engine.shortcuts import mem
+from tigrbl.engine import resolver as _resolver
+from httpx import ASGITransport, AsyncClient
+from sqlalchemy import Column, ForeignKey, Integer, String
+from sqlalchemy.dialects.postgresql import UUID
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import Mapped, Session
+from typing import AsyncIterator, Iterator
+import asyncio
+
+
+def _reset_tigrbl_state() -> None:
+    """Reset shared tigrbl state between test modules and tests."""
+    Base.metadata.clear()
+    v3_builder._SchemaCache.clear()
+    runtime_kernel._default_kernel = runtime_kernel.Kernel()
+
+
+@pytest.fixture(scope="session")
+def event_loop():
+    # pytest-asyncio < 0.21 compatibility pattern; adjust if you use the newer plugin configs
+    loop = asyncio.new_event_loop()
+    yield loop
+    pending = asyncio.all_tasks(loop)
+    for task in pending:
+        task.cancel()
+    if pending:
+        loop.run_until_complete(asyncio.gather(*pending, return_exceptions=True))
+    loop.close()
+
+
+@pytest.fixture(autouse=True)
+def _reset_state():
+    """Ensure clean metadata and caches around each test."""
+    _reset_tigrbl_state()
+    yield
+    _reset_tigrbl_state()
+
+
+def pytest_collect_file(file_path, parent):
+    if file_path.suffix == ".py" and file_path.name.startswith("test_"):
+        _reset_tigrbl_state()
+    return None
+
+
+def pytest_addoption(parser):
+    """Add command line options for database mode."""
+    group = parser.getgroup("database")
+    group.addoption(
+        "--db-mode",
+        choices=["sync", "async"],
+        help="Database mode to test (sync or async). If not specified, tests both modes.",
+    )
+
+
+def pytest_generate_tests(metafunc):
+    """Generate test parameters for db modes."""
+    if "db_mode" in metafunc.fixturenames:
+        db_mode_option = metafunc.config.getoption("--db-mode")
+        if db_mode_option:
+            # Run only the specified mode
+            metafunc.parametrize("db_mode", [db_mode_option])
+        else:
+            # Run both modes by default
+            metafunc.parametrize("db_mode", ["sync", "async"])
+
+
+@pytest.fixture
+def sync_db_session():
+    """Provide a synchronous in-memory SQLite engine and DB session factory."""
+    cfg = mem(async_=False)
+    _resolver.set_default(cfg)
+    prov = _resolver.resolve_provider()
+    engine, maker = prov.ensure()
+
+    def get_db() -> Iterator[Session]:
+        with maker() as session:
+            yield session
+
+    try:
+        yield engine, get_db
+    finally:
+        engine.dispose()
+        _resolver.set_default(None)
+
+
+@pytest_asyncio.fixture
+async def async_db_session():
+    """Provide an asynchronous in-memory SQLite engine and DB session factory."""
+    cfg = mem()
+    _resolver.set_default(cfg)
+    prov = _resolver.resolve_provider()
+    engine, maker = prov.ensure()
+
+    async def get_db() -> AsyncIterator[AsyncSession]:
+        async with maker() as session:
+            yield session
+
+    try:
+        yield engine, get_db
+    finally:
+        await engine.dispose()
+        _resolver.set_default(None)
+
+
+@pytest.fixture
+def create_test_api():
+    """Factory fixture to create Tigrbl instances for testing individual models."""
+
+    def _create_api(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
+
+    return _create_api
+
+
+@pytest_asyncio.fixture
+async def create_test_api_async():
+    """Factory fixture to create async Tigrbl instances for testing individual models."""
+
+    def _create_api_async(model_class):
+        Base.metadata.clear()
+        api = TigrblApp(engine=mem())
+        api.include_model(model_class)
+        return api
+
+    return _create_api_async
+
+
+@pytest.fixture
+def test_models():
+    """Factory fixture to create test model classes."""
+
+    def _create_model(name, mixins=None, extra_fields=None):
+        """Create a test model class with specified mixins and fields."""
+        if mixins is None:
+            mixins = (GUIDPk,)
+
+        attrs = {
+            "__tablename__": f"test_{name.lower()}",
+            "name": Column(String, nullable=False),
+        }
+
+        if extra_fields:
+            attrs.update(extra_fields)
+
+        # Create the model class dynamically
+        model_class = type(f"Test{name}", (Base,) + mixins, attrs)
+        return model_class
+
+    return _create_model
+
+
+@pytest_asyncio.fixture()
+async def api_client(db_mode):
+    """Main fixture for integration tests with Tenant and Item models."""
+    Base.metadata.clear()
+
+    class Tenant(Base, GUIDPk):
+        __tablename__ = "tenants"
+        name = acol(
+            storage=S(type_=String, nullable=False),
+            field=F(py_type=str),
+            io=IO(
+                in_verbs=("create", "update", "replace"),
+                out_verbs=("read", "list"),
+                mutable_verbs=("create", "update", "replace"),
+                filter_ops=("eq",),
+            ),
+        )
+
+    class Item(Base, GUIDPk, BulkCapable):
+        __tablename__ = "items"
+        tenant_id = Column(UUID(as_uuid=True), ForeignKey("tenants.id"), nullable=False)
+        name = Column(String, nullable=False)
+
+        @classmethod
+        def __tigrbl_nested_paths__(cls):
+            return "/tenant/{tenant_id}/item"
+
+    fastapi_app = App()
+
+    if db_mode == "async":
+        api = TigrblApp(engine=mem())
+        api.include_models([Tenant, Item])
+        await api.initialize()
+
+    else:
+        api = TigrblApp(engine=mem(async_=False))
+        api.include_models([Tenant, Item])
+        api.initialize()
+
+    api.mount_jsonrpc()
+    fastapi_app.include_router(api.router)
+    transport = ASGITransport(app=fastapi_app)
+
+    client = AsyncClient(transport=transport, base_url="http://test")
+    return client, api, Item
+
+
+@pytest.fixture
+def sample_tenant_data():
+    """Sample tenant data for testing."""
+    return {"name": "test-tenant"}
+
+
+@pytest.fixture
+def sample_item_data():
+    """Sample item data for testing (requires tenant_id)."""
+
+    def _create_item_data(tenant_id):
+        return {"tenant_id": tenant_id, "name": "test-item"}
+
+    return _create_item_data
+
+
+@pytest_asyncio.fixture()
+async def api_client_v3():
+    Base.metadata.clear()
+
+    class Widget(Base):
+        __tablename__ = "widgets"
+        __allow_unmapped__ = True
+
+        id: Mapped[int] = acol(
+            storage=S(type_=Integer, primary_key=True, autoincrement=True)
+        )
+        name: Mapped[str] = acol(
+            storage=S(type_=String, nullable=False, index=True),
+            field=F(required_in=("create",)),
+            io=IO(
+                in_verbs=("create", "update"),
+                out_verbs=("read", "list"),
+            ),
+        )
+        age: Mapped[int] = acol(
+            storage=S(type_=Integer, nullable=False, default=5),
+            io=IO(
+                in_verbs=("create", "update"),
+                out_verbs=("read", "list"),
+            ),
+        )
+        secret: Mapped[str] = acol(
+            storage=S(
+                type_=String,
+                nullable=False,
+                transform=StorageTransform(to_stored=lambda v, ctx: v.upper()),
+            ),
+            field=F(required_in=("create",)),
+            io=IO(in_verbs=("create",), out_verbs=("read",)),
+        )
+
+        __tigrbl_cols__ = {
+            "id": id,
+            "name": name,
+            "age": age,
+            "secret": secret,
+        }
+
+    cfg = mem()
+    fastapi_app = App()
+    api = TigrblApp(engine=cfg)
+    api.include_model(Widget, prefix="")
+    api.mount_jsonrpc()
+    api.attach_diagnostics()
+    await api.initialize()
+    prov = _resolver.resolve_provider()
+    _, session_maker = prov.ensure()
+    fastapi_app.include_router(api.router)
+    transport = ASGITransport(app=fastapi_app)
+    client = AsyncClient(transport=transport, base_url="http://test")
+    return client, api, Widget, session_maker

tests/i9n/test_acronym_route_name.py

@@ -0,0 +1,16 @@
+import pytest
+from tigrbl import Base
+from tigrbl.orm.mixins import GUIDPk
+from tigrbl.types import Column, String
+
+
+@pytest.mark.i9n
+def test_acronym_model_route(create_test_api):
+    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}
+    assert "/gpgkey" in paths
+    assert all("g_p_g_key" not in p for p in paths)

tests/i9n/test_allow_anon.py

@@ -0,0 +1,239 @@
+from fastapi.testclient import TestClient
+from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
+from tigrbl.engine import resolver as _resolver
+from tigrbl.engine.shortcuts import mem
+from sqlalchemy.orm import sessionmaker
+
+from tigrbl import TigrblApp
+from tigrbl.orm.mixins import GUIDPk
+from tigrbl.orm.tables import Base
+from tigrbl.config.constants import TIGRBL_AUTH_CONTEXT_ATTR
+from tigrbl.types import (
+    AllowAnonProvider,
+    App,
+    AuthNProvider,
+    Column,
+    ForeignKey,
+    HTTPException,
+    PgUUID,
+    Request,
+    Security,
+    String,
+    uuid4,
+)
+
+
+class DummyAuth(AuthNProvider):
+    async def get_principal(
+        self,
+        request: Request,
+        creds: HTTPAuthorizationCredentials | None = Security(
+            HTTPBearer(auto_error=False)
+        ),
+    ):
+        if creds is None:
+            if request.method == "GET":
+                return None
+            raise HTTPException(status_code=409)
+        if creds.credentials != "secret":
+            raise HTTPException(status_code=401)
+        principal = {"sub": "user"}
+        setattr(request.state, TIGRBL_AUTH_CONTEXT_ATTR, principal)
+        return principal
+
+
+def _build_client():
+    Base.metadata.clear()
+
+    class Tenant(Base, GUIDPk):
+        __tablename__ = "tenants"
+        name = Column(String, nullable=False)
+
+    class Item(Base, GUIDPk):
+        __tablename__ = "items"
+        tenant_id = Column(
+            PgUUID(as_uuid=True), ForeignKey("tenants.id"), nullable=False
+        )
+        name = Column(String, nullable=False)
+
+        @classmethod
+        def __tigrbl_allow_anon__(cls):
+            return {"list", "read"}
+
+    cfg = mem(async_=False)
+    auth = DummyAuth()
+    api = TigrblApp(engine=cfg)
+    api.set_auth(authn=auth.get_principal)
+    api.include_models([Tenant, Item])
+    api.initialize()
+    app = App()
+    app.include_router(api.router)
+    prov = _resolver.resolve_provider()
+    engine, maker = prov.ensure()
+    SessionLocal = sessionmaker(bind=engine, expire_on_commit=False)
+    client = TestClient(app)
+    return client, SessionLocal, Tenant, Item
+
+
+def _build_client_attr():
+    Base.metadata.clear()
+
+    class Tenant(Base, GUIDPk):
+        __tablename__ = "tenants"
+        name = Column(String, nullable=False)
+
+    class Item(Base, GUIDPk):
+        __tablename__ = "items"
+        tenant_id = Column(
+            PgUUID(as_uuid=True), ForeignKey("tenants.id"), nullable=False
+        )
+        name = Column(String, nullable=False)
+
+        __tigrbl_allow_anon__ = {"list", "read"}
+
+    cfg = mem(async_=False)
+    auth = DummyAuth()
+    api = TigrblApp(engine=cfg)
+    api.set_auth(authn=auth.get_principal)
+    api.include_models([Tenant, Item])
+    api.initialize()
+    app = App()
+    app.include_router(api.router)
+    prov = _resolver.resolve_provider()
+    engine, maker = prov.ensure()
+    SessionLocal = sessionmaker(bind=engine, expire_on_commit=False)
+    client = TestClient(app)
+    return client, SessionLocal, Tenant, Item
+
+
+def test_allow_anon_list_and_read():
+    client, SessionLocal, Tenant, Item = _build_client()
+    with SessionLocal() as db:
+        tenant = Tenant(id=uuid4(), name="acme")
+        db.add(tenant)
+        db.commit()
+        db.refresh(tenant)
+        item = Item(id=uuid4(), tenant_id=tenant.id, name="thing")
+        db.add(item)
+        db.commit()
+        db.refresh(item)
+        tid = str(tenant.id)
+        iid = str(item.id)
+    assert client.get("/item").status_code == 200
+    assert client.get(f"/item/{iid}").status_code == 200
+    # Requests without credentials are rejected for non-whitelisted routes.
+    payload = {"id": str(uuid4()), "tenant_id": tid, "name": "new"}
+    assert client.post("/item", json=payload).status_code == 409
+
+
+def test_openapi_marks_anon_and_protected_routes():
+    client, SessionLocal, Tenant, Item = _build_client()
+    spec = client.get("/openapi.json").json()
+    anon_op = spec["paths"]["/item"]["get"].get("security")
+    protected_op = spec["paths"]["/item"]["post"].get("security")
+    assert anon_op in (None, [])
+    assert protected_op == [{"HTTPBearer": []}]
+    assert "HTTPBearer" in spec["components"]["securitySchemes"]
+
+
+def _build_client_create_noauth():
+    Base.metadata.clear()
+
+    class Tenant(Base, GUIDPk):
+        __tablename__ = "tenants"
+        name = Column(String, nullable=False)
+
+    class Item(Base, GUIDPk, AllowAnonProvider):
+        __tablename__ = "items"
+        tenant_id = Column(
+            PgUUID(as_uuid=True), ForeignKey("tenants.id"), nullable=False
+        )
+        name = Column(String, nullable=False)
+
+        @classmethod
+        def __tigrbl_allow_anon__(cls):
+            return {"create", "bulk_create"}
+
+    cfg = mem(async_=False)
+    api = TigrblApp(engine=cfg)
+    api.include_models([Tenant, Item])
+    api.initialize()
+    app = App()
+    app.include_router(api.router)
+    prov = _resolver.resolve_provider()
+    engine, maker = prov.ensure()
+    SessionLocal = sessionmaker(bind=engine, expire_on_commit=False)
+    client = TestClient(app)
+    return client, SessionLocal, Tenant, Item
+
+
+def _build_client_create_attr_noauth():
+    Base.metadata.clear()
+
+    class Tenant(Base, GUIDPk):
+        __tablename__ = "tenants"
+        name = Column(String, nullable=False)
+
+    class Item(Base, GUIDPk, AllowAnonProvider):
+        __tablename__ = "items"
+        tenant_id = Column(
+            PgUUID(as_uuid=True), ForeignKey("tenants.id"), nullable=False
+        )
+        name = Column(String, nullable=False)
+
+        __tigrbl_allow_anon__ = {"create", "bulk_create"}
+
+    cfg = mem(async_=False)
+    api = TigrblApp(engine=cfg)
+    api.include_models([Tenant, Item])
+    api.initialize()
+    app = App()
+    app.include_router(api.router)
+    prov = _resolver.resolve_provider()
+    engine, maker = prov.ensure()
+    SessionLocal = sessionmaker(bind=engine, expire_on_commit=False)
+    client = TestClient(app)
+    return client, SessionLocal, Tenant, Item
+
+
+def test_allow_anon_create_method():
+    client, SessionLocal, Tenant, Item = _build_client_create_noauth()
+    with SessionLocal() as db:
+        tenant = Tenant(id=uuid4(), name="acme")
+        db.add(tenant)
+        db.commit()
+        db.refresh(tenant)
+        tid = str(tenant.id)
+    payload = {"id": str(uuid4()), "tenant_id": tid, "name": "one"}
+    assert client.post("/item", json=[payload]).status_code == 201
+
+
+def test_allow_anon_create_attr_noauth():
+    client, SessionLocal, Tenant, Item = _build_client_create_attr_noauth()
+    with SessionLocal() as db:
+        tenant = Tenant(id=uuid4(), name="acme")
+        db.add(tenant)
+        db.commit()
+        db.refresh(tenant)
+        tid = str(tenant.id)
+    payload = {"id": str(uuid4()), "tenant_id": tid, "name": "one"}
+    assert client.post("/item", json=[payload]).status_code == 201
+
+
+def test_allow_anon_list_and_read_attr():
+    client, SessionLocal, Tenant, Item = _build_client_attr()
+    with SessionLocal() as db:
+        tenant = Tenant(id=uuid4(), name="acme")
+        db.add(tenant)
+        db.commit()
+        db.refresh(tenant)
+        item = Item(id=uuid4(), tenant_id=tenant.id, name="thing")
+        db.add(item)
+        db.commit()
+        db.refresh(item)
+        tid = str(tenant.id)
+        iid = str(item.id)
+    assert client.get("/item").status_code == 200
+    assert client.get(f"/item/{iid}").status_code == 200
+    payload = {"id": str(uuid4()), "tenant_id": tid, "name": "new"}
+    assert client.post("/item", json=payload).status_code == 409

tests/i9n/test_apikey_generation.py

@@ -0,0 +1,47 @@
+import pytest
+from tigrbl.types import App, Mapped, String
+from httpx import ASGITransport, AsyncClient
+
+from tigrbl import TigrblApp
+from tigrbl.orm.mixins import (
+    Created,
+    GUIDPk,
+    KeyDigest,
+    LastUsed,
+    ValidityWindow,
+)
+from tigrbl.orm.tables._base import Base
+from tigrbl.specs import F, IO, S, acol
+
+
+class ConcreteApiKey(Base, GUIDPk, Created, LastUsed, ValidityWindow, KeyDigest):
+    """Concrete table for testing API key generation."""
+
+    __abstract__ = False
+    __resource__ = "apikey"
+    __tablename__ = "apikeys_generation"
+
+    label: Mapped[str] = acol(
+        storage=S(String, nullable=False),
+        field=F(required_in=("create",), constraints={"max_length": 120}),
+        io=IO(in_verbs=("create",)),
+    )
+
+
+@pytest.mark.i9n
+@pytest.mark.asyncio
+async def test_api_key_creation_requires_valid_payload(sync_db_session):
+    """Posting without required fields yields an unprocessable entity response."""
+    _, get_sync_db = sync_db_session
+
+    app = App()
+    api = TigrblApp(get_db=get_sync_db)
+    api.include_models([ConcreteApiKey])
+    api.initialize()
+    app.include_router(api.router)
+    transport = ASGITransport(app=app)
+
+    async with AsyncClient(transport=transport, base_url="http://test") as client:
+        res = await client.post("/apikey", json={})
+
+    assert res.status_code == 422

tests/i9n/test_authn_provider_integration.py

@@ -0,0 +1,67 @@
+from tigrbl.types import HTTPException, Request, Security
+from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
+from fastapi.testclient import TestClient
+from tigrbl.engine.shortcuts import mem
+
+from tigrbl import TigrblApp, Base, hook_ctx
+from tigrbl.config.constants import TIGRBL_AUTH_CONTEXT_ATTR
+from tigrbl.orm.mixins import GUIDPk
+from tigrbl.types.authn_abc import AuthNProvider
+
+
+class HookedAuth(AuthNProvider):
+    """Simple AuthN provider that records context via hooks."""
+
+    def __init__(self) -> None:
+        self.ctx_principal: dict | None = None
+
+    async def get_principal(
+        self,
+        request: Request,
+        creds: HTTPAuthorizationCredentials = Security(HTTPBearer()),
+    ) -> dict:
+        if creds.credentials != "secret":
+            raise HTTPException(status_code=401)
+        principal = {"sub": "user", "tid": "tenant"}
+        setattr(request.state, TIGRBL_AUTH_CONTEXT_ATTR, principal)
+        return principal
+
+
+def _build_client_with_auth():
+    Base.metadata.clear()
+
+    auth = HookedAuth()
+
+    class Tenant(Base, GUIDPk):
+        __tablename__ = "tenants"
+
+        @hook_ctx(ops="create", phase="PRE_HANDLER")
+        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()
+    return TestClient(api), auth
+
+
+def test_authn_hooks_and_context_injection():
+    client, auth = _build_client_with_auth()
+
+    payload = {}
+    res = client.post(
+        "/tenant", json=payload, headers={"Authorization": "Bearer secret"}
+    )
+    assert res.status_code == 201
+    assert auth.ctx_principal == {"sub": "user", "tid": "tenant"}
+
+
+def test_authn_unauthorized_errors():
+    client, _ = _build_client_with_auth()
+
+    assert client.get("/tenant").status_code == 403
+    assert (
+        client.get("/tenant", headers={"Authorization": "Bearer wrong"}).status_code
+        == 401
+    )