feat: add e2e smoke test

Full journey smoke test verifying state transitions, data export,
gap loop, service chain with mocked services, data contract
serialization roundtrips, and latency budget.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

tests/test_e2e.py

@@ -0,0 +1,231 @@
+"""End-to-end smoke test: full journey with mocked services."""
+from __future__ import annotations
+
+from app.services.mock_data import (
+    MOCK_ELIGIBILITY_LEDGERS,
+    MOCK_PATIENT_PROFILE,
+    MOCK_TRIAL_CANDIDATES,
+)
+from app.services.state_manager import JOURNEY_STATES
+from trialpath.models import (
+    EligibilityLedger,
+    PatientProfile,
+    SearchAnchors,
+    TrialCandidate,
+)
+
+
+class TestE2EJourney:
+    """Simulate the full 5-state journey: INGEST → PRESCREEN → VALIDATE → GAP → SUMMARY."""
+
+    def _build_session_state(self) -> dict:
+        """Create a minimal session state dict simulating Streamlit."""
+        return {
+            "journey_state": "INGEST",
+            "parlant_session_id": None,
+            "parlant_agent_id": None,
+            "parlant_session_active": False,
+            "patient_profile": None,
+            "uploaded_files": [],
+            "search_anchors": None,
+            "trial_candidates": [],
+            "eligibility_ledger": [],
+            "last_event_offset": 0,
+        }
+
+    def test_full_journey_state_transitions(self):
+        """Verify all state transitions complete in correct order."""
+        state = self._build_session_state()
+
+        # INGEST → PRESCREEN
+        assert state["journey_state"] == "INGEST"
+        state["patient_profile"] = MOCK_PATIENT_PROFILE
+        state["journey_state"] = "PRESCREEN"
+
+        # PRESCREEN → VALIDATE_TRIALS
+        assert state["journey_state"] == "PRESCREEN"
+        anchors = SearchAnchors(
+            condition="Non-Small Cell Lung Cancer",
+            biomarkers=["EGFR"],
+            stage="IIIB",
+        )
+        state["search_anchors"] = anchors
+        state["trial_candidates"] = list(MOCK_TRIAL_CANDIDATES)
+        state["journey_state"] = "VALIDATE_TRIALS"
+
+        # VALIDATE_TRIALS → GAP_FOLLOWUP
+        assert state["journey_state"] == "VALIDATE_TRIALS"
+        state["eligibility_ledger"] = list(MOCK_ELIGIBILITY_LEDGERS)
+        state["journey_state"] = "GAP_FOLLOWUP"
+
+        # GAP_FOLLOWUP → SUMMARY
+        assert state["journey_state"] == "GAP_FOLLOWUP"
+        state["journey_state"] = "SUMMARY"
+
+        assert state["journey_state"] == "SUMMARY"
+
+    def test_journey_produces_exportable_data(self):
+        """Verify end state has all data needed for doctor packet export."""
+        state = self._build_session_state()
+        state["patient_profile"] = MOCK_PATIENT_PROFILE
+        state["trial_candidates"] = list(MOCK_TRIAL_CANDIDATES)
+        state["eligibility_ledger"] = list(MOCK_ELIGIBILITY_LEDGERS)
+        state["journey_state"] = "SUMMARY"
+
+        # Verify export data
+        profile = state["patient_profile"]
+        ledgers = state["eligibility_ledger"]
+        trials = state["trial_candidates"]
+
+        assert isinstance(profile, PatientProfile)
+        assert len(trials) == 3
+        assert len(ledgers) == 3
+
+        eligible = sum(1 for lg in ledgers if lg.traffic_light == "green")
+        uncertain = sum(1 for lg in ledgers if lg.traffic_light == "yellow")
+        ineligible = sum(1 for lg in ledgers if lg.traffic_light == "red")
+
+        assert eligible == 1
+        assert uncertain == 1
+        assert ineligible == 1
+
+    def test_gap_loop_back_to_ingest(self):
+        """Verify GAP_FOLLOWUP can loop back to INGEST for new docs."""
+        state = self._build_session_state()
+        state["patient_profile"] = MOCK_PATIENT_PROFILE
+        state["trial_candidates"] = list(MOCK_TRIAL_CANDIDATES)
+        state["eligibility_ledger"] = list(MOCK_ELIGIBILITY_LEDGERS)
+        state["journey_state"] = "GAP_FOLLOWUP"
+
+        # User decides to upload more documents
+        state["journey_state"] = "INGEST"
+        assert state["journey_state"] == "INGEST"
+
+        # Existing data preserved for re-evaluation
+        assert state["patient_profile"] is not None
+        assert len(state["trial_candidates"]) == 3
+
+    def test_all_journey_states_reachable(self):
+        """Verify each of the 5 journey states can be reached."""
+        state = self._build_session_state()
+        visited = []
+
+        for target_state in JOURNEY_STATES:
+            state["journey_state"] = target_state
+            visited.append(state["journey_state"])
+
+        assert visited == JOURNEY_STATES
+        assert len(visited) == 5
+
+
+class TestE2EWithMockedServices:
+    """E2E test using mocked service calls to verify data flow."""
+
+    def test_extract_to_search_to_evaluate_chain(
+        self, mock_medgemma, mock_gemini
+    ):
+        """Full service chain: extraction → search anchors → evaluate."""
+        from trialpath.services.gemini_planner import GeminiPlanner
+        from trialpath.services.medgemma_extractor import MedGemmaExtractor
+
+        # Step 1: Extract patient profile
+        extractor = MedGemmaExtractor()
+        profile = extractor.extract(["patient_notes.pdf"])
+        assert isinstance(profile, PatientProfile)
+
+        # Step 2: Generate search anchors
+        planner = GeminiPlanner()
+        anchors = planner.generate_search_anchors(profile)
+        assert isinstance(anchors, SearchAnchors)
+
+        # Step 3: Slice + evaluate criteria
+        criteria = planner.slice_criteria(MOCK_TRIAL_CANDIDATES[0])
+        assert len(criteria) >= 1
+
+        # Step 4: Evaluate each criterion
+        assessments = []
+        for c in criteria:
+            if c["type"] == "medical":
+                result = extractor.evaluate_medical_criterion(c["text"], profile)
+            else:
+                result = planner.evaluate_structural_criterion(c["text"], profile)
+            assessments.append({
+                "criterion": c["text"],
+                "decision": result["decision"],
+                "confidence": result.get("confidence", 0.5),
+            })
+        assert len(assessments) == len(criteria)
+
+        # Step 5: Aggregate into ledger
+        ledger = planner.aggregate_assessments(
+            profile=profile,
+            trial=MOCK_TRIAL_CANDIDATES[0],
+            assessments=assessments,
+        )
+        assert isinstance(ledger, EligibilityLedger)
+
+    def test_data_contracts_survive_serialization(self):
+        """Verify all data contracts survive JSON roundtrip."""
+        # PatientProfile
+        p_json = MOCK_PATIENT_PROFILE.model_dump_json()
+        p_restored = PatientProfile.model_validate_json(p_json)
+        assert p_restored.patient_id == MOCK_PATIENT_PROFILE.patient_id
+
+        # TrialCandidate
+        for t in MOCK_TRIAL_CANDIDATES:
+            t_json = t.model_dump_json()
+            t_restored = TrialCandidate.model_validate_json(t_json)
+            assert t_restored.nct_id == t.nct_id
+
+        # EligibilityLedger
+        for lg in MOCK_ELIGIBILITY_LEDGERS:
+            lg_json = lg.model_dump_json()
+            lg_restored = EligibilityLedger.model_validate_json(lg_json)
+            assert lg_restored.nct_id == lg.nct_id
+
+        # SearchAnchors
+        anchors = SearchAnchors(
+            condition="NSCLC",
+            biomarkers=["EGFR", "ALK"],
+            stage="IV",
+        )
+        a_json = anchors.model_dump_json()
+        a_restored = SearchAnchors.model_validate_json(a_json)
+        assert a_restored.condition == "NSCLC"
+
+
+class TestE2ELatencyBudget:
+    """Verify operations complete within latency budget (mocked)."""
+
+    def test_mock_operations_are_fast(self, mock_medgemma, mock_gemini):
+        """With mocked services, full chain should complete near-instantly."""
+        import time
+
+        from trialpath.services.gemini_planner import GeminiPlanner
+        from trialpath.services.medgemma_extractor import MedGemmaExtractor
+
+        start = time.monotonic()
+
+        extractor = MedGemmaExtractor()
+        profile = extractor.extract(["doc.pdf"])
+
+        planner = GeminiPlanner()
+        planner.generate_search_anchors(profile)
+        criteria = planner.slice_criteria(MOCK_TRIAL_CANDIDATES[0])
+
+        for c in criteria:
+            if c["type"] == "medical":
+                extractor.evaluate_medical_criterion(c["text"], profile)
+            else:
+                planner.evaluate_structural_criterion(c["text"], profile)
+
+        planner.aggregate_assessments(
+            profile=profile,
+            trial=MOCK_TRIAL_CANDIDATES[0],
+            assessments=[],
+        )
+        planner.analyze_gaps(profile, list(MOCK_ELIGIBILITY_LEDGERS))
+
+        elapsed = time.monotonic() - start
+        # With mocks, should complete well under 1 second
+        assert elapsed < 1.0, f"Mock pipeline took {elapsed:.2f}s, expected < 1s"