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

belgie_alchemy/__tests__/adapter/test_adapter.py

@@ -1,493 +0,0 @@
-from datetime import UTC, datetime, timedelta
-from uuid import uuid4
-
-import pytest
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from belgie_alchemy import AlchemyAdapter
-from belgie_alchemy.__tests__.fixtures.models import Account, OAuthState, Session, User
-
-
-@pytest.fixture
-def adapter(alchemy_session: AsyncSession) -> AlchemyAdapter:  # noqa: ARG001
-    return AlchemyAdapter(
-        user=User,
-        account=Account,
-        session=Session,
-        oauth_state=OAuthState,
-    )
-
-
-@pytest.mark.asyncio
-async def test_create_user(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
-    user = await adapter.create_user(
-        alchemy_session,
-        email="test@example.com",
-        name="Test User",
-        email_verified=True,
-    )
-
-    assert user.email == "test@example.com"
-    assert user.name == "Test User"
-    assert user.email_verified is True
-    assert user.id is not None
-    assert user.created_at is not None
-
-
-@pytest.mark.asyncio
-async def test_get_user_by_id(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
-    created_user = await adapter.create_user(
-        alchemy_session,
-        email="test@example.com",
-        name="Test User",
-    )
-
-    found_user = await adapter.get_user_by_id(alchemy_session, created_user.id)
-
-    assert found_user is not None
-    assert found_user.id == created_user.id
-    assert found_user.email == "test@example.com"
-
-
-@pytest.mark.asyncio
-async def test_get_user_by_id_not_found(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
-    user = await adapter.get_user_by_id(alchemy_session, uuid4())
-    assert user is None
-
-
-@pytest.mark.asyncio
-async def test_get_user_by_email(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
-    await adapter.create_user(
-        alchemy_session,
-        email="test@example.com",
-        name="Test User",
-    )
-
-    user = await adapter.get_user_by_email(alchemy_session, "test@example.com")
-
-    assert user is not None
-    assert user.email == "test@example.com"
-
-
-@pytest.mark.asyncio
-async def test_get_user_by_email_not_found(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
-    user = await adapter.get_user_by_email(alchemy_session, "nonexistent@example.com")
-    assert user is None
-
-
-@pytest.mark.asyncio
-async def test_update_user(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
-    user = await adapter.create_user(
-        alchemy_session,
-        email="test@example.com",
-        name="Test User",
-    )
-
-    updated_user = await adapter.update_user(
-        alchemy_session,
-        user.id,
-        name="Updated Name",
-        email_verified=True,
-    )
-
-    assert updated_user is not None
-    assert updated_user.name == "Updated Name"
-    assert updated_user.email_verified is True
-
-
-@pytest.mark.asyncio
-async def test_update_user_not_found(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
-    updated_user = await adapter.update_user(
-        alchemy_session,
-        uuid4(),
-        name="Updated Name",
-    )
-    assert updated_user is None
-
-
-@pytest.mark.asyncio
-async def test_create_account(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
-    user = await adapter.create_user(
-        alchemy_session,
-        email="test@example.com",
-    )
-
-    account = await adapter.create_account(
-        alchemy_session,
-        user_id=user.id,
-        provider="google",
-        provider_account_id="12345",
-        access_token="token",
-        refresh_token="refresh",
-        expires_at=datetime.now(UTC) + timedelta(hours=1),
-        token_type="Bearer",
-        scope="openid email",
-        id_token="id_token",
-    )
-
-    assert account.user_id == user.id
-    assert account.provider == "google"
-    assert account.provider_account_id == "12345"
-    assert account.access_token == "token"  # noqa: S105
-    assert account.refresh_token == "refresh"  # noqa: S105
-    assert account.token_type == "Bearer"  # noqa: S105
-
-
-@pytest.mark.asyncio
-async def test_get_account(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
-    user = await adapter.create_user(
-        alchemy_session,
-        email="test@example.com",
-    )
-
-    await adapter.create_account(
-        alchemy_session,
-        user_id=user.id,
-        provider="google",
-        provider_account_id="12345",
-    )
-
-    account = await adapter.get_account(alchemy_session, "google", "12345")
-
-    assert account is not None
-    assert account.provider == "google"
-    assert account.provider_account_id == "12345"
-
-
-@pytest.mark.asyncio
-async def test_get_account_not_found(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
-    account = await adapter.get_account(alchemy_session, "google", "nonexistent")
-    assert account is None
-
-
-@pytest.mark.asyncio
-async def test_create_session(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
-    user = await adapter.create_user(
-        alchemy_session,
-        email="test@example.com",
-    )
-
-    expires_at = datetime.now(UTC) + timedelta(days=7)
-    session = await adapter.create_session(
-        alchemy_session,
-        user_id=user.id,
-        expires_at=expires_at,
-        ip_address="127.0.0.1",
-        user_agent="Test Agent",
-    )
-
-    assert session.user_id == user.id
-    assert session.expires_at.replace(tzinfo=UTC) == expires_at
-    assert session.ip_address == "127.0.0.1"
-    assert session.user_agent == "Test Agent"
-
-
-@pytest.mark.asyncio
-async def test_get_session(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
-    user = await adapter.create_user(
-        alchemy_session,
-        email="test@example.com",
-    )
-
-    created_session = await adapter.create_session(
-        alchemy_session,
-        user_id=user.id,
-        expires_at=datetime.now(UTC) + timedelta(days=7),
-    )
-
-    found_session = await adapter.get_session(alchemy_session, created_session.id)
-
-    assert found_session is not None
-    assert found_session.id == created_session.id
-
-
-@pytest.mark.asyncio
-async def test_get_session_not_found(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
-    session = await adapter.get_session(alchemy_session, uuid4())
-    assert session is None
-
-
-@pytest.mark.asyncio
-async def test_update_session(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
-    user = await adapter.create_user(
-        alchemy_session,
-        email="test@example.com",
-    )
-
-    session = await adapter.create_session(
-        alchemy_session,
-        user_id=user.id,
-        expires_at=datetime.now(UTC) + timedelta(days=7),
-    )
-
-    new_expires = datetime.now(UTC) + timedelta(days=14)
-    updated_session = await adapter.update_session(
-        alchemy_session,
-        session.id,
-        expires_at=new_expires,
-        ip_address="192.168.1.1",
-    )
-
-    assert updated_session is not None
-    assert updated_session.expires_at.replace(tzinfo=UTC) == new_expires
-    assert updated_session.ip_address == "192.168.1.1"
-
-
-@pytest.mark.asyncio
-async def test_update_session_not_found(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
-    updated_session = await adapter.update_session(
-        alchemy_session,
-        uuid4(),
-        expires_at=datetime.now(UTC) + timedelta(days=7),
-    )
-    assert updated_session is None
-
-
-@pytest.mark.asyncio
-async def test_delete_session(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
-    user = await adapter.create_user(
-        alchemy_session,
-        email="test@example.com",
-    )
-
-    session = await adapter.create_session(
-        alchemy_session,
-        user_id=user.id,
-        expires_at=datetime.now(UTC) + timedelta(days=7),
-    )
-
-    deleted = await adapter.delete_session(alchemy_session, session.id)
-    assert deleted is True
-
-    found = await adapter.get_session(alchemy_session, session.id)
-    assert found is None
-
-
-@pytest.mark.asyncio
-async def test_delete_session_not_found(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
-    deleted = await adapter.delete_session(alchemy_session, uuid4())
-    assert deleted is False
-
-
-@pytest.mark.asyncio
-async def test_delete_expired_sessions(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
-    user = await adapter.create_user(
-        alchemy_session,
-        email="test@example.com",
-    )
-
-    await adapter.create_session(
-        alchemy_session,
-        user_id=user.id,
-        expires_at=datetime.now(UTC) - timedelta(days=1),
-    )
-
-    await adapter.create_session(
-        alchemy_session,
-        user_id=user.id,
-        expires_at=datetime.now(UTC) + timedelta(days=7),
-    )
-
-    count = await adapter.delete_expired_sessions(alchemy_session)
-    assert count == 1
-
-
-@pytest.mark.asyncio
-async def test_create_oauth_state(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
-    expires_at = datetime.now(UTC) + timedelta(minutes=10)
-    oauth_state = await adapter.create_oauth_state(
-        alchemy_session,
-        state="random_state_123",
-        expires_at=expires_at,
-        code_verifier="verifier_abc",
-        redirect_url="/dashboard",
-    )
-
-    assert oauth_state.state == "random_state_123"
-    assert oauth_state.code_verifier == "verifier_abc"
-    assert oauth_state.redirect_url == "/dashboard"
-    assert oauth_state.expires_at.replace(tzinfo=UTC) == expires_at
-
-
-@pytest.mark.asyncio
-async def test_get_oauth_state(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
-    await adapter.create_oauth_state(
-        alchemy_session,
-        state="random_state_123",
-        expires_at=datetime.now(UTC) + timedelta(minutes=10),
-    )
-
-    oauth_state = await adapter.get_oauth_state(alchemy_session, "random_state_123")
-
-    assert oauth_state is not None
-    assert oauth_state.state == "random_state_123"
-
-
-@pytest.mark.asyncio
-async def test_get_oauth_state_not_found(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
-    oauth_state = await adapter.get_oauth_state(alchemy_session, "nonexistent")
-    assert oauth_state is None
-
-
-@pytest.mark.asyncio
-async def test_delete_oauth_state(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
-    await adapter.create_oauth_state(
-        alchemy_session,
-        state="random_state_123",
-        expires_at=datetime.now(UTC) + timedelta(minutes=10),
-    )
-
-    deleted = await adapter.delete_oauth_state(alchemy_session, "random_state_123")
-    assert deleted is True
-
-    found = await adapter.get_oauth_state(alchemy_session, "random_state_123")
-    assert found is None
-
-
-@pytest.mark.asyncio
-async def test_delete_oauth_state_not_found(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
-    deleted = await adapter.delete_oauth_state(alchemy_session, "nonexistent")
-    assert deleted is False
-
-
-@pytest.mark.asyncio
-async def test_user_with_custom_fields(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
-    user_data = User(
-        email="custom@example.com",
-        email_verified=True,
-        name="Custom User",
-        image=None,
-        custom_field="custom value",
-    )
-    alchemy_session.add(user_data)
-    await alchemy_session.commit()
-
-    found = await adapter.get_user_by_email(alchemy_session, "custom@example.com")
-    assert found is not None
-    assert found.custom_field == "custom value"
-
-
-@pytest.mark.asyncio
-async def test_delete_user_deletes_user(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
-    user = await adapter.create_user(alchemy_session, email="delete@example.com", name="Delete User")
-
-    deleted = await adapter.delete_user(alchemy_session, user.id)
-
-    assert deleted is True
-    assert await adapter.get_user_by_id(alchemy_session, user.id) is None
-
-
-@pytest.mark.asyncio
-async def test_delete_user_deletes_sessions(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
-    user = await adapter.create_user(alchemy_session, email="delete@example.com", name="Delete User")
-
-    expires_at = datetime.now(UTC) + timedelta(days=1)
-    session1 = await adapter.create_session(alchemy_session, user.id, expires_at.replace(tzinfo=None))
-    session2 = await adapter.create_session(alchemy_session, user.id, expires_at.replace(tzinfo=None))
-
-    await adapter.delete_user(alchemy_session, user.id)
-
-    assert await adapter.get_session(alchemy_session, session1.id) is None
-    assert await adapter.get_session(alchemy_session, session2.id) is None
-
-
-@pytest.mark.asyncio
-async def test_delete_user_deletes_accounts(adapter: AlchemyAdapter, alchemy_session: AsyncSession) -> None:
-    user = await adapter.create_user(alchemy_session, email="delete@example.com", name="Delete User")
-
-    await adapter.create_account(
-        alchemy_session,
-        user.id,
-        "google",
-        "google-123",
-        access_token="token123",
-    )
-
-    await adapter.delete_user(alchemy_session, user.id)
-
-    assert await adapter.get_account(alchemy_session, "google", "google-123") is None
-
-
-@pytest.mark.asyncio
-async def test_delete_user_deletes_all_related_data(
-    adapter: AlchemyAdapter,
-    alchemy_session: AsyncSession,
-) -> None:
-    user = await adapter.create_user(alchemy_session, email="delete@example.com", name="Delete User")
-
-    expires_at = datetime.now(UTC) + timedelta(days=1)
-    session1 = await adapter.create_session(alchemy_session, user.id, expires_at.replace(tzinfo=None))
-    session2 = await adapter.create_session(alchemy_session, user.id, expires_at.replace(tzinfo=None))
-
-    await adapter.create_account(
-        alchemy_session,
-        user.id,
-        "google",
-        "google-123",
-        access_token="token123",
-    )
-    await adapter.create_account(
-        alchemy_session,
-        user.id,
-        "github",
-        "github-456",
-        access_token="token456",
-    )
-
-    deleted = await adapter.delete_user(alchemy_session, user.id)
-
-    assert deleted is True
-    assert await adapter.get_user_by_id(alchemy_session, user.id) is None
-    assert await adapter.get_session(alchemy_session, session1.id) is None
-    assert await adapter.get_session(alchemy_session, session2.id) is None
-    assert await adapter.get_account(alchemy_session, "google", "google-123") is None
-    assert await adapter.get_account(alchemy_session, "github", "github-456") is None
-
-
-@pytest.mark.asyncio
-async def test_delete_user_returns_false_if_user_not_found(
-    adapter: AlchemyAdapter,
-    alchemy_session: AsyncSession,
-) -> None:
-    fake_user_id = uuid4()
-    deleted = await adapter.delete_user(alchemy_session, fake_user_id)
-
-    assert deleted is False
-
-
-@pytest.mark.asyncio
-async def test_delete_user_only_deletes_target_users_data(
-    adapter: AlchemyAdapter,
-    alchemy_session: AsyncSession,
-) -> None:
-    user1 = await adapter.create_user(alchemy_session, email="user1@example.com", name="User 1")
-    user2 = await adapter.create_user(alchemy_session, email="user2@example.com", name="User 2")
-
-    expires_at = datetime.now(UTC) + timedelta(days=1)
-    session1 = await adapter.create_session(alchemy_session, user1.id, expires_at.replace(tzinfo=None))
-    session2 = await adapter.create_session(alchemy_session, user2.id, expires_at.replace(tzinfo=None))
-
-    await adapter.create_account(
-        alchemy_session,
-        user1.id,
-        "google",
-        "google-user1",
-        access_token="token1",
-    )
-    await adapter.create_account(
-        alchemy_session,
-        user2.id,
-        "google",
-        "google-user2",
-        access_token="token2",
-    )
-
-    await adapter.delete_user(alchemy_session, user1.id)
-
-    assert await adapter.get_user_by_id(alchemy_session, user1.id) is None
-    assert await adapter.get_session(alchemy_session, session1.id) is None
-    assert await adapter.get_account(alchemy_session, "google", "google-user1") is None
-
-    assert await adapter.get_user_by_id(alchemy_session, user2.id) is not None
-    assert await adapter.get_session(alchemy_session, session2.id) is not None
-    assert await adapter.get_account(alchemy_session, "google", "google-user2") is not None

belgie_alchemy/__tests__/auth_models/test_auth_models.py

@@ -1,91 +0,0 @@
-from datetime import UTC, datetime, timedelta
-
-import pytest
-from sqlalchemy import select
-from sqlalchemy.exc import IntegrityError
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from belgie_alchemy.__tests__.fixtures.models import Account, OAuthState, Session, User
-
-
-def test_user_model_structure() -> None:
-    """Verify User model demonstrates proper structure."""
-    assert User.__tablename__ == "users"
-    assert not getattr(User, "__abstract__", False)
-    assert hasattr(User, "email")
-    assert hasattr(User, "scopes")
-
-
-def test_user_has_scopes_field() -> None:
-    """Verify User has scopes field that accepts list of strings."""
-    user = User(email="test@example.com")
-    user.scopes = ["read", "write"]
-    assert user.scopes == ["read", "write"]
-
-
-def test_user_relationships_defined() -> None:
-    """Verify User has bidirectional relationships defined."""
-    assert hasattr(User, "accounts")
-    assert hasattr(User, "sessions")
-    assert hasattr(User, "oauth_states")
-
-
-@pytest.mark.asyncio
-async def test_account_unique_constraint(alchemy_session: AsyncSession) -> None:
-    user = User(email="auth@example.com")
-    alchemy_session.add(user)
-    await alchemy_session.commit()
-
-    account = Account(
-        user_id=user.id,
-        provider="google",
-        provider_account_id="abc",
-    )
-    alchemy_session.add(account)
-    await alchemy_session.commit()
-
-    duplicate = Account(
-        user_id=user.id,
-        provider="google",
-        provider_account_id="abc",
-    )
-    alchemy_session.add(duplicate)
-    with pytest.raises(IntegrityError):
-        await alchemy_session.commit()
-    await alchemy_session.rollback()
-
-
-@pytest.mark.asyncio
-async def test_session_relationship(alchemy_session: AsyncSession) -> None:
-    user = User(email="session@example.com")
-    alchemy_session.add(user)
-    await alchemy_session.commit()
-
-    session = Session(
-        user_id=user.id,
-        expires_at=datetime.now(UTC) + timedelta(days=1),
-    )
-    alchemy_session.add(session)
-    await alchemy_session.commit()
-
-    refreshed = await alchemy_session.get(User, user.id)
-    assert refreshed is not None
-    await alchemy_session.refresh(refreshed, attribute_names=["sessions"])
-    assert len(refreshed.sessions) == 1
-
-
-@pytest.mark.asyncio
-async def test_oauth_state_optional_user(alchemy_session: AsyncSession) -> None:
-    state = OAuthState(
-        state="abc",
-        code_verifier=None,
-        redirect_url=None,
-        expires_at=datetime.now(UTC) + timedelta(minutes=5),
-        user_id=None,
-    )
-    alchemy_session.add(state)
-    await alchemy_session.commit()
-
-    rows = await alchemy_session.execute(select(OAuthState))
-    stored = rows.scalar_one()
-    assert stored.user is None

belgie_alchemy/__tests__/base/test_base.py

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