@kenyaemr/esm-ward-app 8.0.1-pre.99 → 8.0.2

package/src/ward-workspace/admit-patient-form-workspace/admit-patient-form.test.tsx

@@ -1,21 +1,16 @@
-import React from 'react';
+import { showSnackbar, useAppContext, useFeatureFlag, useSession } from '@openmrs/esm-framework';
 import { screen } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
+import React from 'react';
+import { mockLocationInpatientWard, mockPatientAlice } from '../../../../../__mocks__';
 import { renderWithSwr } from '../../../../../tools';
+import { mockWardPatientGroupDetails, mockWardViewContext } from '../../../mock';
+import { useAssignedBedByPatient } from '../../hooks/useAssignedBedByPatient';
+import useWardLocation from '../../hooks/useWardLocation';
+import type { DispositionType, WardViewContext } from '../../types';
+import { assignPatientToBed, removePatientFromBed, useAdmitPatient } from '../../ward.resource';
 import AdmitPatientFormWorkspace from './admit-patient-form.workspace';
-import {
-  mockAdmissionLocation,
-  mockInpatientRequest,
-  mockLocationInpatientWard,
-  mockPatientAlice,
-} from '../../../../../__mocks__';
-import type { DispositionType } from '../../types';
 import type { AdmitPatientFormWorkspaceProps } from './types';
