Test that the migration chain keeps the expression indexes (B-97, DAT-75, DAT-56, ARC-62)

batch_alter_table on SQLite rebuilds the table and silently drops
ix_rounds_single_active and ix_users_username_lower, autogenerate never sees them,
and no test ran the migrations (the others build the schema with create_all).

tests/unit/test_migrations.py runs `alembic upgrade head` on an empty file DB in a
subprocess and asserts both indexes exist with their definition (read from
sqlite_master) and that a second active round and a case-variant username are
refused. Verified to fail when a batch_alter_table on rounds is added to the last
migration. The current chain already preserves both indexes, so no migration changes.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

tests/unit/test_migrations.py

@@ -0,0 +1,76 @@
+"""B-97 (DAT-75, DAT-56, ARC-62, ARC-64): the Alembic chain is executed, not assumed.
+
+The two expression indexes that carry invariants — `ix_rounds_single_active` ("at
+most one active round", B-09) and `ix_users_username_lower` ("usernames are
+case-insensitive", B-57) — are invisible to autogenerate, and `batch_alter_table`
+on SQLite rebuilds the table and drops them with only a warning. Every other test
+builds its schema with `Base.metadata.create_all`, so a migration that lost one of
+them would reach production unnoticed. This one runs `alembic upgrade head` on an
+empty database, exactly as the container does at startup.
+
+Alembic runs in a subprocess: env.py calls `asyncio.run` and `fileConfig`, neither of
+which belongs inside the pytest process.
+"""
+
+import os
+import re
+import sqlite3
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+_ROOT = Path(__file__).resolve().parents[2]
+
+
+@pytest.fixture(scope="module")
+def migrated_db(tmp_path_factory) -> Path:
+    db_path = tmp_path_factory.mktemp("migrations") / "migrated.db"
+    env = {**os.environ, "DATABASE_URL": f"sqlite+aiosqlite:///{db_path}"}
+    result = subprocess.run(
+        [sys.executable, "-m", "alembic", "upgrade", "head"],
+        cwd=_ROOT,
+        env=env,
+        capture_output=True,
+        text=True,
+        timeout=120,
+    )
+    assert result.returncode == 0, f"alembic upgrade head failed:\n{result.stderr[-3000:]}"
+    return db_path
+
+
+def _index_sql(db_path: Path, name: str) -> str | None:
+    with sqlite3.connect(db_path) as conn:
+        row = conn.execute("SELECT sql FROM sqlite_master WHERE type = 'index' AND name = ?", (name,)).fetchone()
+    return re.sub(r"\s+", " ", row[0]).lower() if row else None
+
+
+def test_the_expression_indexes_survive_the_whole_migration_chain(migrated_db):
+    """DAT-75 / ARC-62 / B-97: both indexes exist, with their definition, at head."""
+    single_active = _index_sql(migrated_db, "ix_rounds_single_active")
+    assert single_active is not None, "ix_rounds_single_active was lost by a migration"
+    assert "unique index" in single_active
+    assert "on rounds ((1))" in single_active
+    for status in ("open", "closing", "drawing", "paying_out"):
+        assert f"'{status}'" in single_active
+
+    username_lower = _index_sql(migrated_db, "ix_users_username_lower")
+    assert username_lower is not None, "ix_users_username_lower was lost by a migration"
+    assert "unique index" in username_lower
+    assert "lower(username)" in username_lower
+
+
+def test_the_migrated_database_still_enforces_both_invariants(migrated_db):
+    """DAT-75 / B-97: a second active round and a case-variant username are refused."""
+    with sqlite3.connect(migrated_db) as conn:
+        conn.execute("INSERT INTO rounds (status, opened_at) VALUES ('open', '2026-01-01 00:00:00')")
+        with pytest.raises(sqlite3.IntegrityError):
+            conn.execute("INSERT INTO rounds (status, opened_at) VALUES ('closing', '2026-01-01 00:00:00')")
+        # A closed round is not active, so any number of them may coexist.
+        conn.execute("INSERT INTO rounds (status, opened_at) VALUES ('closed', '2026-01-01 00:00:00')")
+
+        columns = "(username, password_hash, derivation_index, address, cached_balance_sats, token_version, created_at)"
+        conn.execute(f"INSERT INTO users {columns} VALUES ('Alice', 'x', 0, 'plm1qa', 0, 0, '2026-01-01 00:00:00')")
+        with pytest.raises(sqlite3.IntegrityError):
+            conn.execute(f"INSERT INTO users {columns} VALUES ('aLICE', 'x', 1, 'plm1qb', 0, 0, '2026-01-01 00:00:00')")