pytest-mrt 0.1.0__py3-none-any.whl

pytest_mrt/__init__.py

@@ -0,0 +1,4 @@
+from .config import MRTConfig
+
+__version__ = "0.1.0"
+__all__ = ["MRTConfig"]

pytest_mrt/cli.py

@@ -0,0 +1,63 @@
+import typer
+from rich.console import Console
+from rich.table import Table
+from rich import box
+
+from . import __version__
+from .core.detector import analyze_migrations
+
+app = typer.Typer(
+    name="mrt",
+    help="MRT — Migration Rollback Tester",
+    no_args_is_help=True,
+)
+console = Console()
+
+
+@app.command("version")
+def version_cmd() -> None:
+    """Show version."""
+    console.print(f"pytest-mrt {__version__}")
+
+
+def _severity_color(s: str) -> str:
+    return "red" if s == "error" else "yellow"
+
+
+@app.command("check")
+def check(
+    versions_dir: str = typer.Argument(help="Path to Alembic versions directory"),
+    strict: bool = typer.Option(False, "--strict", help="Exit 1 on warnings too"),
+) -> None:
+    """Statically analyze migrations for rollback risk patterns."""
+    warnings = analyze_migrations(versions_dir)
+
+    if not warnings:
+        console.print("[green]✓ No rollback risks detected.[/green]")
+        raise typer.Exit(0)
+
+    errors = [w for w in warnings if w.severity == "error"]
+    warns = [w for w in warnings if w.severity == "warning"]
+
+    table = Table(box=box.ROUNDED, title="Rollback Risk Analysis", show_lines=True)
+    table.add_column("Revision", style="cyan", no_wrap=True)
+    table.add_column("Pattern", no_wrap=True)
+    table.add_column("Sev", no_wrap=True)
+    table.add_column("Message")
+
+    for w in warnings:
+        c = _severity_color(w.severity)
+        table.add_row(w.revision, w.pattern, f"[{c}]{w.severity}[/{c}]", w.message)
+
+    console.print(table)
+    console.print()
+
+    if errors:
+        console.print(f"[red]{len(errors)} error(s)[/red], [yellow]{len(warns)} warning(s)[/yellow]")
+        raise typer.Exit(1)
+    elif warns and strict:
+        console.print(f"[yellow]{len(warns)} warning(s)[/yellow] (--strict mode)")
+        raise typer.Exit(1)
+    else:
+        console.print(f"[yellow]{len(warns)} warning(s)[/yellow] — review before deploying")
+        raise typer.Exit(0)

pytest_mrt/config.py

@@ -0,0 +1,8 @@
+from dataclasses import dataclass, field
+
+
+@dataclass
+class MRTConfig:
+    alembic_ini: str = "alembic.ini"
+    db_url: str = ""
+    seed_rows: int = 10

pytest_mrt/core/detector.py

