belgie-alchemy 0.1.0a4__py3-none-any.whl → 0.2.0__py3-none-any.whl

belgie_alchemy/__tests__/conftest.py

@@ -1,39 +0,0 @@
-"""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

@@ -1,12 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,119 +0,0 @@
-"""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

@@ -1,80 +0,0 @@
-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

belgie_alchemy/__tests__/settings/test_settings.py

@@ -1,342 +0,0 @@
-import os
-from importlib.util import find_spec
-from urllib.parse import urlparse
-
-import pytest
-from sqlalchemy import text
-from sqlalchemy.exc import IntegrityError
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from belgie_alchemy.settings import DatabaseSettings
-
-ASYNC_PG_AVAILABLE = find_spec("asyncpg") is not None
-
-
-@pytest.mark.asyncio
-async def test_sqlite_engine_fk_enabled() -> None:
-    db = DatabaseSettings(dialect={"type": "sqlite", "database": ":memory:", "enable_foreign_keys": True})
-
-    async with db.engine.connect() as conn:
-        result = await conn.execute(text("PRAGMA foreign_keys"))
-        value = result.scalar_one()
-
-    assert value == 1
-    await db.engine.dispose()
-
-
-@pytest.mark.asyncio
-async def test_session_maker_expire_disabled() -> None:
-    db = DatabaseSettings(dialect={"type": "sqlite", "database": ":memory:"})
-
-    session_factory = db.session_maker
-    assert session_factory.kw["expire_on_commit"] is False
-
-    async with session_factory() as session:
-        assert isinstance(session, AsyncSession)
-
-    await db.engine.dispose()
-
-
-def test_postgres_url_creation() -> None:
-    if not ASYNC_PG_AVAILABLE:
-        pytest.skip("asyncpg not installed; skip postgres engine test")
-
-    db = DatabaseSettings(
-        dialect={
-            "type": "postgres",
-            "host": "localhost",
-            "port": 5432,
-            "database": "belgie",
-            "username": "user",
-            "password": "secret",
-        },
-    )
-
-    assert db.engine.url.get_backend_name() == "postgresql"
-    assert db.engine.url.get_driver_name() == "asyncpg"
-    assert db.engine.url.username == "user"
-    assert db.engine.url.host == "localhost"
-    assert db.engine.url.database == "belgie"
-    assert db.engine.url.port == 5432
-
-
-@pytest.mark.asyncio
-async def test_sqlite_fk_violations_raise_error() -> None:
-    """Test that foreign key constraints are enforced when enabled."""
-    db = DatabaseSettings(dialect={"type": "sqlite", "database": ":memory:", "enable_foreign_keys": True})
-
-    # Try to insert a child record with invalid FK - should raise IntegrityError
-    async with db.engine.begin() as conn:
-        # Create simple test tables
-        await conn.execute(text("CREATE TABLE test_parents (id INTEGER PRIMARY KEY, name TEXT)"))
-        await conn.execute(
-            text(
-                "CREATE TABLE test_children "
-                "(id INTEGER PRIMARY KEY, parent_id INTEGER NOT NULL REFERENCES test_parents(id), name TEXT)",
-            ),
-        )
-
-    async with db.session_maker() as session:
-        # Try to insert child without parent - should raise IntegrityError
-        with pytest.raises(IntegrityError):  # noqa: PT012
-            await session.execute(text("INSERT INTO test_children (id, parent_id, name) VALUES (1, 999, 'orphan')"))
-            await session.commit()
-
-    await db.engine.dispose()
-
-
-@pytest.mark.asyncio
-async def test_dependency_yields_different_sessions() -> None:
-    """Test that dependency yields different session instances."""
-    db = DatabaseSettings(dialect={"type": "sqlite", "database": ":memory:"})
-
-    sessions = []
-    async for session1 in db.dependency():
-        sessions.append(session1)
-        break
-
-    async for session2 in db.dependency():
-        sessions.append(session2)
-        break
-
-    assert len(sessions) == 2
-    assert sessions[0] is not sessions[1]
-    await db.engine.dispose()
-
-
-@pytest.mark.asyncio
-async def test_dependency_handles_exceptions() -> None:
-    """Test that dependency properly handles exceptions."""
-    db = DatabaseSettings(dialect={"type": "sqlite", "database": ":memory:"})
-
-    # Simulate exception during request handling
-    simulated_error = "Simulated error"
-    try:
-        async for _session in db.dependency():
-            # Force an error
-            raise ValueError(simulated_error)  # noqa: TRY301
-    except ValueError:
-        pass  # Expected
-
-    # Verify we can still get new sessions
-    async for session in db.dependency():
-        assert isinstance(session, AsyncSession)
-        break
-
-    await db.engine.dispose()
-
-
-def test_postgres_settings_validation() -> None:
-    """Test that PostgreSQL settings validates all required fields."""
-    # Test with valid data
-    db = DatabaseSettings(
-        dialect={
-            "type": "postgres",
-            "host": "db.example.com",
-            "port": 5433,
-            "database": "testdb",
-            "username": "testuser",
-            "password": "testpass",
-            "pool_size": 10,
-            "max_overflow": 20,
-        },
-    )
-
-    assert db.dialect.type == "postgres"
-    assert db.dialect.host == "db.example.com"
-    assert db.dialect.port == 5433
-    assert db.dialect.database == "testdb"
-    assert db.dialect.username == "testuser"
-    assert db.dialect.password.get_secret_value() == "testpass"
-    assert db.dialect.pool_size == 10
-    assert db.dialect.max_overflow == 20
-
-
-def test_sqlite_settings_validation() -> None:
-    """Test that SQLite settings validates correctly."""
-    db = DatabaseSettings(
-        dialect={
-            "type": "sqlite",
-            "database": "/tmp/test.db",  # noqa: S108
-            "enable_foreign_keys": False,
-            "echo": True,
-        },
-    )
-
-    assert db.dialect.type == "sqlite"
-    assert db.dialect.database == "/tmp/test.db"  # noqa: S108
-    assert db.dialect.enable_foreign_keys is False
-    assert db.dialect.echo is True
-
-
-# ==================== PostgreSQL Integration Tests ====================
-
-
-@pytest.mark.asyncio
-@pytest.mark.integration
-async def test_postgres_engine_connection() -> None:
-    """Test actual PostgreSQL connection and session creation.
-
-    This test requires a PostgreSQL instance to be available.
-    Set POSTGRES_TEST_URL environment variable or skip.
-    """
-    if not ASYNC_PG_AVAILABLE:
-        pytest.skip("asyncpg not installed")
-
-    # Allow configuring test database via environment
-    test_url = os.getenv("POSTGRES_TEST_URL")
-    if not test_url:
-        pytest.skip("POSTGRES_TEST_URL not set - skipping integration test")
-
-    # Parse URL components (format: postgresql://user:pass@host:port/db)
-    try:
-        parsed = urlparse(test_url)
-        db = DatabaseSettings(
-            dialect={
-                "type": "postgres",
-                "host": parsed.hostname or "localhost",
-                "port": parsed.port or 5432,
-                "database": parsed.path.lstrip("/") if parsed.path else "postgres",
-                "username": parsed.username or "postgres",
-                "password": parsed.password or "",
-            },
-        )
-
-        # Test basic connection
-        async with db.engine.connect() as conn:
-            result = await conn.execute(text("SELECT 1 as test"))
-            value = result.scalar_one()
-            assert value == 1
-
-        await db.engine.dispose()
-
-    except (OSError, IntegrityError) as e:
-        pytest.skip(f"Could not connect to PostgreSQL: {e}")
-
-
-@pytest.mark.asyncio
-@pytest.mark.integration
-async def test_postgres_session_creation() -> None:
-    """Test that PostgreSQL session factory works correctly."""
-    if not ASYNC_PG_AVAILABLE:
-        pytest.skip("asyncpg not installed")
-
-    test_url = os.getenv("POSTGRES_TEST_URL")
-    if not test_url:
-        pytest.skip("POSTGRES_TEST_URL not set - skipping integration test")
-
-    try:
-        parsed = urlparse(test_url)
-        db = DatabaseSettings(
-            dialect={
-                "type": "postgres",
-                "host": parsed.hostname or "localhost",
-                "port": parsed.port or 5432,
-                "database": parsed.path.lstrip("/") if parsed.path else "postgres",
-                "username": parsed.username or "postgres",
-                "password": parsed.password or "",
-            },
-        )
-
-        # Test session creation
-        async with db.session_maker() as session:
-            assert isinstance(session, AsyncSession)
-            result = await session.execute(text("SELECT version()"))
-            version = result.scalar_one()
-            assert "PostgreSQL" in version
-
-        await db.engine.dispose()
-
-    except (OSError, IntegrityError) as e:
-        pytest.skip(f"Could not connect to PostgreSQL: {e}")
-
-
-@pytest.mark.asyncio
-@pytest.mark.integration
-async def test_postgres_dependency_yields_sessions() -> None:
-    """Test that PostgreSQL dependency generator works correctly."""
-    if not ASYNC_PG_AVAILABLE:
-        pytest.skip("asyncpg not installed")
-
-    test_url = os.getenv("POSTGRES_TEST_URL")
-    if not test_url:
-        pytest.skip("POSTGRES_TEST_URL not set - skipping integration test")
-
-    try:
-        parsed = urlparse(test_url)
-        db = DatabaseSettings(
-            dialect={
-                "type": "postgres",
-                "host": parsed.hostname or "localhost",
-                "port": parsed.port or 5432,
-                "database": parsed.path.lstrip("/") if parsed.path else "postgres",
-                "username": parsed.username or "postgres",
-                "password": parsed.password or "",
-            },
-        )
-
-        # Test dependency yields working sessions
-        sessions = []
-        async for session in db.dependency():
-            sessions.append(session)
-            # Verify session works
-            result = await session.execute(text("SELECT 1"))
-            assert result.scalar_one() == 1
-            break
-
-        async for session in db.dependency():
-            sessions.append(session)
-            break
-
-        # Verify different session instances
-        assert len(sessions) == 2
-        assert sessions[0] is not sessions[1]
-
-        await db.engine.dispose()
-
-    except (OSError, IntegrityError) as e:
-        pytest.skip(f"Could not connect to PostgreSQL: {e}")
-
-
-@pytest.mark.asyncio
-@pytest.mark.integration
-async def test_postgres_connection_pooling() -> None:
-    """Test that PostgreSQL connection pooling is configured correctly."""
-    if not ASYNC_PG_AVAILABLE:
-        pytest.skip("asyncpg not installed")
-
-    test_url = os.getenv("POSTGRES_TEST_URL")
-    if not test_url:
-        pytest.skip("POSTGRES_TEST_URL not set - skipping integration test")
-
-    try:
-        parsed = urlparse(test_url)
-        db = DatabaseSettings(
-            dialect={
-                "type": "postgres",
-                "host": parsed.hostname or "localhost",
-                "port": parsed.port or 5432,
-                "database": parsed.path.lstrip("/") if parsed.path else "postgres",
-                "username": parsed.username or "postgres",
-                "password": parsed.password or "",
-                "pool_size": 5,
-                "max_overflow": 10,
-            },
-        )
-
-        # Verify pool settings
-        assert db.dialect.pool_size == 5
-        assert db.dialect.max_overflow == 10
-
-        # Create multiple sessions to test pooling
-        sessions = []
-        for _ in range(3):
-            async with db.session_maker() as session:
-                sessions.append(session)
-                result = await session.execute(text("SELECT 1"))
-                assert result.scalar_one() == 1
-
-        await db.engine.dispose()
-
-    except (OSError, IntegrityError) as e:
-        pytest.skip(f"Could not connect to PostgreSQL: {e}")