fraiseql-confiture 0.3.4__cp311-cp311-win_amd64.whl

confiture/testing/__init__.py

@@ -0,0 +1,38 @@
+"""Confiture Migration Testing Framework.
+
+Comprehensive testing framework for PostgreSQL migrations including:
+- Mutation testing (27 mutations across 4 categories)
+- Performance profiling with regression detection
+- Load testing with 100k+ row validation
+- Advanced scenario testing
+"""
+
+from confiture.testing.frameworks.mutation import (
+    Mutation,
+    MutationCategory,
+    MutationMetrics,
+    MutationRegistry,
+    MutationReport,
+    MutationRunner,
+    MutationSeverity,
+)
+from confiture.testing.frameworks.performance import (
+    MigrationPerformanceProfiler,
+    PerformanceOptimizationReport,
+    PerformanceProfile,
+)
+
+__all__ = [
+    # Mutation testing
+    "Mutation",
+    "MutationRegistry",
+    "MutationRunner",
+    "MutationReport",
+    "MutationMetrics",
+    "MutationSeverity",
+    "MutationCategory",
+    # Performance testing
+    "MigrationPerformanceProfiler",
+    "PerformanceProfile",
+    "PerformanceOptimizationReport",
+]

confiture/testing/fixtures/__init__.py

@@ -0,0 +1,11 @@
+"""Test fixtures and utilities for Confiture migration testing."""
+
+from confiture.testing.fixtures.data_validator import DataValidator
+from confiture.testing.fixtures.migration_runner import MigrationRunner
+from confiture.testing.fixtures.schema_snapshotter import SchemaSnapshotter
+
+__all__ = [
+    "MigrationRunner",
+    "SchemaSnapshotter",
+    "DataValidator",
+]

confiture/testing/fixtures/data_validator.py

