core-framework 0.12.6__py3-none-any.whl → 0.12.8__py3-none-any.whl

core/testing/database.py

@@ -0,0 +1,307 @@
+"""
+Test database utilities.
+
+Provides functions for setting up and tearing down test databases,
+with support for both SQLite (in-memory) and PostgreSQL.
+
+Usage:
+    # Setup
+    engine = await setup_test_db("sqlite+aiosqlite:///:memory:")
+    
+    # Get session
+    async with get_test_session() as session:
+        user = User(email="test@example.com")
+        session.add(user)
+        await session.commit()
+    
+    # Cleanup
+    await teardown_test_db()
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any
+from contextlib import asynccontextmanager
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession
+    from collections.abc import AsyncGenerator
+
+logger = logging.getLogger("core.testing")
+
+# Global test database state
+_test_engine: "AsyncEngine | None" = None
+_test_session_factory: Any = None
+
+
+class TestDatabase:
+    """
+    Test database manager.
+    
+    Manages test database lifecycle including setup, session management,
+    and cleanup. Supports both SQLite and PostgreSQL.
+    
+    Example:
+        db = TestDatabase("sqlite+aiosqlite:///:memory:")
+        await db.setup()
+        
+        async with db.session() as session:
+            # Use session
+            pass
+        
+        await db.teardown()
+    
+    Args:
+        database_url: Database URL
+        echo: Whether to log SQL statements
+        create_tables: Whether to create tables on setup
+    """
+    
+    def __init__(
+        self,
+        database_url: str = "sqlite+aiosqlite:///:memory:",
+        echo: bool = False,
+        create_tables: bool = True,
+    ) -> None:
+        self.database_url = database_url
+        self.echo = echo
+        self.create_tables = create_tables
+        self._engine: "AsyncEngine | None" = None
+        self._session_factory: Any = None
+    
+    async def setup(self) -> "AsyncEngine":
+        """
+        Initialize test database.
+        
+        Creates engine, session factory, and optionally creates all tables.
+        
+        Returns:
+            The database engine
+        """
+        from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker, AsyncSession
+        
+        # Create engine with test-specific settings
+        self._engine = create_async_engine(
+            self.database_url,
+            echo=self.echo,
+            # SQLite-specific settings
+            connect_args={"check_same_thread": False} if "sqlite" in self.database_url else {},
+        )
+        
+        # Create session factory
+        self._session_factory = async_sessionmaker(
+            self._engine,
+            class_=AsyncSession,
+            expire_on_commit=False,
+        )
+        
+        # Create tables if requested
+        if self.create_tables:
+            await self._create_tables()
+        
+        logger.debug(f"Test database initialized: {self.database_url}")
+        return self._engine
+    
+    async def teardown(self) -> None:
+        """
+        Cleanup test database.
+        
+        Drops all tables and disposes of the engine.
+        """
+        if self._engine:
+            # Drop tables
+            await self._drop_tables()
+            
+            # Dispose engine
+            await self._engine.dispose()
+            self._engine = None
+            self._session_factory = None
+        
+        logger.debug("Test database cleaned up")
+    
+    async def _create_tables(self) -> None:
+        """Create all tables from registered models."""
+        try:
+            from core.models import Model
+            metadata = Model.metadata
+        except ImportError:
+            logger.warning("Could not import Model, tables not created")
+            return
+        
+        async with self._engine.begin() as conn:
+            await conn.run_sync(metadata.create_all)
+        
+        logger.debug("Test database tables created")
+    
+    async def _drop_tables(self) -> None:
+        """Drop all tables."""
+        try:
+            from core.models import Model
+            metadata = Model.metadata
+        except ImportError:
+            return
+        
+        async with self._engine.begin() as conn:
+            await conn.run_sync(metadata.drop_all)
+    
+    @asynccontextmanager
+    async def session(self) -> "AsyncGenerator[AsyncSession, None]":
+        """
+        Get a database session.
+        
+        Session is automatically committed on success and rolled back on error.
+        
+        Yields:
+            Database session
+        """
+        if not self._session_factory:
+            raise RuntimeError("Database not initialized. Call setup() first.")
+        
+        session = self._session_factory()
+        try:
+            yield session
+            await session.commit()
+        except Exception:
+            await session.rollback()
+            raise
+        finally:
+            await session.close()
+    
+    async def truncate_all(self) -> None:
+        """
+        Truncate all tables (faster than drop/create for resetting between tests).
+        """
+        try:
+            from core.models import Model
+            metadata = Model.metadata
+        except ImportError:
+            return
+        
+        async with self._engine.begin() as conn:
+            for table in reversed(metadata.sorted_tables):
+                await conn.execute(table.delete())
+        
+        logger.debug("Test database tables truncated")
+    
+    async def __aenter__(self) -> "TestDatabase":
+        """Setup on context enter."""
+        await self.setup()
+        return self
+    
+    async def __aexit__(self, *args) -> None:
+        """Teardown on context exit."""
+        await self.teardown()
+
+
+# =============================================================================
+# Module-level functions for simpler usage
+# =============================================================================
+
+async def setup_test_db(
+    database_url: str = "sqlite+aiosqlite:///:memory:",
+    create_tables: bool = True,
+    echo: bool = False,
+) -> "AsyncEngine":
+    """
+    Setup test database.
+    
+    Initializes the global test database state.
+    
+    Args:
+        database_url: Database URL
+        create_tables: Whether to create tables
+        echo: Whether to log SQL
+    
+    Returns:
+        Database engine
+        
+    Example:
+        engine = await setup_test_db()
+        # ... run tests ...
+        await teardown_test_db()
+    """
+    global _test_engine, _test_session_factory
+    
+    from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker, AsyncSession
+    
+    _test_engine = create_async_engine(
+        database_url,
+        echo=echo,
+        connect_args={"check_same_thread": False} if "sqlite" in database_url else {},
+    )
+    
+    _test_session_factory = async_sessionmaker(
+        _test_engine,
+        class_=AsyncSession,
+        expire_on_commit=False,
+    )
+    
+    if create_tables:
+        try:
+            from core.models import Model
+            async with _test_engine.begin() as conn:
+                await conn.run_sync(Model.metadata.create_all)
+        except ImportError:
+            pass
+    
+    # Also register with core.database for dependencies
+    try:
+        from core import database
+        database._write_session_factory = _test_session_factory
+        database._read_session_factory = _test_session_factory
+    except (ImportError, AttributeError):
+        pass
+    
+    logger.debug(f"Test database setup: {database_url}")
+    return _test_engine
+
+
+async def teardown_test_db() -> None:
+    """
+    Teardown test database.
+    
+    Cleans up the global test database state.
+    """
+    global _test_engine, _test_session_factory
+    
+    if _test_engine:
+        # Drop tables
+        try:
+            from core.models import Model
+            async with _test_engine.begin() as conn:
+                await conn.run_sync(Model.metadata.drop_all)
+        except ImportError:
+            pass
+        
+        await _test_engine.dispose()
+        _test_engine = None
+        _test_session_factory = None
+    
+    logger.debug("Test database teardown complete")
+
+
+@asynccontextmanager
+async def get_test_session() -> "AsyncGenerator[AsyncSession, None]":
+    """
+    Get a test database session.
+    
+    Yields:
+        Database session
+        
+    Example:
+        async with get_test_session() as session:
+            user = await User.objects.using(session).get(id=1)
+    """
+    if not _test_session_factory:
+        raise RuntimeError("Test database not initialized. Call setup_test_db() first.")
+    
+    session = _test_session_factory()
+    try:
+        yield session
+        await session.commit()
+    except Exception:
+        await session.rollback()
+        raise
+    finally:
+        await session.close()

core/testing/factories.py

@@ -0,0 +1,393 @@
+"""
+Data factories for generating test data.
+
+Provides a factory pattern for creating test instances with fake data.
+
+Usage:
+    # Define a factory
+    class UserFactory(Factory):
+        model = User
+        
+        @classmethod
+        def build(cls, **overrides):
+            return {
+                "email": fake.email(),
+                "name": fake.name(),
+                **overrides,
+            }
+    
+    # Use in tests
+    async def test_user_creation(db):
+        user = await UserFactory.create(db)
+        assert user.id is not None
+        
+        users = await UserFactory.create_batch(db, 5)
+        assert len(users) == 5
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TypeVar, Generic, Any, TYPE_CHECKING
+from uuid import uuid4
+
+if TYPE_CHECKING:
+    from sqlalchemy.ext.asyncio import AsyncSession
+
+logger = logging.getLogger("core.testing")
+
+# Try to import faker, provide fallback
+try:
+    from faker import Faker
+    fake = Faker()
+except ImportError:
+    # Minimal fake data generator if faker not installed
+    class MinimalFaker:
+        """Minimal faker replacement when faker is not installed."""
+        
+        _counter = 0
+        
+        def email(self) -> str:
+            self._counter += 1
+            return f"user{self._counter}@example.com"
+        
+        def name(self) -> str:
+            self._counter += 1
+            return f"User {self._counter}"
+        
+        def first_name(self) -> str:
+            return "John"
+        
+        def last_name(self) -> str:
+            return "Doe"
+        
+        def text(self, max_nb_chars: int = 200) -> str:
+            return "Lorem ipsum dolor sit amet." * (max_nb_chars // 30 + 1)
+        
+        def sentence(self) -> str:
+            return "This is a test sentence."
+        
+        def paragraph(self) -> str:
+            return "This is a test paragraph with multiple sentences. It contains some text for testing purposes."
+        
+        def url(self) -> str:
+            self._counter += 1
+            return f"https://example.com/{self._counter}"
+        
+        def uuid4(self) -> str:
+            return str(uuid4())
+        
+        def random_int(self, min: int = 0, max: int = 9999) -> int:
+            import random
+            return random.randint(min, max)
+        
+        def boolean(self) -> bool:
+            import random
+            return random.choice([True, False])
+        
+        def date_this_year(self) -> str:
+            from datetime import date
+            return date.today().isoformat()
+        
+        def date_time_this_year(self):
+            from datetime import datetime
+            return datetime.now()
+        
+        def company(self) -> str:
+            self._counter += 1
+            return f"Company {self._counter}"
+        
+        def phone_number(self) -> str:
+            self._counter += 1
+            return f"+1-555-{self._counter:04d}"
+        
+        def address(self) -> str:
+            return "123 Test Street, Test City, TC 12345"
+    
+    fake = MinimalFaker()
+    logger.warning(
+        "faker not installed. Using minimal fake data generator. "
+        "Install with: pip install faker"
+    )
+
+
+T = TypeVar("T")
+
+
+class Factory(Generic[T]):
+    """
+    Base factory for creating test instances.
+    
+    Subclass this to create factories for your models.
+    
+    Example:
+        class UserFactory(Factory):
+            model = User
+            
+            @classmethod
+            def build(cls, **overrides):
+                return {
+                    "email": fake.email(),
+                    "name": fake.name(),
+                    "is_active": True,
+                    **overrides,
+                }
+        
+        # Build dict (no database)
+        data = UserFactory.build(name="Custom Name")
+        
+        # Create instance (saves to database)
+        user = await UserFactory.create(db)
+        
+        # Create multiple
+        users = await UserFactory.create_batch(db, 10)
+    
+    Attributes:
+        model: The model class to create instances of
+    """
+    
+    model: type[T]
+    
+    @classmethod
+    def build(cls, **overrides) -> dict[str, Any]:
+        """
+        Build a dict of attributes without saving.
+        
+        Override this method in subclasses to define default values.
+        
+        Args:
+            **overrides: Values to override defaults
+            
+        Returns:
+            Dict of model attributes
+        """
+        raise NotImplementedError(
+            f"{cls.__name__} must implement build() method"
+        )
+    
+    @classmethod
+    async def create(
+        cls,
+        db: "AsyncSession",
+        **overrides,
+    ) -> T:
+        """
+        Create and save an instance to the database.
+        
+        Args:
+            db: Database session
+            **overrides: Values to override defaults
+            
+        Returns:
+            Created model instance
+        """
+        data = cls.build(**overrides)
+        instance = cls.model(**data)
+        
+        db.add(instance)
+        await db.commit()
+        await db.refresh(instance)
+        
+        logger.debug(f"Factory created: {cls.model.__name__}")
+        return instance
+    
+    @classmethod
+    async def create_batch(
+        cls,
+        db: "AsyncSession",
+        count: int,
+        **overrides,
+    ) -> list[T]:
+        """
+        Create multiple instances.
+        
+        Args:
+            db: Database session
+            count: Number of instances to create
+            **overrides: Values to override defaults for all instances
+            
+        Returns:
+            List of created instances
+        """
+        instances = []
+        for _ in range(count):
+            instance = await cls.create(db, **overrides)
+            instances.append(instance)
+        
+        logger.debug(f"Factory created batch: {count} x {cls.model.__name__}")
+        return instances
+    
+    @classmethod
+    def build_batch(cls, count: int, **overrides) -> list[dict[str, Any]]:
+        """
+        Build multiple dicts without saving.
+        
+        Args:
+            count: Number of dicts to build
+            **overrides: Values to override defaults
+            
+        Returns:
+            List of dicts
+        """
+        return [cls.build(**overrides) for _ in range(count)]
+
+
+class UserFactory(Factory):
+    """
+    Factory for creating test users.
+    
+    Works with AbstractUser-based models.
+    
+    Example:
+        # Create user with random data
+        user = await UserFactory.create(db)
+        
+        # Create with specific email
+        admin = await UserFactory.create(db, email="admin@example.com", is_superuser=True)
+        
+        # Create batch
+        users = await UserFactory.create_batch(db, 10)
+    """
+    
+    model: type = None  # Set dynamically
+    _default_password: str = "TestPass123!"
+    
+    @classmethod
+    def _get_model(cls):
+        """Get user model from auth config."""
+        if cls.model is not None:
+            return cls.model
+        
+        try:
+            from core.auth.models import get_user_model
+            return get_user_model()
+        except Exception:
+            pass
+        
+        try:
+            from core.auth.models import AbstractUser
+            return AbstractUser
+        except Exception:
+            raise RuntimeError(
+                "Could not determine User model. "
+                "Set UserFactory.model = YourUserModel"
+            )
+    
+    @classmethod
+    def build(cls, **overrides) -> dict[str, Any]:
+        """Build user data dict."""
+        password = overrides.pop("password", cls._default_password)
+        
+        data = {
+            "email": fake.email(),
+            "is_active": True,
+            "is_superuser": False,
+            "is_staff": False,
+        }
+        data.update(overrides)
+        
+        # Handle password hashing
+        if "password_hash" not in data:
+            try:
+                from core.auth.hashers import get_hasher
+                hasher = get_hasher()
+                data["password_hash"] = hasher.hash(password)
+            except Exception:
+                # Fallback: assume model handles password
+                data["_password"] = password
+        
+        return data
+    
+    @classmethod
+    async def create(
+        cls,
+        db: "AsyncSession",
+        **overrides,
+    ) -> Any:
+        """Create and save a user."""
+        model = cls._get_model()
+        
+        data = cls.build(**overrides)
+        
+        # Handle password separately if model has set_password
+        password = data.pop("_password", None)
+        
+        instance = model(**data)
+        
+        if password and hasattr(instance, "set_password"):
+            instance.set_password(password)
+        
+        db.add(instance)
+        await db.commit()
+        await db.refresh(instance)
+        
+        return instance
+
+
+# Additional common factories
+
+class SequenceFactory:
+    """
+    Generate sequential values for unique fields.
+    
+    Example:
+        seq = SequenceFactory("user_{n}@example.com")
+        seq.next()  # "user_1@example.com"
+        seq.next()  # "user_2@example.com"
+    """
+    
+    def __init__(self, template: str, start: int = 1) -> None:
+        """
+        Initialize sequence.
+        
+        Args:
+            template: String template with {n} placeholder
+            start: Starting number
+        """
+        self.template = template
+        self.counter = start
+    
+    def next(self) -> str:
+        """Get next value in sequence."""
+        value = self.template.format(n=self.counter)
+        self.counter += 1
+        return value
+    
+    def reset(self, start: int = 1) -> None:
+        """Reset counter."""
+        self.counter = start
+
+
+class LazyAttribute:
+    """
+    Lazily compute attribute value.
+    
+    Example:
+        class PostFactory(Factory):
+            model = Post
+            
+            @classmethod
+            def build(cls, **overrides):
+                return {
+                    "title": fake.sentence(),
+                    "slug": LazyAttribute(lambda obj: slugify(obj["title"])),
+                    **overrides,
+                }
+    """
+    
+    def __init__(self, func) -> None:
+        self.func = func
+    
+    def __call__(self, obj: dict) -> Any:
+        return self.func(obj)
+
+
+def resolve_lazy_attributes(data: dict) -> dict:
+    """Resolve any LazyAttribute values in a dict."""
+    result = {}
+    for key, value in data.items():
+        if isinstance(value, LazyAttribute):
+            result[key] = value(data)
+        else:
+            result[key] = value
+    return result