@@ -0,0 +1,259 @@
+from __future__ import annotations
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass
+class RiskWarning:
+    revision: str
+    file: str
+    pattern: str
+    message: str
+    severity: str  # "error" | "warning"
+
+
+# ──────────────────────────────────────────────
+# helpers
+# ──────────────────────────────────────────────
+
+def _fn_body(source: str, fn_name: str) -> str:
+    """Extract the body of a top-level function."""
+    m = re.search(
+        rf"def {fn_name}\s*\([^)]*\)\s*(?:->.*?)?\s*:\s*\n((?:[ \t]+[^\n]*\n?)*)",
+        source,
+    )
+    return m.group(1) if m else ""
+
+
+def _upgrade_body(source: str) -> str:
+    return _fn_body(source, "upgrade")
+
+
+def _downgrade_body(source: str) -> str:
+    return _fn_body(source, "downgrade")
+
+
+def _is_noop(body: str) -> bool:
+    stripped = body.strip()
+    return stripped in ("", "pass") or stripped.startswith("pass\n")
+
+
+# ──────────────────────────────────────────────
+# individual checks
+# ──────────────────────────────────────────────
+
+def _check_downgrade_exists(source: str, rev: str, fname: str) -> list[RiskWarning]:
+    if not re.search(r"def downgrade\s*\(", source):
+        return [RiskWarning(rev, fname, "Missing downgrade",
+                            "No downgrade() function — migration is permanently irreversible", "error")]
+    return []
+
+
+def _check_noop_downgrade(source: str, rev: str, fname: str) -> list[RiskWarning]:
+    body = _downgrade_body(source)
+    if body and _is_noop(body):
+        return [RiskWarning(rev, fname, "No-op downgrade",
+                            "downgrade() body is `pass` — migration is irreversible", "error")]
+    return []
+
+
+def _check_drop_column_in_upgrade(source: str, rev: str, fname: str) -> list[RiskWarning]:
+    if re.search(r"op\.drop_column\s*\(", _upgrade_body(source)):
+        return [RiskWarning(rev, fname, "DROP COLUMN in upgrade",
+                            "Column dropped in upgrade — data is permanently lost on rollback", "error")]
+    return []
+
+
+def _check_drop_table_in_upgrade(source: str, rev: str, fname: str) -> list[RiskWarning]:
+    if re.search(r"op\.drop_table\s*\(", _upgrade_body(source)):
+        return [RiskWarning(rev, fname, "DROP TABLE in upgrade",
+                            "Table dropped in upgrade — all data is permanently lost on rollback", "error")]
+    return []
+
+
+def _check_truncate(source: str, rev: str, fname: str) -> list[RiskWarning]:
+    body = _upgrade_body(source)
+    if re.search(r"TRUNCATE\s+", body, re.IGNORECASE):
+        return [RiskWarning(rev, fname, "TRUNCATE",
+                            "TRUNCATE in upgrade destroys data — cannot be rolled back", "error")]
+    return []
+
+
+def _check_run_python_no_reverse(source: str, rev: str, fname: str) -> list[RiskWarning]:
+    warnings = []
+    for m in re.finditer(r"op\.execute\s*\(.*?run_module|op\.run_async\s*\([^)]+\)", source, re.DOTALL):
+        if "reverse_func" not in m.group(0):
+            warnings.append(RiskWarning(rev, fname, "RunPython without reverse",
+                                        "Data transformation has no reverse_func — cannot undo", "error"))
+            break
+    # Also check bulk execute_if patterns
+    return warnings
+
+
+def _check_not_null_no_default(source: str, rev: str, fname: str) -> list[RiskWarning]:
+    warnings = []
+    body = _upgrade_body(source)
+    for m in re.finditer(r"op\.add_column\s*\(([^)]+)\)", body, re.DOTALL):
+        col_expr = m.group(1)
+        has_nullable_false = re.search(r"nullable\s*=\s*False", col_expr)
+        has_server_default = re.search(r"server_default\s*=", col_expr)
+        if has_nullable_false and not has_server_default:
+            warnings.append(RiskWarning(
+                rev, fname, "NOT NULL without default",
+                "ADD NOT NULL column without server_default — will fail on non-empty tables "
+                "and rollback may leave column in invalid state",
+                "warning",
+            ))
+    return warnings
+
+
+def _check_column_type_change(source: str, rev: str, fname: str) -> list[RiskWarning]:
+    warnings = []
+    body = _upgrade_body(source)
+    for m in re.finditer(r"op\.alter_column\s*\([^)]+type_\s*=", body, re.DOTALL):
+        warnings.append(RiskWarning(
+            rev, fname, "Column type change",
+            "Type change may be destructive — verify downgrade restores original type "
+            "and existing data survives conversion",
+            "warning",
+        ))
+        break
+    return warnings
+
+
+def _check_column_size_shrink(source: str, rev: str, fname: str) -> list[RiskWarning]:
+    body = _upgrade_body(source)
+    # Look for VARCHAR/String with smaller length
+    for m in re.finditer(
+        r"op\.alter_column\s*\([^)]+(?:VARCHAR|String)\s*\(\s*(\d+)\s*\)", body, re.DOTALL | re.IGNORECASE
+    ):
+        return [RiskWarning(
+            rev, fname, "Column size change",
+            f"Column resized to {m.group(1)} chars — data exceeding new limit will be truncated on rollback",
+            "warning",
+        )]
+    return []
+
+
+def _check_raw_execute(source: str, rev: str, fname: str) -> list[RiskWarning]:
+    body = _upgrade_body(source)
+    if re.search(r"op\.execute\s*\(", body):
+        return [RiskWarning(
+            rev, fname, "Raw SQL (op.execute)",
+            "op.execute() with raw SQL — manually verify downgrade correctly reverses this",
+            "warning",
+        )]
+    return []
+
+
+def _check_data_migration_no_reverse(source: str, rev: str, fname: str) -> list[RiskWarning]:
+    """Detect bulk data transforms (UPDATE ... SET) in upgrade without reverse."""
+    body = _upgrade_body(source)
+    dg_body = _downgrade_body(source)
+    if re.search(r"UPDATE\s+\w+\s+SET", body, re.IGNORECASE):
+        if not re.search(r"UPDATE\s+\w+\s+SET", dg_body, re.IGNORECASE):
+            return [RiskWarning(
+                rev, fname, "Data transform without reverse",
+                "Bulk UPDATE in upgrade but not in downgrade — data transformation is one-way",
+                "warning",
+            )]
+    return []
+
+
+def _check_cascade_delete(source: str, rev: str, fname: str) -> list[RiskWarning]:
+    if re.search(r"ondelete\s*=\s*['\"]CASCADE['\"]|ON DELETE CASCADE", _upgrade_body(source), re.IGNORECASE):
+        return [RiskWarning(
+            rev, fname, "CASCADE DELETE",
+            "FK with ON DELETE CASCADE added — child rows will be silently deleted if parent is deleted",
+            "warning",
+        )]
+    return []
+
+
+def _check_index_without_concurrently(source: str, rev: str, fname: str) -> list[RiskWarning]:
+    """PostgreSQL: CREATE INDEX without CONCURRENTLY locks the table."""
+    body = _upgrade_body(source)
+    if re.search(r"op\.create_index\s*\(", body):
+        if not re.search(r"postgresql_concurrently\s*=\s*True", body):
+            return [RiskWarning(
+                rev, fname, "INDEX without CONCURRENTLY",
+                "CREATE INDEX without postgresql_concurrently=True — locks table during index build",
+                "warning",
+            )]
+    return []
+
+
+def _check_add_column_with_default_on_large_table(source: str, rev: str, fname: str) -> list[RiskWarning]:
+    """PostgreSQL < 11: ADD COLUMN with DEFAULT rewrites entire table."""
+    body = _upgrade_body(source)
+    for m in re.finditer(r"op\.add_column\s*\([^)]+\)", body, re.DOTALL):
+        col_expr = m.group(0)
+        if re.search(r"server_default\s*=", col_expr) or re.search(r"default\s*=", col_expr):
+            return [RiskWarning(
+                rev, fname, "ADD COLUMN with DEFAULT",
+                "Adding column with DEFAULT may rewrite the entire table on PostgreSQL < 11 — "
+                "causes long lock on large tables",
+                "warning",
+            )]
+    return []
+
+
+def _check_unique_constraint_on_existing(source: str, rev: str, fname: str) -> list[RiskWarning]:
+    body = _upgrade_body(source)
+    if re.search(r"op\.create_unique_constraint\s*\(", body):
+        return [RiskWarning(
+            rev, fname, "UNIQUE constraint on existing data",
+            "Adding UNIQUE constraint — will fail if existing rows have duplicate values",
+            "warning",
+        )]
+    return []
+
+
+def _check_drop_not_null(source: str, rev: str, fname: str) -> list[RiskWarning]:
+    """Making column NOT NULL when downgrade re-adds NULL values."""
+    up = _upgrade_body(source)
+    if re.search(r"op\.alter_column\s*\([^)]+nullable\s*=\s*False", up, re.DOTALL):
+        down = _downgrade_body(source)
+        if not re.search(r"op\.alter_column\s*\([^)]+nullable\s*=\s*True", down, re.DOTALL):
+            return [RiskWarning(
+                rev, fname, "NOT NULL without reverting nullable",
+                "Column set to NOT NULL but downgrade does not restore nullable=True",
+                "warning",
+            )]
+    return []
+
+
+# ──────────────────────────────────────────────
+# public API
+# ──────────────────────────────────────────────
+
+_CHECKS = [
+    _check_downgrade_exists,
+    _check_noop_downgrade,
+    _check_drop_column_in_upgrade,
+    _check_drop_table_in_upgrade,
+    _check_truncate,
+    _check_run_python_no_reverse,
+    _check_not_null_no_default,
+    _check_column_type_change,
+    _check_column_size_shrink,
+    _check_raw_execute,
+    _check_data_migration_no_reverse,
+    _check_cascade_delete,
+    _check_index_without_concurrently,
+    _check_add_column_with_default_on_large_table,
+    _check_unique_constraint_on_existing,
+    _check_drop_not_null,
+]
+
+
+def analyze_migrations(versions_dir: str) -> list[RiskWarning]:
+    warnings: list[RiskWarning] = []
+    for path in sorted(Path(versions_dir).glob("*.py")):
+        source = path.read_text()
+        m = re.search(r'revision\s*=\s*["\']([^"\']+)["\']', source)
+        revision = m.group(1) if m else path.stem
+        for check in _CHECKS:
+            warnings.extend(check(source, revision, path.name))
+    return warnings

