feat: Wire end-to-end pipeline — Dashboard ↔ Gateway ↔ Intelligence

apps/dashboard/src/api/__tests__/graphqlService.test.ts

@@ -14,7 +14,9 @@ import { graphqlClient } from '../graphqlClient';
 import {
  useApprovePARequest,
  useDenyPARequest,
+ useProcessPARequest,
  useConnectionStatus,
+ QUERY_KEYS,
 } from '../graphqlService';
 
 const mockRequest = vi.mocked(graphqlClient.request);
@@ -75,6 +77,65 @@ describe('useDenyPARequest', () => {
  });
 });
 
+describe('useProcessPARequest', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ });
+
+ it('should call processPARequest mutation with correct id', async () => {
+ mockRequest.mockResolvedValueOnce({
+ processPARequest: { id: 'PA-001', status: 'ready' },
+ });
+
+ const { result } = renderHook(() => useProcessPARequest(), {
+ wrapper: createWrapper(),
+ });
+
+ result.current.mutate('PA-001');
+
+ await waitFor(() => expect(result.current.isSuccess).toBe(true));
+ expect(mockRequest).toHaveBeenCalledOnce();
+ const callArgs = mockRequest.mock.calls[0];
+ expect(callArgs[0]).toContain('processPARequest');
+ expect(callArgs[1]).toEqual({ id: 'PA-001' });
+ });
+
+ it('useProcessPARequest_InvalidatesCorrectQueries_OnSuccess', async () => {
+ const queryClient = new QueryClient({
+ defaultOptions: { queries: { retry: false }, mutations: { retry: false } },
+ });
+
+ // Seed the cache with data for each query key we expect to be invalidated
+ queryClient.setQueryData(QUERY_KEYS.paRequests, []);
+ queryClient.setQueryData(QUERY_KEYS.paRequest('PA-002'), { id: 'PA-002' });
+ queryClient.setQueryData(QUERY_KEYS.paStats, { ready: 0 });
+ queryClient.setQueryData(QUERY_KEYS.activity, []);
+
+ const wrapper = ({ children }: { children: React.ReactNode }) =>
+ React.createElement(QueryClientProvider, { client: queryClient }, children);
+
+ mockRequest.mockResolvedValueOnce({
+ processPARequest: { id: 'PA-002', status: 'ready' },
+ });
+
+ const { result } = renderHook(() => useProcessPARequest(), { wrapper });
+
+ // Spy on invalidateQueries
+ const invalidateSpy = vi.spyOn(queryClient, 'invalidateQueries');
+
+ result.current.mutate('PA-002');
+
+ await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+ // Verify all four query keys are invalidated
+ const invalidatedKeys = invalidateSpy.mock.calls.map(call => call[0]?.queryKey);
+ expect(invalidatedKeys).toContainEqual(QUERY_KEYS.paRequests);
+ expect(invalidatedKeys).toContainEqual(QUERY_KEYS.paRequest('PA-002'));
+ expect(invalidatedKeys).toContainEqual(QUERY_KEYS.paStats);
+ expect(invalidatedKeys).toContainEqual(QUERY_KEYS.activity);
+ });
+});
+
 describe('useConnectionStatus', () => {
  beforeEach(() => {
  vi.clearAllMocks();

apps/dashboard/src/components/__tests__/EvidencePanel.test.tsx

@@ -117,4 +117,114 @@ describe('EvidencePanel', () => {
  expect(screen.getByTestId('evidence-skeleton')).toBeInTheDocument();
  });
  });
+
+ describe('Intelligence-shaped evidence', () => {
+ it('EvidencePanel_WithIntelligenceEvidence_DisplaysCriterionIdAsLabel', () => {
+ const intelligenceEvidence: EvidenceItem[] = [
+ {
+ criterionId: 'conservative_therapy',
+ status: 'MET',
+ evidence: 'Patient completed 8 weeks of physical therapy and NSAID treatment',
+ source: 'Clinical Notes - 2026-01-15',
+ confidence: 0.95,
+ },
+ {
+ criterionId: 'medical_necessity',
+ status: 'MET',
+ evidence: 'MRI indicated for evaluation of persistent symptoms',
+ source: 'Order Entry - 2026-01-20',
+ confidence: 0.88,
+ },
+ ];
+ render(<EvidencePanel evidence={intelligenceEvidence} />);
+
+ expect(screen.getByText('Conservative Therapy')).toBeInTheDocument();
+ expect(screen.getByText('Medical Necessity')).toBeInTheDocument();
+ });
+
+ it('EvidencePanel_WithUnclearStatus_ShowsDistinctBadge', () => {
+ const evidence: EvidenceItem[] = [
+ {
+ criterionId: 'diagnosis_present',
+ status: 'UNCLEAR',
+ evidence: 'Diagnosis code needs verification',
+ source: 'System',
+ confidence: 0.5,
+ },
+ ];
+ render(<EvidencePanel evidence={evidence} />);
+
+ const badge = screen.getByText('Unclear');
+ expect(badge).toBeInTheDocument();
+ // UNCLEAR uses warning styling
+ expect(badge.className).toMatch(/bg-warning/);
+ expect(badge.className).toMatch(/text-warning/);
+ // Should NOT use MET (success) or NOT_MET (destructive) styling
+ expect(badge.className).not.toMatch(/bg-success/);
+ expect(badge.className).not.toMatch(/text-success/);
+ expect(badge.className).not.toMatch(/bg-destructive/);
+ expect(badge.className).not.toMatch(/text-destructive/);
+ });
+
+ it('EvidencePanel_WithAllThreeStatuses_ShowsCorrectSummaryBreakdown', () => {
+ const mixedEvidence: EvidenceItem[] = [
+ {
+ criterionId: 'conservative_therapy',
+ status: 'MET',
+ evidence: 'PT completed',
+ source: 'Notes',
+ confidence: 0.95,
+ },
+ {
+ criterionId: 'diagnosis_present',
+ status: 'UNCLEAR',
+ evidence: 'Needs verification',
+ source: 'System',
+ confidence: 0.5,
+ },
+ {
+ criterionId: 'imaging_prior',
+ status: 'NOT_MET',
+ evidence: 'No prior imaging found',
+ source: 'Radiology',
+ confidence: 0.9,
+ },
+ ];
+ render(<EvidencePanel evidence={mixedEvidence} />);
+
+ expect(screen.getByText('3 criteria analyzed')).toBeInTheDocument();
+ });
+
+ it('EvidencePanel_WithLowConfidence_ShowsWarningColor', () => {
+ const evidence: EvidenceItem[] = [
+ {
+ criterionId: 'medical_necessity',
+ status: 'MET',
+ evidence: 'Some evidence found',
+ source: 'Notes',
+ confidence: 0.35,
+ },
+ ];
+ render(<EvidencePanel evidence={evidence} />);
+
+ // 35% confidence should show destructive color (below 0.5 threshold)
+ expect(screen.getByText(/35%/)).toBeInTheDocument();
+ });
+
+ it('EvidencePanel_WithBorderlineConfidence_ShowsCorrectColor', () => {
+ const evidence: EvidenceItem[] = [
+ {
+ criterionId: 'conservative_therapy',
+ status: 'MET',
+ evidence: 'Partial documentation',
+ source: 'Notes',
+ confidence: 0.5,
+ },
+ ];
+ render(<EvidencePanel evidence={evidence} />);
+
+ // 50% is at the boundary — should show warning color
+ expect(screen.getByText(/50%/)).toBeInTheDocument();
+ });
+ });
 });

