vintasend 0.4.0 → 0.4.7

package/dist/examples/vintasend-medplum-example/src/components/encounter/BillingTab.test.tsx

@@ -0,0 +1,1016 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import { MantineProvider } from '@mantine/core';
+import { Notifications } from '@mantine/notifications';
+import { act, fireEvent, render, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { MedplumProvider } from '@medplum/react';
+import type {
+  ChargeItem,
+  ChargeItemDefinition,
+  Claim,
+  CodeableConcept,
+  Coverage,
+  Encounter,
+  Patient,
+  Practitioner,
+} from '@medplum/fhirtypes';
+import { HomerSimpson, MockClient } from '@medplum/mock';
+import { MemoryRouter } from 'react-router';
+import { describe, expect, test, beforeEach, vi } from 'vitest';
+import { BillingTab } from './BillingTab';
+import * as useDebouncedUpdateResourceModule from '../../hooks/useDebouncedUpdateResource';
+import * as claimsUtils from '../../utils/claims';
+import * as chargeItemsUtils from '../../utils/chargeitems';
+import { SAVE_TIMEOUT_MS } from '../../config/constants';
+
+vi.mock('@mantine/notifications', async () => {
+  const actual = await vi.importActual('@mantine/notifications');
+  return {
+    ...actual,
+    showNotification: vi.fn(),
+  };
+});
+
+const { showNotification } = await import('@mantine/notifications');
+
+const mockPatient: Patient = {
+  resourceType: 'Patient',
+  id: 'patient-123',
+  name: [{ given: ['John'], family: 'Doe' }],
+};
+
+const mockEncounter: Encounter = {
+  resourceType: 'Encounter',
+  id: 'encounter-123',
+  status: 'finished',
+  class: { code: 'AMB', system: 'http://terminology.hl7.org/CodeSystem/v3-ActCode' },
+  subject: { reference: `Patient/${HomerSimpson.id}` },
+  participant: [
+    {
+      individual: { reference: 'Practitioner/practitioner-123' },
+    },
+  ],
+};
+
+const mockCoverage: Coverage = {
+  resourceType: 'Coverage',
+  id: 'coverage-123',
+  status: 'active',
+  beneficiary: { reference: 'Patient/patient-123' },
+  payor: [{ reference: 'Organization/organization-123' }],
+};
+
+const mockPractitioner: Practitioner = {
+  resourceType: 'Practitioner',
+  id: 'practitioner-123',
+  name: [{ given: ['Dr.'], family: 'Test' }],
+};
+
+const mockChargeItem: ChargeItem = {
+  resourceType: 'ChargeItem',
+  id: 'charge-123',
+  status: 'billable',
+  subject: { reference: 'Patient/patient-123' },
+  code: {
+    coding: [
+      {
+        system: 'http://www.ama-assn.org/go/cpt',
+        code: '99214',
+        display: 'Office Visit Level 4',
+      },
+    ],
+    text: 'Test Charge',
+  },
+  priceOverride: {
+    value: 100,
+    currency: 'USD',
+  },
+};
+
+const mockClaim: Claim = {
+  resourceType: 'Claim',
+  id: 'claim-123',
+  status: 'active',
+  type: { coding: [{ code: 'professional' }] },
+  use: 'claim',
+  created: new Date().toISOString(),
+  priority: { coding: [{ code: 'normal' }] },
+  insurance: [],
+  patient: { reference: 'Patient/patient-123' },
+  provider: { reference: 'Practitioner/practitioner-123' },
+};
+
+describe('BillingTab', () => {
+  let medplum: MockClient;
+
+  beforeEach(async () => {
+    medplum = new MockClient();
+    vi.clearAllMocks();
+    // Mock useDebouncedUpdateResource to return a function that resolves immediately
+    vi.spyOn(useDebouncedUpdateResourceModule, 'useDebouncedUpdateResource').mockReturnValue(
+      vi.fn().mockResolvedValue(undefined)
+    );
+  });
+
+  const setup = async (props: Partial<Parameters<typeof BillingTab>[0]> = {}): Promise<void> => {
+    return act(async () => {
+      render(
+        <MemoryRouter>
+          <MedplumProvider medplum={medplum}>
+            <MantineProvider>
+              <Notifications />
+              <BillingTab
+                patient={mockPatient}
+                encounter={mockEncounter}
+                setEncounter={vi.fn()}
+                practitioner={mockPractitioner}
+                setPractitioner={vi.fn()}
+                chargeItems={[]}
+                setChargeItems={vi.fn()}
+                claim={undefined}
+                setClaim={vi.fn()}
+                {...props}
+              />
+            </MantineProvider>
+          </MedplumProvider>
+        </MemoryRouter>
+      );
+    });
+  };
+
+  test('renders visit details panel', async () => {
+    await setup();
+    expect(screen.getByText('Visit Details')).toBeInTheDocument();
+    expect(screen.getByText(/Dr\. Test/i)).toBeInTheDocument();
+  });
+
+  test('renders condition list when there are conditions', async () => {
+    const mockCondition = {
+      resourceType: 'Condition' as const,
+      id: 'condition-1',
+      code: {
+        coding: [{ code: 'R51', display: 'Headache' }],
+        text: 'Headache',
+      },
+    };
+
+    vi.spyOn(medplum, 'readReference').mockResolvedValue(mockCondition as any);
+
+    await setup({
+      encounter: {
+        ...mockEncounter,
+        diagnosis: [
+          {
+            condition: { reference: 'Condition/condition-1' },
+          },
+        ],
+      },
+    });
+
+    expect(screen.getByText('Diagnosis')).toBeInTheDocument();
+    expect(screen.getByText('Add Diagnosis')).toBeInTheDocument();
+
+    await waitFor(() => {
+      expect(screen.getByText('Headache')).toBeInTheDocument();
+    });
+  });
+
+  test('renders condition list when there are NO conditions', async () => {
+    await setup({
+      encounter: {
+        ...mockEncounter,
+        diagnosis: [],
+      },
+    });
+
+    expect(screen.getByText('Diagnosis')).toBeInTheDocument();
+    expect(screen.getByText('Add Diagnosis')).toBeInTheDocument();
+    expect(screen.queryByText('Headache')).not.toBeInTheDocument();
+  });
+
+  test('renders charge item list when charge items are provided', async () => {
+    await setup({ chargeItems: [mockChargeItem] });
+
+    expect(screen.getByText('Charge Items')).toBeInTheDocument();
+    expect(screen.getByText('Add Charge Item')).toBeInTheDocument();
+  });
+
+  test('does not render export claim button when no claim', async () => {
+    await setup({ claim: undefined });
+
+    expect(screen.queryByText('Export Claim')).not.toBeInTheDocument();
+  });
+
+  test('renders export claim button when claim exists', async () => {
+    await setup({ claim: mockClaim });
+
+    expect(screen.getByText('Export Claim')).toBeInTheDocument();
+  });
+
+  test('shows export menu options when export button is clicked', async () => {
+    const user = userEvent.setup();
+    await setup({ claim: mockClaim });
+
+    const exportButton = screen.getByText('Export Claim');
+    await user.click(exportButton);
+
+    await waitFor(() => {
+      expect(screen.getByText('CMS 1500 Form')).toBeInTheDocument();
+      expect(screen.getByText('EDI X12')).toBeInTheDocument();
+      expect(screen.getByText('NUCC Crosswalk CSV')).toBeInTheDocument();
+    });
+  });
+
+  test('exports claim as CMS 1500 when option is selected', async () => {
+    const user = userEvent.setup();
+
+    vi.spyOn(medplum, 'searchResources').mockResolvedValue([mockCoverage] as any);
+    vi.spyOn(medplum, 'post').mockResolvedValue({
+      resourceType: 'Media',
+      content: { url: 'https://example.com/claim.pdf' },
+    } as any);
+
+    const windowOpenSpy = vi.spyOn(window, 'open').mockImplementation(() => null);
+
+    await setup({ claim: mockClaim });
+
+    const exportButton = screen.getByText('Export Claim');
+    await user.click(exportButton);
+
+    await waitFor(() => {
+      expect(screen.getByText('CMS 1500 Form')).toBeInTheDocument();
+    });
+
+    await user.click(screen.getByText('CMS 1500 Form'));
+
+    await waitFor(() => {
+      expect(medplum.post).toHaveBeenCalled();
+      expect(windowOpenSpy).toHaveBeenCalledWith('https://example.com/claim.pdf', '_blank');
+    });
+
+    windowOpenSpy.mockRestore();
+  });
+
+  test('renders request billing service button', async () => {
+    await setup({ claim: mockClaim });
+    expect(screen.getByText('Request to connect a billing service')).toBeInTheDocument();
+  });
+
+  test('fetches coverage on mount', async () => {
+    vi.spyOn(medplum, 'searchResources').mockResolvedValue([mockCoverage] as any);
+    await act(async () => {
+      await setup();
+    });
+
+    await waitFor(() => {
+      expect(medplum.searchResources).toHaveBeenCalledWith(
+        'Coverage',
+        expect.stringContaining('patient=Patient/patient-123')
+      );
+    });
+  });
+
+  test('shows notification when EDI X12 menu item is clicked', async () => {
+    const user = userEvent.setup();
+    await setup({ claim: mockClaim });
+
+    const exportButton = screen.getByText('Export Claim');
+    await user.click(exportButton);
+
+    await waitFor(() => {
+      expect(screen.getByText('EDI X12')).toBeInTheDocument();
+    });
+
+    await user.click(screen.getByText('EDI X12'));
+
+    await waitFor(() => {
+      expect(vi.mocked(showNotification)).toHaveBeenCalledWith({
+        title: 'EDI X12',
+        message: 'Please contact sales to enable EDI X12 export',
+        color: 'blue',
+      });
+    });
+  });
+
+  test('shows notification when NUCC Crosswalk CSV menu item is clicked', async () => {
+    const user = userEvent.setup();
+    await setup({ claim: mockClaim });
+
+    const exportButton = screen.getByText('Export Claim');
+    await user.click(exportButton);
+
+    await waitFor(() => {
+      expect(screen.getByText('NUCC Crosswalk CSV')).toBeInTheDocument();
+    });
+
+    await user.click(screen.getByText('NUCC Crosswalk CSV'));
+
+    await waitFor(() => {
+      expect(vi.mocked(showNotification)).toHaveBeenCalledWith({
+        title: 'NUCC Crosswalk',
+        message: 'Please contact sales to enable NUCC Crosswalk export',
+        color: 'blue',
+      });
+    });
+  });
+
+  test('updates claim when charge item is added', async () => {
+    const user = userEvent.setup();
+    const setChargeItems = vi.fn();
+    const setClaim = vi.fn();
+    const debouncedUpdateResource = vi.fn().mockResolvedValue(undefined);
+
+    vi.spyOn(useDebouncedUpdateResourceModule, 'useDebouncedUpdateResource').mockReturnValue(debouncedUpdateResource);
+
+    const mockCptCode: CodeableConcept = {
+      coding: [
+        {
+          system: 'http://www.ama-assn.org/go/cpt',
+          code: '99214',
+          display: 'Office Visit Level 4',
+        },
+      ],
+    };
+    const mockDefinition: ChargeItemDefinition & { id: string } = {
+      resourceType: 'ChargeItemDefinition',
+      id: 'def-123',
+      status: 'active',
+      url: 'http://example.com/charge-item-def',
+      title: 'Test Definition',
+    };
+    const newChargeItem: ChargeItem & { id: string } = {
+      resourceType: 'ChargeItem',
+      id: 'charge-new',
+      status: 'planned',
+      subject: { reference: 'Patient/patient-123' },
+      code: mockCptCode,
+    };
+    const appliedChargeItem: ChargeItem & { id: string } = {
+      ...newChargeItem,
+      priceOverride: { value: 200, currency: 'USD' },
+    };
+
+    const mockClaimItems = [
+      {
+        sequence: 1,
+        productOrService: {
+          coding: [{ system: 'http://www.ama-assn.org/go/cpt', code: '99214' }],
+        },
+      },
+    ];
+
+    // Mock valueSetExpand for CPT code search
+    medplum.valueSetExpand = vi.fn().mockResolvedValue({
+      resourceType: 'ValueSet',
+      expansion: {
+        contains: [
+          {
+            system: 'http://www.ama-assn.org/go/cpt',
+            code: '99214',
+            display: 'Office Visit Level 4',
+          },
+        ],
+      },
+    });
+
+    // Mock searchResources for ChargeItemDefinition search
+    vi.spyOn(medplum, 'searchResources').mockResolvedValue([mockDefinition] as any);
+    vi.spyOn(medplum, 'createResource').mockResolvedValue(newChargeItem);
+    vi.spyOn(chargeItemsUtils, 'applyChargeItemDefinition').mockResolvedValue(appliedChargeItem);
+    vi.spyOn(claimsUtils, 'getCptChargeItems').mockReturnValue(mockClaimItems);
+    vi.spyOn(chargeItemsUtils, 'calculateTotalPrice').mockReturnValue(200);
+
+    await setup({
+      claim: mockClaim,
+      chargeItems: [],
+      setChargeItems,
+      setClaim,
+      encounter: mockEncounter,
+    });
+
+    // Open modal
+    await user.click(screen.getByText('Add Charge Item'));
+
+    await waitFor(() => {
+      expect(screen.getByRole('dialog')).toBeInTheDocument();
+    });
+
+    // Find CPT Code input
+    const cptInputs = screen.getAllByRole('searchbox');
+    const cptInput = cptInputs.find((input) => {
+      const label = input.closest('.mantine-InputWrapper-root')?.querySelector('label');
+      return label?.textContent?.includes('CPT Code');
+    }) as HTMLInputElement;
+
+    expect(cptInput).toBeDefined();
+
+    // Type in CPT code input
+    await act(async () => {
+      await user.type(cptInput, '99214');
+    });
+
+    // Wait for valueSetExpand to be called
+    await waitFor(
+      () => {
+        expect(medplum.valueSetExpand).toHaveBeenCalled();
+      },
+      { timeout: 3000 }
+    );
+
+    // Select the CPT code option
+    await act(async () => {
+      fireEvent.keyDown(cptInput, { key: 'ArrowDown', code: 'ArrowDown' });
+      fireEvent.keyDown(cptInput, { key: 'Enter', code: 'Enter' });
+    });
+
+    // Wait for CPT code to be selected
+    await waitFor(
+      () => {
+        const selectedItems = document.querySelector('[data-testid="selected-items"]');
+        const hasCode =
+          selectedItems?.textContent?.includes('99214') || selectedItems?.textContent?.includes('Office Visit Level 4');
+        return hasCode === true;
+      },
+      { timeout: 3000 }
+    );
+
+    // Find Charge Item Definition input
+    const definitionInputs = screen.getAllByRole('searchbox');
+    const definitionInput = definitionInputs.find((input) => {
+      const placeholder = (input as HTMLInputElement).placeholder;
+      return placeholder?.toLowerCase().includes('charge item definition');
+    }) as HTMLInputElement;
+
+    expect(definitionInput).toBeDefined();
+
+    // Type in definition input
+    await act(async () => {
+      await user.type(definitionInput, 'Test');
+    });
+
+    // Wait for searchResources to be called
+    await waitFor(
+      () => {
+        expect(medplum.searchResources).toHaveBeenCalledWith(
+          'ChargeItemDefinition',
+          expect.any(URLSearchParams),
+          expect.any(Object)
+        );
+      },
+      { timeout: 3000 }
+    );
+
+    // Select the definition option
+    await act(async () => {
+      fireEvent.keyDown(definitionInput, { key: 'ArrowDown', code: 'ArrowDown' });
+      fireEvent.keyDown(definitionInput, { key: 'Enter', code: 'Enter' });
+    });
+
+    // Wait for definition to be selected and button to be enabled
+    await waitFor(
+      () => {
+        const addButtons = screen.getAllByRole('button', { name: 'Add Charge Item' });
+        const submitButton = addButtons.find((btn) => {
+          const htmlBtn = btn as HTMLButtonElement;
+          return htmlBtn.type === 'button' && !htmlBtn.disabled;
+        });
+        return submitButton !== undefined;
+      },
+      { timeout: 5000 }
+    );
+
+    // Submit the form
+    const addButtons = screen.getAllByRole('button', { name: 'Add Charge Item' });
+    const submitButton = addButtons.find((btn) => {
+      const htmlBtn = btn as HTMLButtonElement;
+      return htmlBtn.type === 'button' && !htmlBtn.disabled;
+    });
+
+    expect(submitButton).toBeDefined();
+    if (submitButton) {
+      await user.click(submitButton);
+
+      // Verify charge item was created and updateChargeItems was called
+      await waitFor(() => {
+        expect(medplum.createResource).toHaveBeenCalledWith(
+          expect.objectContaining({
+            resourceType: 'ChargeItem',
+            status: 'planned',
+            code: mockCptCode,
+            definitionCanonical: ['http://example.com/charge-item-def'],
+          })
+        );
+        expect(chargeItemsUtils.applyChargeItemDefinition).toHaveBeenCalled();
+        expect(setChargeItems).toHaveBeenCalledWith([appliedChargeItem]);
+      });
+
+      // Verify claim was updated
+      await waitFor(
+        () => {
+          expect(claimsUtils.getCptChargeItems).toHaveBeenCalledWith([appliedChargeItem], {
+            reference: 'Encounter/encounter-123',
+          });
+          expect(chargeItemsUtils.calculateTotalPrice).toHaveBeenCalledWith([appliedChargeItem]);
+          expect(setClaim).toHaveBeenCalledWith(
+            expect.objectContaining({
+              ...mockClaim,
+              item: mockClaimItems,
+              total: { value: 200 },
+            })
+          );
+          expect(debouncedUpdateResource).toHaveBeenCalledWith(
+            expect.objectContaining({
+              ...mockClaim,
+              item: mockClaimItems,
+              total: { value: 200 },
+            })
+          );
+        },
+        { timeout: 5000 }
+      );
+    }
+  });
+
+  test('creates claim when practitioner is changed and charge items exist', async () => {
+    const setEncounter = vi.fn();
+    const setClaim = vi.fn();
+    const debouncedUpdateResource = vi.fn().mockResolvedValue(undefined);
+
+    vi.spyOn(useDebouncedUpdateResourceModule, 'useDebouncedUpdateResource').mockReturnValue(debouncedUpdateResource);
+
+    const mockPractitioner1: Practitioner = {
+      resourceType: 'Practitioner',
+      id: 'practitioner-1',
+      name: [{ given: ['Dr.'], family: 'Test' }],
+    };
+
+    const mockPractitioner2: Practitioner = {
+      resourceType: 'Practitioner',
+      id: 'practitioner-2',
+      name: [{ given: ['Dr.'], family: 'Smith' }],
+    };
+
+    const appliedChargeItem: ChargeItem & { id: string } = {
+      resourceType: 'ChargeItem',
+      id: 'charge-new',
+      status: 'planned',
+      subject: { reference: 'Patient/patient-123' },
+      code: {
+        coding: [
+          {
+            system: 'http://www.ama-assn.org/go/cpt',
+            code: '99214',
+            display: 'Office Visit Level 4',
+          },
+        ],
+      },
+      priceOverride: { value: 200, currency: 'USD' },
+    };
+
+    const newClaim: Claim & { id: string } = {
+      resourceType: 'Claim',
+      id: 'claim-new',
+      status: 'active',
+      type: { coding: [{ code: 'professional' }] },
+      use: 'claim',
+      created: new Date().toISOString(),
+      priority: { coding: [{ code: 'normal' }] },
+      insurance: [],
+      patient: { reference: 'Patient/patient-123' },
+      provider: { reference: 'Practitioner/practitioner-2' },
+    };
+
+    const updatedEncounter: Encounter = {
+      ...mockEncounter,
+      participant: [
+        {
+          individual: { reference: 'Practitioner/practitioner-2' },
+        },
+      ],
+    };
+
+    await medplum.createResource(mockPractitioner1);
+    await medplum.createResource(mockPractitioner2);
+
+    // Mock searchResources to return different results based on resource type
+    // Use mockResolvedValue for Coverage (called on mount) and mockImplementation for Practitioner
+    vi.spyOn(medplum, 'searchResources')
+      .mockResolvedValueOnce([mockCoverage] as any) // Coverage search on mount
+      .mockResolvedValue([mockPractitioner1, mockPractitioner2] as any); // Practitioner searches
+    vi.spyOn(claimsUtils, 'createClaimFromEncounter').mockResolvedValue(newClaim);
+    vi.spyOn(medplum, 'updateResource').mockResolvedValue(updatedEncounter as any);
+    vi.spyOn(medplum, 'readReference').mockResolvedValue(mockPractitioner2 as any);
+
+    // Setup with charge items but no claim initially
+    await setup({
+      claim: undefined, // No claim initially
+      chargeItems: [appliedChargeItem], // Charge items already present
+      setChargeItems: vi.fn(),
+      setClaim,
+      setEncounter,
+      encounter: {
+        resourceType: 'Encounter',
+        id: 'encounter-123',
+        status: 'finished',
+        class: { code: 'AMB', system: 'http://terminology.hl7.org/CodeSystem/v3-ActCode' },
+        subject: { reference: `Patient/${HomerSimpson.id}` },
+      },
+      practitioner: undefined,
+    });
+
+    await waitFor(() => {
+      expect(screen.getByText('Practitioner')).toBeInTheDocument();
+    });
+
+    const practitionerInput = screen.getByPlaceholderText('Search for practitioner');
+    expect(practitionerInput).toBeDefined();
+
+    await act(async () => {
+      fireEvent.change(practitionerInput, { target: { value: 'Smith' } });
+    });
+
+    await waitFor(
+      () => {
+        const smithOption = screen.queryByText(/Smith/i);
+        expect(smithOption).toBeInTheDocument();
+      },
+      { timeout: 3000 }
+    );
+
+    await act(async () => {
+      const smithOption = screen.getByText(/Smith/i);
+      fireEvent.click(smithOption);
+    });
+
+    await waitFor(
+      () => {
+        expect(medplum.updateResource).toHaveBeenCalled();
+      },
+      { timeout: SAVE_TIMEOUT_MS + 2000 }
+    );
+
+    await waitFor(
+      () => {
+        expect(medplum.readReference).toHaveBeenCalledWith({ reference: 'Practitioner/practitioner-2' });
+      },
+      { timeout: 1000 }
+    );
+
+    await waitFor(
+      () => {
+        expect(claimsUtils.createClaimFromEncounter).toHaveBeenCalledWith(
+          medplum,
+          mockPatient.id,
+          mockEncounter.id,
+          mockPractitioner2.id,
+          [appliedChargeItem]
+        );
+        expect(setClaim).toHaveBeenCalledWith(newClaim);
+      },
+      { timeout: 5000 }
+    );
+  }, 15000);
+
+  test('updates claim when practitioner is changed and claim already exists', async () => {
+    const setEncounter = vi.fn();
+    const setClaim = vi.fn();
+    const debouncedUpdateResource = vi.fn().mockResolvedValue(undefined);
+
+    vi.spyOn(useDebouncedUpdateResourceModule, 'useDebouncedUpdateResource').mockReturnValue(debouncedUpdateResource);
+
+    const mockPractitioner1: Practitioner = {
+      resourceType: 'Practitioner',
+      id: 'practitioner-1',
+      name: [{ given: ['Dr.'], family: 'Test' }],
+    };
+
+    const mockPractitioner2: Practitioner = {
+      resourceType: 'Practitioner',
+      id: 'practitioner-2',
+      name: [{ given: ['Dr.'], family: 'Smith' }],
+    };
+
+    const appliedChargeItem: ChargeItem & { id: string } = {
+      resourceType: 'ChargeItem',
+      id: 'charge-new',
+      status: 'planned',
+      subject: { reference: 'Patient/patient-123' },
+      code: {
+        coding: [
+          {
+            system: 'http://www.ama-assn.org/go/cpt',
+            code: '99214',
+            display: 'Office Visit Level 4',
+          },
+        ],
+      },
+      priceOverride: { value: 200, currency: 'USD' },
+    };
+
+    const existingClaim: Claim & { id: string } = {
+      resourceType: 'Claim',
+      id: 'claim-existing',
+      status: 'active',
+      type: { coding: [{ code: 'professional' }] },
+      use: 'claim',
+      created: new Date().toISOString(),
+      priority: { coding: [{ code: 'normal' }] },
+      insurance: [],
+      patient: { reference: 'Patient/patient-123' },
+      provider: { reference: 'Practitioner/practitioner-1' }, // Original practitioner
+    };
+
+    const updatedClaim: Claim & { id: string } = {
+      ...existingClaim,
+      provider: { reference: 'Practitioner/practitioner-2' }, // Updated practitioner
+    };
+
+    const updatedEncounter: Encounter = {
+      ...mockEncounter,
+      participant: [
+        {
+          individual: { reference: 'Practitioner/practitioner-2' },
+        },
+      ],
+    };
+
+    await medplum.createResource(mockPractitioner1);
+    await medplum.createResource(mockPractitioner2);
+
+    // Mock searchResources to return different results based on resource type
+    vi.spyOn(medplum, 'searchResources')
+      .mockResolvedValueOnce([mockCoverage] as any) // Coverage search on mount
+      .mockResolvedValue([mockPractitioner1, mockPractitioner2] as any); // Practitioner searches
+    vi.spyOn(medplum, 'updateResource').mockImplementation(async (resource: any) => {
+      // Return updated encounter when updating encounter, updated claim when updating claim
+      if (resource.resourceType === 'Encounter') {
+        return updatedEncounter as any;
+      }
+      if (resource.resourceType === 'Claim') {
+        return updatedClaim as any;
+      }
+      return resource;
+    });
+    vi.spyOn(medplum, 'readReference').mockResolvedValue(mockPractitioner2 as any);
+
+    await setup({
+      claim: existingClaim,
+      chargeItems: [appliedChargeItem],
+      setChargeItems: vi.fn(),
+      setClaim,
+      setEncounter,
+      encounter: {
+        resourceType: 'Encounter',
+        id: 'encounter-123',
+        status: 'finished',
+        class: { code: 'AMB', system: 'http://terminology.hl7.org/CodeSystem/v3-ActCode' },
+        subject: { reference: `Patient/${HomerSimpson.id}` },
+        participant: [
+          {
+            individual: { reference: 'Practitioner/practitioner-1' }, // Original practitioner
+          },
+        ],
+      },
+      practitioner: mockPractitioner1, // Start with practitioner-1
+    });
+
+    await waitFor(() => {
+      expect(screen.getByText('Practitioner')).toBeInTheDocument();
+      expect(screen.getByText(/Dr\. Test/i)).toBeInTheDocument();
+    });
+
+    const practitionerText = screen.getByText(/Dr\. Test/i);
+    const practitionerContainer = practitionerText.closest('[data-testid]') || practitionerText.closest('div');
+    const clickableElement =
+      practitionerContainer?.querySelector('button') || practitionerText.closest('button') || practitionerText;
+
+    // Click to open the dropdown
+    await act(async () => {
+      fireEvent.click(clickableElement);
+    });
+
+    await waitFor(
+      () => {
+        const practitionerInput = screen.queryByPlaceholderText('Search for practitioner') as HTMLInputElement;
+        expect(practitionerInput).toBeInTheDocument();
+      },
+      { timeout: 3000 }
+    );
+
+    const practitionerInput = screen.getByPlaceholderText('Search for practitioner');
+
+    await act(async () => {
+      fireEvent.change(practitionerInput, { target: { value: 'Smith' } });
+    });
+
+    await waitFor(
+      () => {
+        const smithOption = screen.queryByText(/Smith/i);
+        expect(smithOption).toBeInTheDocument();
+      },
+      { timeout: 3000 }
+    );
+
+    await act(async () => {
+      const smithOption = screen.getByText(/Smith/i);
+      fireEvent.click(smithOption);
+    });
+
+    await waitFor(
+      () => {
+        expect(medplum.updateResource).toHaveBeenCalled();
+      },
+      { timeout: SAVE_TIMEOUT_MS + 2000 }
+    );
+
+    await waitFor(
+      () => {
+        expect(medplum.readReference).toHaveBeenCalledWith({ reference: 'Practitioner/practitioner-2' });
+      },
+      { timeout: 1000 }
+    );
+
+    await waitFor(
+      () => {
+        const updateCalls = vi.mocked(medplum.updateResource).mock.calls;
+        const claimUpdateCall = updateCalls.find((call) => {
+          const resource = call[0] as Claim;
+          return resource.resourceType === 'Claim' && resource.provider?.reference === 'Practitioner/practitioner-2';
+        });
+        expect(claimUpdateCall).toBeDefined();
+        expect(setClaim).toHaveBeenCalledWith(updatedClaim);
+      },
+      { timeout: 5000 }
+    );
+  }, 15000);
+
+  test('handles export when claim id is missing', async () => {
+    const user = userEvent.setup();
+
+    vi.spyOn(medplum, 'searchResources').mockResolvedValue([mockCoverage] as any);
+    vi.spyOn(medplum, 'post').mockResolvedValue({
+      resourceType: 'Media',
+      content: { url: 'https://example.com/claim.pdf' },
+    } as any);
+
+    // Setup with a claim but with undefined id
+    await setup({ claim: { ...mockClaim, id: undefined } });
+
+    // Export button is visible but clicking it should be a no-op
+    const exportButton = screen.getByText('Export Claim');
+    await user.click(exportButton);
+
+    await waitFor(() => {
+      expect(screen.getByText('CMS 1500 Form')).toBeInTheDocument();
+    });
+
+    await user.click(screen.getByText('CMS 1500 Form'));
+
+    // Post should NOT be called due to early return
+    await waitFor(() => {
+      expect(medplum.post).not.toHaveBeenCalled();
+    });
+  });
+
+  test('shows error when export fails to return Media', async () => {
+    const user = userEvent.setup();
+
+    vi.spyOn(medplum, 'searchResources').mockResolvedValue([mockCoverage] as any);
+    vi.spyOn(medplum, 'post').mockResolvedValue({
+      resourceType: 'OperationOutcome',
+      issue: [{ severity: 'error', code: 'invalid' }],
+    } as any);
+
+    await setup({ claim: mockClaim });
+
+    const exportButton = screen.getByText('Export Claim');
+    await user.click(exportButton);
+
+    await waitFor(() => {
+      expect(screen.getByText('CMS 1500 Form')).toBeInTheDocument();
+    });
+
+    await user.click(screen.getByText('CMS 1500 Form'));
+
+    await waitFor(() => {
+      expect(screen.getByText('Failed to download PDF')).toBeInTheDocument();
+    });
+  });
+
+  test('creates self-pay coverage when no coverage exists', async () => {
+    const user = userEvent.setup();
+
+    // Return empty coverage array first, then return self-pay coverage for the claim
+    const selfPayCoverage: Coverage = {
+      resourceType: 'Coverage',
+      id: 'self-pay-123',
+      status: 'active',
+      beneficiary: { reference: 'Patient/patient-123' },
+      payor: [{ reference: 'Patient/patient-123' }],
+    };
+
+    vi.spyOn(medplum, 'searchResources').mockResolvedValue([] as any);
+    vi.spyOn(medplum, 'createResource').mockResolvedValue(selfPayCoverage as any);
+    vi.spyOn(medplum, 'post').mockResolvedValue({
+      resourceType: 'Media',
+      content: { url: 'https://example.com/claim.pdf' },
+    } as any);
+
+    const windowOpenSpy = vi.spyOn(window, 'open').mockImplementation(() => null);
+
+    await setup({ claim: mockClaim });
+
+    const exportButton = screen.getByText('Export Claim');
+    await user.click(exportButton);
+
+    await waitFor(() => {
+      expect(screen.getByText('CMS 1500 Form')).toBeInTheDocument();
+    });
+
+    await user.click(screen.getByText('CMS 1500 Form'));
+
+    await waitFor(() => {
+      expect(medplum.post).toHaveBeenCalled();
+    });
+
+    windowOpenSpy.mockRestore();
+  });
+
+  test('handles error in encounter change', async () => {
+    const setEncounter = vi.fn();
+    const debouncedUpdateResource = vi.fn().mockResolvedValue(undefined);
+
+    vi.spyOn(useDebouncedUpdateResourceModule, 'useDebouncedUpdateResource').mockReturnValue(debouncedUpdateResource);
+    vi.spyOn(medplum, 'updateResource').mockRejectedValue(new Error('Update failed'));
+
+    await setup({
+      setEncounter,
+      practitioner: undefined,
+      encounter: mockEncounter,
+    });
+
+    await waitFor(() => {
+      expect(screen.getByText('Visit Details')).toBeInTheDocument();
+    });
+  });
+
+  test('exports claim with conditions that have ICD-10 coding', async () => {
+    const user = userEvent.setup();
+
+    const mockCondition = {
+      resourceType: 'Condition' as const,
+      id: 'condition-1',
+      code: {
+        coding: [
+          {
+            system: 'http://hl7.org/fhir/sid/icd-10-cm',
+            code: 'R51',
+            display: 'Headache',
+          },
+        ],
+        text: 'Headache',
+      },
+    };
+
+    vi.spyOn(medplum, 'readReference').mockResolvedValue(mockCondition as any);
+    vi.spyOn(medplum, 'searchResources').mockResolvedValue([mockCoverage] as any);
+    vi.spyOn(medplum, 'post').mockResolvedValue({
+      resourceType: 'Media',
+      content: { url: 'https://example.com/claim.pdf' },
+    } as any);
+
+    const windowOpenSpy = vi.spyOn(window, 'open').mockImplementation(() => null);
+
+    await setup({
+      claim: mockClaim,
+      encounter: {
+        ...mockEncounter,
+        diagnosis: [
+          {
+            condition: { reference: 'Condition/condition-1' },
+          },
+        ],
+      },
+    });
+
+    await waitFor(() => {
+      expect(screen.getByText('Headache')).toBeInTheDocument();
+    });
+
+    const exportButton = screen.getByText('Export Claim');
+    await user.click(exportButton);
+
+    await waitFor(() => {
+      expect(screen.getByText('CMS 1500 Form')).toBeInTheDocument();
+    });
+
+    await user.click(screen.getByText('CMS 1500 Form'));
+
+    await waitFor(() => {
+      expect(medplum.post).toHaveBeenCalled();
+    });
+
+    windowOpenSpy.mockRestore();
+  });
+});