vintasend 0.4.0 → 0.4.7

package/dist/examples/vintasend-medplum-example/src/pages/tasks/TasksPage.test.tsx

@@ -0,0 +1,133 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import { MantineProvider } from '@mantine/core';
+import { MockClient } from '@medplum/mock';
+import { MedplumProvider } from '@medplum/react';
+import { render, screen, waitFor } from '@testing-library/react';
+import type { Task } from '@medplum/fhirtypes';
+import { MemoryRouter, Routes, Route } from 'react-router';
+import type { NavigateFunction } from 'react-router';
+import * as reactRouter from 'react-router';
+import { describe, expect, test, vi, beforeEach } from 'vitest';
+import { TasksPage } from './TasksPage';
+
+describe('TasksPage', () => {
+  let medplum: MockClient;
+  let navigateSpy: NavigateFunction;
+
+  beforeEach(() => {
+    medplum = new MockClient();
+    vi.clearAllMocks();
+    navigateSpy = vi.fn() as NavigateFunction;
+    vi.spyOn(reactRouter, 'useNavigate').mockReturnValue(navigateSpy);
+  });
+
+  const setup = (initialPath = '/Task'): ReturnType<typeof render> => {
+    return render(
+      <MemoryRouter initialEntries={[initialPath]}>
+        <MedplumProvider medplum={medplum}>
+          <MantineProvider>
+            <Routes>
+              <Route path="/Task/:taskId?" element={<TasksPage />} />
+            </Routes>
+          </MantineProvider>
+        </MedplumProvider>
+      </MemoryRouter>
+    );
+  };
+
+  const mockTask: Task & { id: string } = {
+    resourceType: 'Task',
+    id: 'task-123',
+    status: 'in-progress',
+    intent: 'order',
+    code: { text: 'Test Task' },
+    authoredOn: '2023-01-01T12:00:00Z',
+  };
+
+  test('renders TaskBoard component', async () => {
+    vi.spyOn(medplum, 'search').mockResolvedValue({
+      resourceType: 'Bundle',
+      type: 'searchset',
+      total: 0,
+      entry: [],
+    } as any);
+
+    setup('/Task?_sort=-_lastUpdated&_count=20&_total=accurate');
+
+    await waitFor(() => {
+      expect(screen.getByText('My Tasks')).toBeInTheDocument();
+      expect(screen.getByText('All Tasks')).toBeInTheDocument();
+    });
+  });
+
+  test('passes taskId from URL params to TaskBoard', async () => {
+    await medplum.createResource(mockTask);
+    vi.spyOn(medplum, 'search').mockResolvedValue({
+      resourceType: 'Bundle',
+      type: 'searchset',
+      total: 1,
+      entry: [{ resource: mockTask }],
+    } as any);
+    vi.spyOn(medplum, 'readResource').mockResolvedValue(mockTask);
+
+    setup('/Task/task-123?_sort=-_lastUpdated&_count=20&_total=accurate');
+
+    await waitFor(() => {
+      expect(screen.getByText('My Tasks')).toBeInTheDocument();
+    });
+
+    // Verify that TaskBoard receives the taskId by checking if readResource is called
+    await waitFor(
+      () => {
+        expect(medplum.readResource).toHaveBeenCalledWith('Task', 'task-123');
+      },
+      { timeout: 3000 }
+    );
+  });
+
+  test('passes correct query prop to TaskBoard', async () => {
+    vi.spyOn(medplum, 'search').mockResolvedValue({
+      resourceType: 'Bundle',
+      type: 'searchset',
+      total: 0,
+      entry: [],
+    } as any);
+
+    setup('/Task?_sort=-_lastUpdated&_count=20&_total=accurate');
+
+    await waitFor(() => {
+      expect(screen.getByText('My Tasks')).toBeInTheDocument();
+    });
+
+    // Verify that search was called with the correct query parameter
+    await waitFor(() => {
+      expect(medplum.search).toHaveBeenCalled();
+      const searchCalls = vi.mocked(medplum.search).mock.calls;
+      expect(searchCalls.length).toBeGreaterThan(0);
+      // Check that the query includes the sort parameter
+      const queryString = searchCalls[0][1] as string;
+      expect(queryString).toContain('_sort=-_lastUpdated');
+    });
+  });
+
+  test('passes undefined selectedTaskId when no taskId in URL', async () => {
+    vi.spyOn(medplum, 'search').mockResolvedValue({
+      resourceType: 'Bundle',
+      type: 'searchset',
+      total: 0,
+      entry: [],
+    } as any);
+    const readResourceSpy = vi.spyOn(medplum, 'readResource');
+
+    setup('/Task?_sort=-_lastUpdated&_count=20&_total=accurate');
+
+    await waitFor(() => {
+      expect(screen.getByText('My Tasks')).toBeInTheDocument();
+    });
+
+    await waitFor(() => {
+      expect(readResourceSpy).not.toHaveBeenCalled();
+    });
+  });
+});

