sync all project files

app.py

@@ -201,12 +201,11 @@ F1_CSS = """
 
 #race-topbar {
     margin-top: 14px;
-    background: rgba(23, 23, 23, 0.88);
+    background: rgba(23, 23, 23, 0.95);
     border: 1px solid var(--f1-line);
     border-left: 4px solid var(--f1-accent);
     border-radius: 12px;
     padding: 16px;
-    backdrop-filter: blur(18px);
 }
 
 #race-topbar label,

tests/fixtures/2023_British_GP_laps.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ff15e331c4f3a295b46144d5af6b7a15daa5a56917d44fd20173dbe67d79f25a
+size 9641

tests/fixtures/make_fixtures.py

@@ -0,0 +1,48 @@
+"""
+Generate synthetic Parquet fixtures for race_data unit tests.
+Run once: python tests/fixtures/make_fixtures.py
+"""
+
+from pathlib import Path
+import pandas as pd
+import numpy as np
+
+OUT_DIR = Path(__file__).parent
+LAPS_COLUMNS = [
+    "lap_number", "driver_code", "team", "lap_time_s", "compound",
+    "tyre_life", "position", "gap_to_leader_s", "pit_in", "pit_out", "sc_active",
+]
+
+DRIVERS = ["VER", "HAM", "NOR", "PER", "ALO"]
+TOTAL_LAPS = 52
+
+
+def _make_laps() -> pd.DataFrame:
+    rows = []
+    for lap in range(1, TOTAL_LAPS + 1):
+        for i, drv in enumerate(DRIVERS):
+            rows.append({
+                "lap_number": lap,
+                "driver_code": drv,
+                "team": "RBR" if drv in ("VER", "PER") else "MER",
+                "lap_time_s": 90.0 + i * 0.3 + np.random.uniform(-0.1, 0.1),
+                "compound": "MEDIUM" if lap <= 25 else "HARD",
+                "tyre_life": lap if lap <= 25 else lap - 25,
+                "position": i + 1,
+                "gap_to_leader_s": 0.0 if i == 0 else i * 2.5,
+                "pit_in": lap == 26 and i == 0,
+                "pit_out": lap == 27 and i == 0,
+                "sc_active": lap in (10, 11, 12),
+            })
+    df = pd.DataFrame(rows, columns=LAPS_COLUMNS)
+    df["lap_number"] = df["lap_number"].astype("int32")
+    df["tyre_life"] = df["tyre_life"].astype("int32")
+    df["position"] = df["position"].astype("int32")
+    return df
+
+
+if __name__ == "__main__":
+    laps = _make_laps()
+    path = OUT_DIR / "2023_British_GP_laps.parquet"
+    laps.to_parquet(path, index=False)
+    print(f"Written {len(laps)} rows to {path}")

tests/smoke/test_modal_client.py

@@ -0,0 +1,49 @@
+"""Smoke tests for the Modal client (Issue #8).
+
+MANUAL-ONLY — not run in CI.
+
+Run with:
+    python -m pytest tests/smoke/test_modal_client.py -v
+
+WARNING: Each invocation hits live Modal containers and consumes Modal credits.
+Do not add this to CI or run repeatedly without need.
+"""
+
+import time
+
+from modal_backend.client import call_generate_commentary, call_reason_strategy
+
+COMMENTARY_PROMPT = (
+    "LAP 47 of 57 at Monaco. Verstappen leads Hamilton by 6.2 seconds. "
+    "Hamilton is on worn mediums, tyre age 28 laps. "
+    "Generate a 2-sentence broadcast commentary update."
+)
+
+STRATEGY_PROMPT = (
+    "Race: 2023 British Grand Prix\n"
+    "Original outcome: Verstappen won from pole, Hamilton finished P4 after a late pit.\n"
+    "User change: What if Hamilton had pitted 5 laps earlier on lap 30 for fresh mediums?"
+)
+
+
+def test_container1_reachable_and_non_empty():
+    """Container 1 (MiniCPM-o) returns a non-empty text response."""
+    result = call_generate_commentary(prompt=COMMENTARY_PROMPT)
+    assert isinstance(result, dict), "Expected dict response from Container 1"
+    assert result.get("text"), "Container 1 returned empty text"
+
+
+def test_container2_reachable_and_non_empty():
+    """Container 2 (Nemotron Nano) returns a non-empty reasoning chain."""
+    result = call_reason_strategy(prompt=STRATEGY_PROMPT)
+    assert isinstance(result, dict), "Expected dict response from Container 2"
+    assert result.get("reasoning_chain"), "Container 2 returned empty reasoning_chain"
+
+
+def test_warmup_returns_under_2_seconds():
+    """Warmup flag (both containers already warm) completes in under 2 seconds."""
+    start = time.monotonic()
+    call_generate_commentary(prompt="", warmup=True)
+    call_reason_strategy(prompt="", warmup=True)
+    elapsed = time.monotonic() - start
+    assert elapsed < 2.0, f"Warmup took {elapsed:.2f}s — containers may be cold"

tests/test_what_if_tab.py

@@ -0,0 +1,148 @@
+"""Tests for the What-If tab logic in app.py."""
+
+import math
+import types
+import unittest
+from unittest.mock import MagicMock, patch
+
+import pandas as pd
+import sys
+import os
+
+# Ensure project root is on path
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+
+# ── helpers imported directly (no Gradio or Modal needed) ──────────────────
+from app import (
+    _build_timing_table,
+    _build_strategy_prompt,
+    _run_what_if,
+    _PIVOT_LAP_MIN,
+    _PIVOT_LAP_MAX,
+)
+
+
+def _make_window(n_rows=3) -> pd.DataFrame:
+    return pd.DataFrame(
+        {
+            "lap_number": [30, 30, 31],
+            "driver_code": ["VER", "HAM", "VER"],
+            "position": [1, 2, 1],
+            "gap_to_leader_s": [float("nan"), 3.412, float("nan")],
+            "compound": ["MEDIUM", "HARD", "MEDIUM"],
+            "tyre_life": [10, 14, 11],
+            "lap_time_s": [88.1, 88.9, 88.0],
+            "sc_active": [False, False, False],
+        }
+    )
+
+
+class TestBuildTimingTable(unittest.TestCase):
+    def test_header_row_present(self):
+        table = _build_timing_table(_make_window())
+        assert "LAP" in table
+        assert "DRV" in table
+        assert "CMPD" in table
+
+    def test_leader_label(self):
+        table = _build_timing_table(_make_window())
+        assert "LEADER" in table
+
+    def test_gap_formatted(self):
+        table = _build_timing_table(_make_window())
+        assert "3.412" in table
+
+    def test_empty_dataframe(self):
+        result = _build_timing_table(pd.DataFrame())
+        assert "No data" in result
+
+
+class TestBuildStrategyPrompt(unittest.TestCase):
+    def _race(self):
+        return {
+            "name": "British Grand Prix",
+            "season": 2023,
+            "circuit": "Silverstone",
+            "top_finishers": "Verstappen, Hamilton, Alonso",
+        }
+
+    def test_fields_injected(self):
+        table = "LAP  DRV  POS  GAP(s)  CMPD  AGE"
+        prompt = _build_strategy_prompt(self._race(), 35, "What if HAM pitted earlier?", table)
+        assert "British Grand Prix" in prompt
+        assert "2023" in prompt
+        assert "Silverstone" in prompt
+        assert "35" in prompt
+        assert "What if HAM pitted earlier?" in prompt
+        assert table in prompt
+
+
+class TestRunWhatIf(unittest.TestCase):
+    """Test the generator function _run_what_if without hitting Modal."""
+
+    def _collect(self, gen):
+        return list(gen)
+
+    def test_empty_whatif_returns_prompt(self):
+        race = {"season": 2023, "round": 5, "name": "X", "circuit": "Y"}
+        results = self._collect(_run_what_if(race, 30, "   "))
+        left, right = results[0]
+        assert "Enter" in left
+
+    def test_pivot_below_min_shows_warning(self):
+        race = {"season": 2023, "round": 5, "name": "X", "circuit": "Y"}
+        results = self._collect(_run_what_if(race, _PIVOT_LAP_MIN - 1, "some scenario"))
+        left, right = results[0]
+        assert "outside the recommended range" in left
+        assert right == ""
+
+    def test_pivot_above_max_shows_warning(self):
+        race = {"season": 2023, "round": 5, "name": "X", "circuit": "Y"}
+        results = self._collect(_run_what_if(race, _PIVOT_LAP_MAX + 1, "some scenario"))
+        left, right = results[0]
+        assert "outside the recommended range" in left
+        assert right == ""
+
+    def test_pivot_at_boundary_passes_validation(self):
+        race = {"season": 2023, "round": 5, "name": "X", "circuit": "Y"}
+        window_df = _make_window()
+        with patch("app.get_race_window", return_value=window_df), \
+             patch("app.call_reason_strategy", return_value={"reasoning_chain": "Step 1. Step 2."}):
+            results = self._collect(_run_what_if(race, _PIVOT_LAP_MIN, "HAM earlier pit?"))
+        # last yield should contain reasoning in right panel
+        final_left, final_right = results[-1]
+        assert "Step 1" in final_right
+
+    def test_file_not_found_surfaces_error(self):
+        race = {"season": 2023, "round": 5, "name": "X", "circuit": "Y"}
+        with patch("app.get_race_window", side_effect=FileNotFoundError("No cache")):
+            results = self._collect(_run_what_if(race, 30, "some scenario"))
+        # first yield is loading, second is error
+        left, right = results[-1]
+        assert "No cache" in left
+
+    def test_timing_table_in_left_panel_on_success(self):
+        race = {"season": 2023, "round": 5, "name": "X", "circuit": "Y"}
+        window_df = _make_window()
+        with patch("app.get_race_window", return_value=window_df), \
+             patch("app.call_reason_strategy", return_value={"reasoning_chain": "Analysis done."}):
+            results = self._collect(_run_what_if(race, 30, "What if VER pitted?"))
+        final_left, final_right = results[-1]
+        assert "LAP" in final_left
+        assert "Analysis done." in final_right
+
+    def test_no_audio_component(self):
+        """Right panel is plain text — no audio output from _run_what_if."""
+        race = {"season": 2023, "round": 5, "name": "X", "circuit": "Y"}
+        window_df = _make_window()
+        with patch("app.get_race_window", return_value=window_df), \
+             patch("app.call_reason_strategy", return_value={"reasoning_chain": "Reasoning."}):
+            results = self._collect(_run_what_if(race, 30, "What if?"))
+        for left, right in results:
+            # right panel is always a string, never bytes/audio
+            assert isinstance(right, str)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/unit/test_commentary_tab.py

@@ -0,0 +1,167 @@
+"""Unit tests for the Commentary tab handler (Issue #10)."""
+
+import sys
+import types
+import tempfile
+from pathlib import Path
+from unittest.mock import patch, MagicMock
+
+import pandas as pd
+import numpy as np
+import pytest
+
+sys.path.insert(0, str(Path(__file__).parent.parent.parent))
+
+
+# ---------------------------------------------------------------------------
+# Helpers / fixtures
+# ---------------------------------------------------------------------------
+
+@pytest.fixture()
+def lap_df():
+    rows = []
+    for lap in range(15, 26):
+        for driver, pos, team, gap in [
+            ("VER", 1, "Red Bull Racing", 0.0),
+            ("NOR", 2, "McLaren", 4.5),
+        ]:
+            rows.append({
+                "lap_number": lap,
+                "driver_code": driver,
+                "team": team,
+                "position": pos,
+                "gap_to_leader_s": gap,
+                "compound": "MEDIUM",
+                "tyre_life": lap - 10,
+                "lap_time_s": 90.1,
+                "sc_active": False,
+            })
+    return pd.DataFrame(rows)
+
+
+@pytest.fixture()
+def race():
+    return {"season": 2024, "round": 21, "name": "Brazilian GP", "circuit": "Interlagos", "modes": ["commentary"]}
+
+
+# ---------------------------------------------------------------------------
+# _top_two_drivers
+# ---------------------------------------------------------------------------
+
+class TestTopTwoDrivers:
+    def test_returns_p1_p2_at_pivot_lap(self, lap_df):
+        with patch("app._CACHE_DIR") as mock_cache, \
+             patch("app._race_key", return_value="2024_Brazilian_GP"), \
+             patch("pandas.read_parquet", return_value=lap_df):
+            from app import _top_two_drivers
+            driver_a, driver_b, team_name = _top_two_drivers(2024, 21, 20)
+        assert driver_a == "VER"
+        assert driver_b == "NOR"
+        assert team_name == "Red Bull Racing"
+
+    def test_falls_back_to_last_lap_when_pivot_missing(self, lap_df):
+        # pivot_lap=99 doesn't exist — should fall back to lap 25
+        with patch("app._race_key", return_value="2024_Brazilian_GP"), \
+             patch("pandas.read_parquet", return_value=lap_df):
+            from app import _top_two_drivers
+            driver_a, driver_b, team_name = _top_two_drivers(2024, 21, 99)
+        assert driver_a == "VER"
+        assert driver_b == "NOR"
+
+
+# ---------------------------------------------------------------------------
+# _generate_commentary — mocked Modal call
+# ---------------------------------------------------------------------------
+
+class TestGenerateCommentary:
+    def _make_wav_bytes(self):
+        """Minimal valid 16-bit WAV bytes (44-byte header + 2 bytes of silence)."""
+        import struct
+        data = b"\x00\x00"
+        header = struct.pack(
+            "<4sI4s4sIHHIIHH4sI",
+            b"RIFF", 36 + len(data), b"WAVE",
+            b"fmt ", 16, 1, 1, 24000, 48000, 2, 16,
+            b"data", len(data),
+        )
+        return header + data
+
+    def test_broadcast_returns_audio_path_and_text(self, race, lap_df):
+        audio_bytes = self._make_wav_bytes()
+        modal_result = {"text": "Verstappen extends his lead.", "audio_wav": audio_bytes}
+
+        with patch("app._top_two_drivers", return_value=("VER", "NOR", "Red Bull Racing")), \
+             patch("app.get_lap_window", return_value=lap_df), \
+             patch("app.build_commentary_prompt", return_value="[prompt]"), \
+             patch("app.call_generate_commentary", return_value=modal_result):
+            from app import _generate_commentary
+            audio_path, text = _generate_commentary(race, 20, "Broadcast")
+
+        assert text == "Verstappen extends his lead."
+        assert audio_path is not None
+        assert audio_path.endswith(".wav")
+
+    def test_radio_passes_mode_radio_to_prompt_builder(self, race, lap_df):
+        modal_result = {"text": "Box this lap.", "audio_wav": b""}
+
+        with patch("app._top_two_drivers", return_value=("VER", "NOR", "Red Bull Racing")), \
+             patch("app.get_lap_window", return_value=lap_df), \
+             patch("app.build_commentary_prompt", return_value="[prompt]") as mock_build, \
+             patch("app.call_generate_commentary", return_value=modal_result):
+            from app import _generate_commentary
+            _generate_commentary(race, 20, "Radio")
+
+        mock_build.assert_called_once_with(lap_df, "Red Bull Racing", "radio")
+
+    def test_broadcast_passes_mode_broadcast_to_prompt_builder(self, race, lap_df):
+        modal_result = {"text": "Hamilton closes in.", "audio_wav": b""}
+
+        with patch("app._top_two_drivers", return_value=("VER", "HAM", "Red Bull Racing")), \
+             patch("app.get_lap_window", return_value=lap_df), \
+             patch("app.build_commentary_prompt", return_value="[prompt]") as mock_build, \
+             patch("app.call_generate_commentary", return_value=modal_result):
+            from app import _generate_commentary
+            _generate_commentary(race, 20, "Broadcast")
+
+        mock_build.assert_called_once_with(lap_df, "Red Bull Racing", "broadcast")
+
+    def test_no_audio_bytes_returns_none_path(self, race, lap_df):
+        modal_result = {"text": "VER leads.", "audio_wav": b""}
+
+        with patch("app._top_two_drivers", return_value=("VER", "NOR", "Red Bull Racing")), \
+             patch("app.get_lap_window", return_value=lap_df), \
+             patch("app.build_commentary_prompt", return_value="[prompt]"), \
+             patch("app.call_generate_commentary", return_value=modal_result):
+            from app import _generate_commentary
+            audio_path, text = _generate_commentary(race, 20, "Broadcast")
+
+        assert audio_path is None
+        assert text == "VER leads."
+
+
+# ---------------------------------------------------------------------------
+# Two-tier loading copy
+# ---------------------------------------------------------------------------
+
+class TestLoadingMessages:
+    def test_first_call_returns_pit_wall_message(self):
+        from modal_backend.client import get_commentary_loading_message
+        import modal_backend.client as client_mod
+        original = client_mod._commentary_call_count
+        try:
+            client_mod._commentary_call_count = 0
+            msg = get_commentary_loading_message()
+            assert "pit wall" in msg.lower()
+        finally:
+            client_mod._commentary_call_count = original
+
+    def test_subsequent_call_returns_shorter_message(self):
+        from modal_backend.client import get_commentary_loading_message
+        import modal_backend.client as client_mod
+        original = client_mod._commentary_call_count
+        try:
+            client_mod._commentary_call_count = 1
+            msg = get_commentary_loading_message()
+            assert msg != "Connecting to the pit wall… (~20s first call)"
+        finally:
+            client_mod._commentary_call_count = original

tests/unit/test_persona.py

@@ -0,0 +1,186 @@
+"""Unit tests for the persona module (Issue #6)."""
+
+import pytest
+from pathlib import Path
+
+# Allow imports from the project root
+import sys
+sys.path.insert(0, str(Path(__file__).parent.parent.parent))
+
+from prompts.persona import get_system_prompt, _driver_file
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _read_driver_file(name: str) -> str:
+    path = _driver_file(name)
+    return path.read_text(encoding="utf-8")
+
+
+# ---------------------------------------------------------------------------
+# Knowledge cutoff assertions
+# ---------------------------------------------------------------------------
+
+class TestCutoffYear:
+    def test_verstappen_cutoff_present(self):
+        text = _read_driver_file("verstappen")
+        assert "end of 2023" in text.lower() or "2023" in text
+
+    def test_hamilton_cutoff_present(self):
+        text = _read_driver_file("hamilton")
+        assert "end of 2023" in text.lower() or "2023" in text
+
+    def test_norris_cutoff_present(self):
+        text = _read_driver_file("norris")
+        assert "end of 2023" in text.lower() or "2023" in text
+
+    def test_schumacher_cutoff_is_2012(self):
+        text = _read_driver_file("schumacher")
+        assert "2012" in text
+        assert "end of 2012" in text.lower()
+
+    def test_senna_cutoff_is_may_1994(self):
+        text = _read_driver_file("senna")
+        assert "1994" in text
+        assert "may 1994" in text.lower()
+
+
+# ---------------------------------------------------------------------------
+# Schumacher content guard — no forbidden words/years
+# ---------------------------------------------------------------------------
+
+class TestSchumacherContentGuard:
+    def setup_method(self):
+        self.text = _read_driver_file("schumacher").lower()
+
+    def test_no_word_accident(self):
+        assert "accident" not in self.text
+
+    def test_no_word_skiing(self):
+        assert "skiing" not in self.text
+
+    def test_no_year_2013(self):
+        assert "2013" not in self.text
+
+    def test_no_years_after_2012(self):
+        for year in range(2013, 2030):
+            assert str(year) not in self.text, f"Forbidden year {year} found in schumacher.txt"
+
+
+# ---------------------------------------------------------------------------
+# Deflection phrases — non-empty and count
+# ---------------------------------------------------------------------------
+
+class TestDeflectionPhrases:
+    @pytest.mark.parametrize("driver", ["verstappen", "hamilton", "norris", "senna", "schumacher"])
+    def test_deflection_section_present(self, driver):
+        text = _read_driver_file(driver)
+        assert "deflection phrase" in text.lower(), f"{driver}: missing deflection phrases section"
+
+    @pytest.mark.parametrize("driver", ["verstappen", "hamilton", "norris", "senna", "schumacher"])
+    def test_at_least_five_deflection_phrases(self, driver):
+        text = _read_driver_file(driver)
+        # Deflection phrases are numbered list items 1-5
+        count = sum(1 for line in text.splitlines() if line.strip() and line.strip()[0].isdigit() and ". " in line[:4])
+        assert count >= 5, f"{driver}: expected at least 5 numbered deflection phrases, found {count}"
+
+    @pytest.mark.parametrize("driver", ["verstappen", "hamilton", "norris", "senna", "schumacher"])
+    def test_deflection_phrases_non_empty(self, driver):
+        text = _read_driver_file(driver)
+        lines = [l.strip() for l in text.splitlines() if l.strip() and l.strip()[0].isdigit() and ". " in l.strip()[:4]]
+        for line in lines:
+            # Strip leading "1. " etc. and check there's real content
+            content = line.split(". ", 1)[-1].strip()
+            assert len(content) > 10, f"{driver}: deflection phrase too short: {repr(line)}"
+
+
+# ---------------------------------------------------------------------------
+# Personality distinctiveness — spot-check key register words
+# ---------------------------------------------------------------------------
+
+class TestPersonalityRegister:
+    def test_verstappen_blunt_register(self):
+        text = _read_driver_file("verstappen").lower()
+        assert "blunt" in text or "direct" in text
+
+    def test_hamilton_diplomatic_register(self):
+        text = _read_driver_file("hamilton").lower()
+        assert "diplomatic" in text or "articulate" in text or "considered" in text
+
+    def test_norris_self_deprecating_register(self):
+        text = _read_driver_file("norris").lower()
+        assert "self-deprecating" in text or "self deprecating" in text
+
+
+# ---------------------------------------------------------------------------
+# Persona module: get_system_prompt
+# ---------------------------------------------------------------------------
+
+class TestGetSystemPrompt:
+    def test_returns_string_for_all_drivers(self):
+        for driver in ["verstappen", "hamilton", "norris", "senna", "schumacher"]:
+            result = get_system_prompt(driver)
+            assert isinstance(result, str)
+            assert len(result) > 100
+
+    def test_case_insensitive_driver_name(self):
+        lower = get_system_prompt("verstappen")
+        upper = get_system_prompt("Verstappen")
+        mixed = get_system_prompt("VERSTAPPEN")
+        assert lower == upper == mixed
+
+    def test_missing_driver_raises_file_not_found(self):
+        with pytest.raises(FileNotFoundError) as exc_info:
+            get_system_prompt("alonso")
+        assert "alonso" in str(exc_info.value).lower()
+        assert "available drivers" in str(exc_info.value).lower()
+
+    def test_missing_driver_error_is_descriptive(self):
+        with pytest.raises(FileNotFoundError) as exc_info:
+            get_system_prompt("grosjean")
+        msg = str(exc_info.value)
+        # Must name the bad driver and hint at valid ones
+        assert "grosjean" in msg.lower()
+        assert any(d in msg for d in ["verstappen", "hamilton", "norris"])
+
+
+# ---------------------------------------------------------------------------
+# Race context injection
+# ---------------------------------------------------------------------------
+
+class TestRaceContextInjection:
+    RACE = "2023 Dutch Grand Prix, Lap 42 of 72. Verstappen leads by 4.8s on hard tires, age 31."
+
+    def test_race_context_injected_for_verstappen(self):
+        result = get_system_prompt("verstappen", race_context=self.RACE)
+        assert self.RACE in result
+        assert "Current Race Context" in result
+
+    def test_race_context_injected_for_hamilton(self):
+        result = get_system_prompt("hamilton", race_context=self.RACE)
+        assert self.RACE in result
+
+    def test_race_context_injected_for_norris(self):
+        result = get_system_prompt("norris", race_context=self.RACE)
+        assert self.RACE in result
+
+    def test_race_context_silently_absent_for_senna(self):
+        result = get_system_prompt("senna", race_context=self.RACE)
+        # No error raised, race context not injected
+        assert self.RACE not in result
+        assert "Current Race Context" not in result
+
+    def test_race_context_silently_absent_for_schumacher(self):
+        result = get_system_prompt("schumacher", race_context=self.RACE)
+        assert self.RACE not in result
+        assert "Current Race Context" not in result
+
+    def test_none_race_context_active_driver_no_injection(self):
+        result = get_system_prompt("verstappen", race_context=None)
+        assert "Current Race Context" not in result
+
+    def test_empty_race_context_treated_as_absent(self):
+        result = get_system_prompt("verstappen", race_context="")
+        assert "Current Race Context" not in result

tests/unit/test_persona_chat.py

@@ -0,0 +1,281 @@
+"""Unit tests for Issue #12 — Persona Chat tab logic.
+
+Tests cover:
+- Driver selector: correct set of 5 drivers
+- Historical vs active driver classification
+- Race context injection (active drivers only)
+- Persona prompt construction via build_persona_prompt
+- Knowledge cutoff enforcement (deflection phrases present)
+- on_driver_selected: historical notice visibility and race context display
+- on_race_changed: active vs historical behavior
+- on_send: empty input guard, system prompt construction
+- transcribe_audio: raises EnvironmentError when COHERE_API_KEY is missing
+- call_persona_chat: delegates to generate_commentary with merged prompt
+"""
+
+import io
+import sys
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).parent.parent.parent))
+
+from app import (
+    PERSONA_DRIVERS,
+    _ACTIVE_DRIVERS,
+    _HISTORICAL_DRIVERS,
+    _race_context_string,
+)
+from prompts.builder import build_persona_prompt
+
+
+# ── Fixtures ─────────────────────────────────────────────────────────────────
+
+SAMPLE_RACE = {
+    "season": 2023,
+    "name": "British Grand Prix",
+    "circuit": "Silverstone",
+    "round": 10,
+}
+
+
+# ── Driver list ───────────────────────────────────────────────────────────────
+
+class TestDriverList:
+    def test_five_drivers_defined(self):
+        assert len(PERSONA_DRIVERS) == 5
+
+    def test_expected_drivers_present(self):
+        names = {d.lower() for d in PERSONA_DRIVERS}
+        assert names == {"verstappen", "hamilton", "norris", "senna", "schumacher"}
+
+    def test_active_and_historical_sets_are_disjoint(self):
+        assert _ACTIVE_DRIVERS.isdisjoint(_HISTORICAL_DRIVERS)
+
+    def test_all_drivers_classified(self):
+        all_classified = _ACTIVE_DRIVERS | _HISTORICAL_DRIVERS
+        for driver in PERSONA_DRIVERS:
+            assert driver.lower() in all_classified, f"{driver} not classified"
+
+
+# ── Race context string ───────────────────────────────────────────────────────
+
+class TestRaceContextString:
+    def test_includes_season(self):
+        result = _race_context_string(SAMPLE_RACE)
+        assert "2023" in result
+
+    def test_includes_race_name(self):
+        result = _race_context_string(SAMPLE_RACE)
+        assert "British Grand Prix" in result
+
+    def test_includes_circuit(self):
+        result = _race_context_string(SAMPLE_RACE)
+        assert "Silverstone" in result
+
+    def test_includes_round(self):
+        result = _race_context_string(SAMPLE_RACE)
+        assert "10" in result
+
+    def test_returns_string(self):
+        assert isinstance(_race_context_string(SAMPLE_RACE), str)
+
+
+# ── on_driver_selected logic ──────────────────────────────────────────────────
+
+class TestDriverSelectedLogic:
+    """Tests for the on_driver_selected callback logic (extracted inline)."""
+
+    def _run(self, driver: str, race: dict):
+        key = driver.lower()
+        is_historical = key in _HISTORICAL_DRIVERS
+        if is_historical:
+            notice = "Historical drivers don't use race telemetry"
+            ctx_display = ""
+        else:
+            notice = ""
+            ctx_display = _race_context_string(race) if race else ""
+        return is_historical, notice, ctx_display
+
+    def test_senna_is_historical(self):
+        is_h, notice, ctx = self._run("Senna", SAMPLE_RACE)
+        assert is_h is True
+        assert notice != ""
+        assert ctx == ""
+
+    def test_schumacher_is_historical(self):
+        is_h, notice, ctx = self._run("Schumacher", SAMPLE_RACE)
+        assert is_h is True
+        assert ctx == ""
+
+    def test_verstappen_is_active(self):
+        is_h, notice, ctx = self._run("Verstappen", SAMPLE_RACE)
+        assert is_h is False
+        assert notice == ""
+        assert "2023" in ctx
+
+    def test_hamilton_active_gets_race_context(self):
+        is_h, notice, ctx = self._run("Hamilton", SAMPLE_RACE)
+        assert "British Grand Prix" in ctx
+
+    def test_norris_active_gets_race_context(self):
+        is_h, notice, ctx = self._run("Norris", SAMPLE_RACE)
+        assert "Silverstone" in ctx
+
+
+# ── on_race_changed logic ─────────────────────────────────────────────────────
+
+class TestRaceChangedLogic:
+    def _run(self, race: dict, driver: str) -> str:
+        if driver.lower() in _HISTORICAL_DRIVERS:
+            return ""
+        return _race_context_string(race) if race else ""
+
+    def test_active_driver_returns_race_context(self):
+        result = self._run(SAMPLE_RACE, "Verstappen")
+        assert "British Grand Prix" in result
+
+    def test_historical_driver_returns_empty(self):
+        result = self._run(SAMPLE_RACE, "Senna")
+        assert result == ""
+
+    def test_schumacher_returns_empty(self):
+        result = self._run(SAMPLE_RACE, "Schumacher")
+        assert result == ""
+
+
+# ── on_send guard: empty input ────────────────────────────────────────────────
+
+class TestOnSendEmptyInputGuard:
+    def _send_results(self, driver, user_text, race):
+        # Reproduce the empty-check from on_send
+        if not user_text or not user_text.strip():
+            return [("Please record or type a question first.", None)]
+        return []
+
+    def test_empty_string_triggers_guard(self):
+        results = self._send_results("Verstappen", "", SAMPLE_RACE)
+        assert results
+        assert "Please record or type a question first." in results[0][0]
+
+    def test_whitespace_triggers_guard(self):
+        results = self._send_results("Verstappen", "   ", SAMPLE_RACE)
+        assert results
+        assert results[0][1] is None
+
+    def test_none_triggers_guard(self):
+        results = self._send_results("Verstappen", None, SAMPLE_RACE)
+        assert results
+
+
+# ── Persona prompt construction ───────────────────────────────────────────────
+
+class TestPersonaPromptConstruction:
+    def test_active_driver_receives_race_context(self):
+        ctx = _race_context_string(SAMPLE_RACE)
+        prompt = build_persona_prompt("verstappen", race_context=ctx)
+        assert "British Grand Prix" in prompt
+        assert "Current Race Context" in prompt
+
+    def test_historical_driver_no_race_context(self):
+        ctx = _race_context_string(SAMPLE_RACE)
+        prompt = build_persona_prompt("senna", race_context=ctx)
+        assert "Current Race Context" not in prompt
+
+    def test_cutoff_block_present_for_all_drivers(self):
+        for driver in ["verstappen", "hamilton", "norris", "senna", "schumacher"]:
+            prompt = build_persona_prompt(driver)
+            assert "Knowledge Cutoff" in prompt, f"{driver}: missing cutoff block"
+
+    def test_senna_prompt_does_not_contain_post_1994_events(self):
+        prompt = build_persona_prompt("senna").lower()
+        assert "may 1994" in prompt or "1994" in prompt
+
+    def test_schumacher_prompt_does_not_mention_accident(self):
+        prompt = build_persona_prompt("schumacher").lower()
+        assert "accident" not in prompt
+        assert "skiing" not in prompt
+
+
+# ── Knowledge cutoff enforcement ──────────────────────────────────────────────
+
+class TestKnowledgeCutoffEnforcement:
+    """Deflection phrases must be present for all drivers (enforced by persona files)."""
+
+    @pytest.mark.parametrize("driver", ["verstappen", "hamilton", "norris", "senna", "schumacher"])
+    def test_deflection_section_in_prompt(self, driver):
+        prompt = build_persona_prompt(driver)
+        assert "deflection phrase" in prompt.lower(), f"{driver}: no deflection section"
+
+
+# ── transcribe_audio: missing API key ────────────────────────────────────────
+
+class TestTranscribeAudioMissingKey:
+    def test_raises_environment_error_without_key(self):
+        from modal_backend.client import transcribe_audio
+
+        mock_cohere = MagicMock()
+        with patch.dict("sys.modules", {"cohere": mock_cohere}):
+            import os
+            saved = os.environ.pop("COHERE_API_KEY", None)
+            try:
+                with pytest.raises(EnvironmentError, match="COHERE_API_KEY"):
+                    transcribe_audio(b"fake audio bytes")
+            finally:
+                if saved is not None:
+                    os.environ["COHERE_API_KEY"] = saved
+
+
+# ── call_persona_chat delegates correctly ─────────────────────────────────────
+
+class TestCallPersonaChat:
+    def test_delegates_to_persona_chat(self):
+        mock_result = {"text": "I will win.", "audio_wav": b""}
+        with patch("modal_backend.client._persona_chat") as mock_fn:
+            mock_fn.remote.return_value = mock_result
+            from modal_backend.client import call_persona_chat
+
+            result = call_persona_chat(
+                system_prompt="You are Verstappen.",
+                user_message="Will you win?",
+            )
+            assert result["text"] == "I will win."
+            mock_fn.remote.assert_called_once()
+
+    def test_warmup_does_not_increment_call_count(self):
+        mock_result = {}
+        with patch("modal_backend.client._persona_chat") as mock_fn:
+            mock_fn.remote.return_value = mock_result
+            import modal_backend.client as client_mod
+
+            before = client_mod._persona_call_count
+            from modal_backend.client import call_persona_chat
+
+            call_persona_chat(system_prompt="", user_message="", warmup=True)
+            assert client_mod._persona_call_count == before
+
+    def test_non_warmup_increments_call_count(self):
+        mock_result = {"text": "ok", "audio_wav": b""}
+        with patch("modal_backend.client._persona_chat") as mock_fn:
+            mock_fn.remote.return_value = mock_result
+            import modal_backend.client as client_mod
+
+            before = client_mod._persona_call_count
+            from modal_backend.client import call_persona_chat
+
+            call_persona_chat(system_prompt="s", user_message="q", warmup=False)
+            assert client_mod._persona_call_count == before + 1
+
+
+# ── get_persona_loading_message ───────────────────────────────────────────────
+
+class TestGetPersonaLoadingMessage:
+    def test_returns_string(self):
+        from modal_backend.client import get_persona_loading_message
+
+        result = get_persona_loading_message()
+        assert isinstance(result, str)
+        assert len(result) > 5
+

