@kenyaemr/esm-ward-app 7.0.3-pre.89 → 8.0.0

package/src/ward-view-header/ward-view-header.component.tsx

@@ -1,16 +1,16 @@
 import React from 'react';
 import styles from './ward-view-header.scss';
 import AdmissionRequestsBar from './admission-requests-bar.component';
-import { type Location } from '@openmrs/esm-framework';
+import useWardLocation from '../hooks/useWardLocation';
 
-interface WardViewHeaderProps {
-  location: Location;
-}
-const WardViewHeader: React.FC<WardViewHeaderProps> = ({ location }) => {
+interface WardViewHeaderProps {}
+
+const WardViewHeader: React.FC<WardViewHeaderProps> = () => {
+  const { location } = useWardLocation();
   return (
     <div className={styles.wardViewHeader}>
-      <h4>{location.display}</h4>
-      <AdmissionRequestsBar location={location} />
+      <h4>{location?.display}</h4>
+      <AdmissionRequestsBar />
     </div>
   );
 };

package/src/ward-view-header/ward-view-header.scss

@@ -1,7 +1,7 @@
-@use '@carbon/styles/scss/spacing';
+@use '@carbon/layout';
 
 .wardViewHeader {
-  margin: spacing.$spacing-05 0;
+  margin: layout.$spacing-05 0;
   display: flex;
   align-items: center;
   justify-content: space-between;

package/src/ward-workspace/admission-request-card/admission-request-card-actions.component.tsx

@@ -0,0 +1,29 @@
+import { Button } from '@carbon/react';
+import { ArrowRightIcon, launchWorkspace, useLayoutType } from '@openmrs/esm-framework';
+import React, { useCallback } from 'react';
+import { useTranslation } from 'react-i18next';
+import type { WardPatientCard } from '../../types';
+import type { AdmitPatientFormWorkspaceProps } from '../admit-patient-form-workspace/types';
+import styles from './admission-request-card.scss';
+
+const AdmissionRequestCardActions: WardPatientCard = ({ patient, inpatientRequest }) => {
+  const { dispositionType } = inpatientRequest;
+  const { t } = useTranslation();
+  const responsiveSize = useLayoutType() === 'tablet' ? 'lg' : 'md';
+  const launchPatientAdmissionForm = useCallback(
+    () => launchWorkspace<AdmitPatientFormWorkspaceProps>('admit-patient-form-workspace', { patient, dispositionType }),
+    [],
+  );
+  return (
+    <div className={styles.admissionRequestActionBar}>
+      <Button kind="ghost" size={responsiveSize}>
+        {t('transferElsewhere', 'Transfer elsewhere')}
+      </Button>
+      <Button kind="ghost" renderIcon={ArrowRightIcon} size={responsiveSize} onClick={launchPatientAdmissionForm}>
+        {t('admitPatient', 'Admit patient')}
+      </Button>
+    </div>
+  );
+};
+
+export default AdmissionRequestCardActions;

package/src/ward-workspace/admission-request-card/admission-request-card-header.component.tsx

@@ -0,0 +1,51 @@
+import { ExtensionSlot, formatDatetime, getLocale } from '@openmrs/esm-framework';
+import classNames from 'classnames';
+import React from 'react';
+import WardPatientWorkspaceBanner from '../patient-banner/patient-banner.component';
+import styles from './admission-request-card.scss';
+import type WardPatientCard from '../../ward-patient-card/ward-patient-card.component';
+import { useCurrentWardCardConfig } from '../../hooks/useCurrentWardCardConfig';
+import { WardPatientCardElement } from '../../ward-patient-card/ward-patient-card-element.component';
+import WardPatientName from '../../ward-patient-card/row-elements/ward-patient-name';
+
+const AdmissionRequestCardHeader: WardPatientCard = (wardPatient) => {
+  const { inpatientRequest } = wardPatient;
+  const { dispositionEncounter } = inpatientRequest;
+  const { id, headerRowElements } = useCurrentWardCardConfig();
+  const { patient } = wardPatient;
+  const extensionSlotState = wardPatient;
+
+  const rowsExtensionSlotName = id == 'default' ? 'ward-patient-card-slot' : `ward-patient-card-${id}-slot`;
+
+  return (
+    <div className={styles.admissionRequestCardHeaderContainer}>
+      <div className={styles.admissionRequestCardHeader}>
+        <WardPatientName patient={patient} />
+        {headerRowElements.map((elementId, i) => (
+          <WardPatientCardElement
+            key={`ward-card-${patient.uuid}-header-${i}`}
+            elementId={elementId}
+            {...wardPatient}
+          />
+        ))}
+      </div>
+      <div className={classNames(styles.admissionRequestCardHeader, styles.admissionEncounterDetails)}>
+        <div>
+          {formatDatetime(new Date(dispositionEncounter?.encounterDatetime), {
+            locale: getLocale(),
+            mode: 'standard',
+          })}
+        </div>
+        <div>{dispositionEncounter?.encounterProviders?.map((provider) => provider?.provider?.display).join(',')}</div>
+        <div>{dispositionEncounter?.location?.display}</div>
+      </div>
+      <ExtensionSlot
+        name={rowsExtensionSlotName}
+        state={extensionSlotState}
+        className={styles.admissionRequestCardRow}
+      />
+    </div>
+  );
+};
+
+export default AdmissionRequestCardHeader;

package/src/ward-workspace/admission-request-card/admission-request-card.component.tsx

@@ -0,0 +1,16 @@
+import React from 'react';
+import type { WardPatientCard } from '../../types';
+import AdmissionRequestCardActions from './admission-request-card-actions.component';
+import AdmissionRequestCardHeader from './admission-request-card-header.component';
+import styles from './admission-request-card.scss';
+
+const AdmissionRequestCard: WardPatientCard = (wardPatient) => {
+  return (
+    <div className={styles.admissionRequestCard}>
+      <AdmissionRequestCardHeader {...wardPatient} />
+      <AdmissionRequestCardActions {...wardPatient} />
+    </div>
+  );
+};
+
+export default AdmissionRequestCard;

package/src/ward-workspace/admission-request-card/admission-request-card.scss

@@ -0,0 +1,49 @@
+@use '@carbon/type';
+@use '@carbon/layout';
+@use '@openmrs/esm-styleguide/src/vars' as *;
+
+.admissionRequestCard {
+  background-color: $ui-03;
+  border: 1px solid $color-gray-30;
+  height: fit-content;
+  color: $color-gray-70;
+  margin-bottom: layout.$spacing-05;
+}
+
+.admissionRequestCardHeaderContainer {
+  padding: layout.$spacing-03;
+}
+
+.admissionRequestCardHeader {
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+
+  > div:not(:first-of-type):not(:empty)::before {
+    content: '·';
+    padding: layout.$spacing-02;
+  }
+}
+
+.admissionRequestCardRow {
+  padding: layout.$spacing-05;
+  margin: layout.$spacing-03;
+  background-color: white;
+}
+
+.admissionEncounterDetails {
+  @include type.type-style('helper-text-01');
+  color: $text-02;
+  margin-top: layout.$spacing-03;
+}
+
+.admissionRequestActionBar {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  border-top: 1px solid $text-03;
+
+  svg {
+    fill: $interactive-01 !important;
+  }
+}

package/src/ward-workspace/admission-request-workspace/admission-requests-workspace.scss

@@ -0,0 +1,12 @@
+@use '@carbon/layout';
+@use '@openmrs/esm-styleguide/src/vars' as *;
+
+.admissionRequestsWorkspace {
+  padding: layout.$spacing-04;
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(280px, 1fr));
+  gap: layout.$spacing-05;
+}
+.content {
+  padding: layout.$spacing-05;
+}

package/src/ward-workspace/admission-request-workspace/admission-requests-workspace.test.tsx

@@ -0,0 +1,48 @@
+import React from 'react';
+import { screen } from '@testing-library/react';
+import { defineConfigSchema } from '@openmrs/esm-framework';
+import { useInpatientRequest } from '../../hooks/useInpatientRequest';
+import { configSchema } from '../../config-schema';
+import useWardLocation from '../../hooks/useWardLocation';
+import AdmissionRequestsWorkspace from './admission-requests.workspace';
+import { mockInpatientRequest, mockLocationInpatientWard } from '../../../../../__mocks__';
+import { renderWithSwr } from '../../../../../tools';
+
+defineConfigSchema('@openmrs/esm-ward-app', configSchema);
+
+jest.mock('../../hooks/useInpatientRequest', () => ({
+  useInpatientRequest: jest.fn(),
+}));
+jest.mock('../../hooks/useWardLocation', () => jest.fn());
+
+const mockUseWardLocation = useWardLocation as jest.Mock;
+mockUseWardLocation.mockReturnValue({
+  location: mockLocationInpatientWard,
+  isLoadingLocation: false,
+  errorFetchingLocation: null,
+  invalidLocation: false,
+});
+
+const mockInpatientRequestResponse = {
+  error: undefined,
+  mutate: jest.fn(),
+  isValidating: false,
+  isLoading: false,
+  inpatientRequests: [mockInpatientRequest],
+};
+
+jest.mocked(useInpatientRequest).mockReturnValue(mockInpatientRequestResponse);
+
+const workspaceProps = {
+  closeWorkspace: jest.fn(),
+  promptBeforeClosing: jest.fn(),
+  closeWorkspaceWithSavedChanges: jest.fn(),
+  setTitle: jest.fn(),
+};
+
+describe('Admission Requests Workspace', () => {
+  it('should render a admission request card', () => {
+    renderWithSwr(<AdmissionRequestsWorkspace {...workspaceProps} />);
+    expect(screen.getByText(mockInpatientRequest.patient.person?.preferredName?.display as string)).toBeInTheDocument();
+  });
+});

package/src/ward-workspace/admission-request-workspace/admission-requests.workspace.tsx

@@ -0,0 +1,61 @@
+import React from 'react';
+import styles from './admission-requests-workspace.scss';
+import AdmissionRequestCard from '../admission-request-card/admission-request-card.component';
+import { Search } from '@carbon/react';
+import { ErrorState } from '@openmrs/esm-framework';
+import { useTranslation } from 'react-i18next';
+import { useInpatientRequest } from '../../hooks/useInpatientRequest';
+import { type InpatientRequest } from '../../types';
+
+interface AdmissionRequestsWorkspaceProps {}
+const AdmissionRequestsWorkspace: React.FC<AdmissionRequestsWorkspaceProps> = () => {
+  const {
+    inpatientRequests,
+    isLoading: isLoadingInpatientRequests,
+    error: errorFetchingInpatientRequests,
+  } = useInpatientRequest(['ADMIT', 'TRANSFER']);
+  const { t } = useTranslation();
+  const [searchTerm, setSearchTerm] = React.useState('');
+  const handleSearch = (event: React.ChangeEvent<HTMLInputElement>) => {
+    setSearchTerm(event.target.value);
+  };
+
+  return (
+    <div className={styles.admissionRequestsWorkspaceContainer}>
+      <Search
+        labelText=""
+        value={searchTerm}
+        onChange={handleSearch}
+        size="lg"
+        placeholder={t('searchForPatient', 'Search for a patient')}
+        disabled
+      />
+
+      <div className={styles.content}>
+        {isLoadingInpatientRequests ? (
+          <>Loading</>
+        ) : errorFetchingInpatientRequests ? (
+          <ErrorState
+            headerTitle={t('admissionRequests', 'Admission requests')}
+            error={errorFetchingInpatientRequests}
+          />
+        ) : (
+          <>
+            {inpatientRequests.map((request: InpatientRequest, i) => (
+              <AdmissionRequestCard
+                key={`admission-request-card-${i}`}
+                patient={request.patient}
+                visit={request.visit}
+                bed={null}
+                inpatientRequest={request}
+                inpatientAdmission={null}
+              />
+            ))}
+          </>
+        )}
+      </div>
+    </div>
+  );
+};
+
+export default AdmissionRequestsWorkspace;

package/src/ward-workspace/admit-patient-form-workspace/admit-patient-form.scss

@@ -0,0 +1,35 @@
+@use '@carbon/type';
+@use '@carbon/layout';
+@use '@openmrs/esm-styleguide/src/vars' as *;
+
+.form {
+  display: flex;
+  height: 100%;
+  justify-content: space-between;
+  flex-direction: column;
+}
+
+.formContent {
+  padding: layout.$spacing-05;
+}
+
+.formError {
+  margin: (-(layout.$spacing-05)) (-(layout.$spacing-05)) layout.$spacing-05 (-(layout.$spacing-05));
+}
+
+.buttonSet button {
+  max-width: unset !important;
+  width: 50% !important;
+}
+
+.bedSelectionDropdown {
+  margin-top: layout.$spacing-03;
+}
+
+.errorNotifications {
+  margin-top: layout.$spacing-05;
+}
+
+.productiveHeading02 {
+  @include type.type-style('heading-compact-02');
+}

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

@@ -0,0 +1,341 @@
+import React from 'react';
+import { screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { renderWithSwr } from '../../../../../tools';
+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(),
+}));
+
+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);
+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 mockWorkspaceProps: AdmitPatientFormWorkspaceProps = {
+  patient: mockPatientAlice,
+  closeWorkspace: jest.fn(),
+  closeWorkspaceWithSavedChanges: jest.fn(),
+  promptBeforeClosing: jest.fn(),
+  setTitle: jest.fn(),
+  dispositionType: 'ADMIT',
+};
+
+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',
+        identifier: 'current-provider-identifier',
+      },
+      authenticated: true,
+      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,
+    });
+  });
+
+  it('should render admit patient form', async () => {
+    const user = userEvent.setup();
+    renderAdmissionForm();
+    const cancelButton = screen.getByRole('button', { name: 'Cancel' });
+    await user.click(cancelButton);
+    expect(mockWorkspaceProps.closeWorkspace).toHaveBeenCalledWith({
+      ignoreChanges: true,
+    });
+    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();
+  });
+
+  it('should block the form if emr configuration is not fetched properly', () => {
+    mockedUseEmrConfiguration.mockReturnValue({
+      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,
+    });
+    renderAdmissionForm();
+    expect(screen.getByText('Select a bed')).toBeInTheDocument();
+    expect(screen.getByText('No beds configured for Inpatient Ward location')).toBeInTheDocument();
+  });
+
+  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');
+    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(mockedShowSnackbar).toHaveBeenCalledWith({
+      kind: 'success',
+      subtitle: '{{patientName}} has been successfully admitted and assigned to bed bed3',
+      title: 'Patient admitted successfully',
+    });
+  });
+
+  it('should show snackbar if there was an issue creating an encounter', async () => {
+    mockedOpenmrsFetch.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');
+    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',
+      subtitle: 'Failed to create encounter',
+    });
+  });
+
+  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',
+        },
+      });
+    });
+
+    const user = userEvent.setup();
+    renderAdmissionForm();
+    const combobox = screen.getByRole('combobox', {
+      name: 'Choose an option',
+    });
+    await user.click(combobox);
+    const bedOption = screen.getByText('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',
+      subtitle: 'Patient admitted successfully but fail to assign bed to patient',
+    });
+  });
+
+  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',
+      },
+    });
+    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(mockedShowSnackbar).toHaveBeenCalledWith({
+      kind: 'success',
+      subtitle: 'Patient admitted successfully to Inpatient Ward',
+      title: 'Patient admitted successfully',
+    });
+  });
+});