@@ -0,0 +1,229 @@
+"""Data validation utility for migration testing.
+
+Validates data integrity after migrations by checking row counts, constraints,
+and foreign key relationships. Can be extracted to confiture-testing package.
+"""
+
+from dataclasses import dataclass
+
+import psycopg
+from psycopg import sql
+
+
+@dataclass
+class DataBaseline:
+    """Baseline data snapshot before migration."""
+
+    table_row_counts: dict[str, int]
+    foreign_key_violations: int
+    null_violations: int
+    constraint_violations: int
+
+
+class DataValidator:
+    """Validate data integrity after migrations.
+
+    Generic data validation that can be extracted to confiture-testing.
+    """
+
+    def __init__(self, connection: psycopg.Connection):
+        """Initialize data validator.
+
+        Args:
+            connection: PostgreSQL connection for validation queries
+        """
+        self.connection = connection
+
+    def capture_baseline(self) -> DataBaseline:
+        """Capture baseline data state before migration.
+
+        Returns:
+            DataBaseline with row counts and constraint violation status
+        """
+        with self.connection.cursor() as cur:
+            # Get row counts for all tables
+            cur.execute(
+                """
+                SELECT schemaname, relname, n_live_tup
+                FROM pg_stat_user_tables
+                ORDER BY schemaname, relname
+                """
+            )
+            row_counts = {f"{row[0]}.{row[1]}": row[2] for row in cur.fetchall()}
+
+            # Check for FK violations (should be 0)
+            fk_violations = self._count_fk_violations(cur)
+
+            # Check for null violations in NOT NULL columns
+            null_violations = self._count_null_violations(cur)
+
+            # Check for constraint violations
+            constraint_violations = 0  # Placeholder for generic checks
+
+            return DataBaseline(
+                table_row_counts=row_counts,
+                foreign_key_violations=fk_violations,
+                null_violations=null_violations,
+                constraint_violations=constraint_violations,
+            )
+
+    def no_data_loss(self, baseline: DataBaseline, allow_additions: bool = True) -> bool:
+        """Verify no data was lost during migration.
+
+        Args:
+            baseline: Baseline data state before migration
+            allow_additions: If False, reject unexpected data additions
+
+        Returns:
+            True if no data loss detected, False otherwise
+        """
+        current = self.capture_baseline()
+
+        for table, baseline_count in baseline.table_row_counts.items():
+            current_count = current.table_row_counts.get(table, 0)
+
+            if current_count < baseline_count:
+                # Data loss detected
+                return False
+
+            if not allow_additions and current_count > baseline_count:
+                # Unexpected data additions
+                return False
+
+        return True
+
+    def constraints_valid(self) -> bool:
+        """Verify all constraints are valid after migration.
+
+        Returns:
+            True if all constraints valid, False otherwise
+        """
+        with self.connection.cursor() as cur:
+            # Check FK violations
+            if self._count_fk_violations(cur) > 0:
+                return False
+
+            # Check NULL violations
+            return self._count_null_violations(cur) == 0
+
+    def validate_indexes(self) -> list[str]:
+        """Validate all indexes are valid and not broken.
+
+        Returns:
+            List of invalid index names (empty if all valid)
+        """
+        with self.connection.cursor() as cur:
+            cur.execute(
+                """
+                SELECT schemaname, tablename, indexname
+                FROM pg_indexes
+                WHERE indexdef IS NULL OR indexdef ~ 'INVALID'
+                """
+            )
+            invalid_indexes = [f"{row[0]}.{row[1]}.{row[2]}" for row in cur.fetchall()]
+
+            return invalid_indexes
+
+    def get_row_count(self, table_name: str) -> int:
+        """Get current row count for a specific table.
+
+        Args:
+            table_name: Fully qualified table name (schema.table)
+
+        Returns:
+            Number of rows in the table
+        """
+        try:
+            with self.connection.cursor() as cur:
+                # Handle schema.table format
+                if "." in table_name:
+                    schema, table = table_name.split(".", 1)
+                    cur.execute(
+                        sql.SQL("SELECT COUNT(*) FROM {}.{}").format(
+                            sql.Identifier(schema),
+                            sql.Identifier(table),
+                        )
+                    )
+                else:
+                    cur.execute(
+                        sql.SQL("SELECT COUNT(*) FROM {}").format(sql.Identifier(table_name))
+                    )
+                row = cur.fetchone()
+                return row[0] if row else 0
+        except Exception:
+            return 0
+
+    def _count_fk_violations(self, cur: psycopg.Cursor) -> int:
+        """Count foreign key constraint violations.
+
+        Args:
+            cur: Database cursor
+
+        Returns:
+            Number of FK constraints that are not validated
+        """
+        try:
+            cur.execute(
+                """
+                SELECT COUNT(*)
+                FROM pg_constraint
+                WHERE contype = 'f'
+                  AND convalidated = false
+                """
+            )
+            row = cur.fetchone()
+            return row[0] if row else 0
+        except Exception:
+            # If query fails, assume no violations (constraint might not exist)
+            return 0
+
+    def _count_null_violations(self, _cur: psycopg.Cursor) -> int:
+        """Count NULL violations in NOT NULL columns.
+
+        This is a simplified check - in production you'd want to check each column.
+
+        Args:
+            _cur: Database cursor (unused in simplified implementation)
+
+        Returns:
+            Number of NULL violations detected (simplified to 0 for now)
+        """
+        # Simplified implementation - would need to check each NOT NULL column
+        # to find actual violations. For now, return 0.
+        return 0
+
+    def check_foreign_key_integrity(self, table_name: str, _fk_column: str) -> bool:
+        """Check if foreign key values in a column all have valid references.
+
+        Args:
+            table_name: Table to check (schema.table format)
+            _fk_column: Foreign key column name (unused in simplified implementation)
+
+        Returns:
+            True if all FK values are valid, False otherwise
+        """
+        try:
+            with self.connection.cursor() as cur:
+                # Get the table and column info
+                cur.execute(
+                    """
+                    SELECT constraint_name, confrelid::regclass, confkey
+                    FROM pg_constraint
+                    WHERE contype = 'f'
+                      AND conrelid = %s::regclass
+                    """,
+                    (table_name,),
+                )
+                fk_info = cur.fetchone()
+
+                if not fk_info:
+                    # No foreign key constraint found
+                    return True
+
+                # Simple check: just verify the constraint is valid
+                # More detailed check would require analyzing actual data
+                return True
+
+        except Exception:
+            # If validation fails, assume it's valid (prefer false negatives)
+            return True

confiture/testing/fixtures/migration_runner.py

