belgie-alchemy 0.1.0a4__py3-none-any.whl

belgie_alchemy/__tests__/base/test_base.py

@@ -0,0 +1,90 @@
+from datetime import UTC, datetime
+from pathlib import Path
+from tempfile import TemporaryDirectory
+
+import pytest
+from sqlalchemy import Integer, event, select
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
+from sqlalchemy.orm import Mapped, mapped_column
+
+from belgie_alchemy.__tests__.fixtures.models import User
+from belgie_alchemy.base import NAMING_CONVENTION, Base
+from belgie_alchemy.types import DateTimeUTC
+
+
+def test_type_annotation_map_uses_datetimeutc() -> None:
+    mapping = Base.type_annotation_map
+    assert mapping[datetime] is DateTimeUTC
+
+
+def test_datetime_annotation_auto_uses_datetimeutc() -> None:
+    """Verify that Mapped[datetime] automatically uses DateTimeUTC without explicit column type."""
+
+    class TestModel(Base):
+        __tablename__ = "test_auto_datetime"
+        id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True, init=False)
+        # No explicit DateTimeUTC type specified - should be inferred from type_annotation_map
+        timestamp: Mapped[datetime]
+
+    timestamp_column = TestModel.__table__.c.timestamp  # type: ignore[attr-defined]
+    assert isinstance(timestamp_column.type, DateTimeUTC)
+
+
+def test_naming_convention_applied() -> None:
+    assert Base.metadata.naming_convention == NAMING_CONVENTION
+
+
+def test_dataclass_kw_only_init() -> None:
+    user = User(email="a@b.com")
+    assert user.email == "a@b.com"
+
+
+@pytest.mark.asyncio
+async def test_file_based_sqlite_database() -> None:
+    """Test that models work correctly with file-based SQLite database."""
+    with TemporaryDirectory() as tmpdir:
+        db_path = Path(tmpdir) / "test.db"
+        db_url = f"sqlite+aiosqlite:///{db_path}"
+
+        # Create engine with file-based database
+        engine = create_async_engine(db_url, echo=False)
+
+        # Enable foreign keys for SQLite
+        @event.listens_for(engine.sync_engine, "connect")
+        def _enable_fk(dbapi_conn, _connection_record) -> None:
+            cursor = dbapi_conn.cursor()
+            cursor.execute("PRAGMA foreign_keys=ON")
+            cursor.close()
+
+        # Create tables
+        async with engine.begin() as conn:
+            await conn.run_sync(Base.metadata.create_all)
+
+        # Create session factory
+        session_factory = async_sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
+
+        # Test basic operations
+        async with session_factory() as session:
+            # Create user
+            user = User(email="file_db_test@example.com", name="Test User")
+            session.add(user)
+            await session.commit()
+
+            user_id = user.id
+
+        # Verify persistence by reading in new session
+        async with session_factory() as session:
+            result = await session.execute(select(User).where(User.id == user_id))
+            retrieved_user = result.scalar_one()
+
+            assert retrieved_user.email == "file_db_test@example.com"
+            assert retrieved_user.name == "Test User"
+            assert retrieved_user.created_at is not None
+            assert retrieved_user.created_at.tzinfo is UTC
+
+        # Cleanup
+        await engine.dispose()
+
+        # Verify database file was created
+        assert db_path.exists()
+        assert db_path.stat().st_size > 0

belgie_alchemy/__tests__/conftest.py