pytest_mrt/core/runner.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from alembic import command
+from alembic.config import Config as AlembicConfig
+from alembic.script import ScriptDirectory
+from sqlalchemy import create_engine
+from sqlalchemy.engine import Engine
+
+
+class MigrationRunner:
+    def __init__(self, alembic_ini: str, db_url: str):
+        self.db_url = db_url
+        self.alembic_cfg = AlembicConfig(alembic_ini)
+        self.alembic_cfg.set_main_option("sqlalchemy.url", db_url)
+        self.engine: Engine = create_engine(db_url)
+
+    def upgrade(self, revision: str = "head") -> None:
+        command.upgrade(self.alembic_cfg, revision)
+
+    def downgrade(self, revision: str = "-1") -> None:
+        command.downgrade(self.alembic_cfg, revision)
+
+    def downgrade_base(self) -> None:
+        command.downgrade(self.alembic_cfg, "base")
+
+    def current_revision(self) -> str | None:
+        from alembic.runtime.migration import MigrationContext
+        with self.engine.connect() as conn:
+            ctx = MigrationContext.configure(conn)
+            return ctx.get_current_revision()
+
+    def get_revisions(self) -> list:
+        """All revisions in upgrade order (oldest → newest)."""
+        script = ScriptDirectory.from_config(self.alembic_cfg)
+        return list(reversed(list(script.walk_revisions("base", "heads"))))
+
+    def get_versions_dir(self) -> str:
+        script = ScriptDirectory.from_config(self.alembic_cfg)
+        return script.dir