@@ -0,0 +1,167 @@
+"""Migration execution utility for testing.
+
+Wraps confiture migrations to provide structured test results and execution
+tracking for PrintOptim's migration test suite.
+"""
+
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+import psycopg
+
+
+@dataclass
+class MigrationResult:
+    """Result of a migration execution."""
+
+    success: bool
+    migration_file: str
+    duration_seconds: float
+    stdout: str
+    stderr: str
+    error: Exception | None = None
+
+
+class MigrationRunner:
+    """Execute migrations in test environment using confiture.
+
+    This wraps confiture's Migrator to provide test utilities for:
+    - Executing migrations with timing
+    - Capturing structured results
+    - Supporting dry-run mode
+    - Tracking rollbacks
+    """
+
+    def __init__(self, connection: psycopg.Connection, migrations_dir: Path | None = None):
+        """Initialize migration runner.
+
+        Args:
+            connection: PostgreSQL connection for migration execution
+            migrations_dir: Path to migrations directory (default: db/migrations)
+        """
+        self.connection = connection
+        self.migrations_dir = migrations_dir or (
+            Path(__file__).parent.parent.parent.parent.parent / "db" / "migrations"
+        )
+
+    def run(self, migration_name: str, dry_run: bool = False) -> MigrationResult:
+        """Execute a migration.
+
+        Args:
+            migration_name: Name without extension (e.g., "002_add_floor_plan")
+            dry_run: If True, only show what would be executed
+
+        Returns:
+            MigrationResult with execution details
+        """
+        migration_file = self.migrations_dir / f"{migration_name}.sql"
+
+        if not migration_file.exists():
+            raise FileNotFoundError(f"Migration not found: {migration_file}")
+
+        start_time = time.time()
+
+        try:
+            if dry_run:
+                # Parse SQL but don't execute
+                with open(migration_file) as f:
+                    sql = f.read()
+                return MigrationResult(
+                    success=True,
+                    migration_file=str(migration_file),
+                    duration_seconds=0,
+                    stdout=f"DRY-RUN: Would execute migration {migration_name}\n"
+                    f"SQL preview (first 500 chars):\n{sql[:500]}...",
+                    stderr="",
+                )
+
+            # Execute migration within a transaction
+            with self.connection.cursor() as cur:
+                with open(migration_file) as f:
+                    sql = f.read()
+
+                # Execute the migration SQL
+                cur.execute(sql)
+                self.connection.commit()
+
+            duration = time.time() - start_time
+
+            return MigrationResult(
+                success=True,
+                migration_file=str(migration_file),
+                duration_seconds=duration,
+                stdout=f"✓ Migration {migration_name} executed successfully in {duration:.3f}s",
+                stderr="",
+            )
+
+        except Exception as e:
+            duration = time.time() - start_time
+            self.connection.rollback()
+
+            return MigrationResult(
+                success=False,
+                migration_file=str(migration_file),
+                duration_seconds=duration,
+                stdout="",
+                stderr=str(e),
+                error=e,
+            )
+
+    def rollback(self, migration_name: str) -> MigrationResult:
+        """Execute rollback for a migration.
+
+        Args:
+            migration_name: Name without _rollback suffix (e.g., "002_add_floor_plan")
+
+        Returns:
+            MigrationResult with execution details
+        """
+        rollback_file = self.migrations_dir / f"{migration_name}_rollback.sql"
+
+        if not rollback_file.exists():
+            raise FileNotFoundError(f"Rollback not found: {rollback_file}")
+
+        # Execute rollback (same logic as run)
+        return self.run(f"{migration_name}_rollback")
+
+    def get_applied_migrations(self) -> list[str]:
+        """Get list of applied migrations from confiture tracking table.
+
+        Returns:
+            List of migration slugs that have been applied
+        """
+        try:
+            with self.connection.cursor() as cur:
+                cur.execute(
+                    """
+                    SELECT slug
+                    FROM confiture_migrations
+                    ORDER BY applied_at ASC
+                    """
+                )
+                return [row[0] for row in cur.fetchall()]
+        except Exception:
+            # Table doesn't exist yet or other error - return empty list
+            return []
+
+    def get_pending_migrations(self) -> list[str]:
+        """Get list of pending migrations not yet applied.
+
+        Returns:
+            List of migration file names (without .sql) that haven't been applied
+        """
+        applied = self.get_applied_migrations()
+        applied_set = set(applied)
+
+        # Find all migration files (not rollbacks)
+        migration_files = sorted(
+            [
+                f.stem
+                for f in self.migrations_dir.glob("*.sql")
+                if not f.name.endswith("_rollback.sql") and f.name[0].isdigit()
+            ]
+        )
+
+        # Return only those not yet applied
+        return [m for m in migration_files if m not in applied_set]