@@ -0,0 +1,39 @@
+"""Pytest fixtures for alchemy tests."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import pytest_asyncio
+
+from belgie_alchemy.__tests__.fixtures.database import get_test_engine, get_test_session_factory
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncGenerator
+
+    from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession, async_sessionmaker
+
+
+@pytest_asyncio.fixture
+async def alchemy_engine() -> AsyncGenerator[AsyncEngine, None]:
+    """Create an isolated in-memory SQLite engine for testing.
+
+    Each test gets its own in-memory database, so Base.metadata.create_all
+    is safe even when tests run in parallel - there's no shared state.
+    """
+    engine = await get_test_engine()
+    yield engine
+    await engine.dispose()
+
+
+@pytest_asyncio.fixture
+async def alchemy_session_factory(alchemy_engine: AsyncEngine) -> async_sessionmaker[AsyncSession]:
+    return await get_test_session_factory(alchemy_engine)
+
+
+@pytest_asyncio.fixture
+async def alchemy_session(
+    alchemy_session_factory: async_sessionmaker[AsyncSession],
+) -> AsyncGenerator[AsyncSession, None]:
+    async with alchemy_session_factory() as session:
+        yield session

belgie_alchemy/__tests__/fixtures/__init__.py

@@ -0,0 +1,12 @@
+from belgie_alchemy.__tests__.fixtures.database import get_test_db, get_test_engine, get_test_session_factory
+from belgie_alchemy.__tests__.fixtures.models import Account, OAuthState, Session, User
+
+__all__ = [
+    "Account",
+    "OAuthState",
+    "Session",
+    "User",
+    "get_test_db",
+    "get_test_engine",
+    "get_test_session_factory",
+]

belgie_alchemy/__tests__/fixtures/database.py

@@ -0,0 +1,38 @@
+from collections.abc import AsyncGenerator
+
+from sqlalchemy import event
+from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession, async_sessionmaker, create_async_engine
+
+from belgie_alchemy import Base
+
+TEST_DATABASE_URL = "sqlite+aiosqlite:///:memory:"
+
+
+async def get_test_engine() -> AsyncEngine:
+    engine = create_async_engine(
+        TEST_DATABASE_URL,
+        echo=False,
+    )
+
+    @event.listens_for(engine.sync_engine, "connect")
+    def _enable_foreign_keys(dbapi_conn, _connection_record) -> None:
+        cursor = dbapi_conn.cursor()
+        cursor.execute("PRAGMA foreign_keys=ON")
+        cursor.close()
+
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+    return engine
+
+
+async def get_test_session_factory(engine: AsyncEngine) -> async_sessionmaker[AsyncSession]:
+    return async_sessionmaker(
+        engine,
+        class_=AsyncSession,
+        expire_on_commit=False,
+    )
+
+
+async def get_test_db(session_factory: async_sessionmaker[AsyncSession]) -> AsyncGenerator[AsyncSession, None]:
+    async with session_factory() as session:
+        yield session

belgie_alchemy/__tests__/fixtures/models.py

@@ -0,0 +1,119 @@
+"""Test models for alchemy tests.
+
+Defines concrete auth models for testing. These mirror the examples in
+examples/alchemy/auth_models.py and demonstrate how users would define
+their own models.
+"""
+
+from __future__ import annotations
+
+from datetime import datetime  # noqa: TC003
+from uuid import UUID  # noqa: TC003
+
+from sqlalchemy import JSON, ForeignKey, Text, UniqueConstraint
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from belgie_alchemy import Base, DateTimeUTC, PrimaryKeyMixin, TimestampMixin
+
+
+class User(Base, PrimaryKeyMixin, TimestampMixin):
+    """Test User model."""
+
+    __tablename__ = "users"
+
+    email: Mapped[str] = mapped_column(unique=True, index=True)
+    email_verified: Mapped[bool] = mapped_column(default=False)
+    name: Mapped[str | None] = mapped_column(default=None)
+    image: Mapped[str | None] = mapped_column(default=None)
+    scopes: Mapped[list[str] | None] = mapped_column(JSON, default=None)
+    custom_field: Mapped[str | None] = mapped_column(default=None)
+
+    accounts: Mapped[list[Account]] = relationship(
+        back_populates="user",
+        cascade="all, delete-orphan",
+        init=False,
+    )
+    sessions: Mapped[list[Session]] = relationship(
+        back_populates="user",
+        cascade="all, delete-orphan",
+        init=False,
+    )
+    oauth_states: Mapped[list[OAuthState]] = relationship(
+        back_populates="user",
+        cascade="all, delete-orphan",
+        init=False,
+    )
+
+
+class Account(Base, PrimaryKeyMixin, TimestampMixin):
+    """Test Account model."""
+
+    __tablename__ = "accounts"
+
+    user_id: Mapped[UUID] = mapped_column(
+        ForeignKey("users.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    )
+    provider: Mapped[str] = mapped_column(Text)
+    provider_account_id: Mapped[str] = mapped_column(Text)
+    access_token: Mapped[str | None] = mapped_column(default=None)
+    refresh_token: Mapped[str | None] = mapped_column(default=None)
+    expires_at: Mapped[datetime | None] = mapped_column(DateTimeUTC, default=None)
+    token_type: Mapped[str | None] = mapped_column(default=None)
+    scope: Mapped[str | None] = mapped_column(default=None)
+    id_token: Mapped[str | None] = mapped_column(default=None)
+
+    user: Mapped[User] = relationship(
+        back_populates="accounts",
+        lazy="selectin",
+        init=False,
+    )
+
+    __table_args__ = (
+        UniqueConstraint(
+            "provider",
+            "provider_account_id",
+            name="uq_accounts_provider_provider_account_id",
+        ),
+    )
+
+
+class Session(Base, PrimaryKeyMixin, TimestampMixin):
+    """Test Session model."""
+
+    __tablename__ = "sessions"
+
+    user_id: Mapped[UUID] = mapped_column(
+        ForeignKey("users.id", ondelete="cascade", onupdate="cascade"),
+        nullable=False,
+    )
+    expires_at: Mapped[datetime] = mapped_column(DateTimeUTC)
+    ip_address: Mapped[str | None] = mapped_column(default=None)
+    user_agent: Mapped[str | None] = mapped_column(default=None)
+
+    user: Mapped[User] = relationship(
+        back_populates="sessions",
+        lazy="selectin",
+        init=False,
+    )
+
+
+class OAuthState(Base, PrimaryKeyMixin, TimestampMixin):
+    """Test OAuthState model."""
+
+    __tablename__ = "oauth_states"
+
+    state: Mapped[str] = mapped_column(unique=True, index=True)
+    user_id: Mapped[UUID | None] = mapped_column(
+        ForeignKey("users.id", ondelete="set null", onupdate="cascade"),
+        nullable=True,
+    )
+    expires_at: Mapped[datetime] = mapped_column(DateTimeUTC)
+    code_verifier: Mapped[str | None] = mapped_column(default=None)
+    redirect_url: Mapped[str | None] = mapped_column(default=None)
+
+    user: Mapped[User] | None = relationship(
+        back_populates="oauth_states",
+        lazy="selectin",
+        init=False,
+    )

belgie_alchemy/__tests__/mixins/test_mixins.py

@@ -0,0 +1,80 @@
+from uuid import UUID
+
+import pytest
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from belgie_alchemy.__tests__.fixtures.models import User
+
+
+def test_primary_key_mixin_defaults() -> None:
+    id_column = User.__table__.c.id  # type: ignore[attr-defined]
+    assert id_column.primary_key
+    assert str(id_column.server_default.arg) == "gen_random_uuid()"
+    assert id_column.index
+
+
+def test_primary_key_client_side_generation() -> None:
+    """Test that UUID is generated client-side via default_factory."""
+    user1 = User(email="user1@example.com")
+    user2 = User(email="user2@example.com")
+
+    # UUIDs should be generated automatically
+    assert isinstance(user1.id, UUID)
+    assert isinstance(user2.id, UUID)
+
+    # UUIDs should be unique
+    assert user1.id != user2.id
+
+
+@pytest.mark.asyncio
+async def test_primary_key_persists_client_generated_uuid(alchemy_session: AsyncSession) -> None:
+    """Test that client-generated UUIDs are persisted correctly."""
+    user = User(email="persist@example.com")
+    original_id = user.id
+
+    alchemy_session.add(user)
+    await alchemy_session.commit()
+
+    # Refresh from database
+    await alchemy_session.refresh(user)
+
+    # UUID should be unchanged
+    assert user.id == original_id
+    assert isinstance(user.id, UUID)
+
+
+@pytest.mark.asyncio
+async def test_primary_key_unique_constraint(alchemy_session: AsyncSession) -> None:
+    """Test that duplicate UUIDs are rejected by unique constraint."""
+    user1 = User(email="user1@example.com")
+    alchemy_session.add(user1)
+    await alchemy_session.commit()
+
+    # Save the ID and expunge user1 to avoid identity conflicts
+    user1_id = user1.id
+    alchemy_session.expunge(user1)
+
+    # Try to create another user with the same ID
+    user2 = User(email="user2@example.com")
+    user2.id = user1_id  # Force same ID
+
+    alchemy_session.add(user2)
+    with pytest.raises(IntegrityError):
+        await alchemy_session.commit()
+
+    await alchemy_session.rollback()
+
+
+def test_timestamp_mixin_defaults() -> None:
+    user = User(email="defaults@example.com")
+    assert user.created_at is not None
+    assert user.updated_at is not None
+    assert user.deleted_at is None
+
+
+def test_mark_deleted_sets_timestamp() -> None:
+    user = User(email="x@example.com")
+    assert user.deleted_at is None
+    user.mark_deleted()
+    assert user.deleted_at is not None