package/dist/examples/vintasend-medplum-example/src/pages/tasks/TasksPage.tsx

@@ -0,0 +1,91 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import type { Task } from '@medplum/fhirtypes';
+import React, { useEffect, useState } from 'react';
+import type { JSX } from 'react';
+import { useLocation, useNavigate, useParams } from 'react-router';
+import classes from './TasksPage.module.css';
+import { TaskBoard } from '../../components/tasks/TaskBoard';
+import { formatSearchQuery, getReferenceString, Operator } from '@medplum/core';
+import type { SearchRequest } from '@medplum/core';
+import { Loading, useMedplumProfile } from '@medplum/react';
+import { normalizeTaskSearch } from '../../utils/task-search';
+
+export function TasksPage(): JSX.Element {
+  const { taskId } = useParams();
+  const navigate = useNavigate();
+  const location = useLocation();
+  const profile = useMedplumProfile();
+  const [parsedSearch, setParsedSearch] = useState<SearchRequest>();
+
+  useEffect(() => {
+    const { normalizedSearch, needsNavigation } = normalizeTaskSearch(location.pathname, location.search);
+    if (needsNavigation) {
+      navigate(`/Task${formatSearchQuery(normalizedSearch)}`)?.catch(console.error);
+    } else {
+      setParsedSearch(normalizedSearch);
+    }
+  }, [location, navigate]);
+
+  if (!parsedSearch) {
+    return <Loading />;
+  }
+
+  const onNew = (task: Task): void => {
+    navigate(getTaskUri(task))?.catch(console.error);
+  };
+
+  const getTaskUri = (task: Task): string => {
+    return `/Task/${task.id}${formatSearchQuery(parsedSearch)}`;
+  };
+
+  const onDelete = (_: Task): void => {
+    navigate(`/Task${formatSearchQuery(parsedSearch)}`)?.catch(console.error);
+  };
+
+  const onChange = (search: SearchRequest): void => {
+    navigate(`/Task${formatSearchQuery(search)}`)?.catch(console.error);
+  };
+
+  const myTasksFilters = parsedSearch.filters?.filter((f) => f.code !== 'owner') || [];
+  if (profile) {
+    const profileRef = getReferenceString(profile);
+    if (profileRef) {
+      myTasksFilters.push({
+        code: 'owner',
+        operator: Operator.EQUALS,
+        value: profileRef,
+      });
+    }
+  }
+  const myTasksSearch: SearchRequest = {
+    ...parsedSearch,
+    filters: myTasksFilters,
+    offset: 0,
+  };
+
+  const allTasksFilters = parsedSearch.filters?.filter((f) => f.code !== 'owner') || [];
+  const allTasksSearch: SearchRequest = {
+    ...parsedSearch,
+    filters: allTasksFilters,
+    offset: 0,
+  };
+
+  const myTasksQuery = formatSearchQuery(myTasksSearch);
+  const allTasksQuery = formatSearchQuery(allTasksSearch);
+
+  return (
+    <div className={classes.container}>
+      <TaskBoard
+        query={formatSearchQuery(parsedSearch).substring(1)}
+        selectedTaskId={taskId}
+        onDelete={onDelete}
+        onNew={onNew}
+        onChange={onChange}
+        getTaskUri={getTaskUri}
+        myTasksUri={myTasksQuery ? `/Task?${myTasksQuery.substring(1)}` : '/Task'}
+        allTasksUri={allTasksQuery ? `/Task?${allTasksQuery.substring(1)}` : '/Task'}
+      />
+    </div>
+  );
+}