pytest_mrt/core/schema.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+from dataclasses import dataclass, field
+from sqlalchemy import inspect
+from sqlalchemy.engine import Engine
+
+_INTERNAL_TABLES = {"alembic_version"}
+
+
+@dataclass
+class ColumnInfo:
+    name: str
+    type_str: str
+    nullable: bool
+    default: str | None = None
+    primary_key: bool = False
+
+
+@dataclass
+class TableInfo:
+    name: str
+    columns: dict[str, ColumnInfo] = field(default_factory=dict)
+    pk_cols: list[str] = field(default_factory=list)
+    fk_tables: list[str] = field(default_factory=list)
+
+
+@dataclass
+class SchemaSnapshot:
+    tables: dict[str, TableInfo] = field(default_factory=dict)
+
+    @classmethod
+    def capture(cls, engine: Engine) -> SchemaSnapshot:
+        snap = cls()
+        with engine.connect() as conn:
+            insp = inspect(conn)
+            for tname in insp.get_table_names():
+                if tname in _INTERNAL_TABLES:
+                    continue
+                ti = TableInfo(name=tname)
+                pk_info = insp.get_pk_constraint(tname)
+                ti.pk_cols = pk_info.get("constrained_columns", [])
+                ti.fk_tables = list({
+                    fk["referred_table"]
+                    for fk in insp.get_foreign_keys(tname)
+                })
+                for col in insp.get_columns(tname):
+                    ti.columns[col["name"]] = ColumnInfo(
+                        name=col["name"],
+                        type_str=str(col["type"]),
+                        nullable=col.get("nullable", True),
+                        default=str(col["default"]) if col.get("default") is not None else None,
+                        primary_key=col["name"] in ti.pk_cols,
+                    )
+                snap.tables[tname] = ti
+        return snap
+
+
+@dataclass
+class SchemaIssue:
+    table: str
+    message: str
+    severity: str  # "error" | "warning"
+
+
+@dataclass
+class SchemaDiff:
+    dropped_tables: list[str] = field(default_factory=list)
+    added_tables: list[str] = field(default_factory=list)
+    dropped_columns: dict[str, list[str]] = field(default_factory=dict)
+    added_columns: dict[str, list[str]] = field(default_factory=dict)
+    type_changed: dict[str, list[tuple[str, str, str]]] = field(default_factory=dict)
+
+    @classmethod
+    def compute(cls, before: SchemaSnapshot, after: SchemaSnapshot) -> SchemaDiff:
+        diff = cls()
+        before_t = set(before.tables)
+        after_t = set(after.tables)
+        diff.dropped_tables = sorted(before_t - after_t)
+        diff.added_tables = sorted(after_t - before_t)
+        for t in before_t & after_t:
+            before_c = set(before.tables[t].columns)
+            after_c = set(after.tables[t].columns)
+            dropped = sorted(before_c - after_c)
+            added = sorted(after_c - before_c)
+            if dropped:
+                diff.dropped_columns[t] = dropped
+            if added:
+                diff.added_columns[t] = added
+            for col in before_c & after_c:
+                bt = before.tables[t].columns[col].type_str
+                at = after.tables[t].columns[col].type_str
+                if bt != at:
+                    diff.type_changed.setdefault(t, []).append((col, bt, at))
+        return diff
+
+    def verify_restored(
+        self, before: SchemaSnapshot, after_rollback: SchemaSnapshot
+    ) -> list[SchemaIssue]:
+        issues = []
+        before_t = set(before.tables)
+        restored_t = set(after_rollback.tables)
+
+        for t in before_t - restored_t:
+            issues.append(SchemaIssue(t, f"Table '{t}' missing after rollback", "error"))
+
+        for t in restored_t - before_t:
+            issues.append(
+                SchemaIssue(t, f"Table '{t}' still exists after rollback — downgrade is incomplete", "error")
+            )
+
+        for t in before_t & restored_t:
+            before_c = set(before.tables[t].columns)
+            restored_c = set(after_rollback.tables[t].columns)
+            for col in before_c - restored_c:
+                issues.append(SchemaIssue(t, f"Column '{t}.{col}' missing after rollback", "error"))
+            for col in restored_c - before_c:
+                issues.append(
+                    SchemaIssue(t, f"Column '{t}.{col}' still present after rollback — downgrade is incomplete", "warning")
+                )
+
+        return issues

pytest_mrt/core/seeder.py

@@ -0,0 +1,152 @@
+from __future__ import annotations
+import re
+import uuid
+from datetime import date, datetime, time
+from typing import Any
+
+from sqlalchemy import inspect, text
+from sqlalchemy.engine import Engine
+
+from .schema import ColumnInfo, TableInfo
+
+
+def _generate_value(col: ColumnInfo, index: int) -> Any:
+    t = col.type_str.upper()
+    if any(x in t for x in ("INT", "SERIAL", "BIGINT", "SMALLINT")):
+        return index * 1000 + 1
+    if any(x in t for x in ("FLOAT", "DOUBLE", "REAL", "NUMERIC", "DECIMAL")):
+        return float(index * 1000 + 1)
+    if "BOOL" in t:
+        return True
+    if "UUID" in t:
+        return str(uuid.UUID(int=index + 10**12))
+    if "JSON" in t:
+        return '{"mrt": true}'
+    if any(x in t for x in ("BYTEA", "BLOB", "BINARY")):
+        return b"mrt_seed"
+    if "TIMESTAMP" in t or "DATETIME" in t:
+        return datetime(2024, 1, 1, index % 24, 0, 0)
+    if "DATE" in t:
+        return date(2024, 1, index % 28 + 1)
+    if "TIME" in t:
+        return time(index % 24, 0, 0)
+    if any(x in t for x in ("VARCHAR", "TEXT", "CHAR", "STRING", "CLOB")):
+        m = re.search(r"\((\d+)\)", t)
+        limit = int(m.group(1)) if m else 255
+        val = f"mrt_seed_{index:05d}"
+        return val[:limit]
+    return f"mrt_{index}"
+
+
+def _topological_order(tables: dict[str, TableInfo]) -> list[str]:
+    """Return table names ordered so FK parents come before children."""
+    order: list[str] = []
+    visited: set[str] = set()
+
+    def visit(name: str) -> None:
+        if name in visited:
+            return
+        visited.add(name)
+        for parent in tables.get(name, TableInfo(name)).fk_tables:
+            if parent in tables:
+                visit(parent)
+        order.append(name)
+
+    for name in tables:
+        visit(name)
+    return order
+
+
+class SmartSeeder:
+    def __init__(self, engine: Engine):
+        self.engine = engine
+        # table_name -> list of (pk_col, pk_val)
+        self._seeded: dict[str, list[Any]] = {}
+
+    def seed_all(self, tables: dict[str, TableInfo], count: int = 3) -> None:
+        for tname in _topological_order(tables):
+            self.seed_table(tables[tname], count)
+
+    def seed_table(self, table: TableInfo, count: int = 3) -> None:
+        if not table.pk_cols:
+            return
+
+        pk_col = table.pk_cols[0]
+        inserted_pks: list[Any] = []
+
+        for i in range(count):
+            row: dict[str, Any] = {}
+            for col_name, col_info in table.columns.items():
+                if col_info.primary_key and any(
+                    x in col_info.type_str.upper() for x in ("SERIAL", "AUTOINCREMENT")
+                ):
+                    continue
+                if not col_info.nullable and col_info.default is None:
+                    row[col_name] = _generate_value(col_info, i + len(self._seeded) * 100)
+                elif not col_info.nullable:
+                    row[col_name] = _generate_value(col_info, i + len(self._seeded) * 100)
+
+            if not row:
+                continue
+
+            cols = ", ".join(f'"{c}"' for c in row)
+            placeholders = ", ".join(f":{c}" for c in row)
+            stmt = text(f'INSERT INTO "{table.name}" ({cols}) VALUES ({placeholders})')
+
+            try:
+                with self.engine.begin() as conn:
+                    conn.execute(stmt, row)
+                    if pk_col in row:
+                        inserted_pks.append(row[pk_col])
+                    else:
+                        # Auto-generated PK — fetch last inserted
+                        result = conn.execute(
+                            text(f'SELECT "{pk_col}" FROM "{table.name}" ORDER BY "{pk_col}" DESC LIMIT 1')
+                        )
+                        val = result.scalar()
+                        if val is not None:
+                            inserted_pks.append(val)
+            except Exception:
+                # FK or constraint we can't satisfy — skip this table
+                pass
+
+        if inserted_pks:
+            self._seeded.setdefault(table.name, []).extend(inserted_pks)
+
+    def verify(self) -> list[str]:
+        failures: list[str] = []
+        with self.engine.connect() as conn:
+            insp = inspect(conn)
+            existing = set(insp.get_table_names())
+
+        for tname, pk_vals in self._seeded.items():
+            if tname not in existing:
+                failures.append(f"Table '{tname}' no longer exists after rollback — all data lost")
+                continue
+
+            with self.engine.connect() as conn:
+                insp = inspect(conn)
+                pk_info = insp.get_pk_constraint(tname)
+                pk_cols = pk_info.get("constrained_columns", [])
+                if not pk_cols:
+                    continue
+                pk_col = pk_cols[0]
+
+                placeholders = ", ".join(f":v{i}" for i in range(len(pk_vals)))
+                params = {f"v{i}": v for i, v in enumerate(pk_vals)}
+                result = conn.execute(
+                    text(f'SELECT COUNT(*) FROM "{tname}" WHERE "{pk_col}" IN ({placeholders})'),
+                    params,
+                )
+                found = result.scalar() or 0
+
+            if found < len(pk_vals):
+                lost = len(pk_vals) - found
+                failures.append(
+                    f"Table '{tname}': {lost}/{len(pk_vals)} row(s) lost after rollback"
+                )
+
+        return failures
+
+    def reset(self) -> None:
+        self._seeded.clear()

