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

package/src/context/GroupFormWorkflowReducer.test.ts

@@ -0,0 +1,302 @@
+import { navigate } from '@openmrs/esm-framework';
+import { initialWorkflowState } from './GroupFormWorkflowContext';
+import reducer, { fdeGroupWorkflowStorageName, fdeGroupWorkflowStorageVersion } from './GroupFormWorkflowReducer';
+
+jest.mock('uuid', () => ({
+  v4: jest.fn(() => 'generated-session-uuid'),
+}));
+
+const mockNavigate = jest.mocked(navigate);
+
+const buildState = (formStateOverrides = {}, rootStateOverrides = {}) => ({
+  ...initialWorkflowState,
+  activeFormUuid: 'group-form',
+  userUuid: 'user-1',
+  forms: {
+    'group-form': {
+      workflowState: 'NEW_GROUP_SESSION',
+      groupUuid: null,
+      groupName: null,
+      groupMembers: [],
+      activePatientUuid: null,
+      activeEncounterUuid: null,
+      activeVisitUuid: null,
+      activeSessionUuid: null,
+      patientUuids: [],
+      encounters: {},
+      visits: {},
+      ...formStateOverrides,
+    },
+  },
+  ...rootStateOverrides,
+});
+
+describe('GroupFormWorkflowReducer', () => {
+  beforeEach(() => {
+    localStorage.clear();
+  });
+
+  it('initializes a fresh group workflow state when there is no saved session', () => {
+    const state = reducer(initialWorkflowState, {
+      type: 'INITIALIZE_WORKFLOW_STATE',
+      activeFormUuid: 'group-form',
+      userUuid: 'user-1',
+    });
+
+    expect(state.activeFormUuid).toBe('group-form');
+    expect(state.forms['group-form']).toMatchObject({
+      workflowState: 'NEW_GROUP_SESSION',
+      groupUuid: null,
+      patientUuids: [],
+      encounters: {},
+      visits: {},
+    });
+
+    expect(JSON.parse(localStorage.getItem(`${fdeGroupWorkflowStorageName}:user-1`))).toMatchObject({
+      _storageVersion: fdeGroupWorkflowStorageVersion,
+      activeFormUuid: 'group-form',
+    });
+  });
+
+  it('restores a saved workflow and derives the current patient and visit state', () => {
+    localStorage.setItem(
+      `${fdeGroupWorkflowStorageName}:user-1`,
+      JSON.stringify({
+        _storageVersion: fdeGroupWorkflowStorageVersion,
+        activeFormUuid: 'group-form',
+        userUuid: 'user-1',
+        forms: {
+          'group-form': {
+            workflowState: 'EDIT_FORM',
+            patientUuids: ['patient-a', 'patient-b'],
+            encounters: {
+              'patient-a': 'encounter-a',
+            },
+            visits: {
+              'patient-a': 'visit-a',
+            },
+          },
+        },
+      }),
+    );
+
+    const state = reducer(initialWorkflowState, {
+      type: 'INITIALIZE_WORKFLOW_STATE',
+      activeFormUuid: 'group-form',
+      userUuid: 'user-1',
+    });
+
+    expect(state.forms['group-form']).toMatchObject({
+      workflowState: 'EDIT_FORM',
+      activePatientUuid: 'patient-a',
+      activeEncounterUuid: 'encounter-a',
+      activeVisitUuid: 'visit-a',
+      activeSessionUuid: 'generated-session-uuid',
+    });
+  });
+
+  it('stores the selected group and clears the active patient state', () => {
+    const state = buildState({
+      activePatientUuid: 'patient-z',
+      activeEncounterUuid: 'encounter-z',
+      activeVisitUuid: 'visit-z',
+      activeSessionUuid: 'session-z',
+    });
+
+    const nextState = reducer(state, {
+      type: 'SET_GROUP',
+      group: {
+        uuid: 'cohort-1',
+        name: 'Nutrition Cohort',
+        cohortMembers: [{ patient: { uuid: 'patient-a' } }, { patient: { uuid: 'patient-b' } }],
+      },
+    });
+
+    expect(nextState.forms['group-form']).toMatchObject({
+      groupUuid: 'cohort-1',
+      groupName: 'Nutrition Cohort',
+      groupMembers: ['patient-a', 'patient-b'],
+      patientUuids: ['patient-a', 'patient-b'],
+      activePatientUuid: null,
+      activeEncounterUuid: null,
+      activeVisitUuid: null,
+      activeSessionUuid: null,
+    });
+  });
+
+  it('sets session metadata and moves to the first patient in edit mode', () => {
+    const state = buildState({
+      patientUuids: ['patient-a', 'patient-b'],
+      encounters: {
+        'patient-a': 'encounter-a',
+      },
+      visits: {
+        'patient-a': 'visit-a',
+      },
+    });
+
+    const nextState = reducer(state, {
+      type: 'SET_SESSION_META',
+      meta: {
+        sessionName: 'April Session',
+        practitionerName: 'Alice',
+        sessionDate: '2026-04-15',
+        sessionNotes: 'Notes',
+      },
+    });
+
+    expect(nextState.forms['group-form']).toMatchObject({
+      sessionMeta: {
+        sessionName: 'April Session',
+        practitionerName: 'Alice',
+        sessionDate: '2026-04-15',
+        sessionNotes: 'Notes',
+      },
+      activePatientUuid: 'patient-a',
+      activeEncounterUuid: 'encounter-a',
+      activeVisitUuid: 'visit-a',
+      activeSessionUuid: 'generated-session-uuid',
+      workflowState: 'EDIT_FORM',
+    });
+  });
+
+  it('adds and removes patient UUIDs without duplicating entries', () => {
+    const state = buildState({
+      patientUuids: ['patient-a'],
+    });
+
+    const unchangedState = reducer(state, {
+      type: 'ADD_PATIENT_UUID',
+      patientUuid: 'patient-a',
+    });
+    expect(unchangedState).toBe(state);
+
+    const addedState = reducer(state, {
+      type: 'ADD_PATIENT_UUID',
+      patientUuid: 'patient-b',
+    });
+    expect(addedState.forms['group-form'].patientUuids).toEqual(['patient-a', 'patient-b']);
+
+    const removedState = reducer(addedState, {
+      type: 'REMOVE_PATIENT_UUID',
+      patientUuid: 'patient-a',
+    });
+    expect(removedState.forms['group-form'].patientUuids).toEqual(['patient-b']);
+  });
+
+  it('dispatches validate events and stores the visit UUID for the active patient', () => {
+    const dispatchEventSpy = jest.spyOn(window, 'dispatchEvent');
+    const state = buildState({
+      workflowState: 'EDIT_FORM',
+      activePatientUuid: 'patient-a',
+    });
+
+    const validatingState = reducer(state, {
+      type: 'VALIDATE_FOR_NEXT',
+    });
+
+    expect(validatingState.forms['group-form'].workflowState).toBe('VALIDATE_FOR_NEXT');
+    const event = dispatchEventSpy.mock.calls[0][0] as CustomEvent;
+    expect(event.detail).toEqual({
+      formUuid: 'group-form',
+      patientUuid: 'patient-a',
+      action: 'validateForm',
+    });
+
+    const visitState = reducer(state, {
+      type: 'UPDATE_VISIT_UUID',
+      visitUuid: 'visit-a',
+    });
+
+    expect(visitState.forms['group-form']).toMatchObject({
+      activeVisitUuid: 'visit-a',
+      visits: {
+        'patient-a': 'visit-a',
+      },
+    });
+  });
+
+  it('submits for next and advances to the requested patient after saving', () => {
+    const dispatchEventSpy = jest.spyOn(window, 'dispatchEvent');
+    const state = buildState(
+      {
+        workflowState: 'EDIT_FORM',
+        activePatientUuid: 'patient-a',
+        patientUuids: ['patient-a', 'patient-b', 'patient-c'],
+        visits: {
+          'patient-c': 'visit-c',
+        },
+      },
+      {
+        nextPatientUuid: null,
+      },
+    );
+
+    const submittingState = reducer(state, {
+      type: 'SUBMIT_FOR_NEXT',
+      nextPatientUuid: 'patient-c',
+    });
+
+    expect(submittingState.forms['group-form'].workflowState).toBe('SUBMIT_FOR_NEXT');
+    expect(submittingState.nextPatientUuid).toBe('patient-c');
+    const submitEvent = dispatchEventSpy.mock.calls[0][0] as CustomEvent;
+    expect(submitEvent.detail).toEqual({
+      formUuid: 'group-form',
+      patientUuid: 'patient-a',
+      action: 'onSubmit',
+    });
+
+    const savedState = reducer(submittingState, {
+      type: 'SAVE_ENCOUNTER',
+      encounterUuid: 'encounter-a',
+    });
+
+    expect(savedState.forms['group-form']).toMatchObject({
+      workflowState: 'EDIT_FORM',
+      activePatientUuid: 'patient-c',
+      activeEncounterUuid: null,
+      activeVisitUuid: 'visit-c',
+      encounters: {
+        'patient-a': 'encounter-a',
+      },
+    });
+  });
+
+  it('clears the active session pointers when going to review', () => {
+    const state = buildState({
+      workflowState: 'EDIT_FORM',
+      activePatientUuid: 'patient-a',
+      activeEncounterUuid: 'encounter-a',
+      activeVisitUuid: 'visit-a',
+      activeSessionUuid: 'session-a',
+    });
+
+    const nextState = reducer(state, {
+      type: 'GO_TO_REVIEW',
+    });
+
+    expect(nextState.forms['group-form']).toMatchObject({
+      workflowState: 'REVIEW',
+      activePatientUuid: null,
+      activeEncounterUuid: null,
+      activeVisitUuid: null,
+      activeSessionUuid: null,
+    });
+  });
+
+  it('destroys the active group session and navigates back to forms', () => {
+    const state = buildState({
+      workflowState: 'SUBMIT_FOR_COMPLETE',
+      activePatientUuid: 'patient-a',
+    });
+
+    const nextState = reducer(state, {
+      type: 'DESTROY_SESSION',
+    });
+
+    expect(nextState.activeFormUuid).toBeNull();
+    expect(nextState.forms).toEqual({});
+    expect(nextState.formDestroyed).toBe(true);
+    expect(mockNavigate).toHaveBeenCalledWith({ to: '${openmrsSpaBase}/forms' });
+  });
+});

package/src/context/GroupFormWorkflowReducer.ts

@@ -365,7 +365,7 @@ const reducer = (state, action) => {
           [state.activeFormUuid]: {
             ...state.forms[state.activeFormUuid],
             activeEncounterUuid: null,
-            activVisitUuid: null,
+            activeVisitUuid: null,
             activePatientUuid: null,
             activeSessionUuid: null,
             workflowState: 'REVIEW',

package/src/declarations.d.ts

@@ -1,3 +1,2 @@
 declare module '*.css';
 declare module '*.scss';
-declare type SideNavProps = object;

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();
+  });
+});