package/dist/examples/vintasend-medplum-example/src/test-utils/render.tsx

@@ -0,0 +1,20 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// Sets up MantineProvider for all tests
+// See: https://mantine.dev/guides/vitest/
+
+import { MantineProvider } from '@mantine/core';
+import { act, fireEvent, screen, render as testingLibraryRender, waitFor } from '@testing-library/react';
+import type { RenderResult } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import type { UserEvent } from '@testing-library/user-event';
+
+export type { RenderResult, UserEvent };
+export { act, fireEvent, screen, userEvent, waitFor };
+
+export function render(ui: React.ReactNode): RenderResult {
+  return testingLibraryRender(<>{ui}</>, {
+    wrapper: ({ children }: { children: React.ReactNode }) => <MantineProvider>{children}</MantineProvider>,
+  });
+}

package/dist/examples/vintasend-medplum-example/src/test.setup.ts

@@ -0,0 +1,49 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+// See: https://mantine.dev/guides/vitest/
+
+import '@testing-library/jest-dom';
+
+import { MemoryStorage, indexSearchParameterBundle, indexStructureDefinitionBundle } from '@medplum/core';
+import { SEARCH_PARAMETER_BUNDLE_FILES, readJson } from '@medplum/definitions';
+import type { Bundle, SearchParameter } from '@medplum/fhirtypes';
+import { vi } from 'vitest';
+
+const { getComputedStyle } = window;
+window.getComputedStyle = (elt) => getComputedStyle(elt);
+window.HTMLElement.prototype.scrollIntoView = () => {};
+
+Object.defineProperty(window, 'matchMedia', {
+  writable: true,
+  value: vi.fn().mockImplementation((query) => ({
+    matches: false,
+    media: query,
+    onchange: null,
+    addListener: vi.fn(),
+    removeListener: vi.fn(),
+    addEventListener: vi.fn(),
+    removeEventListener: vi.fn(),
+    dispatchEvent: vi.fn(),
+  })),
+});
+
+class ResizeObserver {
+  observe(): void {}
+  unobserve(): void {}
+  disconnect(): void {}
+}
+
+window.ResizeObserver = ResizeObserver;
+
+// jsdom does not implement scrollIntoView
+// See: https://github.com/jsdom/jsdom/issues/1695#issuecomment-449931788
+Element.prototype.scrollIntoView = vi.fn();
+
+indexStructureDefinitionBundle(readJson('fhir/r4/profiles-types.json') as Bundle);
+indexStructureDefinitionBundle(readJson('fhir/r4/profiles-resources.json') as Bundle);
+indexStructureDefinitionBundle(readJson('fhir/r4/profiles-medplum.json') as Bundle);
+for (const filename of SEARCH_PARAMETER_BUNDLE_FILES) {
+  indexSearchParameterBundle(readJson(filename) as Bundle<SearchParameter>);
+}
+
+Object.defineProperty(globalThis.window, 'sessionStorage', { value: new MemoryStorage() });

package/dist/examples/vintasend-medplum-example/src/types/encounter.ts

@@ -0,0 +1,8 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export enum ChartNoteStatus {
+  Unsigned = 'unsigned',
+  Signed = 'signed',
+  SignedAndLocked = 'signedAndLocked',
+}

package/dist/examples/vintasend-medplum-example/src/types/spaces.ts

@@ -0,0 +1,10 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export interface Message {
+  role: 'user' | 'assistant' | 'system' | 'tool';
+  content: string | null;
+  tool_calls?: any[];
+  tool_call_id?: string;
+  resources?: string[];
+}

package/dist/examples/vintasend-medplum-example/src/utils/chargeitems.test.ts