pytest_mrt/core/verifier.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+from dataclasses import dataclass, field
+
+from .runner import MigrationRunner
+from .schema import SchemaSnapshot, SchemaDiff
+from .seeder import SmartSeeder
+
+
+@dataclass
+class RevisionResult:
+    revision: str
+    passed: bool
+    failures: list[str] = field(default_factory=list)
+
+    def failure_summary(self) -> str:
+        return "\n".join(f"  - {f}" for f in self.failures)
+
+
+class RollbackVerifier:
+    """
+    For each revision under test:
+      1. Seed data into tables that exist BEFORE this migration (pre-upgrade state)
+      2. Upgrade to the revision
+      3. Downgrade one step
+      4. Verify schema is exactly restored + seeded data survived
+    """
+
+    def __init__(self, runner: MigrationRunner):
+        self.runner = runner
+
+    def check_revision(self, revision: str) -> RevisionResult:
+        seeder = SmartSeeder(self.runner.engine)
+        failures: list[str] = []
+
+        # Capture state before this migration
+        schema_before = SchemaSnapshot.capture(self.runner.engine)
+
+        # Seed into pre-existing tables — these rows must survive rollback
+        seeder.seed_all(schema_before.tables)
+
+        # Apply and then revert the migration
+        self.runner.upgrade(revision)
+        self.runner.downgrade()
+
+        schema_restored = SchemaSnapshot.capture(self.runner.engine)
+
+        # Schema must be exactly as before (no missing tables, no leftover tables)
+        diff = SchemaDiff()
+        for issue in diff.verify_restored(schema_before, schema_restored):
+            failures.append(issue.message)
+
+        # Data seeded before upgrade must survive the round-trip
+        failures.extend(seeder.verify())
+
+        return RevisionResult(
+            revision=revision,
+            passed=len(failures) == 0,
+            failures=failures,
+        )
+
+    def check_all(self) -> list[RevisionResult]:
+        """Test every revision independently in sequence."""
+        results: list[RevisionResult] = []
+        self.runner.downgrade_base()
+
+        for rev in self.runner.get_revisions():
+            result = self.check_revision(rev.revision)
+            results.append(result)
+            # Advance to this revision so the next check starts from correct state
+            self.runner.upgrade(rev.revision)
+
+        return results