tests/unit/test_prompt_builder.py

@@ -0,0 +1,232 @@
+"""Unit tests for the Prompt Builder module (Issue #7)."""
+
+import sys
+from pathlib import Path
+
+import pandas as pd
+import pytest
+
+sys.path.insert(0, str(Path(__file__).parent.parent.parent))
+
+from prompts.builder import (
+    build_commentary_prompt,
+    build_persona_prompt,
+    build_strategy_prompt,
+    _ANTI_HALLUCINATION,
+    _MINICPM_TOKEN_LIMIT,
+    _NEMOTRON_TOKEN_LIMIT,
+    _CHARS_PER_TOKEN,
+)
+from data.race_data import WINDOW_COLUMNS
+
+
+# ---------------------------------------------------------------------------
+# Fixture: minimal 10-lap × 2-driver DataFrame
+# ---------------------------------------------------------------------------
+
+@pytest.fixture()
+def lap_df() -> pd.DataFrame:
+    rows = []
+    for lap in range(41, 51):  # laps 41-50, pivot=45
+        for driver, pos, gap in [("VER", 1, 0.0), ("HAM", 2, 6.2)]:
+            rows.append({
+                "lap_number": lap,
+                "driver_code": driver,
+                "position": pos,
+                "gap_to_leader_s": gap,
+                "compound": "MEDIUM",
+                "tyre_life": lap - 30,
+                "lap_time_s": 90.1 + (lap * 0.01),
+                "sc_active": False,
+            })
+    return pd.DataFrame(rows, columns=WINDOW_COLUMNS)
+
+
+# ---------------------------------------------------------------------------
+# Commentary — broadcast mode
+# ---------------------------------------------------------------------------
+
+class TestBroadcastMode:
+    def test_returns_string(self, lap_df):
+        result = build_commentary_prompt(lap_df, "Oracle Red Bull Racing", "broadcast")
+        assert isinstance(result, str)
+
+    def test_team_name_interpolated(self, lap_df):
+        result = build_commentary_prompt(lap_df, "Oracle Red Bull Racing", "broadcast")
+        assert "Oracle Red Bull Racing" in result
+
+    def test_lap_data_interpolated(self, lap_df):
+        result = build_commentary_prompt(lap_df, "Oracle Red Bull Racing", "broadcast")
+        assert "VER" in result
+        assert "HAM" in result
+
+    def test_broadcast_tone_marker_present(self, lap_df):
+        result = build_commentary_prompt(lap_df, "Oracle Red Bull Racing", "broadcast")
+        # Template contains "television broadcast" or "broadcast commentator"
+        assert "broadcast" in result.lower()
+
+    def test_within_minicpm_context_window(self, lap_df):
+        result = build_commentary_prompt(lap_df, "Oracle Red Bull Racing", "broadcast")
+        assert len(result) <= _MINICPM_TOKEN_LIMIT * _CHARS_PER_TOKEN
+
+
+# ---------------------------------------------------------------------------
+# Commentary — radio mode
+# ---------------------------------------------------------------------------
+
+class TestRadioMode:
+    def test_returns_string(self, lap_df):
+        result = build_commentary_prompt(lap_df, "Mercedes-AMG Petronas", "radio")
+        assert isinstance(result, str)
+
+    def test_team_name_interpolated(self, lap_df):
+        result = build_commentary_prompt(lap_df, "Mercedes-AMG Petronas", "radio")
+        assert "Mercedes-AMG Petronas" in result
+
+    def test_radio_tone_marker_present(self, lap_df):
+        result = build_commentary_prompt(lap_df, "Mercedes-AMG Petronas", "radio")
+        # Template contains "race engineer" or "team radio"
+        assert "radio" in result.lower() or "race engineer" in result.lower()
+
+    def test_within_minicpm_context_window(self, lap_df):
+        result = build_commentary_prompt(lap_df, "Mercedes-AMG Petronas", "radio")
+        assert len(result) <= _MINICPM_TOKEN_LIMIT * _CHARS_PER_TOKEN
+
+
+# ---------------------------------------------------------------------------
+# Broadcast vs radio are structurally different
+# ---------------------------------------------------------------------------
+
+class TestBroadcastVsRadioStructure:
+    def test_prompts_are_different(self, lap_df):
+        broadcast = build_commentary_prompt(lap_df, "Oracle Red Bull Racing", "broadcast")
+        radio = build_commentary_prompt(lap_df, "Oracle Red Bull Racing", "radio")
+        assert broadcast != radio
+
+    def test_different_instruction_sections(self, lap_df):
+        broadcast = build_commentary_prompt(lap_df, "Oracle Red Bull Racing", "broadcast")
+        radio = build_commentary_prompt(lap_df, "Oracle Red Bull Racing", "radio")
+        # Broadcast instructs TV-style full names; radio uses terse fragments
+        assert "television" in broadcast.lower() or "global audience" in broadcast.lower()
+        assert "terse" in radio.lower() or "clipped" in radio.lower() or "race engineer" in radio.lower()
+
+    def test_invalid_mode_raises(self, lap_df):
+        with pytest.raises(ValueError, match="Unknown commentary mode"):
+            build_commentary_prompt(lap_df, "Red Bull", "freestyle")
+
+
+# ---------------------------------------------------------------------------
+# Strategy mode
+# ---------------------------------------------------------------------------
+
+class TestStrategyMode:
+    WHAT_IF = "What if Hamilton had pitted 5 laps earlier on lap 30 for fresh mediums?"
+
+    def test_returns_string(self, lap_df):
+        result = build_strategy_prompt(lap_df, self.WHAT_IF)
+        assert isinstance(result, str)
+
+    def test_lap_data_interpolated(self, lap_df):
+        result = build_strategy_prompt(lap_df, self.WHAT_IF)
+        assert "VER" in result
+        assert "HAM" in result
+
+    def test_what_if_variable_interpolated(self, lap_df):
+        result = build_strategy_prompt(lap_df, self.WHAT_IF)
+        assert self.WHAT_IF.strip() in result
+
+    def test_anti_hallucination_instruction_present(self, lap_df):
+        result = build_strategy_prompt(lap_df, self.WHAT_IF)
+        assert _ANTI_HALLUCINATION in result
+
+    def test_anti_hallucination_references_invented_values(self, lap_df):
+        result = build_strategy_prompt(lap_df, self.WHAT_IF)
+        assert "invent" in result.lower() or "fabricat" in result.lower()
+
+    def test_within_nemotron_context_window(self, lap_df):
+        result = build_strategy_prompt(lap_df, self.WHAT_IF)
+        assert len(result) <= _NEMOTRON_TOKEN_LIMIT * _CHARS_PER_TOKEN
+
+
+# ---------------------------------------------------------------------------
+# Persona mode — cutoff block
+# ---------------------------------------------------------------------------
+
+class TestPersonaMode:
+    def test_returns_string_for_active_driver(self):
+        result = build_persona_prompt("verstappen")
+        assert isinstance(result, str)
+        assert len(result) > 100
+
+    def test_cutoff_block_appended_for_active_driver(self):
+        for driver in ["verstappen", "hamilton", "norris"]:
+            result = build_persona_prompt(driver)
+            assert "Knowledge Cutoff" in result, f"{driver}: missing cutoff block"
+            assert "end of 2023" in result, f"{driver}: wrong cutoff year"
+
+    def test_cutoff_block_appended_for_historical_drivers(self):
+        result_senna = build_persona_prompt("senna")
+        assert "Knowledge Cutoff" in result_senna
+        assert "1994" in result_senna
+
+        result_schumi = build_persona_prompt("schumacher")
+        assert "Knowledge Cutoff" in result_schumi
+        assert "2012" in result_schumi
+
+    def test_race_context_injected_for_active_driver(self):
+        ctx = "2023 Dutch GP, Lap 42. Verstappen leads by 4.8s."
+        result = build_persona_prompt("verstappen", race_context=ctx)
+        assert ctx in result
+        assert "Current Race Context" in result
+
+    def test_race_context_absent_for_historical_driver(self):
+        ctx = "2023 Dutch GP, Lap 42."
+        result = build_persona_prompt("senna", race_context=ctx)
+        assert ctx not in result
+        assert "Current Race Context" not in result
+
+        result_s = build_persona_prompt("schumacher", race_context=ctx)
+        assert ctx not in result_s
+
+    def test_cutoff_block_comes_after_persona_text(self):
+        result = build_persona_prompt("verstappen")
+        persona_end = result.index("Knowledge Cutoff")
+        # There must be substantial persona content before the cutoff block
+        assert persona_end > 200
+
+    def test_missing_driver_raises_file_not_found(self):
+        with pytest.raises(FileNotFoundError):
+            build_persona_prompt("alonso")
+
+    def test_within_minicpm_context_window(self):
+        result = build_persona_prompt("verstappen")
+        assert len(result) <= _MINICPM_TOKEN_LIMIT * _CHARS_PER_TOKEN
+
+
+# ---------------------------------------------------------------------------
+# Prompt length validation
+# ---------------------------------------------------------------------------
+
+class TestPromptLengthValidation:
+    def test_oversized_strategy_prompt_raises(self):
+        # Build a DataFrame with enough rows to exceed Nemotron's limit
+        rows = []
+        for lap in range(1, 5001):
+            rows.append({
+                "lap_number": lap,
+                "driver_code": "VER",
+                "position": 1,
+                "gap_to_leader_s": 0.0,
+                "compound": "HARD",
+                "tyre_life": lap,
+                "lap_time_s": 90.0,
+                "sc_active": False,
+            })
+        huge_df = pd.DataFrame(rows, columns=WINDOW_COLUMNS)
+        with pytest.raises(ValueError, match="context window"):
+            build_strategy_prompt(huge_df, "any change")
+
+    def test_max_10lap_2driver_strategy_within_bounds(self, lap_df):
+        # The standard 10-lap × 2-driver window must not trip the limit
+        result = build_strategy_prompt(lap_df, "Hamilton pits 5 laps earlier.")
+        assert len(result) <= _NEMOTRON_TOKEN_LIMIT * _CHARS_PER_TOKEN

