fixturify 0.1.9__py3-none-any.whl

fixturify/sql_d/_strategies/_aiomysql.py

@@ -0,0 +1,63 @@
+"""Strategy for aiomysql (MySQL async) driver."""
+
+from typing import Any, TYPE_CHECKING
+
+from ._base import AsyncSqlExecutionStrategy
+
+if TYPE_CHECKING:
+    from .._config import SqlTestConfig
+
+
+class AiomysqlStrategy(AsyncSqlExecutionStrategy):
+    """Execution strategy for aiomysql (MySQL async)."""
+
+    driver_name = "aiomysql"
+    is_async = True
+    default_port = 3306
+    param_mapping = {
+        "host": "host",
+        "database": "db",
+        "user": "user",
+        "password": "password",
+        "port": "port",
+    }
+
+    async def execute_async(self, sql_content: str, config: "SqlTestConfig") -> None:
+        """Execute SQL using aiomysql."""
+        driver = self.get_driver_module()
+        params = self.build_connection_params(config)
+        
+        connection = await driver.connect(**params)
+        try:
+            async with connection.cursor() as cursor:
+                # aiomysql doesn't support multi-statement by default
+                await self._execute_statements(cursor, sql_content)
+            await connection.commit()
+        finally:
+            connection.close()
+            if hasattr(connection, "wait_closed"):
+                await connection.wait_closed()
+
+    async def _execute_statements(self, cursor: Any, sql_content: str) -> None:
+        """
+        Execute multiple SQL statements for aiomysql.
+
+        aiomysql doesn't execute multiple statements by default.
+        We split by semicolon and execute each statement separately.
+
+        Args:
+            cursor: Async database cursor
+            sql_content: SQL content with potentially multiple statements
+        """
+        statements = [s.strip() for s in sql_content.split(";") if s.strip()]
+        for statement in statements:
+            # Skip comments-only statements
+            if statement.startswith("--") and "\n" not in statement:
+                continue
+            await cursor.execute(statement)
+            # Consume any results to avoid unread result issues
+            try:
+                await cursor.fetchall()
+            except Exception:
+                # No results to fetch (e.g., INSERT, UPDATE, DELETE, DDL)
+                pass

fixturify/sql_d/_strategies/_aiosqlite.py

@@ -0,0 +1,29 @@
+"""Strategy for aiosqlite (SQLite async) driver."""
+
+from typing import TYPE_CHECKING
+
+from ._base import AsyncSqlExecutionStrategy
+
+if TYPE_CHECKING:
+    from .._config import SqlTestConfig
+
+
+class AiosqliteStrategy(AsyncSqlExecutionStrategy):
+    """Execution strategy for aiosqlite (SQLite async)."""
+
+    driver_name = "aiosqlite"
+    is_async = True
+    default_port = 0  # SQLite doesn't use ports
+    param_mapping = {
+        "database": "database",
+    }
+
+    async def execute_async(self, sql_content: str, config: "SqlTestConfig") -> None:
+        """Execute SQL using aiosqlite."""
+        driver = self.get_driver_module()
+        params = self.build_connection_params(config)
+        
+        database_path = params.get("database", ":memory:")
+        async with driver.connect(database_path) as connection:
+            await connection.executescript(sql_content)
+            await connection.commit()

fixturify/sql_d/_strategies/_asyncpg.py

@@ -0,0 +1,34 @@
+"""Strategy for asyncpg (PostgreSQL async) driver."""
+
+from typing import TYPE_CHECKING
+
+from ._base import AsyncSqlExecutionStrategy
+
+if TYPE_CHECKING:
+    from .._config import SqlTestConfig
+
+
+class AsyncpgStrategy(AsyncSqlExecutionStrategy):
+    """Execution strategy for asyncpg (PostgreSQL async)."""
+
+    driver_name = "asyncpg"
+    is_async = True
+    default_port = 5432
+    param_mapping = {
+        "host": "host",
+        "database": "database",
+        "user": "user",
+        "password": "password",
+        "port": "port",
+    }
+
+    async def execute_async(self, sql_content: str, config: "SqlTestConfig") -> None:
+        """Execute SQL using asyncpg."""
+        driver = self.get_driver_module()
+        params = self.build_connection_params(config)
+        
+        connection = await driver.connect(**params)
+        try:
+            await connection.execute(sql_content)
+        finally:
+            await connection.close()

