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

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/src/hooks/useGetPatient.ts

@@ -5,11 +5,20 @@ const useGetPatient = (patientUuid) => {
   const [patient, setPatient] = useState(null);
 
   useEffect(() => {
-    if (!patientUuid) {
-      setPatient(null);
-    } else {
-      getPatient(patientUuid);
+    let cancelled = false;
+    setPatient(null);
+
+    if (patientUuid) {
+      fetchCurrentPatient(patientUuid).then((result) => {
+        if (!cancelled) {
+          setPatient(result);
+        }
+      });
     }
+
+    return () => {
+      cancelled = true;
+    };
   }, [patientUuid]);
 
   const getPatient = async (uuid) => {

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