vintasend 0.4.0 → 0.4.7

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

@@ -0,0 +1,732 @@
+// SPDX-FileCopyrightText: Copyright Orangebot, Inc. and Medplum contributors
+// SPDX-License-Identifier: Apache-2.0
+import { MantineProvider } from '@mantine/core';
+import { act, render, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { MedplumProvider } from '@medplum/react';
+import type { ClinicalImpression, Encounter, Practitioner, Provenance, Task } from '@medplum/fhirtypes';
+import { HomerSimpson, MockClient } from '@medplum/mock';
+import { MemoryRouter } from 'react-router';
+import { describe, expect, test, beforeEach, vi } from 'vitest';
+import { EncounterChart } from './EncounterChart';
+import { createReference } from '@medplum/core';
+
+const mockPractitioner: Practitioner = {
+  resourceType: 'Practitioner',
+  id: 'practitioner-123',
+  name: [{ given: ['Dr.'], family: 'Test' }],
+};
+
+const mockEncounter: Encounter = {
+  resourceType: 'Encounter',
+  id: 'encounter-123',
+  status: 'in-progress',
+  class: {
+    system: 'http://terminology.hl7.org/CodeSystem/v3-ActCode',
+    code: 'AMB',
+  },
+  subject: { reference: `Patient/${HomerSimpson.id}` },
+  participant: [
+    {
+      individual: createReference(mockPractitioner),
+    },
+  ],
+};
+
+const mockClinicalImpression: ClinicalImpression = {
+  resourceType: 'ClinicalImpression',
+  id: 'clinical-123',
+  status: 'in-progress',
+  subject: createReference(HomerSimpson),
+  encounter: createReference(mockEncounter),
+  note: [{ text: 'Test clinical note' }],
+};
+
+const mockTask: Task = {
+  resourceType: 'Task',
+  id: 'task-123',
+  status: 'in-progress',
+  intent: 'order',
+  encounter: createReference(mockEncounter),
+  authoredOn: '2024-01-01T10:00:00Z',
+};
+
+describe('EncounterChart', () => {
+  let medplum: MockClient;
+
+  beforeEach(async () => {
+    medplum = new MockClient();
+    await medplum.createResource(mockPractitioner);
+    await medplum.createResource(mockEncounter);
+    await medplum.createResource(mockClinicalImpression);
+    vi.clearAllMocks();
+  });
+
+  const setup = (props: Partial<Parameters<typeof EncounterChart>[0]> = {}): ReturnType<typeof render> => {
+    return render(
+      <MemoryRouter>
+        <MedplumProvider medplum={medplum}>
+          <MantineProvider>
+            <EncounterChart encounter={mockEncounter} {...props} />
+          </MantineProvider>
+        </MedplumProvider>
+      </MemoryRouter>
+    );
+  };
+
+  test('renders loading spinner initially', () => {
+    setup();
+    // The Loading component renders a spinner, not text
+    const loader = document.querySelector('.mantine-Loader-root');
+    expect(loader).toBeInTheDocument();
+  });
+
+  test('renders encounter header after loading', async () => {
+    setup();
+
+    await waitFor(() => {
+      expect(screen.getByText('Visit')).toBeInTheDocument();
+    });
+  });
+
+  test('renders chart note textarea', async () => {
+    setup();
+
+    await waitFor(() => {
+      expect(screen.getByText('Fill chart note')).toBeInTheDocument();
+    });
+
+    const textarea = screen.getByRole('textbox');
+    expect(textarea).toBeInTheDocument();
+    expect(textarea).toHaveValue('Test clinical note');
+  });
+
+  test('updates chart note on change', async () => {
+    const user = userEvent.setup();
+    vi.spyOn(medplum, 'updateResource').mockResolvedValue(mockClinicalImpression as any);
+
+    setup();
+
+    await waitFor(() => {
+      expect(screen.getByText('Fill chart note')).toBeInTheDocument();
+    });
+
+    const textarea = screen.getByRole('textbox');
+    await user.clear(textarea);
+    await user.type(textarea, 'Updated note');
+
+    await waitFor(
+      () => {
+        expect(medplum.updateResource).toHaveBeenCalled();
+      },
+      { timeout: 3000 }
+    );
+  });
+
+  test('displays tasks when available', async () => {
+    await medplum.createResource(mockTask);
+
+    setup();
+
+    await waitFor(() => {
+      expect(screen.getByText('Visit')).toBeInTheDocument();
+    });
+  });
+
+  test('renders notes tab by default', async () => {
+    setup();
+
+    await waitFor(() => {
+      expect(screen.getByText('Visit')).toBeInTheDocument();
+    });
+
+    // The notes tab should be active by default
+    await waitFor(() => {
+      expect(screen.getByText('Fill chart note')).toBeInTheDocument();
+    });
+  });
+
+  test('switches to details tab when clicked', async () => {
+    const user = userEvent.setup();
+    setup();
+
+    await waitFor(() => {
+      expect(screen.getByText('Visit')).toBeInTheDocument();
+    });
+
+    await waitFor(() => {
+      expect(screen.getByText('Fill chart note')).toBeInTheDocument();
+    });
+
+    const detailsTab = screen.getByText('Details & Billing');
+    await user.click(detailsTab);
+
+    await waitFor(() => {
+      expect(screen.queryByText('Fill chart note')).not.toBeInTheDocument();
+    });
+  });
+
+  test('switches back to notes tab when clicked', async () => {
+    const user = userEvent.setup();
+    setup();
+
+    await waitFor(() => {
+      expect(screen.getByText('Visit')).toBeInTheDocument();
+    });
+
+    const detailsTab = screen.getByText('Details & Billing');
+    await user.click(detailsTab);
+
+    await waitFor(() => {
+      expect(screen.queryByText('Fill chart note')).not.toBeInTheDocument();
+    });
+
+    const notesTab = screen.getByText('Note & Tasks');
+    await user.click(notesTab);
+
+    await waitFor(() => {
+      expect(screen.getByText('Fill chart note')).toBeInTheDocument();
+    });
+  });
+
+  test('displays billing tab content when details tab is active', async () => {
+    const user = userEvent.setup();
+    setup();
+
+    await waitFor(() => {
+      expect(screen.getByText('Visit')).toBeInTheDocument();
+    });
+
+    const detailsTab = screen.getByText('Details & Billing');
+    await user.click(detailsTab);
+
+    await waitFor(() => {
+      expect(screen.queryByText('Fill chart note')).not.toBeInTheDocument();
+    });
+  });
+
+  test('fetches provenances on mount', async () => {
+    vi.spyOn(medplum, 'searchResources').mockResolvedValue([] as any);
+
+    setup();
+
+    await waitFor(() => {
+      expect(medplum.searchResources).toHaveBeenCalledWith(
+        'Provenance',
+        expect.stringContaining('target=Encounter/encounter-123')
+      );
+    });
+  });
+
+  test('chart note is enabled when not signed', async () => {
+    vi.spyOn(medplum, 'searchResources').mockImplementation((resourceType: string) => {
+      if (resourceType === 'Provenance') {
+        return [] as any;
+      }
+      if (resourceType === 'ClinicalImpression') {
+        return [mockClinicalImpression];
+      }
+      if (resourceType === 'Task') {
+        return [];
+      }
+      return [];
+    });
+
+    setup();
+
+    await waitFor(() => {
+      expect(screen.getByText('Fill chart note')).toBeInTheDocument();
+    });
+
+    const textarea = screen.getByRole('textbox');
+    expect(textarea).not.toBeDisabled();
+  });
+
+  test('handles encounter status change', async () => {
+    const user = userEvent.setup();
+    vi.spyOn(medplum, 'updateResource').mockResolvedValue({ ...mockEncounter, status: 'finished' } as any);
+
+    setup();
+
+    await waitFor(() => {
+      expect(screen.getByText('In Progress')).toBeInTheDocument();
+    });
+
+    const statusButton = screen.getByText('In Progress');
+    await user.click(statusButton);
+
+    await waitFor(() => {
+      expect(screen.getByText('Finished')).toBeInTheDocument();
+    });
+  });
+
+  test('renders with encounter reference', async () => {
+    const encounterRef = { reference: 'Encounter/encounter-123' };
+
+    await act(async () => {
+      setup({ encounter: encounterRef });
+    });
+
+    await waitFor(() => {
+      expect(screen.getByText('Visit')).toBeInTheDocument();
+    });
+  });
+
+  test('fetches tasks for encounter', async () => {
+    await medplum.createResource(mockTask);
+
+    vi.spyOn(medplum, 'searchResources');
+
+    setup();
+
+    await waitFor(() => {
+      expect(medplum.searchResources).toHaveBeenCalledWith(
+        'Task',
+        expect.stringContaining('encounter=Encounter/encounter-123'),
+        expect.any(Object)
+      );
+    });
+  });
+
+  test('fetches clinical impressions for encounter', async () => {
+    vi.spyOn(medplum, 'searchResources');
+
+    setup();
+
+    await waitFor(() => {
+      expect(medplum.searchResources).toHaveBeenCalledWith(
+        'ClinicalImpression',
+        expect.stringContaining('encounter=Encounter/encounter-123')
+      );
+    });
+  });
+
+  describe('signing functionality', () => {
+    const finishedEncounter: Encounter = {
+      ...mockEncounter,
+      status: 'finished',
+    };
+
+    const getSignButton = (): HTMLElement | null => {
+      const buttons = screen.getAllByRole('button');
+      return buttons.find((btn) => btn.querySelector('svg')) || null;
+    };
+
+    test('signs without locking - textarea remains enabled', async () => {
+      const user = userEvent.setup();
+      const mockProvenance: Provenance = {
+        resourceType: 'Provenance',
+        id: 'provenance-1',
+        target: [createReference(finishedEncounter)],
+        recorded: new Date().toISOString(),
+        agent: [
+          {
+            who: createReference(mockPractitioner),
+          },
+        ],
+      };
+
+      // Mock searchResources to return empty initially, then return provenance after signing
+      let provenanceReturned = false;
+      vi.spyOn(medplum, 'searchResources').mockImplementation((resourceType: string) => {
+        if (resourceType === 'Provenance') {
+          return Promise.resolve(provenanceReturned ? [mockProvenance] : []) as any;
+        }
+        if (resourceType === 'ClinicalImpression') {
+          return Promise.resolve([mockClinicalImpression]) as any;
+        }
+        if (resourceType === 'Task') {
+          return Promise.resolve([]) as any;
+        }
+        return Promise.resolve([]) as any;
+      });
+
+      vi.spyOn(medplum, 'createResource').mockImplementation(async (resource: any) => {
+        if (resource.resourceType === 'Provenance') {
+          provenanceReturned = true;
+          return mockProvenance as any;
+        }
+        return resource;
+      });
+
+      await medplum.createResource(finishedEncounter);
+      setup({ encounter: finishedEncounter });
+
+      await waitFor(() => {
+        expect(screen.getByText('Fill chart note')).toBeInTheDocument();
+      });
+
+      await waitFor(() => {
+        const signButton = getSignButton();
+        expect(signButton).toBeInTheDocument();
+      });
+
+      const signButton = getSignButton();
+      if (signButton) {
+        await user.click(signButton);
+      }
+
+      await waitFor(() => {
+        expect(screen.getByText('Just Sign')).toBeInTheDocument();
+      });
+
+      await user.click(screen.getByText('Just Sign'));
+
+      await waitFor(() => {
+        expect(medplum.createResource).toHaveBeenCalledWith(
+          expect.objectContaining({
+            resourceType: 'Provenance',
+            target: [createReference(finishedEncounter)],
+          })
+        );
+      });
+
+      // Wait for modal to close and component to update
+      // Textarea should still be enabled after signing without locking
+      await waitFor(
+        () => {
+          const chartNoteCard = screen.getByText('Fill chart note').closest('.mantine-Card-root');
+          const textarea = chartNoteCard?.querySelector('textarea');
+          expect(textarea).not.toBeDisabled();
+        },
+        { timeout: 3000 }
+      );
+    });
+
+    test('signs with locking - textarea becomes disabled', async () => {
+      const user = userEvent.setup();
+      const completedClinicalImpression: ClinicalImpression = {
+        ...mockClinicalImpression,
+        status: 'completed',
+      };
+      const mockProvenance: Provenance = {
+        resourceType: 'Provenance',
+        id: 'provenance-1',
+        target: [createReference(finishedEncounter)],
+        recorded: new Date().toISOString(),
+        agent: [
+          {
+            who: createReference(mockPractitioner),
+          },
+        ],
+      };
+
+      // Mock searchResources to return empty initially, then return provenance after signing
+      let provenanceReturned = false;
+      vi.spyOn(medplum, 'searchResources').mockImplementation((resourceType: string) => {
+        if (resourceType === 'Provenance') {
+          return Promise.resolve(provenanceReturned ? [mockProvenance] : []) as any;
+        }
+        if (resourceType === 'ClinicalImpression') {
+          return Promise.resolve([completedClinicalImpression]) as any;
+        }
+        if (resourceType === 'Task') {
+          return Promise.resolve([]) as any;
+        }
+        return Promise.resolve([]) as any;
+      });
+
+      vi.spyOn(medplum, 'createResource').mockImplementation(async (resource: any) => {
+        if (resource.resourceType === 'Provenance') {
+          provenanceReturned = true;
+          return mockProvenance as any;
+        }
+        return resource;
+      });
+
+      await medplum.createResource(finishedEncounter);
+      setup({ encounter: finishedEncounter });
+
+      await waitFor(() => {
+        expect(screen.getByText('Fill chart note')).toBeInTheDocument();
+      });
+
+      await waitFor(() => {
+        const signButton = getSignButton();
+        expect(signButton).toBeInTheDocument();
+      });
+
+      const signButton = getSignButton();
+      if (signButton) {
+        await user.click(signButton);
+      }
+
+      await waitFor(() => {
+        expect(screen.getByText('Sign & Lock Note')).toBeInTheDocument();
+      });
+
+      await user.click(screen.getByText('Sign & Lock Note'));
+
+      await waitFor(() => {
+        expect(medplum.createResource).toHaveBeenCalledWith(
+          expect.objectContaining({
+            resourceType: 'Provenance',
+            target: [createReference(finishedEncounter)],
+          })
+        );
+      });
+
+      // Wait for modal to close and component to update
+      // Textarea should be disabled after signing with locking
+      await waitFor(
+        () => {
+          const chartNoteCard = screen.getByText('Fill chart note').closest('.mantine-Card-root');
+          const textarea = chartNoteCard?.querySelector('textarea');
+          expect(textarea).toBeDisabled();
+        },
+        { timeout: 3000 }
+      );
+    });
+
+    test('signs with locking - completes incomplete tasks', async () => {
+      const user = userEvent.setup();
+      const incompleteTask: Task = {
+        ...mockTask,
+        id: 'task-incomplete',
+        status: 'in-progress',
+      };
+      const completedTask: Task = {
+        ...incompleteTask,
+        status: 'completed',
+      };
+
+      const completedClinicalImpression: ClinicalImpression = {
+        ...mockClinicalImpression,
+        status: 'completed',
+      };
+      const mockProvenance: Provenance = {
+        resourceType: 'Provenance',
+        id: 'provenance-1',
+        target: [createReference(finishedEncounter)],
+        recorded: new Date().toISOString(),
+        agent: [
+          {
+            who: createReference(mockPractitioner),
+          },
+        ],
+      };
+
+      await medplum.createResource(incompleteTask);
+      let provenanceReturned = false;
+      vi.spyOn(medplum, 'updateResource').mockResolvedValue(completedTask as any);
+      vi.spyOn(medplum, 'createResource').mockImplementation(async (resource: any) => {
+        if (resource.resourceType === 'Provenance') {
+          provenanceReturned = true;
+          return mockProvenance as any;
+        }
+        return resource;
+      });
+      vi.spyOn(medplum, 'searchResources').mockImplementation((resourceType: string) => {
+        if (resourceType === 'Provenance') {
+          return Promise.resolve(provenanceReturned ? [mockProvenance] : []) as any;
+        }
+        if (resourceType === 'ClinicalImpression') {
+          return Promise.resolve([completedClinicalImpression]) as any;
+        }
+        if (resourceType === 'Task') {
+          return Promise.resolve([incompleteTask]) as any;
+        }
+        return Promise.resolve([]) as any;
+      });
+
+      await medplum.createResource(finishedEncounter);
+      setup({ encounter: finishedEncounter });
+
+      await waitFor(() => {
+        expect(screen.getByText('Fill chart note')).toBeInTheDocument();
+      });
+
+      await waitFor(() => {
+        const signButton = getSignButton();
+        expect(signButton).toBeInTheDocument();
+      });
+
+      const signButton = getSignButton();
+      if (signButton) {
+        await user.click(signButton);
+      }
+
+      await waitFor(() => {
+        expect(screen.getByText('Sign & Lock Note')).toBeInTheDocument();
+      });
+
+      await user.click(screen.getByText('Sign & Lock Note'));
+
+      // Verify that incomplete tasks are updated to completed
+      await waitFor(
+        () => {
+          expect(medplum.updateResource).toHaveBeenCalledWith(
+            expect.objectContaining({
+              resourceType: 'Task',
+              id: 'task-incomplete',
+              status: 'completed',
+            })
+          );
+        },
+        { timeout: 3000 }
+      );
+    });
+
+    test('signs with locking - does not update already completed tasks', async () => {
+      const user = userEvent.setup();
+      const completedTask: Task = {
+        ...mockTask,
+        id: 'task-completed',
+        status: 'completed',
+      };
+
+      const completedClinicalImpression: ClinicalImpression = {
+        ...mockClinicalImpression,
+        status: 'completed',
+      };
+      const mockProvenance: Provenance = {
+        resourceType: 'Provenance',
+        id: 'provenance-1',
+        target: [createReference(finishedEncounter)],
+        recorded: new Date().toISOString(),
+        agent: [
+          {
+            who: createReference(mockPractitioner),
+          },
+        ],
+      };
+
+      await medplum.createResource(completedTask);
+      let provenanceReturned = false;
+      vi.spyOn(medplum, 'updateResource');
+      vi.spyOn(medplum, 'createResource').mockImplementation(async (resource: any) => {
+        if (resource.resourceType === 'Provenance') {
+          provenanceReturned = true;
+          return mockProvenance as any;
+        }
+        return resource;
+      });
+      vi.spyOn(medplum, 'searchResources').mockImplementation((resourceType: string) => {
+        if (resourceType === 'Provenance') {
+          return Promise.resolve(provenanceReturned ? [mockProvenance] : []) as any;
+        }
+        if (resourceType === 'ClinicalImpression') {
+          return Promise.resolve([completedClinicalImpression]) as any;
+        }
+        if (resourceType === 'Task') {
+          return Promise.resolve([completedTask]) as any;
+        }
+        return Promise.resolve([]) as any;
+      });
+
+      await medplum.createResource(finishedEncounter);
+      setup({ encounter: finishedEncounter });
+
+      await waitFor(() => {
+        expect(screen.getByText('Fill chart note')).toBeInTheDocument();
+      });
+
+      await waitFor(() => {
+        const signButton = getSignButton();
+        expect(signButton).toBeInTheDocument();
+      });
+
+      const signButton = getSignButton();
+      if (signButton) {
+        await user.click(signButton);
+      }
+
+      await waitFor(() => {
+        expect(screen.getByText('Sign & Lock Note')).toBeInTheDocument();
+      });
+
+      await user.click(screen.getByText('Sign & Lock Note'));
+
+      await waitFor(
+        () => {
+          expect(medplum.createResource).toHaveBeenCalled();
+        },
+        { timeout: 3000 }
+      );
+
+      // Verify that completed tasks are not updated
+      const updateCalls = vi.mocked(medplum.updateResource).mock.calls;
+      const taskUpdateCalls = updateCalls.filter((call) => call[0]?.resourceType === 'Task');
+      expect(taskUpdateCalls).toHaveLength(0);
+    });
+
+    test('chart note is disabled when signed and locked', async () => {
+      const mockProvenance: Provenance = {
+        resourceType: 'Provenance',
+        id: 'provenance-1',
+        target: [createReference(finishedEncounter)],
+        recorded: new Date().toISOString(),
+        agent: [
+          {
+            who: createReference(mockPractitioner),
+          },
+        ],
+      };
+
+      const completedClinicalImpression: ClinicalImpression = {
+        ...mockClinicalImpression,
+        status: 'completed',
+      };
+
+      vi.spyOn(medplum, 'searchResources').mockImplementation((resourceType: string) => {
+        if (resourceType === 'Provenance') {
+          return [mockProvenance] as any;
+        }
+        if (resourceType === 'ClinicalImpression') {
+          return [completedClinicalImpression] as any;
+        }
+        return [] as any;
+      });
+
+      setup({ encounter: finishedEncounter });
+
+      await waitFor(() => {
+        expect(screen.getByText('Fill chart note')).toBeInTheDocument();
+      });
+
+      // Textarea should be disabled when signed and locked
+      await waitFor(() => {
+        const chartNoteCard = screen.getByText('Fill chart note').closest('.mantine-Card-root');
+        const textarea = chartNoteCard?.querySelector('textarea');
+        expect(textarea).toBeDisabled();
+      });
+    });
+
+    test('chart note is enabled when signed but not locked', async () => {
+      const mockProvenance: Provenance = {
+        resourceType: 'Provenance',
+        id: 'provenance-1',
+        target: [createReference(finishedEncounter)],
+        recorded: new Date().toISOString(),
+        agent: [
+          {
+            who: createReference(mockPractitioner),
+          },
+        ],
+      };
+
+      vi.spyOn(medplum, 'searchResources').mockImplementation((resourceType: string) => {
+        if (resourceType === 'Provenance') {
+          return [mockProvenance] as any;
+        }
+        if (resourceType === 'ClinicalImpression') {
+          return [mockClinicalImpression] as any;
+        }
+        return [] as any;
+      });
+
+      setup({ encounter: finishedEncounter });
+
+      await waitFor(() => {
+        expect(screen.getByText('Fill chart note')).toBeInTheDocument();
+      });
+
+      // Textarea should be enabled when signed but not locked
+      await waitFor(() => {
+        const chartNoteCard = screen.getByText('Fill chart note').closest('.mantine-Card-root');
+        const textarea = chartNoteCard?.querySelector('textarea');
+        expect(textarea).not.toBeDisabled();
+      });
+    });
+  });
+});