pytest_mrt/plugin.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+import pytest
+
+from .config import MRTConfig
+from .core.runner import MigrationRunner
+from .core.seeder import SmartSeeder
+from .core.verifier import RevisionResult, RollbackVerifier
+
+
+class MRTFixture:
+    def __init__(self, config: MRTConfig):
+        self._runner = MigrationRunner(config.alembic_ini, config.db_url)
+        self._seeder = SmartSeeder(self._runner.engine)
+        self._verifier = RollbackVerifier(self._runner)
+
+    # ── migration control ──────────────────────────────────────────────
+
+    def upgrade(self, revision: str = "head") -> None:
+        self._runner.upgrade(revision)
+
+    def downgrade(self, revision: str = "-1") -> None:
+        self._runner.downgrade(revision)
+
+    # ── manual seeding ────────────────────────────────────────────────
+
+    def seed(self, table: str, rows: list[dict], pk_col: str = "id") -> None:
+        from .core.schema import SchemaSnapshot
+        snap = SchemaSnapshot.capture(self._runner.engine)
+        if table in snap.tables:
+            self._seeder.seed_table(snap.tables[table])
+        else:
+            raise ValueError(f"Table '{table}' not found in current schema")
+
+    # ── assertions ────────────────────────────────────────────────────
+
+    def assert_data_intact(self) -> None:
+        failures = self._seeder.verify()
+        if failures:
+            pytest.fail("Rollback caused data loss:\n" + "\n".join(f"  - {f}" for f in failures))
+
+    def check_revision(self, revision: str) -> RevisionResult:
+        return self._verifier.check_revision(revision)
+
+    def check_all(self) -> list[RevisionResult]:
+        return self._verifier.check_all()
+
+    def assert_reversible(self, revision: str = "head") -> None:
+        result = self._verifier.check_revision(revision)
+        if not result.passed:
+            pytest.fail(f"Migration {revision} is not safely reversible:\n{result.failure_summary()}")
+
+    def assert_all_reversible(self) -> None:
+        from .reporter import print_check_all_summary
+        results = self._verifier.check_all()
+        print_check_all_summary(results)
+        failed = [r for r in results if not r.passed]
+        if failed:
+            lines = []
+            for r in failed:
+                lines.append(f"  revision {r.revision}:")
+                lines.append(r.failure_summary())
+            pytest.fail("Some migrations are not safely reversible:\n" + "\n".join(lines))
+
+    def reset(self) -> None:
+        self._seeder.reset()
+
+
+def pytest_configure(config: pytest.Config) -> None:
+    config.addinivalue_line("markers", "mrt: migration rollback test")
+
+
+@pytest.fixture
+def mrt(request: pytest.FixtureRequest) -> MRTFixture:
+    cfg: MRTConfig = getattr(request.config, "_mrt_config", None) or MRTConfig()
+    fixture = MRTFixture(cfg)
+    yield fixture
+    fixture.reset()

pytest_mrt/reporter.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+from rich import box
+
+from .core.verifier import RevisionResult
+
+console = Console()
+
+
+def print_revision_result(result: RevisionResult) -> None:
+    if result.passed:
+        console.print(f"  [green]✓[/green]  [bold]{result.revision}[/bold]  [dim]reversible[/dim]")
+    else:
+        console.print(f"  [red]✗[/red]  [bold]{result.revision}[/bold]  [red]data loss detected[/red]")
+        for f in result.failures:
+            console.print(f"     [dim]└─[/dim] [red]{f}[/red]")
+
+
+def print_check_all_summary(results: list[RevisionResult]) -> None:
+    passed = [r for r in results if r.passed]
+    failed = [r for r in results if not r.passed]
+
+    console.print()
+    console.rule("[bold]MRT — Migration Rollback Test[/bold]", style="dim")
+    console.print()
+
+    for result in results:
+        print_revision_result(result)
+
+    console.print()
+
+    if not failed:
+        console.print(Panel(
+            f"[green]All {len(results)} migration(s) are safely reversible.[/green]",
+            border_style="green",
+        ))
+    else:
+        lines = Text()
+        lines.append(f"{len(failed)} migration(s) will cause data loss on rollback.\n\n", style="red bold")
+        for r in failed:
+            lines.append(f"  {r.revision}\n", style="red")
+            for f in r.failures:
+                lines.append(f"    └─ {f}\n", style="dim")
+        console.print(Panel(lines, border_style="red", title="[red]Rollback Unsafe[/red]"))
+
+    console.print()
+
+
+def print_static_check_header(versions_dir: str) -> None:
+    console.print()
+    console.rule(f"[bold]MRT static analysis[/bold]  [dim]{versions_dir}[/dim]", style="dim")
+    console.print()

pytest_mrt-0.1.0.dist-info/METADATA