fixturify/sql_d/_strategies/_base.py

@@ -0,0 +1,118 @@
+"""Base classes for SQL execution strategies."""
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .._config import SqlTestConfig
+
+
+class SqlExecutionStrategy(ABC):
+    """
+    Abstract base class for synchronous SQL execution strategies.
+
+    Each strategy handles execution for a specific database driver.
+    Strategies encapsulate driver-specific behavior like:
+    - Connection handling
+    - Multi-statement execution
+    - Error handling
+    """
+
+    # Driver name (used for registration)
+    driver_name: str = ""
+
+    # Whether this is an async strategy
+    is_async: bool = False
+
+    # Default port for this driver
+    default_port: int = 0
+
+    # Parameter name mapping from SqlTestConfig to driver-specific names
+    param_mapping: Dict[str, str] = {}
+
+    @abstractmethod
+    def execute(self, sql_content: str, config: "SqlTestConfig") -> None:
+        """
+        Execute SQL content against the database.
+
+        Args:
+            sql_content: SQL statements to execute
+            config: Database connection configuration
+        """
+        pass
+
+    def build_connection_params(self, config: "SqlTestConfig") -> Dict[str, Any]:
+        """
+        Build connection parameters for this driver.
+
+        Args:
+            config: Database connection configuration
+
+        Returns:
+            Dictionary of driver-specific connection parameters
+        """
+        params: Dict[str, Any] = {}
+
+        if "host" in self.param_mapping:
+            params[self.param_mapping["host"]] = config.host
+
+        if "database" in self.param_mapping:
+            params[self.param_mapping["database"]] = config.database
+
+        if "user" in self.param_mapping:
+            params[self.param_mapping["user"]] = config.user
+
+        if "password" in self.param_mapping:
+            params[self.param_mapping["password"]] = config.password
+
+        if "port" in self.param_mapping:
+            port = config.port or self.default_port
+            if port:  # Skip if port is 0 (e.g., SQLite)
+                params[self.param_mapping["port"]] = port
+
+        return params
+
+    def get_driver_module(self) -> Any:
+        """
+        Import and return the driver module.
+
+        Returns:
+            The imported driver module
+
+        Raises:
+            ImportError: If driver is not installed
+        """
+        import importlib
+
+        try:
+            return importlib.import_module(self.driver_name)
+        except ImportError as e:
+            raise ImportError(
+                f"Database driver '{self.driver_name}' is not installed. "
+                f"Install it with: pip install {self.driver_name}"
+            ) from e
+
+
+class AsyncSqlExecutionStrategy(SqlExecutionStrategy):
+    """
+    Abstract base class for asynchronous SQL execution strategies.
+    """
+
+    is_async: bool = True
+
+    @abstractmethod
+    async def execute_async(self, sql_content: str, config: "SqlTestConfig") -> None:
+        """
+        Execute SQL content against the database asynchronously.
+
+        Args:
+            sql_content: SQL statements to execute
+            config: Database connection configuration
+        """
+        pass
+
+    def execute(self, sql_content: str, config: "SqlTestConfig") -> None:
+        """Sync execute - raises error for async strategies."""
+        raise RuntimeError(
+            f"Strategy {self.driver_name} is async. Use execute_async() instead."
+        )

fixturify/sql_d/_strategies/_mysql.py