@@ -0,0 +1,141 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import type { ChargeItem, ChargeItemDefinition, Encounter } from '@medplum/fhirtypes';
+import { MockClient } from '@medplum/mock';
+import { describe, expect, test, beforeEach, vi, afterEach } from 'vitest';
+import * as chargeitemsModule from './chargeitems';
+
+const { applyChargeItemDefinition, getChargeItemsForEncounter, calculateTotalPrice } = chargeitemsModule;
+
+describe('chargeitems utils', () => {
+  let medplum: MockClient;
+
+  beforeEach(() => {
+    medplum = new MockClient();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('applyChargeItemDefinition', () => {
+    const chargeItem: ChargeItem = {
+      resourceType: 'ChargeItem',
+      id: 'charge-1',
+      status: 'planned',
+      code: {
+        text: 'Test Charge Item',
+        coding: [{ system: 'http://example.com', code: '1234' }],
+      },
+      subject: { reference: 'Patient/patient-1' },
+    };
+
+    test('returns original charge item when no definition canonical', async () => {
+      const result = await applyChargeItemDefinition(medplum as any, chargeItem);
+      expect(result).toBe(chargeItem);
+    });
+
+    test('returns original charge item when definition not found', async () => {
+      const canonicalItem: ChargeItem = {
+        ...chargeItem,
+        definitionCanonical: ['ChargeItemDefinition/123'],
+      };
+      const searchSpy = vi.spyOn(medplum, 'searchResources').mockResolvedValue([] as any);
+
+      const result = await applyChargeItemDefinition(medplum as any, canonicalItem);
+
+      expect(searchSpy).toHaveBeenCalledWith('ChargeItemDefinition', 'url=ChargeItemDefinition/123');
+      expect(result).toBe(canonicalItem);
+    });
+
+    test('applies definition and returns updated charge item', async () => {
+      const canonicalItem: ChargeItem = {
+        ...chargeItem,
+        definitionCanonical: ['ChargeItemDefinition/123'],
+      };
+      const definition: ChargeItemDefinition = {
+        resourceType: 'ChargeItemDefinition',
+        id: 'cid-1',
+        url: 'http://example.com/chargeitemdefinition/123',
+        status: 'active',
+      };
+      vi.spyOn(medplum, 'searchResources').mockResolvedValue([definition] as any);
+      const updatedChargeItem: ChargeItem = { ...canonicalItem, status: 'billable' };
+      const postSpy = vi.spyOn(medplum, 'post').mockResolvedValue(updatedChargeItem);
+
+      const result = await applyChargeItemDefinition(medplum as any, canonicalItem);
+
+      expect(postSpy).toHaveBeenCalledWith(
+        medplum.fhirUrl('ChargeItemDefinition', 'cid-1', '$apply'),
+        expect.objectContaining({
+          resourceType: 'Parameters',
+        })
+      );
+      expect(result).toEqual(updatedChargeItem);
+    });
+  });
+
+  describe('getChargeItemsForEncounter', () => {
+    test('returns empty array when encounter missing', async () => {
+      const result = await getChargeItemsForEncounter(medplum as any, undefined as unknown as Encounter);
+      expect(result).toEqual([]);
+    });
+
+    test('fetches charge items for encounter', async () => {
+      const encounter: Encounter = {
+        resourceType: 'Encounter',
+        id: 'enc-1',
+        status: 'finished',
+        class: { code: 'AMB', system: 'http://terminology.hl7.org/CodeSystem/v3-ActCode' },
+      };
+      const chargeItem: ChargeItem = {
+        resourceType: 'ChargeItem',
+        id: 'charge-1',
+        status: 'billable',
+        code: {
+          text: 'Test Charge Item',
+          coding: [{ system: 'http://example.com', code: '1234' }],
+        },
+        subject: { reference: 'Patient/patient-1' },
+      };
+      vi.spyOn(medplum, 'searchResources').mockResolvedValue([chargeItem] as any);
+
+      const result = await getChargeItemsForEncounter(medplum as any, encounter);
+
+      expect(result).toEqual([chargeItem]);
+    });
+  });
+
+  describe('calculateTotalPrice', () => {
+    test('sums up price overrides', () => {
+      const items: ChargeItem[] = [
+        {
+          resourceType: 'ChargeItem',
+          id: '1',
+          status: 'billable',
+          priceOverride: { value: 10 },
+          code: { text: 'Test Charge Item', coding: [{ system: 'http://example.com', code: '1234' }] },
+          subject: { reference: 'Patient/patient-1' },
+        },
+        {
+          resourceType: 'ChargeItem',
+          id: '2',
+          status: 'billable',
+          priceOverride: { value: 15.5 },
+          code: { text: 'Test Charge Item', coding: [{ system: 'http://example.com', code: '1234' }] },
+          subject: { reference: 'Patient/patient-1' },
+        },
+        {
+          resourceType: 'ChargeItem',
+          id: '3',
+          status: 'billable',
+          priceOverride: { value: 20 },
+          code: { text: 'Test Charge Item', coding: [{ system: 'http://example.com', code: '1234' }] },
+          subject: { reference: 'Patient/patient-1' },
+        },
+      ];
+
+      expect(calculateTotalPrice(items)).toBe(45.5);
+    });
+  });
+});

package/dist/examples/vintasend-medplum-example/src/utils/chargeitems.ts

@@ -0,0 +1,59 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import { getReferenceString } from '@medplum/core';
+import type { MedplumClient } from '@medplum/core';
+import type { ChargeItem, Encounter } from '@medplum/fhirtypes';
+
+export const CPT = 'http://www.ama-assn.org/go/cpt';
+
+/**
+ * Standalone function to fetch and apply ChargeItemDefinition to charge item
+ * @param medplum - Medplum client instance
+ * @param chargeItem - Current charge item
+ * @returns Promise with updated charge items
+ */
+export async function applyChargeItemDefinition(medplum: MedplumClient, chargeItem: ChargeItem): Promise<ChargeItem> {
+  if (!chargeItem.definitionCanonical || chargeItem.definitionCanonical.length === 0) {
+    return chargeItem;
+  }
+
+  const searchResult = await medplum.searchResources(
+    'ChargeItemDefinition',
+    `url=${chargeItem.definitionCanonical[0]}`
+  );
+
+  if (searchResult.length === 0) {
+    return chargeItem;
+  }
+
+  const chargeItemDefinition = searchResult[0];
+  const applyResult = await medplum.post(medplum.fhirUrl('ChargeItemDefinition', chargeItemDefinition.id, '$apply'), {
+    resourceType: 'Parameters',
+    parameter: [
+      {
+        name: 'chargeItem',
+        valueReference: {
+          reference: getReferenceString(chargeItem),
+        },
+      },
+    ],
+  });
+
+  return applyResult as ChargeItem;
+}
+
+export async function getChargeItemsForEncounter(medplum: MedplumClient, encounter: Encounter): Promise<ChargeItem[]> {
+  if (!encounter) {
+    return [];
+  }
+
+  const chargeItems = await medplum.searchResources('ChargeItem', `context=${getReferenceString(encounter)}`);
+  const updatedChargeItems = await Promise.all(
+    chargeItems.map((chargeItem) => applyChargeItemDefinition(medplum, chargeItem))
+  );
+  return updatedChargeItems;
+}
+
+export function calculateTotalPrice(items: ChargeItem[]): number {
+  return items.reduce((sum, item) => sum + (item.priceOverride?.value || 0), 0);
+}

package/dist/examples/vintasend-medplum-example/src/utils/claims.test.ts

@@ -0,0 +1,153 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import { CPT } from '@medplum/core';
+import type { ChargeItem, Claim, Coverage } from '@medplum/fhirtypes';
+import { MockClient } from '@medplum/mock';
+import { describe, expect, test, beforeEach, vi, afterEach } from 'vitest';
+import * as coverageModule from './coverage';
+import { createClaimFromEncounter, getCptChargeItems } from './claims';
+
+describe('claims utils', () => {
+  let medplum: MockClient;
+
+  beforeEach(() => {
+    medplum = new MockClient();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('getCptChargeItems', () => {
+    test('filters charge items to CPT codings and preserves modifiers', () => {
+      const cptItem: ChargeItem = {
+        resourceType: 'ChargeItem',
+        id: 'charge-1',
+        code: {
+          text: 'Test CPT',
+          coding: [
+            { system: CPT, code: '1234' },
+            { system: 'http://example.com', code: 'other' },
+          ],
+        },
+        priceOverride: { value: 42 },
+        extension: [
+          {
+            url: 'http://hl7.org/fhir/StructureDefinition/chargeitem-modifier',
+            valueCodeableConcept: { coding: [{ code: '59' }] },
+          },
+        ],
+        status: 'billable',
+        subject: { reference: 'Patient/patient-1' },
+      };
+      const nonCptItem: ChargeItem = {
+        resourceType: 'ChargeItem',
+        id: 'charge-2',
+        code: { coding: [{ system: 'http://example.com', code: 'not-cpt' }] },
+        status: 'billable',
+        subject: { reference: 'Patient/patient-1' },
+      };
+
+      const items = getCptChargeItems([cptItem, nonCptItem], { reference: 'Encounter/enc-1' });
+
+      expect(items).toHaveLength(1);
+      expect(items[0]).toEqual(
+        expect.objectContaining({
+          sequence: 1,
+          encounter: [{ reference: 'Encounter/enc-1' }],
+          productOrService: expect.objectContaining({
+            coding: [{ system: CPT, code: '1234' }],
+            text: 'Test CPT',
+          }),
+          modifier: [{ coding: [{ code: '59' }] }],
+          net: { value: 42 },
+        })
+      );
+    });
+  });
+
+  describe('createClaimFromEncounter', () => {
+    const chargeItems: ChargeItem[] = [
+      {
+        resourceType: 'ChargeItem',
+        id: 'charge-1',
+        code: { coding: [{ system: CPT, code: '1111' }], text: 'Visit' },
+        priceOverride: { value: 25 },
+        status: 'billable',
+        subject: { reference: 'Patient/patient-1' },
+      },
+    ];
+
+    test('creates claim using existing coverage', async () => {
+      const coverage: Coverage = {
+        resourceType: 'Coverage',
+        id: 'coverage-1',
+        status: 'active',
+        beneficiary: { reference: 'Patient/patient-1' },
+        payor: [{ reference: 'Organization/organization-1' }],
+      };
+      const claim: Claim = {
+        resourceType: 'Claim',
+        id: 'claim-1',
+        status: 'draft',
+        type: { coding: [{ code: 'professional' }] },
+        use: 'claim',
+        created: new Date().toISOString(),
+        patient: { reference: 'Patient/patient-1' },
+        provider: { reference: 'Practitioner/practitioner-1' },
+        priority: { coding: [{ code: 'normal' }] },
+        insurance: [{ sequence: 1, focal: true, coverage: { reference: 'Coverage/coverage-1' } }],
+        item: [
+          {
+            sequence: 1,
+            encounter: [{ reference: 'Encounter/encounter-1' }],
+            productOrService: { coding: [{ system: CPT, code: '1111' }], text: 'Visit' },
+            net: { value: 25 },
+          },
+        ],
+        total: { value: 25 },
+      };
+      vi.spyOn(medplum, 'searchResources').mockResolvedValue([coverage] as any);
+      const createSpy = vi.spyOn(medplum, 'createResource').mockResolvedValue(claim as any);
+
+      const result = await createClaimFromEncounter(
+        medplum as any,
+        'patient-1',
+        'encounter-1',
+        'practitioner-1',
+        chargeItems
+      );
+
+      expect(createSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          insurance: [
+            expect.objectContaining({
+              coverage: { reference: 'Coverage/coverage-1' },
+            }),
+          ],
+          patient: { reference: 'Patient/patient-1' },
+          provider: expect.objectContaining({ reference: 'Practitioner/practitioner-1' }),
+          total: { value: 25 },
+        })
+      );
+      expect(result).toBe(claim);
+    });
+
+    test('creates self-pay coverage when no coverage exists', async () => {
+      vi.spyOn(medplum, 'searchResources').mockResolvedValue([] as any);
+      const createdCoverage: Coverage = {
+        resourceType: 'Coverage',
+        id: 'coverage-self',
+        status: 'active',
+        beneficiary: { reference: 'Patient/patient-1' },
+        payor: [{ reference: 'Organization/organization-1' }],
+      };
+      const coverageSpy = vi.spyOn(coverageModule, 'createSelfPayCoverage').mockResolvedValue(createdCoverage);
+      vi.spyOn(medplum, 'createResource').mockResolvedValue({ resourceType: 'Claim' } as any);
+
+      await createClaimFromEncounter(medplum as any, 'patient-1', 'enc-1', 'prac-1', chargeItems);
+
+      expect(coverageSpy).toHaveBeenCalledWith(medplum, 'patient-1');
+    });
+  });
+});