@@ -0,0 +1,335 @@
+Metadata-Version: 2.4
+Name: pytest-mrt
+Version: 0.1.0
+Summary: Catch database migration rollback failures before they reach production
+Project-URL: Homepage, https://github.com/croc100/pytest-mrt
+Project-URL: Repository, https://github.com/croc100/pytest-mrt
+Project-URL: Issues, https://github.com/croc100/pytest-mrt/issues
+Project-URL: Changelog, https://github.com/croc100/pytest-mrt/releases
+Author: croc100
+License: MIT License
+        
+        Copyright (c) 2026 croc100
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Keywords: alembic,database,migrations,pytest,rollback,sqlalchemy,testing
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Pytest
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+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 :: Database
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.10
+Requires-Dist: alembic>=1.9
+Requires-Dist: pytest>=7.0
+Requires-Dist: rich>=13.0
+Requires-Dist: sqlalchemy>=2.0
+Requires-Dist: typer>=0.9
+Provides-Extra: asyncpg
+Requires-Dist: asyncpg; extra == 'asyncpg'
+Provides-Extra: dev
+Requires-Dist: hatch; extra == 'dev'
+Requires-Dist: psycopg2-binary; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Provides-Extra: postgres
+Requires-Dist: psycopg2-binary; extra == 'postgres'
+Description-Content-Type: text/markdown
+
+# pytest-mrt
+
+<p align="center">
+  <strong>Migration Rollback Tester</strong><br>
+  Catch database migration disasters before they reach production.
+</p>
+
+<p align="center">
+  <a href="https://pypi.org/project/pytest-mrt"><img src="https://img.shields.io/pypi/v/pytest-mrt?color=blue" alt="PyPI"></a>
+  <a href="https://github.com/croc100/pytest-mrt/actions"><img src="https://img.shields.io/github/actions/workflow/status/croc100/pytest-mrt/ci.yml?branch=main" alt="CI"></a>
+  <a href="https://pypi.org/project/pytest-mrt"><img src="https://img.shields.io/pypi/pyversions/pytest-mrt" alt="Python"></a>
+  <a href="https://github.com/croc100/pytest-mrt/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-Apache%202.0-green" alt="License"></a>
+</p>
+
+---
+
+## The problem
+
+It's 2am. Your new feature is deployed. Something is wrong. You run `alembic downgrade -1`.
+
+The command succeeds. But the data is gone.
+
+The column came back. The rows didn't.
+
+---
+
+This happens because **most tools only check if your migration runs without errors** — not whether your data survives the round-trip. `alembic downgrade` can succeed while silently destroying everything it was supposed to restore.
+
+**pytest-mrt** tests the full cycle: seed real data → upgrade → downgrade → verify nothing was lost.
+
+---
+
+## Install
+
+```bash
+pip install pytest-mrt
+```
+
+---
+
+## Quickstart
+
+```python
+# conftest.py
+from pytest_mrt import MRTConfig
+
+def pytest_configure(config):
+    config._mrt_config = MRTConfig(
+        alembic_ini="alembic.ini",
+        db_url="postgresql://localhost/myapp_test",
+    )
+```
+
+```python
+# test_migrations.py
+def test_all_migrations_are_reversible(mrt):
+    mrt.assert_all_reversible()
+```
+
+```
+$ pytest test_migrations.py -s
+
+  ──────────── MRT — Migration Rollback Test ────────────
+
+  ✓  001  reversible
+  ✓  002  reversible
+  ✓  003  reversible
+  ✗  004  data loss detected
+     └─ Table 'users': 3/3 rows lost after rollback
+  ✗  005  data loss detected
+     └─ Table 'users' still exists after rollback — downgrade is incomplete
+
+  ╭─────────────────────────────────────────────────────╮
+  │  2 migration(s) will cause data loss on rollback.   │
+  │    004                                              │
+  │      └─ Table 'users': 3/3 rows lost after rollback │
+  │    005                                              │
+  │      └─ Table 'users' still exists after rollback   │
+  ╰─────────────────────────────────────────────────────╯
+```
+
+---
+
+## What it catches
+
+### Static analysis — before you even run
+
+| Pattern | Severity | Why it's dangerous |
+|---|---|---|
+| `op.drop_column()` in upgrade | 🔴 error | Column data is permanently gone |
+| `op.drop_table()` in upgrade | 🔴 error | All table data is permanently gone |
+| `TRUNCATE` in migration | 🔴 error | Destroys data with no undo |
+| `def downgrade(): pass` | 🔴 error | Rollback silently does nothing |
+| No `downgrade()` function | 🔴 error | Migration is completely irreversible |
+| `RunPython` without `reverse_func` | 🔴 error | Data transformation cannot be undone |
+| `NOT NULL` without `server_default` | 🟡 warning | Will fail on non-empty tables |
+| `ALTER COLUMN type_=...` | 🟡 warning | Type conversion may lose data |
+| `op.execute()` with raw SQL | 🟡 warning | Cannot verify reversibility |
+| Bulk `UPDATE` without reverse | 🟡 warning | One-way data transformation |
+| `ON DELETE CASCADE` added | 🟡 warning | Child rows silently deleted |
+| `CREATE INDEX` without `CONCURRENTLY` | 🟡 warning | Locks table during index build |
+| `ADD COLUMN` with `DEFAULT` | 🟡 warning | Full table rewrite on PostgreSQL < 11 |
+| `CREATE UNIQUE CONSTRAINT` | 🟡 warning | Will fail if duplicates exist |
+| `NOT NULL` without restoring `nullable` | 🟡 warning | Downgrade leaves column in wrong state |
+
+Run static analysis without a database:
+
+```bash
+mrt check migrations/versions/
+```
+
+```
+╭──────────────────────────────────────────────────────────────────────────────╮
+│                          Rollback Risk Analysis                              │
+├──────────┬──────────────────────┬─────────────┬───────────────────────────  │
+│ Revision │ Pattern              │ Sev         │ Message                       │
+├──────────┼──────────────────────┼─────────────┼───────────────────────────  │
+│ 004      │ DROP COLUMN          │ error       │ Data loss on rollback         │
+│ 005      │ No-op downgrade      │ error       │ downgrade() does nothing      │
+│ 006      │ INDEX without CONC.  │ warning     │ Locks table during build      │
+╰──────────────────────────────────────────────────────────────────────────────╯
+2 error(s), 1 warning(s)
+```
+
+### Dynamic verification — with real data
+
+pytest-mrt seeds actual rows before each migration, then checks they survive the downgrade:
+
+```python
+def test_specific_revision(mrt):
+    result = mrt.check_revision("abc123")
+    assert result.passed, result.failure_summary()
+```
+
+Or test everything at once:
+
+```python
+def test_all_migrations(mrt):
+    mrt.assert_all_reversible()
+```
+
+---
+
+## How it works
+
+For each migration revision, pytest-mrt:
+
+```
+1. Capture schema at current state
+2. Seed real data into all existing tables
+3. Run upgrade to this revision
+4. Run downgrade (one step back)
+5. Verify schema is exactly restored
+6. Verify every seeded row survived
+```
+
+This catches failures that syntax checks miss:
+- Schema comes back, but seeded rows are gone → **data loss**
+- Downgrade is a no-op, table still exists → **rollback did nothing**
+- Column returns but with wrong type → **schema drift**
+
+---
+
+## Supported databases
+
+| Database | Status |
+|---|---|
+| PostgreSQL | ✅ Full support |
+| SQLite | ✅ Full support (great for CI) |
+| MySQL / MariaDB | 🔜 Planned |
+
+---
+
+## CI integration
+
+Add to your GitHub Actions workflow:
+
+```yaml
+- name: Test migration rollbacks
+  run: pytest tests/test_migrations.py -v -s
+```
+
+Or use the static check as a fast pre-flight:
+
+```yaml
+- name: Static migration analysis
+  run: mrt check migrations/versions/ --strict
+```
+
+`--strict` makes warnings fail the build, not just errors.
+
+---
+
+## Configuration
+
+```python
+# conftest.py
+from pytest_mrt import MRTConfig
+
+def pytest_configure(config):
+    config._mrt_config = MRTConfig(
+        alembic_ini="alembic.ini",       # path to alembic.ini
+        db_url="postgresql://...",        # test database URL
+        seed_rows=5,                      # rows to seed per table (default: 3)
+    )
+```
+
+Use environment variables for CI:
+
+```python
+import os
+from pytest_mrt import MRTConfig
+
+def pytest_configure(config):
+    config._mrt_config = MRTConfig(
+        alembic_ini="alembic.ini",
+        db_url=os.environ["TEST_DATABASE_URL"],
+    )
+```
+
+---
+
+## Examples
+
+See [`examples/blog/`](examples/blog/) for a complete working example with:
+- Safe migrations (add nullable column, create table)
+- Dangerous migrations (drop column with data, no-op downgrade)
+- How pytest-mrt catches each failure
+
+```bash
+cd examples/blog
+pip install pytest-mrt
+pytest test_migrations.py -v -s
+```
+
+---
+
+## FAQ
+
+**Does it modify my production database?**
+No. pytest-mrt only runs against the database URL you provide in `MRTConfig`. Always use a test database.
+
+**Does it work with Django migrations?**
+Django support is on the roadmap. Currently only Alembic is supported.
+
+**How is this different from pytest-alembic?**
+`pytest-alembic` checks that migrations run without errors and that your schema matches your models. It does **not** verify that data survives a rollback. pytest-mrt focuses specifically on that gap.
+
+**My migration intentionally drops a column. Will this always fail?**
+Yes — dropping a column destroys data. That's exactly what pytest-mrt warns you about. If you want to proceed, you can exclude specific revisions or mark the test as expected-to-fail.
+
+---
+
+## Roadmap
+
+- [x] Alembic support
+- [x] Static risk analysis CLI (`mrt check`)
+- [x] Dynamic data integrity verification
+- [x] GitHub Actions CI
+- [ ] Django Migrations support
+- [ ] MySQL / MariaDB support
+- [ ] HTML report output
+- [ ] Per-revision exclusions (`@mrt.skip("004", reason="...")`)
+- [ ] PyPI release
+
+---
+
+## Contributing
+
+Contributions are welcome. See [CONTRIBUTING.md](CONTRIBUTING.md).
+
+---
+
+## License
+
+Apache 2.0

