@olaboot/esm-patient-registration-app 9.2.1 → 10.0.2

package/src/patient-registration/section/patient-relationships/relationships-section.test.tsx

@@ -1,15 +1,18 @@
 import React from 'react';
+import { vi, describe, it, expect, test } from 'vitest';
+import userEvent from '@testing-library/user-event';
+import { screen, waitFor } from '@testing-library/react';
 import { Form, Formik } from 'formik';
-import { screen } from '@testing-library/react';
 import { type Resources } from '../../../offline.resources';
 import { type FormValues } from '../../patient-registration.types';
 import { PatientRegistrationContextProvider } from '../../patient-registration-context';
 import { RelationshipsSection } from './relationships-section.component';
 import { ResourcesContextProvider } from '../../../resources-context';
 import { renderWithContext } from 'tools';
+import { initialFormValues } from '../../patient-registration.component';
 
-jest.mock('../../patient-registration.resource', () => ({
-  fetchPerson: jest.fn().mockResolvedValue({
+vi.mock('../../patient-registration.resource', () => ({
+  fetchPerson: vi.fn().mockResolvedValue({
     data: {
       results: [
         { uuid: '42ae5ce0-d64b-11ea-9064-5adc43bbdd24', display: 'Person 1' },
@@ -19,95 +22,286 @@ jest.mock('../../patient-registration.resource', () => ({
   }),
 }));
 
-let mockResourcesContextValue = {
-  addressTemplate: null,
-  currentSession: {
-    authenticated: true,
-    sessionId: 'JSESSION',
-    currentProvider: { uuid: '45ce6c2e-dd5a-11e6-9d9c-0242ac150002', identifier: 'PRO-123' },
-  },
-  identifierTypes: [],
-  relationshipTypes: null,
-} as Resources;
-
-const initialContextValues = {
-  currentPhoto: 'data:image/png;base64,1234567890',
-  identifierTypes: [],
-  inEditMode: false,
-  initialFormValues: {} as FormValues,
-  isOffline: false,
-  setCapturePhotoProps: jest.fn(),
-  setFieldValue: jest.fn(),
-  setFieldTouched: jest.fn(),
-  setInitialFormValues: jest.fn(),
-  validationSchema: null,
-  values: {} as FormValues,
+const mockRelationshipTypes = {
+  results: [
+    {
+      displayAIsToB: 'Mother',
+      aIsToB: 'Mother',
+      bIsToA: 'Child',
+      displayBIsToA: 'Child',
+      uuid: '42ae5ce0-d64b-11ea-9064-5adc43bbdd34',
+    },
+    {
+      displayAIsToB: 'Father',
+      aIsToB: 'Father',
+      bIsToA: 'Child',
+      displayBIsToA: 'Child',
+      uuid: '52ae5ce0-d64b-11ea-9064-5adc43bbdd24',
+    },
+  ],
 };
 
+/**
+ * Helper to render RelationshipsSection with Formik for state-dependent tests.
+ */
+function renderRelationshipsSectionWithFormik(
+  initialValues: Partial<FormValues> = {},
+  resourcesContextValue: Resources,
+) {
+  const defaultValues = {
+    ...initialFormValues,
+    relationships: [],
+    ...initialValues,
+  };
+
+  let formValuesRef: FormValues = { ...initialFormValues, ...defaultValues } as FormValues;
+
+  const utils = renderWithContext(
+    <Formik initialValues={defaultValues} onSubmit={() => {}}>
+      {({ setFieldValue, values }) => {
+        formValuesRef = { ...initialFormValues, ...values } as FormValues;
+        return (
+          <Form>
+            <PatientRegistrationContextProvider
+              value={{
+                identifierTypes: [],
+                values: formValuesRef,
+                validationSchema: null,
+                inEditMode: false,
+                setFieldValue: setFieldValue as any,
+                setCapturePhotoProps: vi.fn(),
+                setFieldTouched: vi.fn().mockResolvedValue(undefined),
+                currentPhoto: '',
+                isOffline: false,
+                initialFormValues: formValuesRef,
+              }}>
+              <RelationshipsSection />
+            </PatientRegistrationContextProvider>
+          </Form>
+        );
+      }}
+    </Formik>,
+    ResourcesContextProvider,
+    resourcesContextValue,
+  );
+
+  return {
+    ...utils,
+    getFormValues: () => formValuesRef,
+  };
+}
+
 describe('RelationshipsSection', () => {
-  it('renders a loader when relationshipTypes are not available', () => {
-    renderWithContext(
-      <Formik initialValues={{}} onSubmit={null}>
-        <Form>
-          <RelationshipsSection />
-        </Form>
-      </Formik>,
-      ResourcesContextProvider,
-      mockResourcesContextValue,
-    );
-
-    expect(screen.getByLabelText(/loading relationships section/i)).toBeInTheDocument();
-    expect(screen.getByRole('progressbar')).toBeInTheDocument();
-    expect(screen.queryByText(/add relationship/i)).not.toBeInTheDocument();
+  describe('Loading state', () => {
+    it('renders a loader when relationshipTypes are not available', () => {
+      const mockResourcesContextValue = {
+        addressTemplate: null,
+        currentSession: {
+          authenticated: true,
+          sessionId: 'JSESSION',
+          currentProvider: { uuid: '45ce6c2e-dd5a-11e6-9d9c-0242ac150002', identifier: 'PRO-123' },
+        },
+        identifierTypes: [],
+        relationshipTypes: null,
+      } as Resources;
+
+      renderRelationshipsSectionWithFormik({}, mockResourcesContextValue);
+
+      expect(screen.getByLabelText(/loading relationships section/i)).toBeInTheDocument();
+      expect(screen.getByRole('progressbar')).toBeInTheDocument();
+      expect(screen.queryByText(/add relationship/i)).not.toBeInTheDocument();
+    });
   });
 
-  it('renders relationships when relationshipTypes are available', () => {
-    const relationshipTypes = {
-      results: [
+  describe('Rendering', () => {
+    it('renders the relationships section when relationshipTypes are available', () => {
+      const mockResourcesContextValue = {
+        addressTemplate: null,
+        currentSession: {
+          authenticated: true,
+          sessionId: 'JSESSION',
+          currentProvider: { uuid: '45ce6c2e-dd5a-11e6-9d9c-0242ac150002', identifier: 'PRO-123' },
+        },
+        identifierTypes: [],
+        relationshipTypes: mockRelationshipTypes,
+      } as Resources;
+
+      renderRelationshipsSectionWithFormik({}, mockResourcesContextValue);
+
+      expect(screen.getByLabelText(/relationships section/i)).toBeInTheDocument();
+      expect(screen.getByRole('button', { name: /add relationship/i })).toBeInTheDocument();
+    });
+
+    it('renders existing relationships', () => {
+      const mockResourcesContextValue = {
+        addressTemplate: null,
+        currentSession: {
+          authenticated: true,
+          sessionId: 'JSESSION',
+          currentProvider: { uuid: '45ce6c2e-dd5a-11e6-9d9c-0242ac150002', identifier: 'PRO-123' },
+        },
+        identifierTypes: [],
+        relationshipTypes: mockRelationshipTypes,
+      } as Resources;
+
+      renderRelationshipsSectionWithFormik(
         {
-          displayAIsToB: 'Mother',
-          aIsToB: 'Mother',
-          bIsToA: 'Child',
-          displayBIsToA: 'Child',
-          uuid: '42ae5ce0-d64b-11ea-9064-5adc43bbdd34',
+          relationships: [
+            {
+              action: 'ADD',
+              relatedPersonUuid: '11524ae7-3ef6-4ab6-aff6-804ffc58704a',
+              relatedPersonName: 'John Doe',
+              relationshipType: '',
+            },
+          ],
+        },
+        mockResourcesContextValue,
+      );
+
+      expect(screen.getByLabelText(/relationships section/i)).toBeInTheDocument();
+      expect(screen.getByRole('heading', { name: /relationship/i })).toBeInTheDocument();
+      expect(screen.getByRole('button', { name: /delete/i })).toBeInTheDocument();
+      expect(screen.getByRole('searchbox', { name: /full name/i })).toBeInTheDocument();
+    });
+
+    it('renders relationship type options', () => {
+      const mockResourcesContextValue = {
+        addressTemplate: null,
+        currentSession: {
+          authenticated: true,
+          sessionId: 'JSESSION',
+          currentProvider: { uuid: '45ce6c2e-dd5a-11e6-9d9c-0242ac150002', identifier: 'PRO-123' },
         },
+        identifierTypes: [],
+        relationshipTypes: mockRelationshipTypes,
+      } as Resources;
+
+      renderRelationshipsSectionWithFormik(
         {
-          displayAIsToB: 'Father',
-          aIsToB: 'Father',
-          bIsToA: 'Child',
-          displayBIsToA: 'Child',
-          uuid: '52ae5ce0-d64b-11ea-9064-5adc43bbdd24',
+          relationships: [{ action: 'ADD', relatedPersonUuid: '', relationshipType: '' }],
         },
-      ],
-    };
-    mockResourcesContextValue = {
-      ...mockResourcesContextValue,
-      relationshipTypes: relationshipTypes,
-    };
-
-    renderWithContext(
-      <Formik
-        initialValues={{
-          relationships: [{ action: 'ADD', relatedPersonUuid: '11524ae7-3ef6-4ab6-aff6-804ffc58704a' }],
-        }}
-        onSubmit={null}>
-        <Form>
-          <PatientRegistrationContextProvider value={initialContextValues}>
-            <RelationshipsSection />
-          </PatientRegistrationContextProvider>
-        </Form>
-      </Formik>,
-      ResourcesContextProvider,
-      mockResourcesContextValue,
-    );
-
-    expect(screen.getByLabelText(/relationships section/i)).toBeInTheDocument();
-    expect(screen.getByRole('heading', { name: /relationship/i })).toBeInTheDocument();
-    expect(screen.getByRole('button', { name: /delete/i })).toBeInTheDocument();
-    expect(screen.getByRole('button', { name: /add relationship/i })).toBeInTheDocument();
-    expect(screen.getByRole('searchbox', { name: /full name/i })).toBeInTheDocument();
-    expect(screen.getByRole('option', { name: /mother/i })).toBeInTheDocument();
-    expect(screen.getByRole('option', { name: /father/i })).toBeInTheDocument();
-    expect(screen.getAllByRole('option', { name: /child/i }).length).toEqual(2);
+        mockResourcesContextValue,
+      );
+
+      expect(screen.getByRole('option', { name: /mother/i })).toBeInTheDocument();
+      expect(screen.getByRole('option', { name: /father/i })).toBeInTheDocument();
+      expect(screen.getAllByRole('option', { name: /child/i }).length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('User interaction', () => {
+    it('adds a new relationship when user clicks add relationship button', async () => {
+      const user = userEvent.setup();
+      const mockResourcesContextValue = {
+        addressTemplate: null,
+        currentSession: {
+          authenticated: true,
+          sessionId: 'JSESSION',
+          currentProvider: { uuid: '45ce6c2e-dd5a-11e6-9d9c-0242ac150002', identifier: 'PRO-123' },
+        },
+        identifierTypes: [],
+        relationshipTypes: mockRelationshipTypes,
+      } as Resources;
+
+      const { getFormValues } = renderRelationshipsSectionWithFormik({}, mockResourcesContextValue);
+
+      const addButton = screen.getByRole('button', { name: /add relationship/i });
+      expect(addButton).toBeInTheDocument();
+
+      await user.click(addButton);
+
+      await waitFor(() => {
+        const formValues = getFormValues();
+        expect(formValues.relationships.length).toBe(1);
+      });
+
+      await waitFor(() => {
+        const formValues = getFormValues();
+        expect(formValues.relationships[0]?.action).toBe('ADD');
+      });
+
+      // New relationship form should be visible
+      expect(screen.getByRole('searchbox', { name: /full name/i })).toBeInTheDocument();
+    });
+
+    it('removes a new relationship from the array when user clicks delete button', async () => {
+      const user = userEvent.setup();
+      const mockResourcesContextValue = {
+        addressTemplate: null,
+        currentSession: {
+          authenticated: true,
+          sessionId: 'JSESSION',
+          currentProvider: { uuid: '45ce6c2e-dd5a-11e6-9d9c-0242ac150002', identifier: 'PRO-123' },
+        },
+        identifierTypes: [],
+        relationshipTypes: mockRelationshipTypes,
+      } as Resources;
+
+      const { getFormValues } = renderRelationshipsSectionWithFormik(
+        {
+          relationships: [
+            { action: 'ADD', relatedPersonUuid: 'test-uuid', relatedPersonName: 'Test Person', relationshipType: '' },
+          ],
+        },
+        mockResourcesContextValue,
+      );
+
+      expect(getFormValues().relationships.length).toBe(1);
+
+      const deleteButton = screen.getByRole('button', { name: /delete/i });
+      expect(deleteButton).toBeInTheDocument();
+
+      await user.click(deleteButton);
+
+      // For new relationships (action: 'ADD'), clicking delete removes them from the array
+      await waitFor(() => {
+        const formValues = getFormValues();
+        expect(formValues.relationships.length).toBe(0);
+      });
+    });
+
+    it('marks an existing relationship for deletion when user clicks delete button', async () => {
+      const user = userEvent.setup();
+      const mockResourcesContextValue = {
+        addressTemplate: null,
+        currentSession: {
+          authenticated: true,
+          sessionId: 'JSESSION',
+          currentProvider: { uuid: '45ce6c2e-dd5a-11e6-9d9c-0242ac150002', identifier: 'PRO-123' },
+        },
+        identifierTypes: [],
+        relationshipTypes: mockRelationshipTypes,
+      } as Resources;
+
+      const { getFormValues } = renderRelationshipsSectionWithFormik(
+        {
+          relationships: [
+            {
+              uuid: 'existing-relationship-uuid',
+              relatedPersonUuid: 'test-uuid',
+              relatedPersonName: 'Test Person',
+              relationshipType: '42ae5ce0-d64b-11ea-9064-5adc43bbdd34/aIsToB',
+            },
+          ],
+        },
+        mockResourcesContextValue,
+      );
+
+      const deleteButton = screen.getByRole('button', { name: /delete/i });
+      expect(deleteButton).toBeInTheDocument();
+
+      await user.click(deleteButton);
+
+      // For existing relationships (with uuid, no action), clicking delete sets action to 'DELETE'
+      await waitFor(() => {
+        const formValues = getFormValues();
+        expect(formValues.relationships[0]?.action).toBe('DELETE');
+      });
+
+      // Should show restore notification
+      await waitFor(() => {
+        expect(screen.getByText(/relationship removed/i)).toBeInTheDocument();
+      });
+    });
   });
 });

package/src/patient-registration/section/section-wrapper.component.tsx

@@ -23,7 +23,7 @@ export const SectionWrapper = ({ sectionDefinition, index }: SectionWrapperProps
    * t('relationshipsSection', 'Relationships')
    */
   return (
-    <div id={sectionDefinition.id} style={{ scrollMarginTop: '4rem' }}>
+    <div id={sectionDefinition.id} style={{ scrollMarginTop: '1rem' }}>
       <h3 className={styles.productiveHeading02} style={{ color: '#161616' }}>
         {index + 1}. {t(`${sectionDefinition.id}Section`, sectionDefinition.name)}
       </h3>

package/src/patient-registration/ui-components/overlay/overlay.test.tsx

@@ -0,0 +1,104 @@
+import React from 'react';
+import { vi, describe, it, expect, beforeEach } from 'vitest';
+import userEvent from '@testing-library/user-event';
+import { render, screen } from '@testing-library/react';
+import { useLayoutType, isDesktop } from '@openmrs/esm-framework';
+import Overlay from './overlay.component';
+
+const mockUseLayoutType = vi.mocked(useLayoutType);
+const mockIsDesktop = vi.mocked(isDesktop);
+/**
+ * Helper to render Overlay component.
+ */
+function renderOverlay(
+  close = vi.fn(),
+  header = 'Test Header',
+  buttonsGroup?: React.ReactElement,
+  children?: React.ReactNode,
+) {
+  return render(<Overlay close={close} header={header} buttonsGroup={buttonsGroup} children={children} />);
+}
+
+describe('Overlay component', () => {
+  const mockClose = vi.fn();
+
+  beforeEach(() => {
+    mockIsDesktop.mockReturnValue(true);
+    mockUseLayoutType.mockReturnValue('desktop' as any);
+  });
+
+  describe('Desktop layout', () => {
+    it('renders header text', () => {
+      renderOverlay(mockClose, 'Test Header');
+
+      expect(screen.getByText('Test Header')).toBeInTheDocument();
+    });
+
+    it('renders close button with icon', () => {
+      renderOverlay(mockClose, 'Test Header');
+
+      const closeButton = screen.getByRole('button', { name: /close overlay/i });
+      expect(closeButton).toBeInTheDocument();
+    });
+
+    it('calls close when close button is clicked', async () => {
+      const user = userEvent.setup();
+      renderOverlay(mockClose, 'Test Header');
+
+      const closeButton = screen.getByRole('button', { name: /close overlay/i });
+      await user.click(closeButton);
+
+      expect(mockClose).toHaveBeenCalledTimes(1);
+    });
+
+    it('renders children content', () => {
+      renderOverlay(mockClose, 'Test Header', undefined, <div>Test Content</div>);
+
+      expect(screen.getByText('Test Content')).toBeInTheDocument();
+    });
+
+    it('renders buttonsGroup when provided', () => {
+      const buttonsGroup = (
+        <div>
+          <button>Save</button>
+          <button>Cancel</button>
+        </div>
+      );
+      renderOverlay(mockClose, 'Test Header', buttonsGroup);
+
+      expect(screen.getByRole('button', { name: /save/i })).toBeInTheDocument();
+      expect(screen.getByRole('button', { name: /cancel/i })).toBeInTheDocument();
+    });
+  });
+
+  describe('Tablet layout', () => {
+    beforeEach(() => {
+      mockIsDesktop.mockReturnValue(false);
+      mockUseLayoutType.mockReturnValue('tablet' as any);
+    });
+
+    it('renders header with back arrow button', () => {
+      renderOverlay(mockClose, 'Test Header');
+
+      const backButton = screen.getByRole('button', { name: /close overlay/i });
+      expect(backButton).toBeInTheDocument();
+      expect(screen.getByText('Test Header')).toBeInTheDocument();
+    });
+
+    it('calls close when back button is clicked', async () => {
+      const user = userEvent.setup();
+      renderOverlay(mockClose, 'Test Header');
+
+      const backButton = screen.getByRole('button', { name: /close overlay/i });
+      await user.click(backButton);
+
+      expect(mockClose).toHaveBeenCalledTimes(1);
+    });
+
+    it('renders children content in tablet layout', () => {
+      renderOverlay(mockClose, 'Test Header', undefined, <div>Tablet Content</div>);
+
+      expect(screen.getByText('Tablet Content')).toBeInTheDocument();
+    });
+  });
+});

package/src/patient-registration/validation/patient-registration-validation.test.ts

@@ -1,9 +1,10 @@
 import dayjs from 'dayjs';
+import { vi, describe, it, expect, beforeEach } from 'vitest';
 import { getConfig } from '@openmrs/esm-framework';
 import { type RegistrationConfig } from '../../config-schema';
 import { getValidationSchema } from './patient-registration-validation';
 
-const mockGetConfig = jest.mocked(getConfig);
+const mockGetConfig = vi.mocked(getConfig);
 
 describe('Patient registration validation', () => {
   beforeEach(() => {

package/src/patient-registration/validation/patient-registration-validation.ts

@@ -1,11 +1,15 @@
 import dayjs from 'dayjs';
 import * as Yup from 'yup';
+import type { ObjectSchema } from 'yup';
 import mapValues from 'lodash/mapValues';
 import { type RegistrationConfig } from '../../config-schema';
 import { type FormValues } from '../patient-registration.types';
 import { getDatetime } from '../patient-registration.resource';
 
-export function getValidationSchema(config: RegistrationConfig, t: (key: string, defaultValue: string) => string) {
+export function getValidationSchema(
+  config: RegistrationConfig,
+  t: (key: string, defaultValue: string) => string,
+): ObjectSchema<any> {
   return Yup.object({
     givenName: Yup.string().required(t('givenNameRequired', 'Given name is required')),
     familyName: Yup.string().required(t('familyNameRequired', 'Family name is required')),
@@ -56,7 +60,7 @@ export function getValidationSchema(config: RegistrationConfig, t: (key: string,
       .max(new Date(), t('deathDateInFuture', 'Death date cannot be in future'))
       .test(
         'deathDate-after-birthdate',
-        t('deathdayInvalidDate', 'Death date and time cannot be before the birthday'),
+        t('deathdayBeforeBirthday', 'Death date and time cannot be before the birthday'),
         function (value) {
           const { birthdate } = this.parent;
           if (birthdate && value) {
@@ -95,7 +99,9 @@ export function getValidationSchema(config: RegistrationConfig, t: (key: string,
     }),
     nonCodedCauseOfDeath: Yup.string().when(['isDead', 'deathCause'], {
       is: (isDead, deathCause) => isDead && deathCause === config.freeTextFieldConceptUuid,
-      then: Yup.string().required(t('nonCodedCauseOfDeathRequired', 'Cause of death is required')),
+      then: Yup.string().required(
+        t('nonCodedCauseOfDeathRequiredWhenSelected', 'Non-coded cause of death is required'),
+      ),
       otherwise: Yup.string().nullable(),
     }),
     email: Yup.string().optional().email(t('invalidEmail', 'Invalid email')),

package/src/root.component.tsx

@@ -2,8 +2,8 @@ import React, { useMemo } from 'react';
 import classNames from 'classnames';
 import useSWRImmutable from 'swr/immutable';
 import { BrowserRouter, Route, Routes } from 'react-router-dom';
-import { Grid, Row } from '@carbon/react';
-import { ExtensionSlot, useConnectivity, useSession } from '@openmrs/esm-framework';
+import { Grid } from '@carbon/react';
+import { useConnectivity, useSession } from '@openmrs/esm-framework';
 import {
   fetchAddressTemplate,
   fetchAllRelationshipTypes,
@@ -34,9 +34,6 @@ export default function Root() {
   return (
     <main className={classNames('omrs-main-content', styles.root)}>
       <Grid className={styles.grid}>
-        <Row>
-          <ExtensionSlot name="breadcrumbs-slot" />
-        </Row>
         <ResourcesContextProvider
           value={{
             addressTemplate,

package/src/widgets/cancel-patient-edit.test.tsx

@@ -1,22 +1,59 @@
 import React from 'react';
+import { vi, describe, it, expect } from 'vitest';
 import userEvent from '@testing-library/user-event';
 import { screen, render } from '@testing-library/react';
 import CancelPatientEdit from './cancel-patient-edit.modal';
 
+/**
+ * Helper to render CancelPatientEdit modal.
+ */
+function renderCancelPatientEditModal(close = vi.fn(), onConfirm = vi.fn()) {
+  return render(<CancelPatientEdit close={close} onConfirm={onConfirm} />);
+}
+
 describe('CancelPatientEdit modal', () => {
-  const mockClose = jest.fn();
-  const mockOnConfirm = jest.fn();
+  const mockClose = vi.fn();
+  const mockOnConfirm = vi.fn();
+
+  describe('Rendering', () => {
+    it('renders modal with title and message', () => {
+      renderCancelPatientEditModal(mockClose, mockOnConfirm);
+
+      expect(screen.getByText(/are you sure you want to discard these changes\?/i)).toBeInTheDocument();
+      expect(
+        screen.getByText(/your unsaved changes will be lost if you proceed to discard the form/i),
+      ).toBeInTheDocument();
+    });
+
+    it('renders Cancel and Discard buttons', () => {
+      renderCancelPatientEditModal(mockClose, mockOnConfirm);
+
+      expect(screen.getByRole('button', { name: /cancel/i })).toBeInTheDocument();
+      expect(screen.getByRole('button', { name: /discard/i })).toBeInTheDocument();
+    });
+  });
+
+  describe('User interaction', () => {
+    it('calls close when Cancel button is clicked', async () => {
+      const user = userEvent.setup();
+      renderCancelPatientEditModal(mockClose, mockOnConfirm);
+
+      const cancelButton = screen.getByRole('button', { name: /cancel/i });
+      await user.click(cancelButton);
+
+      expect(mockClose).toHaveBeenCalledTimes(1);
+      expect(mockOnConfirm).not.toHaveBeenCalled();
+    });
 
-  it('renders the modal and triggers close and onConfirm functions', async () => {
-    const user = userEvent.setup();
-    render(<CancelPatientEdit close={mockClose} onConfirm={mockOnConfirm} />);
+    it('calls onConfirm when Discard button is clicked', async () => {
+      const user = userEvent.setup();
+      renderCancelPatientEditModal(mockClose, mockOnConfirm);
 
-    const cancelButton = screen.getByRole('button', { name: /Cancel/i });
-    await user.click(cancelButton);
-    expect(mockClose).toHaveBeenCalledTimes(1);
+      const discardButton = screen.getByRole('button', { name: /discard/i });
+      await user.click(discardButton);
 
-    const discardButton = screen.getByRole('button', { name: /discard/i });
-    await user.click(discardButton);
-    expect(mockOnConfirm).toHaveBeenCalledTimes(1);
+      expect(mockOnConfirm).toHaveBeenCalledTimes(1);
+      expect(mockClose).not.toHaveBeenCalled();
+    });
   });
 });