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

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

@@ -0,0 +1,190 @@
+import React from 'react';
+import { act, render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { getGlobalStore, useConfig, useSession, useStore } from '@openmrs/esm-framework';
+import FormBootstrap from '../FormBootstrap';
+import GroupFormWorkflowContext from '../context/GroupFormWorkflowContext';
+import GroupSessionWorkspace from './GroupSessionWorkspace';
+
+jest.mock('@openmrs/esm-framework', () => ({
+  getGlobalStore: jest.fn(),
+  useConfig: jest.fn(),
+  useSession: jest.fn(),
+  useStore: jest.fn(),
+}));
+
+jest.mock('uuid', () => ({
+  v4: jest.fn(() => 'generated-visit-uuid'),
+}));
+
+jest.mock('../FormBootstrap', () => ({
+  __esModule: true,
+  default: jest.fn(() => <div data-testid="form-bootstrap" />),
+}));
+
+jest.mock('../patient-card/PatientCard', () => ({
+  __esModule: true,
+  default: ({ patientUuid, editEncounter }) => (
+    <button data-testid={`patient-card-${patientUuid}`} onClick={() => editEncounter(patientUuid)}>
+      {patientUuid}
+    </button>
+  ),
+}));
+
+jest.mock('../CancelModal', () => ({
+  __esModule: true,
+  default: () => null,
+}));
+
+jest.mock('../CompleteModal', () => ({
+  __esModule: true,
+  default: () => null,
+}));
+
+const mockGetGlobalStore = jest.mocked(getGlobalStore);
+const mockUseConfig = jest.mocked(useConfig);
+const mockUseSession = jest.mocked(useSession);
+const mockUseStore = jest.mocked(useStore);
+const mockFormBootstrap = FormBootstrap as jest.Mock;
+
+const renderWorkspace = (contextOverrides = {}) => {
+  const defaultContext = {
+    workflowState: 'EDIT_FORM',
+    patientUuids: ['patient-a', 'patient-b'],
+    activePatientUuid: 'patient-a',
+    activeEncounterUuid: null,
+    activeVisitUuid: null,
+    activeFormUuid: 'group-form',
+    activeGroupUuid: 'group-1',
+    activeGroupName: 'Nutrition Cohort',
+    activeSessionUuid: 'session-1',
+    activeSessionMeta: {
+      sessionName: 'April Session',
+      practitionerName: 'Alice',
+      sessionDate: '2026-04-15',
+      sessionNotes: 'Bring notebooks',
+    },
+    groupVisitTypeUuid: 'visit-type-1',
+    encounters: {},
+    saveEncounter: jest.fn(),
+    updateVisitUuid: jest.fn(),
+    submitForNext: jest.fn(),
+  };
+
+  return render(
+    <GroupFormWorkflowContext.Provider value={{ ...defaultContext, ...contextOverrides } as never}>
+      <GroupSessionWorkspace />
+    </GroupFormWorkflowContext.Provider>,
+  );
+};
+
+describe('GroupSessionWorkspace', () => {
+  beforeEach(() => {
+    mockGetGlobalStore.mockReturnValue('ampath-form-state' as never);
+    mockUseStore.mockReturnValue({
+      'group-form': 'ready',
+    } as never);
+    mockUseSession.mockReturnValue({
+      sessionLocation: {
+        uuid: 'session-location',
+        display: 'General Hospital',
+      },
+    } as never);
+    mockUseConfig.mockReturnValue({
+      groupSessionConcepts: {
+        sessionName: 'concept-session-name',
+        practitionerName: 'concept-practitioner',
+        sessionNotes: 'concept-notes',
+        sessionDate: 'concept-date',
+        cohortId: 'concept-cohort-id',
+        cohortName: 'concept-cohort-name',
+        sessionUuid: 'concept-session-uuid',
+      },
+    } as never);
+  });
+
+  it('builds encounter payloads with group-session metadata when no visit exists yet', () => {
+    const updateVisitUuid = jest.fn();
+    renderWorkspace({ updateVisitUuid });
+
+    const [formBootstrapProps] = mockFormBootstrap.mock.calls[0];
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const payload: Record<string, any> = {
+      obs: [
+        {
+          concept: 'weight-concept',
+          value: '70',
+          groupMembers: [{ concept: 'height-concept', value: '175' }],
+        },
+      ],
+    };
+
+    act(() => {
+      formBootstrapProps.handleEncounterCreate(payload);
+    });
+
+    const expectedObsDatetime = new Date('2026-04-15').toISOString();
+
+    expect(payload.location).toBe('session-location');
+    expect(payload.encounterDatetime).toBe(expectedObsDatetime);
+    expect(payload.obs[0]).toEqual(
+      expect.objectContaining({
+        obsDatetime: expectedObsDatetime,
+        groupMembers: [
+          expect.objectContaining({
+            concept: 'height-concept',
+            value: '175',
+            obsDatetime: expectedObsDatetime,
+          }),
+        ],
+      }),
+    );
+    expect(payload.obs).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ concept: 'concept-session-name', value: 'April Session' }),
+        expect.objectContaining({ concept: 'concept-practitioner', value: 'Alice' }),
+        expect.objectContaining({ concept: 'concept-notes', value: 'Bring notebooks' }),
+        expect.objectContaining({ concept: 'concept-date', value: '2026-04-15' }),
+        expect.objectContaining({ concept: 'concept-cohort-id', value: 'group-1' }),
+        expect.objectContaining({ concept: 'concept-cohort-name', value: 'Nutrition Cohort' }),
+        expect.objectContaining({ concept: 'concept-session-uuid', value: 'session-1' }),
+      ]),
+    );
+    expect(payload.visit).toEqual({
+      startDatetime: '2026-04-15',
+      stopDatetime: '2026-04-15',
+      uuid: 'generated-visit-uuid',
+      patient: {
+        uuid: 'patient-a',
+      },
+      location: {
+        uuid: 'session-location',
+      },
+      visitType: {
+        uuid: 'visit-type-1',
+      },
+    });
+    expect(updateVisitUuid).toHaveBeenCalledWith('generated-visit-uuid');
+  });
+
+  it('wires patient switching and save actions through the workflow callbacks', async () => {
+    const user = userEvent.setup();
+    const saveEncounter = jest.fn();
+    const submitForNext = jest.fn();
+    renderWorkspace({ saveEncounter, submitForNext });
+
+    const [formBootstrapProps] = mockFormBootstrap.mock.calls[0];
+
+    act(() => {
+      formBootstrapProps.handlePostResponse({ uuid: 'encounter-1' });
+    });
+
+    expect(saveEncounter).toHaveBeenCalledWith('encounter-1');
+
+    await user.click(screen.getByTestId('patient-card-patient-b'));
+    expect(submitForNext).toHaveBeenCalledWith('patient-b');
+
+    await user.click(screen.getByRole('button', { name: 'Next patient' }));
+    expect(submitForNext).toHaveBeenCalledWith();
+  });
+});

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/tsconfig.json

@@ -5,7 +5,7 @@
     "allowSyntheticDefaultImports": true,
     "jsx": "react",
     "skipLibCheck": true,
-    "moduleResolution": "node",
+    "moduleResolution": "bundler",
     "lib": [
       "dom",
       "es5",