@databricks-solutions/lakebase-scm-utils 0.3.2 → 0.3.4

package/templates/project/python/tests/conftest.py

@@ -8,9 +8,19 @@ from app.main import app
 
 
 @pytest.fixture()
-def client():
-    """FastAPI TestClient for making HTTP requests."""
-    return TestClient(app)
+def client(request):
+    """FastAPI TestClient for making HTTP requests.
+
+    Tagged with the test's ``@pytest.mark.testid`` via the ``X-Consort-Test-Id`` header, so the
+    backend's per-test capture (``app/consort_capture.py``) attributes the rows each request
+    RETRIEVES/STORES to this test — exactly as the Vitest fetch shim and the Playwright fixture do.
+    (Direct ``db_session`` setup/asserts bypass the app and are not captured, by design: the capture
+    is what the test did THROUGH the app's ``/api``.)"""
+    c = TestClient(app)
+    test_id = _consort_testid(request.node)
+    if test_id:
+        c.headers["X-Consort-Test-Id"] = test_id
+    return c
 
 
 @pytest.fixture()
@@ -54,3 +64,122 @@ def _restore_migration_head_after_each_test():
         # Everything else (a real schema error) propagates and fails loudly, which
         # is the correct behavior for a genuinely broken restore.
         print(f"WARNING: migration-head restore failed during teardown: {exc}")
+
+
+# --- Per-test "green as it runs" signal for the dashboard -------------------------------------
+# Each test tagged `@pytest.mark.testid("T37")` streams its lifecycle to `.consort/test-run.jsonl`:
+# `running` when it STARTS (pytest_runtest_setup), then `green`/`red`/`skipped` when it FINISHES
+# (pytest_runtest_makereport, the CALL phase). A dashboard tails that file and lights each bubble
+# the moment it changes, so even a single whole-suite run (story cadence) shows per-test progress —
+# pending -> running -> green — not an all-at-once batch flip. The `file` disambiguates a reused id
+# across features (F1 and F2 may both have a T37); the reader keys by (scenario_file + id) and takes
+# the LAST write per key, so running -> green composes. Observability only.
+
+
+def _consort_testid(item):
+    """The test's ``@pytest.mark.testid(...)`` id, or ``None`` when it carries no marker."""
+    return next((m.args[0] for m in item.iter_markers("testid") if m.args), None)
+
+
+def _consort_emit_test_run(test_id, status, item):
+    """Append one per-test line to ``.consort/test-run.jsonl``. Best-effort with a SCOPED except
+    (the only errors this body can raise: file I/O, JSON serialization) — never a blanket
+    ``except Exception``, which the kit's deterministic broad-integrity-except test-smell gate
+    correctly flags even in a conftest. A reporter write must never break the suite."""
+    try:
+        import json
+        from datetime import datetime, timezone
+        from pathlib import Path
+
+        root = Path(__file__).resolve().parent.parent
+        rel = str(Path(str(item.fspath))).replace(f"{root}/", "")
+        out = root / ".consort"
+        out.mkdir(parents=True, exist_ok=True)
+        line = json.dumps(
+            {"ts": datetime.now(timezone.utc).isoformat(), "test_id": test_id, "status": status, "file": rel, "kind": "behavior"}
+        )
+        with open(out / "test-run.jsonl", "a", encoding="utf-8") as fh:
+            fh.write(line + "\n")
+    except (OSError, ValueError, TypeError):
+        pass
+
+
+def _consort_capture_tables(test_id, item):
+    """Append a per-test TABLE snapshot to ``.consort/table-snapshots.jsonl``, keyed by test id: the
+    rows of each public app table AS THIS TEST LEFT THEM, captured on the CALL phase (before teardown
+    prunes). The dashboard shows the table 'as of' the running/selected test — same corpus/one-reader
+    path as the test-status view. Read-only + row-capped. A ``@migration`` test runs on its OWN
+    isolated ephemeral branch and drops/recreates the table, so its snapshot is flagged ``isolated``.
+    Best-effort with a SCOPED except (DB errors + file I/O + JSON) — never a blanket catch, never
+    breaks the suite."""
+    try:
+        import json
+        import re
+        from datetime import datetime, timezone
+        from pathlib import Path
+
+        from sqlalchemy import text
+        from sqlalchemy.exc import SQLAlchemyError
+
+        from app.database import engine
+
+        isolated = any(True for _ in item.iter_markers("migration"))
+        ident = re.compile(r"[A-Za-z_][A-Za-z0-9_]*")
+        root = Path(__file__).resolve().parent.parent
+        rel = str(Path(str(item.fspath))).replace(f"{root}/", "")
+        out = root / ".consort"
+        out.mkdir(parents=True, exist_ok=True)
+        ts = datetime.now(timezone.utc).isoformat()
+        lines = []
+        try:
+            with engine.connect() as conn:
+                names = [
+                    r[0]
+                    for r in conn.execute(
+                        text(
+                            "select tablename from pg_tables where schemaname='public' "
+                            "and tablename <> 'alembic_version' order by 1"
+                        )
+                    )
+                ]
+                for name in names:
+                    if not ident.fullmatch(name):
+                        continue
+                    rows = [dict(r) for r in conn.execute(text(f'SELECT * FROM "{name}" ORDER BY 1 DESC LIMIT 50')).mappings()]
+                    total = conn.execute(text(f'SELECT count(*) FROM "{name}"')).scalar()
+                    lines.append(
+                        json.dumps(
+                            {"ts": ts, "test_id": test_id, "file": rel, "table": name, "rows": rows, "row_count": total, "isolated": isolated},
+                            default=str,
+                        )
+                    )
+        except SQLAlchemyError:
+            return  # branch unreachable / mid-migration — skip this snapshot, never fail the test
+        if lines:
+            with open(out / "table-snapshots.jsonl", "a", encoding="utf-8") as fh:
+                fh.write("\n".join(lines) + "\n")
+    except (OSError, ValueError, TypeError):
+        pass
+
+
+def pytest_runtest_setup(item):
+    """Emit ``running`` the moment a tagged test starts, so the dashboard shows it in-flight."""
+    test_id = _consort_testid(item)
+    if test_id:
+        _consort_emit_test_run(test_id, "running", item)
+
+
+@pytest.hookimpl(wrapper=True)
+def pytest_runtest_makereport(item, call):
+    """Emit the FINAL status on the CALL phase, and capture the per-test table snapshot (before
+    teardown prunes). A ``makereport`` wrapper (NOT the ``logreport`` hook, whose ``TestReport``
+    carries no test node) so the ``testid`` marker is reachable off ``item``; always returns the
+    real report unchanged so pytest's own reporting is untouched."""
+    report = yield
+    if report.when == "call":
+        test_id = _consort_testid(item)
+        if test_id:
+            status = "green" if report.passed else "red" if report.failed else "skipped"
+            _consort_emit_test_run(test_id, status, item)
+            _consort_capture_tables(test_id, item)
+    return report