@@ -0,0 +1,70 @@
+"""Strategy for mysql.connector (MySQL) driver."""
+
+from typing import Any, TYPE_CHECKING
+
+from ._base import SqlExecutionStrategy
+
+if TYPE_CHECKING:
+    from .._config import SqlTestConfig
+
+
+class MysqlConnectorStrategy(SqlExecutionStrategy):
+    """Execution strategy for mysql.connector (MySQL)."""
+
+    driver_name = "mysql.connector"
+    is_async = False
+    default_port = 3306
+    param_mapping = {
+        "host": "host",
+        "database": "database",
+        "user": "user",
+        "password": "password",
+        "port": "port",
+    }
+
+    def execute(self, sql_content: str, config: "SqlTestConfig") -> None:
+        """Execute SQL using mysql.connector."""
+        driver = self.get_driver_module()
+        params = self.build_connection_params(config)
+        
+        connection = driver.connect(**params)
+        try:
+            cursor = connection.cursor()
+            try:
+                # MySQL connector doesn't support multi-statement by default
+                self._execute_statements(cursor, sql_content, driver)
+                connection.commit()
+            finally:
+                cursor.close()
+        finally:
+            connection.close()
+
+    def _execute_statements(self, cursor: Any, sql_content: str, driver: Any) -> None:
+        """
+        Execute multiple SQL statements for MySQL.
+
+        MySQL connector doesn't execute multiple statements by default.
+        We split by semicolon and execute each statement separately.
+
+        **Limitations:**
+        - This naive splitting breaks with semicolons inside string literals
+        - Stored procedures with DELIMITER changes are not supported
+        - Multi-line comments containing semicolons may cause issues
+
+        Args:
+            cursor: Database cursor
+            sql_content: SQL content with potentially multiple statements
+            driver: The mysql.connector module
+        """
+        statements = [s.strip() for s in sql_content.split(";") if s.strip()]
+        for statement in statements:
+            # Skip comments-only statements
+            if statement.startswith("--") and "\n" not in statement:
+                continue
+            cursor.execute(statement)
+            # Consume any results to avoid "Unread result found" error
+            try:
+                cursor.fetchall()
+            except driver.errors.InterfaceError:
+                # No results to fetch (e.g., INSERT, UPDATE, DELETE, DDL)
+                pass

fixturify/sql_d/_strategies/_psycopg.py

@@ -0,0 +1,35 @@
+"""Strategy for psycopg (PostgreSQL async) driver."""
+
+from typing import TYPE_CHECKING
+
+from ._base import AsyncSqlExecutionStrategy
+
+if TYPE_CHECKING:
+    from .._config import SqlTestConfig
+
+
+class PsycopgStrategy(AsyncSqlExecutionStrategy):
+    """Execution strategy for psycopg (PostgreSQL async)."""
+
+    driver_name = "psycopg"
+    is_async = True
+    default_port = 5432
+    param_mapping = {
+        "host": "host",
+        "database": "dbname",
+        "user": "user",
+        "password": "password",
+        "port": "port",
+    }
+
+    async def execute_async(self, sql_content: str, config: "SqlTestConfig") -> None:
+        """Execute SQL using psycopg async connection."""
+        driver = self.get_driver_module()
+        params = self.build_connection_params(config)
+
+        connection = await driver.AsyncConnection.connect(**params)
+        try:
+            await connection.execute(sql_content)
+            await connection.commit()
+        finally:
+            await connection.close()

fixturify/sql_d/_strategies/_psycopg2.py

@@ -0,0 +1,40 @@
+"""Strategy for psycopg2 (PostgreSQL) driver."""
+
+from typing import TYPE_CHECKING
+
+from ._base import SqlExecutionStrategy
+
+if TYPE_CHECKING:
+    from .._config import SqlTestConfig
+
+
+class Psycopg2Strategy(SqlExecutionStrategy):
+    """Execution strategy for psycopg2 (PostgreSQL)."""
+
+    driver_name = "psycopg2"
+    is_async = False
+    default_port = 5432
+    param_mapping = {
+        "host": "host",
+        "database": "dbname",
+        "user": "user",
+        "password": "password",
+        "port": "port",
+    }
+
+    def execute(self, sql_content: str, config: "SqlTestConfig") -> None:
+        """Execute SQL using psycopg2."""
+        driver = self.get_driver_module()
+        params = self.build_connection_params(config)
+        
+        connection = driver.connect(**params)
+        try:
+            cursor = connection.cursor()
+            try:
+                # psycopg2 supports multi-statement execution
+                cursor.execute(sql_content)
+                connection.commit()
+            finally:
+                cursor.close()
+        finally:
+            connection.close()