-import { useAdmissionLocation } from '../../hooks/useAdmissionLocation';
-import { openmrsFetch, provide, showSnackbar, useFeatureFlag, useSession } from '@openmrs/esm-framework';
-import useEmrConfiguration from '../../hooks/useEmrConfiguration';
-import useWardLocation from '../../hooks/useWardLocation';
-import { useInpatientRequest } from '../../hooks/useInpatientRequest';
 
 jest.mock('../../hooks/useAdmissionLocation', () => ({
   useAdmissionLocation: jest.fn(),
@@ -23,20 +18,47 @@ jest.mock('../../hooks/useAdmissionLocation', () => ({
 
 jest.mock('../../hooks/useWardLocation', () => jest.fn());
 
-jest.mock('../../hooks/useEmrConfiguration', () => jest.fn());
-
 jest.mock('../../hooks/useInpatientRequest', () => ({
   useInpatientRequest: jest.fn(),
 }));
 
-const mockedUseInpatientRequest = jest.mocked(useInpatientRequest);
-const mockedUseEmrConfiguration = jest.mocked(useEmrConfiguration);
+jest.mock('../../hooks/useWardPatientGrouping', () => ({
+  useWardPatientGrouping: jest.fn(),
+}));
+
+jest.mock('../../hooks/useInpatientAdmission', () => ({
+  useInpatientAdmission: jest.fn(),
+}));
+
+jest.mock('../../hooks/useAssignedBedByPatient', () => ({
+  useAssignedBedByPatient: jest.fn(),
+}));
+
+jest.mock('../../ward.resource', () => ({
+  createEncounter: jest.fn(),
+  useAdmitPatient: jest.fn(),
+  assignPatientToBed: jest.fn(),
+  removePatientFromBed: jest.fn(),
+}));
+
 const mockedUseWardLocation = jest.mocked(useWardLocation);
-const mockedOpenmrsFetch = jest.mocked(openmrsFetch);
-const mockedUseAdmissionLocation = jest.mocked(useAdmissionLocation);
 const mockedUseFeatureFlag = jest.mocked(useFeatureFlag);
 const mockedShowSnackbar = jest.mocked(showSnackbar);
 const mockedUseSession = jest.mocked(useSession);
+const mockedUseAssignedBedByPatient = jest.mocked(useAssignedBedByPatient);
+const mockedAssignPatientToBed = jest.mocked(assignPatientToBed);
+const mockedRemovePatientFromBed = jest.mocked(removePatientFromBed);
+const mockedUseAdmitPatient = jest.mocked(useAdmitPatient);
+
+jest.mocked(useAppContext<WardViewContext>).mockReturnValue(mockWardViewContext);
+
+const mockUseAdmitPatientObj: ReturnType<typeof useAdmitPatient> = {
+  admitPatient: jest.fn(),
+  isLoadingEmrConfiguration: false,
+  errorFetchingEmrConfiguration: false,
+};
+jest.mocked(useAdmitPatient).mockReturnValue(mockUseAdmitPatientObj);
+const mockedAdmitPatient = mockUseAdmitPatientObj.admitPatient;
 
 const mockWorkspaceProps: AdmitPatientFormWorkspaceProps = {
   patient: mockPatientAlice,
@@ -51,18 +73,10 @@ function renderAdmissionForm(dispositionType: DispositionType = 'ADMIT') {
   renderWithSwr(<AdmitPatientFormWorkspace {...{ ...mockWorkspaceProps, dispositionType }} />);
 }
 
-const mockedMutateInpatientRequest = jest.fn();
-
 describe('Testing AdmitPatientForm', () => {
   beforeEach(() => {
     jest.clearAllMocks();
-    mockedUseAdmissionLocation.mockReturnValue({
-      isLoading: false,
-      isValidating: false,
-      admissionLocation: mockAdmissionLocation,
-      mutate: jest.fn(),
-      error: undefined,
-    });
+
     mockedUseSession.mockReturnValue({
       currentProvider: {
         uuid: 'current-provider-uuid',
@@ -72,38 +86,48 @@ describe('Testing AdmitPatientForm', () => {
       sessionId: 'session-id',
     });
     mockedUseFeatureFlag.mockReturnValue(true);
-    mockedUseEmrConfiguration.mockReturnValue({
-      isLoadingEmrConfiguration: false,
-      errorFetchingEmrConfiguration: null,
-      // @ts-ignore - we only need these two keys for now
-      emrConfiguration: {
-        admissionEncounterType: {
-          uuid: 'admission-encounter-type-uuid',
-          display: 'Admission Encounter',
-        },
-        transferWithinHospitalEncounterType: {
-          uuid: 'transfer-within-hospital-encounter-type-uuid',
-          display: 'Transfer Within Hospital Encounter Type',
-        },
-        clinicianEncounterRole: {
-          uuid: 'clinician-encounter-role-uuid',
-        },
-      },
-      mutateEmrConfiguration: jest.fn(),
-    });
-    mockedUseInpatientRequest.mockReturnValue({
-      mutate: mockedMutateInpatientRequest,
-      error: undefined,
-      inpatientRequests: [mockInpatientRequest],
-      isLoading: false,
-      isValidating: false,
-    });
+
     mockedUseWardLocation.mockReturnValue({
       location: mockLocationInpatientWard,
       invalidLocation: false,
       isLoadingLocation: false,
       errorFetchingLocation: null,
     });
+
+    // @ts-ignore - we don't need to mock the entire object
+    mockedUseAssignedBedByPatient.mockReturnValue({
+      data: {
+        data: {
+          results: [
+            {
+              bedId: 1,
+              bedNumber: 1,
+              bedType: null,
+              patients: [mockPatientAlice],
+              physicalLocation: mockLocationInpatientWard,
+            },
+          ],
+        },
+      },
+    });
+
+    // @ts-ignore - we only need these two keys for now
+    mockedAdmitPatient.mockResolvedValue({
+      ok: true,
+      data: {
+        uuid: 'encounter-uuid',
+      },
+    });
+
+    // @ts-ignore - we only need the ok key for now
+    mockedAssignPatientToBed.mockResolvedValue({
+      ok: true,
+    });
+
+    // @ts-ignore - we only need the ok key for now
+    mockedRemovePatientFromBed.mockResolvedValue({
+      ok: true,
+    });
   });
 
   it('should render admit patient form', async () => {
@@ -116,118 +140,45 @@ describe('Testing AdmitPatientForm', () => {
     });
     screen.getByText('Admit');
     expect(screen.getByText('Select a bed')).toBeInTheDocument();
-    await user.click(
-      screen.getByRole('combobox', {
-        name: 'Choose an option',
-      }),
-    );
-    expect(screen.getByText('bed1 · Alice Johnson')).toBeInTheDocument();
-    expect(screen.getByText('bed2 · Empty')).toBeInTheDocument();
-    expect(screen.getByText('bed3 · Empty')).toBeInTheDocument();
-    expect(screen.getByText('bed4 · Empty')).toBeInTheDocument();
+
+    expect(screen.getByRole('radio', { name: 'bed1 · Alice Johnson' })).toBeInTheDocument();
+    expect(screen.getByRole('radio', { name: 'bed2 · Empty' })).toBeInTheDocument();
+    expect(screen.getByRole('radio', { name: 'bed3 · Empty' })).toBeInTheDocument();
+    expect(screen.getByRole('radio', { name: 'bed4 · Empty' })).toBeInTheDocument();
   });
 
   it('should block the form if emr configuration is not fetched properly', () => {
-    mockedUseEmrConfiguration.mockReturnValue({
+    mockedUseAdmitPatient.mockReturnValueOnce({
+      admitPatient: mockedAdmitPatient,
       isLoadingEmrConfiguration: false,
       errorFetchingEmrConfiguration: true,
-      emrConfiguration: null,
-      mutateEmrConfiguration: jest.fn(),
     });
 
     renderAdmissionForm();
 
     const admitButton = screen.getByText('Admit');
     expect(admitButton).toBeDisabled();
-    expect(screen.getByText("Some parts of the form didn't load")).toBeInTheDocument();
-    expect(
-      screen.getByText(
-        'Fetching EMR configuration failed. Try refreshing the page or contact your system administrator.',
-      ),
-    ).toBeInTheDocument();
-  });
-
-  it('should render admit patient form if bed management module is not present', () => {
-    mockedUseFeatureFlag.mockReturnValue(false);
-    renderAdmissionForm();
-    expect(screen.getByText('Select a bed')).toBeInTheDocument();
-    expect(screen.getByText('Unable to select beds')).toBeInTheDocument();
-    expect(screen.getByText('Bed management module is not present to allow bed selection')).toBeInTheDocument();
   });
 
   it('should render admit patient form if bed management module is present, but no beds are configured', () => {
     mockedUseFeatureFlag.mockReturnValue(true);
-    mockedUseAdmissionLocation.mockReturnValueOnce({
-      isLoading: false,
-      isValidating: false,
-      admissionLocation: {
-        ...mockAdmissionLocation,
-        totalBeds: 0,
-        bedLayouts: [],
-      },
-      mutate: jest.fn(),
-      error: null,
-    });
+    const replacedProperty = jest.replaceProperty(mockWardPatientGroupDetails(), 'bedLayouts', []);
     renderAdmissionForm();
     expect(screen.getByText('Select a bed')).toBeInTheDocument();
-    expect(screen.getByText('No beds configured for Inpatient Ward location')).toBeInTheDocument();
+    expect(screen.getByText(/No beds configured/i)).toBeInTheDocument();
+    replacedProperty.restore();
   });
 
   it('should submit the form, create encounter and submit bed', async () => {
-    mockedUseAdmissionLocation.mockReturnValueOnce({
-      isLoading: false,
-      isValidating: false,
-      admissionLocation: mockAdmissionLocation,
-      mutate: jest.fn(),
-      error: null,
-    });
-    // @ts-ignore - we only need these two keys for now
-    mockedOpenmrsFetch.mockResolvedValue({
-      ok: true,
-      data: {
-        uuid: 'encounter-uuid',
-      },
-    });
     const user = userEvent.setup();
     renderAdmissionForm();
-    const combobox = screen.getByRole('combobox', {
-      name: 'Choose an option',
-    });
-    await user.click(combobox);
-    const bedOption = screen.getByText('bed3 · Empty');
+    const bedOption = screen.getByRole('radio', { name: 'bed3 · Empty' });
     await user.click(bedOption);
     const admitButton = screen.getByRole('button', { name: 'Admit' });
     expect(admitButton).toBeEnabled();
     await user.click(admitButton);
-    expect(mockedOpenmrsFetch).toHaveBeenCalledTimes(2);
-    expect(mockedOpenmrsFetch).toHaveBeenCalledWith('/ws/rest/v1/encounter', {
-      method: 'POST',
-      headers: {
-        'content-type': 'application/json',
-      },
-      body: {
-        patient: mockPatientAlice.uuid,
-        encounterType: 'admission-encounter-type-uuid',
-        location: mockAdmissionLocation.ward.uuid,
-        obs: [],
-        encounterProviders: [
-          {
-            provider: 'current-provider-uuid',
-            encounterRole: 'clinician-encounter-role-uuid',
-          },
-        ],
-      },
-    });
-    expect(mockedOpenmrsFetch).toHaveBeenCalledWith('/ws/rest/v1/beds/3', {
-      method: 'POST',
-      headers: {
-        'content-type': 'application/json',
-      },
-      body: {
-        patientUuid: mockPatientAlice.uuid,
-        encounterUuid: 'encounter-uuid',
-      },
-    });
+    expect(mockedAdmitPatient).toHaveBeenCalledWith(mockPatientAlice, 'ADMIT');
+    expect(mockedAssignPatientToBed).toHaveBeenCalledWith(3, mockPatientAlice.uuid, 'encounter-uuid');
     expect(mockedShowSnackbar).toHaveBeenCalledWith({
       kind: 'success',
       subtitle: '{{patientName}} has been successfully admitted and assigned to bed bed3',
@@ -236,19 +187,14 @@ describe('Testing AdmitPatientForm', () => {
   });
 
   it('should show snackbar if there was an issue creating an encounter', async () => {
-    mockedOpenmrsFetch.mockRejectedValue(new Error('Failed to create encounter'));
+    mockedAdmitPatient.mockRejectedValue(new Error('Failed to create encounter'));
     const user = userEvent.setup();
     renderAdmissionForm();
-    const combobox = screen.getByRole('combobox', {
-      name: 'Choose an option',
-    });
-    await user.click(combobox);
-    const bedOption = screen.getByText('bed3 · Empty');
+    const bedOption = screen.getByRole('radio', { name: 'bed3 · Empty' });
     await user.click(bedOption);
     const admitButton = screen.getByRole('button', { name: 'Admit' });
     expect(admitButton).toBeEnabled();
     await user.click(admitButton);
-    expect(mockedOpenmrsFetch).toHaveBeenCalledTimes(1);
     expect(mockedShowSnackbar).toHaveBeenCalledWith({
       kind: 'error',
       title: 'Failed to admit patient',
@@ -257,31 +203,15 @@ describe('Testing AdmitPatientForm', () => {
   });
 
   it('should show warning snackbar if encounter was created and bed assignment was not successful', async () => {
-    // @ts-ignore - matching whole FetchResponse type is not necessary
-    mockedOpenmrsFetch.mockImplementation((url) => {
-      if (url.startsWith('/ws/rest/v1/beds')) {
-        return Promise.reject(new Error('Failed to assign bed'));
-      }
-      return Promise.resolve({
-        ok: true,
-        data: {
-          uuid: 'encounter-uuid',
-        },
-      });
-    });
+    mockedAssignPatientToBed.mockRejectedValue(new Error('Failed to assign bed'));
 
     const user = userEvent.setup();
     renderAdmissionForm();
-    const combobox = screen.getByRole('combobox', {
-      name: 'Choose an option',
-    });
-    await user.click(combobox);
-    const bedOption = screen.getByText('bed3 · Empty');
+    const bedOption = screen.getByRole('radio', { name: 'bed3 · Empty' });
     await user.click(bedOption);
     const admitButton = screen.getByRole('button', { name: 'Admit' });
     expect(admitButton).toBeEnabled();
     await user.click(admitButton);
-    expect(mockedOpenmrsFetch).toHaveBeenCalledTimes(2);
     expect(mockedShowSnackbar).toHaveBeenCalledWith({
       kind: 'warning',
       title: 'Patient admitted successfully',
@@ -289,49 +219,14 @@ describe('Testing AdmitPatientForm', () => {
     });
   });
 
-  it('should admit patient if no beds are configured', async () => {
-    mockedUseAdmissionLocation.mockReturnValueOnce({
-      isLoading: false,
-      isValidating: false,
-      admissionLocation: {
-        ...mockAdmissionLocation,
-        totalBeds: 0,
-        bedLayouts: [],
-      },
-      mutate: jest.fn(),
-      error: null,
-    });
-    // @ts-ignore - we only need these two keys for now
-    mockedOpenmrsFetch.mockResolvedValue({
-      ok: true,
-      data: {
-        uuid: 'encounter-uuid',
-      },
-    });
+  it('should admit patient if no bed is selected', async () => {
     const user = userEvent.setup();
     renderAdmissionForm();
     const admitButton = screen.getByRole('button', { name: 'Admit' });
     expect(admitButton).toBeEnabled();
     await user.click(admitButton);
-    expect(mockedOpenmrsFetch).toHaveBeenCalledTimes(1);
-    expect(mockedOpenmrsFetch).toHaveBeenCalledWith('/ws/rest/v1/encounter', {
-      method: 'POST',
-      headers: {
-        'content-type': 'application/json',
-      },
-      body: {
-        patient: mockPatientAlice.uuid,
-        encounterType: 'admission-encounter-type-uuid',
-        location: mockAdmissionLocation.ward.uuid,
-        obs: [],
-        encounterProviders: [
-          {
-            provider: 'current-provider-uuid',
-            encounterRole: 'clinician-encounter-role-uuid',
-          },
-        ],
-      },
-    });
+    expect(mockedAdmitPatient).toHaveBeenCalledWith(mockPatientAlice, 'ADMIT');
+    expect(mockedRemovePatientFromBed).toHaveBeenCalledWith(1, mockPatientAlice.uuid);
     expect(mockedShowSnackbar).toHaveBeenCalledWith({
       kind: 'success',
       subtitle: 'Patient admitted successfully to Inpatient Ward',