apps/dashboard/src/components/__tests__/PARequestCard.test.tsx

@@ -0,0 +1,148 @@
+import { describe, it, expect, vi } from 'vitest';
+import { render, screen, fireEvent } from '@testing-library/react';
+import { PARequestCard, type PARequest } from '../PARequestCard';
+
+// Mock @tanstack/react-router Link component
+vi.mock('@tanstack/react-router', () => ({
+ Link: ({ children, to, params }: { children: React.ReactNode; to: string; params?: Record<string, string> }) => (
+ <a href={`${to}/${params?.transactionId ?? ''}`} data-testid="router-link">
+ {children}
+ </a>
+ ),
+}));
+
+function createMockPARequest(overrides: Partial<PARequest> = {}): PARequest {
+ return {
+ id: 'PA-001',
+ patientName: 'Jane Smith',
+ patientId: 'MRN-12345',
+ procedureCode: '72148',
+ procedureName: 'MRI Lumbar Spine',
+ payer: 'Blue Cross Blue Shield',
+ currentStep: 'process',
+ createdAt: new Date().toISOString(),
+ encounterId: 'ENC-001',
+ ...overrides,
+ };
+}
+
+describe('PARequestCard', () => {
+ describe('rendering', () => {
+ it('PARequestCard_WithValidRequest_DisplaysPatientInfo', () => {
+ const request = createMockPARequest();
+ render(<PARequestCard request={request} />);
+
+ expect(screen.getByText('Jane Smith')).toBeInTheDocument();
+ expect(screen.getByText(/MRN-12345/)).toBeInTheDocument();
+ });
+
+ it('PARequestCard_WithValidRequest_DisplaysProcedure', () => {
+ const request = createMockPARequest();
+ render(<PARequestCard request={request} />);
+
+ expect(screen.getByText('72148')).toBeInTheDocument();
+ expect(screen.getByText('MRI Lumbar Spine')).toBeInTheDocument();
+ });
+
+ it('PARequestCard_WithValidRequest_DisplaysPayer', () => {
+ const request = createMockPARequest();
+ render(<PARequestCard request={request} />);
+
+ expect(screen.getByText('Blue Cross Blue Shield')).toBeInTheDocument();
+ });
+ });
+
+ describe('confidence display', () => {
+ it('PARequestCard_WithHighConfidence_DisplaysPercentage', () => {
+ const request = createMockPARequest({ confidenceScore: 0.92 });
+ render(<PARequestCard request={request} />);
+
+ expect(screen.getByText(/92%/)).toBeInTheDocument();
+ });
+
+ it('PARequestCard_WithMediumConfidence_DisplaysPercentage', () => {
+ const request = createMockPARequest({ confidenceScore: 0.65 });
+ render(<PARequestCard request={request} />);
+
+ expect(screen.getByText(/65%/)).toBeInTheDocument();
+ });
+
+ it('PARequestCard_WithLowConfidence_DisplaysReviewBadge', () => {
+ const request = createMockPARequest({ confidenceScore: 0.42 });
+ render(<PARequestCard request={request} />);
+
+ // Low confidence (< 0.5) shows "Review" text in a badge (data-slot="badge")
+ const badges = screen.getAllByText('Review');
+ const confidenceBadge = badges.find(el => el.getAttribute('data-slot') === 'badge');
+ expect(confidenceBadge).toBeDefined();
+ });
+
+ it('PARequestCard_WithUndefinedConfidence_ShowsNoConfidenceBadge', () => {
+ const request = createMockPARequest({ confidenceScore: undefined });
+ render(<PARequestCard request={request} />);
+
+ // No confidence percentage badge should render
+ expect(screen.queryByText(/\d+%/)).not.toBeInTheDocument();
+ // The only "Review" text should be from the WorkflowProgress step, not a badge
+ const reviewElements = screen.queryAllByText('Review');
+ const confidenceBadge = reviewElements.find(el => el.getAttribute('data-slot') === 'badge');
+ expect(confidenceBadge).toBeUndefined();
+ });
+
+ it('PARequestCard_WithRealConfidenceRange_DisplaysCorrectly', () => {
+ // Test with various realistic confidence values from Intelligence
+ const request = createMockPARequest({ confidenceScore: 0.78 });
+ render(<PARequestCard request={request} />);
+
+ expect(screen.getByText(/78%/)).toBeInTheDocument();
+ });
+ });
+
+ describe('workflow states', () => {
+ it('PARequestCard_InProcessingState_ShowsProcessingIndicator', () => {
+ const request = createMockPARequest({ currentStep: 'process' });
+ render(<PARequestCard request={request} />);
+
+ expect(screen.getByText('Processing...')).toBeInTheDocument();
+ });
+
+ it('PARequestCard_InDeliverState_ShowsReviewButton', () => {
+ const request = createMockPARequest({ currentStep: 'deliver' });
+ render(<PARequestCard request={request} />);
+
+ expect(screen.getByText('Review & Confirm')).toBeInTheDocument();
+ });
+
+ it('PARequestCard_InReviewCompletedState_ShowsSubmittedMessage', () => {
+ const request = createMockPARequest({
+ currentStep: 'review',
+ stepStatuses: { review: 'completed' },
+ });
+ render(<PARequestCard request={request} />);
+
+ expect(screen.getByText('Submitted to athenahealth')).toBeInTheDocument();
+ });
+ });
+
+ describe('attention flag', () => {
+ it('PARequestCard_RequiresAttention_HasWarningRing', () => {
+ const request = createMockPARequest({ requiresAttention: true });
+ const { container } = render(<PARequestCard request={request} />);
+
+ const card = container.firstChild as HTMLElement;
+ expect(card.className).toMatch(/ring-warning/);
+ });
+ });
+
+ describe('callbacks', () => {
+ it('PARequestCard_OnReviewClick_CallsCallback', () => {
+ const onReview = vi.fn();
+ const request = createMockPARequest({ currentStep: 'deliver' });
+ render(<PARequestCard request={request} onReview={onReview} />);
+
+ fireEvent.click(screen.getByText('Review & Confirm'));
+
+ expect(onReview).toHaveBeenCalledWith('PA-001');
+ });
+ });
+});