fixturify/sql_d/_strategies/_registry.py

@@ -0,0 +1,109 @@
+"""Registry for SQL execution strategies."""
+
+from typing import Dict, Optional, Type
+
+from ._base import SqlExecutionStrategy
+
+
+class StrategyRegistry:
+    """
+    Registry for SQL execution strategies.
+
+    Maps driver names to strategy classes.
+    """
+
+    def __init__(self):
+        """Initialize empty registry."""
+        self._strategies: Dict[str, SqlExecutionStrategy] = {}
+        self._strategy_classes: Dict[str, Type[SqlExecutionStrategy]] = {}
+
+    def register(self, strategy_class: Type[SqlExecutionStrategy]) -> None:
+        """
+        Register a strategy class.
+
+        Args:
+            strategy_class: The strategy class to register.
+        """
+        name = strategy_class.driver_name
+        if not name:
+            raise ValueError(f"Strategy class {strategy_class} has no driver_name")
+        self._strategy_classes[name] = strategy_class
+
+    def get(self, driver_name: str) -> Optional[SqlExecutionStrategy]:
+        """
+        Get a strategy instance by driver name.
+
+        Args:
+            driver_name: The driver name.
+
+        Returns:
+            Strategy instance or None if not registered.
+        """
+        if driver_name not in self._strategies:
+            if driver_name in self._strategy_classes:
+                self._strategies[driver_name] = self._strategy_classes[driver_name]()
+        return self._strategies.get(driver_name)
+
+    def get_or_raise(self, driver_name: str) -> SqlExecutionStrategy:
+        """
+        Get a strategy instance, raising if not found.
+
+        Args:
+            driver_name: The driver name.
+
+        Returns:
+            Strategy instance.
+
+        Raises:
+            ValueError: If driver is not registered.
+        """
+        strategy = self.get(driver_name)
+        if strategy is None:
+            available = ", ".join(self._strategy_classes.keys())
+            raise ValueError(
+                f"Unsupported driver: {driver_name}. "
+                f"Available drivers: {available}"
+            )
+        return strategy
+
+    def is_async(self, driver_name: str) -> bool:
+        """Check if a driver uses async execution."""
+        strategy = self.get(driver_name)
+        return strategy.is_async if strategy else False
+
+
+# Global registry instance
+_registry: Optional[StrategyRegistry] = None
+
+
+def get_strategy_registry() -> StrategyRegistry:
+    """
+    Get the global strategy registry, initializing if needed.
+
+    Returns:
+        The global StrategyRegistry instance.
+    """
+    global _registry
+    if _registry is None:
+        _registry = StrategyRegistry()
+        _register_default_strategies(_registry)
+    return _registry
+
+
+def _register_default_strategies(registry: StrategyRegistry) -> None:
+    """Register all built-in strategies."""
+    from ._psycopg2 import Psycopg2Strategy
+    from ._psycopg import PsycopgStrategy
+    from ._mysql import MysqlConnectorStrategy
+    from ._sqlite import Sqlite3Strategy
+    from ._asyncpg import AsyncpgStrategy
+    from ._aiomysql import AiomysqlStrategy
+    from ._aiosqlite import AiosqliteStrategy
+
+    registry.register(Psycopg2Strategy)
+    registry.register(PsycopgStrategy)
+    registry.register(MysqlConnectorStrategy)
+    registry.register(Sqlite3Strategy)
+    registry.register(AsyncpgStrategy)
+    registry.register(AiomysqlStrategy)
+    registry.register(AiosqliteStrategy)

fixturify/sql_d/_strategies/_sqlite.py

