@openmrs/esm-fast-data-entry-app 1.4.2-pre.704 → 1.4.2-pre.706

package/src/group-form-entry-workflow/SessionMetaWorkspace.test.tsx

@@ -0,0 +1,94 @@
+import React, { useEffect } from 'react';
+import { render, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { useFormContext } from 'react-hook-form';
+import GroupFormWorkflowContext from '../context/GroupFormWorkflowContext';
+import SessionMetaWorkspace from './SessionMetaWorkspace';
+
+jest.mock('../CancelModal', () => ({
+  __esModule: true,
+  default: () => null,
+}));
+
+jest.mock('./SessionDetailsForm', () => ({
+  __esModule: true,
+  default: function MockSessionDetailsForm() {
+    const { register, setValue } = useFormContext();
+
+    useEffect(() => {
+      setValue('sessionName', 'April Session');
+      setValue('practitionerName', 'Alice');
+      setValue('sessionDate', ['2026-04-15']);
+      setValue('sessionNotes', 'Bring notebooks');
+    }, [setValue]);
+
+    return (
+      <>
+        <input aria-label="Session Name" {...register('sessionName', { required: true })} />
+        <input aria-label="Practitioner Name" {...register('practitionerName', { required: true })} />
+        <input aria-label="Session Notes" {...register('sessionNotes', { required: true })} />
+      </>
+    );
+  },
+}));
+
+const renderSessionMetaWorkspace = (contextOverrides = {}) =>
+  render(
+    <GroupFormWorkflowContext.Provider
+      value={
+        {
+          workflowState: 'NEW_GROUP_SESSION',
+          patientUuids: ['patient-a'],
+          activeGroupUuid: 'group-1',
+          setSessionMeta: jest.fn(),
+          ...contextOverrides,
+        } as never
+      }
+    >
+      <SessionMetaWorkspace />
+    </GroupFormWorkflowContext.Provider>,
+  );
+
+describe('SessionMetaWorkspace', () => {
+  it('submits the session metadata with the normalized session date', async () => {
+    const user = userEvent.setup();
+    const setSessionMeta = jest.fn();
+    renderSessionMetaWorkspace({ setSessionMeta });
+
+    await user.click(screen.getByRole('button', { name: 'Create New Session' }));
+
+    await waitFor(() => {
+      expect(setSessionMeta).toHaveBeenCalledWith(
+        expect.objectContaining({
+          groupUuid: 'group-1',
+          sessionName: 'April Session',
+          practitionerName: 'Alice',
+          sessionDate: '2026-04-15',
+          sessionNotes: 'Bring notebooks',
+        }),
+      );
+    });
+  });
+
+  it('shows the group selection error when submitted without a chosen group', async () => {
+    const user = userEvent.setup();
+    const setSessionMeta = jest.fn();
+    renderSessionMetaWorkspace({
+      activeGroupUuid: null,
+      setSessionMeta,
+    });
+
+    await user.click(screen.getByRole('button', { name: 'Create New Session' }));
+
+    expect(await screen.findByText('Please choose a group.')).toBeInTheDocument();
+    expect(setSessionMeta).not.toHaveBeenCalled();
+  });
+
+  it('disables session creation until the participant list is populated', () => {
+    renderSessionMetaWorkspace({
+      patientUuids: [],
+    });
+
+    expect(screen.getByRole('button', { name: 'Create New Session' })).toBeDisabled();
+  });
+});

package/src/group-form-entry-workflow/group-search-header/GroupSearchHeader.test.tsx

@@ -0,0 +1,121 @@
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { showSnackbar, useConfig, useSession } from '@openmrs/esm-framework';
+import GroupFormWorkflowContext from '../../context/GroupFormWorkflowContext';
+import GroupSearchHeader from './GroupSearchHeader';
+
+let selectedGroup;
+
+jest.mock('../group-search/CompactGroupSearch', () => ({
+  __esModule: true,
+  default: ({ selectGroupAction }) => (
+    <button data-testid="compact-group-search" onClick={() => selectGroupAction(selectedGroup)}>
+      Select group
+    </button>
+  ),
+}));
+
+jest.mock('../../add-group-modal/AddGroupModal', () => ({
+  __esModule: true,
+  default: ({ isOpen }) => (isOpen ? <div data-testid="add-group-modal" /> : null),
+}));
+
+const mockShowSnackbar = jest.mocked(showSnackbar);
+const mockUseConfig = jest.mocked(useConfig);
+const mockUseSession = jest.mocked(useSession);
+
+const renderGroupSearchHeader = (contextOverrides = {}) =>
+  render(
+    <GroupFormWorkflowContext.Provider
+      value={
+        {
+          activeGroupUuid: null,
+          setGroup: jest.fn(),
+          destroySession: jest.fn(),
+          ...contextOverrides,
+        } as never
+      }
+    >
+      <GroupSearchHeader />
+    </GroupFormWorkflowContext.Provider>,
+  );
+
+describe('GroupSearchHeader', () => {
+  beforeEach(() => {
+    mockUseSession.mockReturnValue({
+      sessionLocation: {
+        uuid: 'session-location',
+        display: 'General Hospital',
+      },
+    } as never);
+    mockUseConfig.mockReturnValue({
+      enforcePatientListLocationMatch: true,
+    } as never);
+  });
+
+  it('blocks group selection when location enforcement is enabled and locations mismatch', async () => {
+    const user = userEvent.setup();
+    const setGroup = jest.fn();
+    selectedGroup = {
+      uuid: 'group-1',
+      location: {
+        uuid: 'other-location',
+        display: 'Remote Clinic',
+      },
+    };
+
+    renderGroupSearchHeader({ setGroup });
+
+    await user.click(screen.getByTestId('compact-group-search'));
+
+    expect(mockShowSnackbar).toHaveBeenCalledWith(
+      expect.objectContaining({
+        kind: 'error',
+        title: 'Location Mismatch',
+        subtitle: 'Cannot select group from Remote Clinic for a session at General Hospital',
+      }),
+    );
+    expect(setGroup).not.toHaveBeenCalled();
+  });
+
+  it('sorts cohort members by display name before storing the selected group', async () => {
+    const user = userEvent.setup();
+    const setGroup = jest.fn();
+    selectedGroup = {
+      uuid: 'group-1',
+      location: {
+        uuid: 'session-location',
+        display: 'General Hospital',
+      },
+      cohortMembers: [
+        { patient: { person: { names: [{ display: 'zoe zebra' }] } } },
+        { patient: { person: { names: [{ display: 'Alice Able' }] } } },
+        { patient: { person: { names: [{ display: 'ben Brown' }] } } },
+      ],
+    };
+
+    renderGroupSearchHeader({ setGroup });
+
+    await user.click(screen.getByTestId('compact-group-search'));
+
+    expect(setGroup).toHaveBeenCalledTimes(1);
+    expect(setGroup.mock.calls[0][0].cohortMembers.map((member) => member.patient.person.names[0].display)).toEqual([
+      'Alice Able',
+      'ben Brown',
+      'zoe zebra',
+    ]);
+  });
+
+  it('opens the add-group modal and lets the user cancel the session', async () => {
+    const user = userEvent.setup();
+    const destroySession = jest.fn();
+    renderGroupSearchHeader({ destroySession });
+
+    await user.click(screen.getByRole('button', { name: 'Create New Group' }));
+    expect(screen.getByTestId('add-group-modal')).toBeInTheDocument();
+
+    await user.click(screen.getByRole('button', { name: 'Cancel' }));
+    expect(destroySession).toHaveBeenCalledTimes(1);
+  });
+});

package/src/hooks/useGetPatient.test.tsx

@@ -0,0 +1,113 @@
+import React from 'react';
+import { act, render, screen } from '@testing-library/react';
+import { fetchCurrentPatient } from '@openmrs/esm-framework';
+import useGetPatient from './useGetPatient';
+
+jest.mock('@openmrs/esm-framework', () => ({
+  fetchCurrentPatient: jest.fn(),
+}));
+
+type Deferred<T> = {
+  promise: Promise<T>;
+  resolve: (value: T) => void;
+};
+
+const createDeferred = <T,>(): Deferred<T> => {
+  let resolve: (value: T) => void;
+  const promise = new Promise<T>((res) => {
+    resolve = res;
+  });
+
+  return {
+    promise,
+    resolve,
+  };
+};
+
+const mockFetchCurrentPatient = fetchCurrentPatient as jest.MockedFunction<typeof fetchCurrentPatient>;
+
+const TestHarness = ({ patientUuid }: { patientUuid?: string }) => {
+  const patient = useGetPatient(patientUuid);
+  const patientName = patient ? (patient as { name: string }).name : 'none';
+
+  return <div data-testid="patient-name">{patientName}</div>;
+};
+
+describe('useGetPatient', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('ignores stale responses after patientUuid changes', async () => {
+    const patientARequest = createDeferred<fhir.Patient>();
+    const patientBRequest = createDeferred<fhir.Patient>();
+
+    mockFetchCurrentPatient.mockImplementation((uuid) => {
+      if (uuid === 'patient-a') {
+        return patientARequest.promise;
+      }
+
+      if (uuid === 'patient-b') {
+        return patientBRequest.promise;
+      }
+
+      throw new Error(`Unexpected patient uuid: ${uuid}`);
+    });
+
+    const { rerender } = render(<TestHarness patientUuid="patient-a" />);
+
+    rerender(<TestHarness patientUuid="patient-b" />);
+
+    await act(async () => {
+      patientBRequest.resolve({ id: 'patient-b', name: 'Patient B' } as unknown as fhir.Patient);
+      await patientBRequest.promise;
+    });
+
+    expect(screen.getByTestId('patient-name')).toHaveTextContent('Patient B');
+
+    await act(async () => {
+      patientARequest.resolve({ id: 'patient-a', name: 'Patient A' } as unknown as fhir.Patient);
+      await patientARequest.promise;
+    });
+
+    expect(screen.getByTestId('patient-name')).toHaveTextContent('Patient B');
+    expect(mockFetchCurrentPatient).toHaveBeenNthCalledWith(1, 'patient-a');
+    expect(mockFetchCurrentPatient).toHaveBeenNthCalledWith(2, 'patient-b');
+  });
+
+  it('clears the previous patient while the next patient is loading', async () => {
+    const patientBRequest = createDeferred<fhir.Patient>();
+    mockFetchCurrentPatient.mockImplementation((uuid) => {
+      if (uuid === 'patient-a') {
+        return Promise.resolve({ id: 'patient-a', name: 'Patient A' } as unknown as fhir.Patient);
+      }
+
+      if (uuid === 'patient-b') {
+        return patientBRequest.promise;
+      }
+
+      throw new Error(`Unexpected patient uuid: ${uuid}`);
+    });
+
+    const { rerender } = render(<TestHarness patientUuid="patient-a" />);
+
+    expect(await screen.findByText('Patient A')).toBeInTheDocument();
+
+    rerender(<TestHarness patientUuid="patient-b" />);
+
+    expect(screen.getByTestId('patient-name')).toHaveTextContent('none');
+  });
+
+  it('clears the patient and skips fetching when patientUuid is removed', async () => {
+    mockFetchCurrentPatient.mockResolvedValue({ id: 'patient-a', name: 'Patient A' } as unknown as fhir.Patient);
+
+    const { rerender } = render(<TestHarness patientUuid="patient-a" />);
+
+    expect(await screen.findByText('Patient A')).toBeInTheDocument();
+
+    rerender(<TestHarness />);
+
+    expect(screen.getByTestId('patient-name')).toHaveTextContent('none');
+    expect(mockFetchCurrentPatient).toHaveBeenCalledTimes(1);
+  });
+});

package/e2e/specs/sample-test.spec.ts

@@ -1,10 +0,0 @@
-import { test, expect } from '@playwright/test';
-import { FastDataEntryPage } from '../pages';
-
-// This test is a sample E2E test. You can delete it.
-
-test('sample-test', async ({ page }) => {
-  const fastDataEntryPage = new FastDataEntryPage(page);
-  await fastDataEntryPage.goto();
-  await expect(page.getByText('Fast Data Entry')).toBeVisible();
-});