tests/unit/test_race_data.py

@@ -0,0 +1,116 @@
+"""Unit tests for the Race Data Module (Issue #3)."""
+
+import io
+from pathlib import Path
+
+import pandas as pd
+import pytest
+
+import sys
+sys.path.insert(0, str(Path(__file__).parent.parent.parent))
+
+import data.race_data as rdm
+
+FIXTURES = Path(__file__).parent.parent / "fixtures"
+
+# Minimal YAML covering one race that matches the fixture filename
+_YAML_CONTENT = b"""
+races:
+  - season: 2023
+    round: 10
+    name: "British GP"
+    circuit: "Silverstone"
+    modes: [what_if, demo_anchor]
+"""
+
+
+@pytest.fixture(autouse=True)
+def patch_paths(monkeypatch, tmp_path):
+    """Redirect module to use fixture Parquet and inline YAML."""
+    yaml_file = tmp_path / "curated_races.yaml"
+    yaml_file.write_bytes(_YAML_CONTENT)
+    monkeypatch.setattr(rdm, "_CACHE_DIR", FIXTURES)
+    monkeypatch.setattr(rdm, "_YAML_PATH", yaml_file)
+
+
+# ---------------------------------------------------------------------------
+# Window correctness
+# ---------------------------------------------------------------------------
+
+class TestWindowBounds:
+    def test_mid_race_pivot_returns_11_laps(self):
+        df = rdm.get_lap_window(2023, 10, 30, "VER", "HAM")
+        laps = sorted(df["lap_number"].unique())
+        assert laps == list(range(25, 36))
+
+    def test_mid_race_only_two_drivers(self):
+        df = rdm.get_lap_window(2023, 10, 30, "VER", "HAM")
+        assert set(df["driver_code"].unique()) == {"VER", "HAM"}
+
+    def test_pivot_near_start_truncates_at_lap_1(self):
+        df = rdm.get_lap_window(2023, 10, 3, "VER", "HAM")
+        assert df["lap_number"].min() == 1
+        assert df["lap_number"].max() == 8
+
+    def test_pivot_near_end_truncates_at_final_lap(self):
+        # Fixture has 52 laps; pivot 50 => window [45, 52]
+        df = rdm.get_lap_window(2023, 10, 50, "VER", "HAM")
+        assert df["lap_number"].min() == 45
+        assert df["lap_number"].max() == 52
+
+    def test_result_sorted_by_lap_then_driver(self):
+        df = rdm.get_lap_window(2023, 10, 20, "VER", "HAM")
+        expected = df.sort_values(["lap_number", "driver_code"]).reset_index(drop=True)
+        pd.testing.assert_frame_equal(df.reset_index(drop=True), expected)
+
+
+# ---------------------------------------------------------------------------
+# Columns
+# ---------------------------------------------------------------------------
+
+class TestColumns:
+    def test_returns_exactly_required_columns(self):
+        df = rdm.get_lap_window(2023, 10, 20, "VER", "HAM")
+        assert list(df.columns) == rdm.WINDOW_COLUMNS
+
+    def test_sc_active_is_boolean(self):
+        df = rdm.get_lap_window(2023, 10, 10, "VER", "HAM")
+        assert df["sc_active"].dtype == bool
+
+    def test_sc_active_true_on_sc_laps(self):
+        df = rdm.get_lap_window(2023, 10, 10, "VER", "HAM")
+        sc_laps = set(df.loc[df["sc_active"], "lap_number"].unique())
+        # Fixture sets sc_active on laps 10, 11, 12
+        assert {10, 11, 12}.issubset(sc_laps)
+
+
+# ---------------------------------------------------------------------------
+# Error cases
+# ---------------------------------------------------------------------------
+
+class TestErrors:
+    def test_wrong_driver_code_raises_value_error(self):
+        with pytest.raises(ValueError) as exc_info:
+            rdm.get_lap_window(2023, 10, 20, "VER", "ZZZ")
+        assert "ZZZ" in str(exc_info.value)
+        assert "Available drivers" in str(exc_info.value)
+
+    def test_missing_parquet_raises_file_not_found(self, monkeypatch, tmp_path):
+        monkeypatch.setattr(rdm, "_CACHE_DIR", tmp_path)
+        with pytest.raises(FileNotFoundError) as exc_info:
+            rdm.get_lap_window(2023, 10, 20, "VER", "HAM")
+        assert "fetch_races.py" in str(exc_info.value)
+        assert "2023" in str(exc_info.value)
+
+    def test_corrupted_parquet_raises_value_error(self, monkeypatch, tmp_path):
+        bad_file = tmp_path / "2023_British_GP_laps.parquet"
+        bad_file.write_bytes(b"this is not a parquet file")
+        monkeypatch.setattr(rdm, "_CACHE_DIR", tmp_path)
+        with pytest.raises(ValueError) as exc_info:
+            rdm.get_lap_window(2023, 10, 20, "VER", "HAM")
+        assert "Failed to read" in str(exc_info.value)
+
+    def test_unknown_race_raises_value_error(self):
+        with pytest.raises(ValueError) as exc_info:
+            rdm.get_lap_window(2021, 1, 20, "VER", "HAM")
+        assert "not found in curated_races.yaml" in str(exc_info.value)