tests: pytest + playwright headless smoke harness

First Space-side test harness; sets up the floor for the Phase D
bundle's per-commit unit + UI tests (split leaderboard, pending-row
defaults, OAuth-required submit) without slipping a regression past
a build-only check.

requirements-dev.txt pulls -r requirements.txt then adds pytest +
playwright. One `pip install -r requirements-dev.txt && playwright
install chromium` brings a fresh venv up to speed.

tests/conftest.py exposes a session-scoped `app_url` fixture: boots
app.py in a subprocess on a free port, polls until the HTTP server
answers, yields the URL, tears the process down on teardown. Logs
land in a tmp file so a startup failure surfaces the real Gradio
traceback rather than a bare RuntimeError. Boot-time stuck-pending
sweep in submit.py is disabled via CADGENBENCH_DISABLE_BOOT_SWEEP=1
so the fixture is fast and offline-tolerant.

tests/test_smoke.py launches headless Chromium via playwright's sync
API, navigates to the fixture's URL, and asserts the Leaderboard /
Submit / About tabs all render. If the Space won't load these three
tabs every downstream test is meaningless; this is the gate.

None of these files ship into the production image (the Dockerfile
only COPYs *.py from the repo root plus results.jsonl), so the push
rebuilds an identical image and verifying RUNNING is a no-op safety
check.

requirements-dev.txt

@@ -0,0 +1,16 @@
+# Dev-only deps for the Space test harness. Use:
+#
+#   pip install -r requirements-dev.txt
+#   playwright install chromium
+#
+# Runtime deps (gradio, gradio_leaderboard, pandas, ...) are pulled in
+# via the -r line below so a fresh venv only needs the one install
+# command above. cadgenbench itself is installed separately (either
+# editable from the sibling cadgenbench/ checkout, or pip-installed
+# from github.com/huggingface/cadgenbench like the Dockerfile does);
+# the unit tests in later commits will mock the cadgenbench surfaces
+# they actually need.
+-r requirements.txt
+
+pytest>=8.0
+playwright>=1.40

tests/conftest.py

@@ -0,0 +1,90 @@
+"""Shared pytest fixtures for the Space test suite.
+
+Two responsibilities:
+
+1. Put the Space root on ``sys.path`` so unit tests in later commits
+   can ``import leaderboard`` / ``import submit`` directly without a
+   package layout shim.
+2. Expose an ``app_url`` session fixture that boots ``app.py`` in a
+   subprocess on a free port, polls until the HTTP server answers,
+   yields the URL, and terminates the process on teardown. The
+   subprocess's stdout + stderr are captured to a tmp log file so a
+   readiness-timeout or early exit surfaces the actual Gradio log.
+"""
+from __future__ import annotations
+
+import os
+import socket
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+import pytest
+import requests
+
+SPACE_ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(SPACE_ROOT))
+
+APP_BOOT_TIMEOUT_SECONDS = 90
+
+
+def _pick_free_port() -> int:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.bind(("127.0.0.1", 0))
+        return s.getsockname()[1]
+
+
+def _wait_for_ready(proc: subprocess.Popen, url: str, log_path: Path) -> None:
+    deadline = time.time() + APP_BOOT_TIMEOUT_SECONDS
+    while time.time() < deadline:
+        if proc.poll() is not None:
+            raise RuntimeError(
+                f"app.py exited with code {proc.returncode} before HTTP "
+                f"was ready. Log:\n{log_path.read_text()}"
+            )
+        try:
+            if requests.get(url, timeout=2).status_code == 200:
+                return
+        except requests.RequestException:
+            pass
+        time.sleep(0.5)
+    raise RuntimeError(
+        f"app.py did not respond on {url} within "
+        f"{APP_BOOT_TIMEOUT_SECONDS}s. Log:\n{log_path.read_text()}"
+    )
+
+
+@pytest.fixture(scope="session")
+def app_url(tmp_path_factory):
+    port = _pick_free_port()
+    log_path = tmp_path_factory.mktemp("space-smoke") / "app.log"
+    env = {
+        **os.environ,
+        "GRADIO_SERVER_NAME": "127.0.0.1",
+        "GRADIO_SERVER_PORT": str(port),
+        # submit.py's boot-time stuck-pending sweep hits the Hub on
+        # import. Off in tests so a Hub blip doesn't slow the fixture
+        # or pollute the log; the sweep is exercised separately in
+        # submit-specific tests.
+        "CADGENBENCH_DISABLE_BOOT_SWEEP": "1",
+    }
+    log_file = log_path.open("w", buffering=1)
+    proc = subprocess.Popen(
+        [sys.executable, "app.py"],
+        cwd=str(SPACE_ROOT),
+        env=env,
+        stdout=log_file,
+        stderr=subprocess.STDOUT,
+    )
+    try:
+        _wait_for_ready(proc, f"http://127.0.0.1:{port}", log_path)
+        yield f"http://127.0.0.1:{port}"
+    finally:
+        proc.terminate()
+        try:
+            proc.wait(timeout=10)
+        except subprocess.TimeoutExpired:
+            proc.kill()
+            proc.wait(timeout=5)
+        log_file.close()

tests/test_smoke.py

@@ -0,0 +1,28 @@
+"""Playwright headless smoke test.
+
+Boots ``app.py`` in a subprocess (via the ``app_url`` fixture in
+:mod:`conftest`) and asserts the three Gradio tabs render. Acts as
+the Phase D minimum: if the Space won't load any tab, every other
+test downstream is meaningless.
+
+Requires:
+- ``pip install -r requirements-dev.txt``
+- ``playwright install chromium`` (one-off, fetches the bundled browser)
+"""
+from __future__ import annotations
+
+from playwright.sync_api import expect, sync_playwright
+
+
+def test_three_tabs_render(app_url):
+    with sync_playwright() as p:
+        browser = p.chromium.launch(headless=True)
+        try:
+            page = browser.new_page()
+            page.goto(app_url)
+            for tab_name in ("Leaderboard", "Submit", "About"):
+                expect(page.get_by_role("tab", name=tab_name)).to_be_visible(
+                    timeout=15_000
+                )
+        finally:
+            browser.close()