pytest_mrt-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+pytest_mrt/__init__.py,sha256=Z9a-gTCwskapo7A8bauDfG77l447IrcD1bnozyZOL7I,77
+pytest_mrt/cli.py,sha256=pkXGYwbZf6Ki-RwICBlP2iMmqOEdBsf4d0TpYLxchNY,1957
+pytest_mrt/config.py,sha256=50-JZLptavXqNQLwWFZMvs36s_7V5aM-xEyKalT0gBs,153
+pytest_mrt/plugin.py,sha256=0hhCbex9GX_iIdLIHsnyrh5ngwtHW9RlLfSiJwmrEbw,3139
+pytest_mrt/reporter.py,sha256=MBJYLw_0cZCwF_32RN0iO5XGKbiP6a4q62OPFVE84s4,1821
+pytest_mrt/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pytest_mrt/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pytest_mrt/core/detector.py,sha256=8xhvqJUK2TW-oKtPTM7weeQSldPpxyMKsf5FiyxKVZM,10485
+pytest_mrt/core/runner.py,sha256=INmvcT6rhPudxOlcuKyq2j7ewOcyj49_c_4Enab78RQ,1446
+pytest_mrt/core/schema.py,sha256=_pTMqqUFicU8Wi7TcZOKXpPLkDsoqn4c96MK9mLBYyE,4322
+pytest_mrt/core/seeder.py,sha256=1n_-VmMAbEr924IjxfLiJYqMZKseJNeW7A5vLuRcAUM,5456
+pytest_mrt/core/verifier.py,sha256=pI3NGSxDcXd28xfbFH-K0XVLWDqUdy38jK7h81GxyV8,2315
+pytest_mrt-0.1.0.dist-info/METADATA,sha256=Jxb0M37GqTy2iIXJM-j_3_ztorxsKMDoPBTLy3wzYKk,12029
+pytest_mrt-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+pytest_mrt-0.1.0.dist-info/entry_points.txt,sha256=sXUH1xz6G48-QRXBUpvQnTr_LpQwXQMKsLEBP60XCiI,79
+pytest_mrt-0.1.0.dist-info/licenses/LICENSE,sha256=y1u42SEfipXW9_1zN2r6M__JguUyOd7i5L6B1mHyDMc,1064
+pytest_mrt-0.1.0.dist-info/RECORD,,

pytest_mrt-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

pytest_mrt-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+mrt = pytest_mrt.cli:app
+
+[pytest11]
+mrt = pytest_mrt.plugin

pytest_mrt-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 croc100
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.