@@ -0,0 +1,33 @@
+"""Strategy for sqlite3 driver."""
+
+from typing import TYPE_CHECKING
+
+from ._base import SqlExecutionStrategy
+
+if TYPE_CHECKING:
+    from .._config import SqlTestConfig
+
+
+class Sqlite3Strategy(SqlExecutionStrategy):
+    """Execution strategy for sqlite3."""
+
+    driver_name = "sqlite3"
+    is_async = False
+    default_port = 0  # SQLite doesn't use ports
+    param_mapping = {
+        "database": "database",
+    }
+
+    def execute(self, sql_content: str, config: "SqlTestConfig") -> None:
+        """Execute SQL using sqlite3."""
+        driver = self.get_driver_module()
+        params = self.build_connection_params(config)
+        
+        database_path = params.get("database", ":memory:")
+        connection = driver.connect(database_path)
+        try:
+            # SQLite supports executescript for multi-statement execution
+            connection.executescript(sql_content)
+            connection.commit()
+        finally:
+            connection.close()

fixturify-0.1.9.dist-info/METADATA

@@ -0,0 +1,122 @@
+Metadata-Version: 2.4
+Name: fixturify
+Version: 0.1.9
+Summary: A collection of convenient testing utilities for Python
+Project-URL: Homepage, https://github.com/eleven-sea/pytools
+Project-URL: Repository, https://github.com/eleven-sea/pytools
+Project-URL: Issues, https://github.com/eleven-sea/pytools/issues
+Author: eleven-sea
+License-Expression: MIT
+Keywords: fixtures,json,mocking,pytest,sql,testing
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Pytest
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.10
+Requires-Dist: deepdiff>=6.0
+Description-Content-Type: text/markdown
+
+# pytools
+
+A collection of Python testing utilities.
+
+## Installation
+
+```bash
+pip install fixturify
+```
+
+## Modules
+
+| Module | Description | Docs |
+|--------|-------------|------|
+| [sql](docs/sql.md) | Execute SQL files before/after tests | [docs/sql.md](docs/sql.md) |
+| [read](docs/read.md) | Inject JSON fixtures into test functions | [docs/read.md](docs/read.md) |
+| [http](docs/http.md) | Record and replay HTTP calls | [docs/http.md](docs/http.md) |
+| [JsonAssert](docs/json_assert.md) | Compare objects to JSON files | [docs/json_assert.md](docs/json_assert.md) |
+| [ObjectMapper](docs/object_mapper.md) | Bidirectional object-JSON mapping | [docs/object_mapper.md](docs/object_mapper.md) |
+
+## Quick examples
+
+### sql
+
+```python
+from fixturify import sql, Phase
+
+@sql(path="./setup.sql")
+@sql(path="./cleanup.sql", phase=Phase.AFTER)
+def test_database():
+    # SQL executed before and after test
+    pass
+```
+
+### read
+
+```python
+from fixturify import read
+
+@read.fixture(path="./fixtures/user.json", fixture_name="user", object_class=User)
+def test_user(user: User):
+    assert user.name == "John"
+```
+
+### http
+
+```python
+from fixturify import http
+
+@http(path="./fixtures/api.json")
+def test_api():
+    # First run: records HTTP calls
+    # Next runs: replays from file
+    response = requests.get("https://api.example.com/users")
+    assert response.status_code == 200
+```
+
+### JsonAssert
+
+```python
+from fixturify import JsonAssert
+
+def test_response():
+    data = {"name": "John", "age": 30}
+    JsonAssert(data).ignore("age").compare_to_file("./expected.json")
+```
+
+### ObjectMapper
+
+```python
+from fixturify import ObjectMapper
+
+# Object to JSON
+user = User(name="John", age=30)
+data = ObjectMapper(user).to_json()
+
+# JSON to object
+data = {"name": "John", "age": 30}
+user = ObjectMapper(data).to_object(User)
+```
+
+## Public API
+
+```python
+from fixturify import (
+    # Decorators
+    sql,
+    read,
+    http,
+    # Enums
+    Phase,
+    # Config
+    SqlTestConfig,
+    HttpTestConfig,
+    # Classes
+    JsonAssert,
+    ObjectMapper,
+)
+```