@ampath/esm-patient-registration-app 6.0.1-pre.6 → 6.0.1-pre.66

package/src/patient-registration/field/person-attributes/person-attribute-field.test.tsx

@@ -1,187 +0,0 @@
-import React from 'react';
-import { render, screen } from '@testing-library/react';
-import { usePersonAttributeType } from './person-attributes.resource';
-import { PersonAttributeField } from './person-attribute-field.component';
-import { useConceptAnswers } from '../field.resource';
-import { Form, Formik } from 'formik';
-import { type FieldDefinition } from '../../../config-schema';
-
-jest.mock('./person-attributes.resource'); // Mock the usePersonAttributeType hook
-jest.mock('../field.resource'); // Mock the useConceptAnswers hook
-
-jest.mock('formik', () => ({
-  ...jest.requireActual('formik'),
-}));
-
-const mockedUsePersonAttributeType = usePersonAttributeType as jest.Mock;
-const mockedUseConceptAnswers = useConceptAnswers as jest.Mock;
-
-let fieldDefinition: FieldDefinition;
-
-describe('PersonAttributeField', () => {
-  let mockPersonAttributeType = {
-    format: 'java.lang.String',
-    display: 'Referred by',
-    uuid: '4dd56a75-14ab-4148-8700-1f4f704dc5b0',
-  };
-
-  beforeEach(() => {
-    fieldDefinition = {
-      id: 'referredby',
-      name: 'Referred by',
-      type: 'person attribute',
-      uuid: '4dd56a75-14ab-4148-8700-1f4f704dc5b0',
-      answerConceptSetUuid: '6682d17f-0777-45e4-a39b-93f77eb3531c',
-      validation: {
-        matches: '',
-        required: true,
-      },
-      showHeading: true,
-    };
-    mockedUsePersonAttributeType.mockReturnValue({
-      data: mockPersonAttributeType,
-      isLoading: false,
-      error: null,
-      uuid: '14d4f066-15f5-102d-96e4-000c29c2a5d7d',
-    });
-  });
-
-  afterEach(() => {
-    jest.resetAllMocks();
-  });
-
-  it('renders the text input field for String format', () => {
-    render(
-      <Formik initialValues={{}} onSubmit={() => {}}>
-        <Form>
-          <PersonAttributeField fieldDefinition={fieldDefinition} />
-        </Form>
-      </Formik>,
-    );
-
-    const input = screen.getByLabelText(/Referred by/i) as HTMLInputElement;
-    expect(screen.getByRole('heading')).toBeInTheDocument();
-    expect(input).toBeInTheDocument();
-    expect(input.type).toBe('text');
-  });
-
-  it('should not show heading if showHeading is false', () => {
-    fieldDefinition = {
-      ...fieldDefinition,
-      showHeading: false,
-    };
-
-    render(
-      <Formik initialValues={{}} onSubmit={() => {}}>
-        <Form>
-          <PersonAttributeField fieldDefinition={fieldDefinition} />
-        </Form>
-      </Formik>,
-    );
-    expect(screen.queryByRole('heading')).not.toBeInTheDocument();
-  });
-
-  it('renders the coded attribute field for Concept format', () => {
-    mockedUsePersonAttributeType.mockReturnValue({
-      data: { ...mockPersonAttributeType, format: 'org.openmrs.Concept' },
-      isLoading: false,
-      error: null,
-    });
-
-    fieldDefinition = {
-      id: 'referredby',
-      ...fieldDefinition,
-      label: 'Referred by',
-    };
-
-    mockedUseConceptAnswers.mockReturnValueOnce({
-      data: [
-        { uuid: '1', display: 'Option 1' },
-        { uuid: '2', display: 'Option 2' },
-      ],
-      isLoading: false,
-    });
-
-    render(
-      <Formik initialValues={{}} onSubmit={() => {}}>
-        <Form>
-          <PersonAttributeField fieldDefinition={fieldDefinition} />
-        </Form>
-      </Formik>,
-    );
-
-    const input = screen.getByLabelText(/Referred by/i) as HTMLInputElement;
-    expect(input).toBeInTheDocument();
-    expect(input.type).toBe('select-one');
-    expect(screen.getByText('Option 1')).toBeInTheDocument();
-    expect(screen.getByText('Option 2')).toBeInTheDocument();
-  });
-
-  it('renders an error notification if attribute type has unknown format', () => {
-    mockedUsePersonAttributeType.mockReturnValue({
-      data: { ...mockPersonAttributeType, format: 'unknown' },
-      isLoading: false,
-      error: null,
-    });
-
-    render(
-      <Formik initialValues={{}} onSubmit={() => {}}>
-        <Form>
-          <PersonAttributeField fieldDefinition={fieldDefinition} />
-        </Form>
-      </Formik>,
-    );
-
-    expect(screen.getByText('Error')).toBeInTheDocument();
-    expect(screen.getByText(/Patient attribute type has unknown format/i)).toBeInTheDocument();
-  });
-  it('renders an error notification if unable to fetch attribute type', () => {
-    mockedUsePersonAttributeType.mockReturnValue({
-      data: null,
-      isLoading: false,
-      error: new Error('Failed to fetch attribute type'),
-    });
-
-    fieldDefinition = {
-      uuid: 'attribute-uuid',
-      label: 'Attribute',
-      showHeading: false,
-    };
-
-    render(
-      <Formik initialValues={{}} onSubmit={() => {}}>
-        <Form>
-          <PersonAttributeField fieldDefinition={fieldDefinition} />
-        </Form>
-      </Formik>,
-    );
-
-    expect(screen.getByText('Error')).toBeInTheDocument();
-    expect(screen.getByText(/Unable to fetch person attribute type/i)).toBeInTheDocument();
-  });
-
-  it('renders a skeleton if attribute type is loading', () => {
-    mockedUsePersonAttributeType.mockReturnValue({
-      data: null,
-      isLoading: true,
-      error: null,
-    });
-
-    fieldDefinition = {
-      uuid: 'attribute-uuid',
-      label: 'Attribute',
-      showHeading: true,
-    };
-
-    render(
-      <Formik initialValues={{}} onSubmit={() => {}}>
-        <Form>
-          <PersonAttributeField fieldDefinition={fieldDefinition} />
-        </Form>
-      </Formik>,
-    );
-    const input = screen.findByLabelText(/Reffered by/i);
-    expect(screen.getByText(/Attribute/i)).toBeInTheDocument();
-    expect(input).not.toBeNull(); // checks that the input is not rendered when the attribute type is loading
-  });
-});

package/src/patient-registration/field/person-attributes/text-person-attribute-field.test.tsx

@@ -1,88 +0,0 @@
-import React from 'react';
-import { render, screen } from '@testing-library/react';
-import userEvent from '@testing-library/user-event';
-import { Form, Formik } from 'formik';
-import { TextPersonAttributeField } from './text-person-attribute-field.component';
-
-describe('TextPersonAttributeField', () => {
-  const mockPersonAttributeType = {
-    format: 'java.lang.String',
-    display: 'Referred by',
-    uuid: '4dd56a75-14ab-4148-8700-1f4f704dc5b0',
-  };
-
-  it('renders the input field with a label', () => {
-    render(
-      <Formik initialValues={{}} onSubmit={() => {}}>
-        <Form>
-          <TextPersonAttributeField
-            id="attributeId"
-            personAttributeType={mockPersonAttributeType}
-            label="Custom Label"
-          />
-        </Form>
-      </Formik>,
-    );
-
-    expect(screen.getByRole('textbox', { name: /custom label \(optional\)/i })).toBeInTheDocument();
-  });
-
-  it('renders the input field with the default label if label prop is not provided', () => {
-    render(
-      <Formik initialValues={{}} onSubmit={() => {}}>
-        <Form>
-          <TextPersonAttributeField id="attributeId" personAttributeType={mockPersonAttributeType} />
-        </Form>
-      </Formik>,
-    );
-
-    expect(screen.getByRole('textbox', { name: /referred by \(optional\)/i })).toBeInTheDocument();
-  });
-
-  it('validates the input with the provided validationRegex', async () => {
-    const user = userEvent.setup();
-    const validationRegex = '^[A-Z]+$'; // Accepts only uppercase letters
-
-    render(
-      <Formik initialValues={{}} onSubmit={() => {}}>
-        <Form>
-          <TextPersonAttributeField
-            id="attributeId"
-            personAttributeType={mockPersonAttributeType}
-            validationRegex={validationRegex}
-          />
-        </Form>
-      </Formik>,
-    );
-
-    const textbox = screen.getByRole('textbox', { name: /referred by \(optional\)/i });
-    expect(textbox).toBeInTheDocument();
-
-    // Valid input: "ABC"
-    await user.type(textbox, 'ABC');
-    await user.tab();
-
-    expect(screen.queryByText(/invalid input/i)).not.toBeInTheDocument();
-    await user.clear(textbox);
-
-    // // Invalid input: "abc" (contains lowercase letters)
-    await user.type(textbox, 'abc');
-    await user.tab();
-    expect(screen.getByText(/invalid input/i)).toBeInTheDocument();
-  });
-
-  it('renders the input field as required when required prop is true', () => {
-    render(
-      <Formik initialValues={{}} onSubmit={() => {}}>
-        <Form>
-          <TextPersonAttributeField id="attributeId" personAttributeType={mockPersonAttributeType} required />
-        </Form>
-      </Formik>,
-    );
-    const textbox = screen.getByRole('textbox', { name: /referred by/i });
-
-    // Required attribute should be truthy on the input element
-    expect(textbox).toBeInTheDocument();
-    expect(textbox).toBeRequired();
-  });
-});

package/src/patient-registration/form-manager.test.ts

@@ -1,67 +0,0 @@
-import { FormManager } from './form-manager';
-import { type FormValues } from './patient-registration.types';
-
-jest.mock('./patient-registration.resource');
-
-const formValues: FormValues = {
-  patientUuid: '',
-  givenName: '',
-  middleName: '',
-  familyName: '',
-  additionalGivenName: '',
-  additionalMiddleName: '',
-  additionalFamilyName: '',
-  addNameInLocalLanguage: false,
-  gender: '',
-  birthdate: '',
-  yearsEstimated: 1000,
-  monthsEstimated: 11,
-  birthdateEstimated: false,
-  telephoneNumber: '',
-  isDead: false,
-  deathDate: 'string',
-  deathCause: 'string',
-  relationships: [],
-  address: {
-    address1: '',
-    address2: '',
-    cityVillage: '',
-    stateProvince: 'New York',
-    country: 'string',
-    postalCode: 'string',
-  },
-  identifiers: {
-    foo: {
-      identifierUuid: 'aUuid',
-      identifierName: 'Foo',
-      required: false,
-      initialValue: 'foo',
-      identifierValue: 'foo',
-      identifierTypeUuid: 'identifierType',
-      preferred: true,
-      autoGeneration: false,
-      selectedSource: {
-        uuid: 'some-uuid',
-        name: 'unique',
-        autoGenerationOption: { manualEntryEnabled: true, automaticGenerationEnabled: false },
-      },
-    },
-  },
-};
-
-describe('FormManager', () => {
-  describe('createIdentifiers', () => {
-    it('uses the uuid of a field name if it exists', async () => {
-      const result = await FormManager.savePatientIdentifiers(true, undefined, formValues.identifiers, {}, 'Nyc');
-      expect(result).toEqual([
-        {
-          uuid: 'aUuid',
-          identifier: 'foo',
-          identifierType: 'identifierType',
-          location: 'Nyc',
-          preferred: true,
-        },
-      ]);
-    });
-  });
-});

package/src/patient-registration/input/basic-input/select/select-input.test.tsx

@@ -1,49 +0,0 @@
-import React from 'react';
-import { render, screen } from '@testing-library/react';
-import userEvent from '@testing-library/user-event';
-import { Formik, Form } from 'formik';
-import { SelectInput } from './select-input.component';
-
-describe('the select input', () => {
-  const setupSelect = async () => {
-    render(
-      <Formik initialValues={{ select: '' }} onSubmit={null}>
-        <Form>
-          <SelectInput label="Select" name="select" options={['A Option', 'B Option']} required />
-        </Form>
-      </Formik>,
-    );
-    return screen.getByLabelText('Select') as HTMLInputElement;
-  };
-
-  it('exists', async () => {
-    const input = await setupSelect();
-    expect(input.type).toEqual('select-one');
-  });
-
-  it('can input data', async () => {
-    const user = userEvent.setup();
-    const input = await setupSelect();
-    const expected = 'A Option';
-
-    await user.selectOptions(input, expected);
-
-    await expect(input.value).toEqual(expected);
-  });
-
-  it('should show optional label if the input is not required', async () => {
-    render(
-      <Formik initialValues={{ select: '' }} onSubmit={null}>
-        <Form>
-          <SelectInput label="Select" name="select" options={['A Option', 'B Option']} />
-        </Form>
-      </Formik>,
-    );
-
-    await expect(screen.findByRole('combobox'));
-
-    const selectInput = screen.getByRole('combobox', { name: 'Select (optional)' }) as HTMLSelectElement;
-    expect(selectInput.labels).toHaveLength(1);
-    expect(selectInput.labels[0]).toHaveTextContent('Select (optional)');
-  });
-});

package/src/patient-registration/input/custom-input/autosuggest/autosuggest.test.tsx

@@ -1,132 +0,0 @@
-import React from 'react';
-import { Autosuggest } from './autosuggest.component';
-import { BrowserRouter } from 'react-router-dom';
-import { render, screen } from '@testing-library/react';
-import userEvent from '@testing-library/user-event';
-
-const mockPersons = [
-  {
-    uuid: 'randomuuid1',
-    display: 'John Doe',
-  },
-  {
-    uuid: 'randomuuid2',
-    display: 'John Smith',
-  },
-  {
-    uuid: 'randomuuid3',
-    display: 'James Smith',
-  },
-  {
-    uuid: 'randomuuid4',
-    display: 'Spider Man',
-  },
-];
-
-const mockedGetSearchResults = async (query: string) => {
-  return mockPersons.filter((person) => {
-    return person.display.toUpperCase().includes(query.toUpperCase());
-  });
-};
-
-const mockedHandleSuggestionSelected = jest.fn((field, value) => [field, value]);
-
-describe('Autosuggest', () => {
-  afterEach(() => mockedHandleSuggestionSelected.mockClear());
-
-  it('renders a search box', () => {
-    renderAutosuggest();
-
-    expect(screen.getByRole('searchbox')).toBeInTheDocument();
-    expect(screen.queryByRole('list')).toBeNull();
-  });
-
-  it('renders matching search results in a list when the user types a query', async () => {
-    const user = userEvent.setup();
-
-    renderAutosuggest();
-
-    const searchbox = screen.getByRole('searchbox');
-    await user.type(searchbox, 'john');
-
-    const list = screen.getByRole('list');
-
-    expect(list).toBeInTheDocument();
-    expect(list.children).toHaveLength(2);
-    expect(screen.getAllByRole('listitem')[0]).toHaveTextContent('John Doe');
-    expect(screen.getAllByRole('listitem')[1]).toHaveTextContent('John Smith');
-  });
-
-  it('clears the list of suggestions when a suggestion is selected', async () => {
-    const user = userEvent.setup();
-
-    renderAutosuggest();
-
-    let list = screen.queryByRole('list');
-    expect(list).toBeNull();
-
-    const searchbox = screen.getByRole('searchbox');
-    await user.type(searchbox, 'john');
-
-    list = screen.getByRole('list');
-    expect(list).toBeInTheDocument();
-
-    const listitems = screen.getAllByRole('listitem');
-    await user.click(listitems[0]);
-
-    expect(mockedHandleSuggestionSelected).toHaveBeenLastCalledWith('person', 'randomuuid1');
-
-    list = screen.queryByRole('list');
-    expect(list).toBeNull();
-  });
-
-  it('changes suggestions when a search input is changed', async () => {
-    const user = userEvent.setup();
-
-    renderAutosuggest();
-
-    let list = screen.queryByRole('list');
-    expect(list).toBeNull();
-
-    const searchbox = screen.getByRole('searchbox');
-    await user.type(searchbox, 'john');
-
-    const suggestion = await screen.findByText('John Doe');
-    expect(suggestion).toBeInTheDocument();
-
-    await user.clear(searchbox);
-
-    list = screen.queryByRole('list');
-    expect(list).toBeNull();
-  });
-
-  it('hides the list of suggestions when the user clicks outside of the component', async () => {
-    const user = userEvent.setup();
-
-    renderAutosuggest();
-
-    const input = screen.getByRole('searchbox');
-
-    await user.type(input, 'john');
-    await screen.findByText('John Doe');
-    await user.click(document.body);
-
-    expect(screen.queryByText('John Doe')).not.toBeInTheDocument();
-  });
-});
-
-function renderAutosuggest() {
-  render(
-    <BrowserRouter>
-      <Autosuggest
-        getSearchResults={mockedGetSearchResults}
-        getDisplayValue={(item) => item.display}
-        getFieldValue={(item) => item.uuid}
-        id="person"
-        labelText=""
-        onSuggestionSelected={mockedHandleSuggestionSelected}
-        placeholder="Find Person"
-      />
-    </BrowserRouter>,
-  );
-}

package/src/patient-registration/input/custom-input/identifier/identifier-input.test.tsx

@@ -1,107 +0,0 @@
-import React from 'react';
-import { render, screen } from '@testing-library/react';
-import { Formik, Form } from 'formik';
-import { IdentifierInput } from './identifier-input.component';
-import { initialFormValues } from '../../../patient-registration.component';
-import { type PatientIdentifierType } from '../../../patient-registration-types';
-
-jest.mock('@openmrs/esm-framework', () => {
-  const originalModule = jest.requireActual('@openmrs/esm-framework');
-
-  return {
-    ...originalModule,
-    validator: jest.fn(),
-  };
-});
-
-describe.skip('identifier input', () => {
-  const openmrsID = {
-    name: 'OpenMRS ID',
-    fieldName: 'openMrsId',
-    required: true,
-    uuid: '05a29f94-c0ed-11e2-94be-8c13b969e334',
-    format: null,
-    isPrimary: true,
-    identifierSources: [
-      {
-        uuid: '691eed12-c0f1-11e2-94be-8c13b969e334',
-        name: 'Generator 1 for OpenMRS ID',
-        autoGenerationOption: {
-          manualEntryEnabled: false,
-          automaticGenerationEnabled: true,
-        },
-      },
-      {
-        uuid: '01af8526-cea4-4175-aa90-340acb411771',
-        name: 'Generator 2 for OpenMRS ID',
-        autoGenerationOption: {
-          manualEntryEnabled: true,
-          automaticGenerationEnabled: true,
-        },
-      },
-    ],
-    autoGenerationSource: null,
-  };
-  const setupIdentifierInput = async (identifierType: PatientIdentifierType) => {
-    initialFormValues['source-for-' + identifierType.fieldName] = identifierType.identifierSources[0].name;
-    render(
-      <Formik initialValues={initialFormValues} onSubmit={null}>
-        <Form>
-          <IdentifierInput identifierType={identifierType} />
-        </Form>
-      </Formik>,
-    );
-    const identifierInput = screen.getByLabelText(identifierType.fieldName) as HTMLInputElement;
-    let identifierSourceSelectInput = screen.getByLabelText('source-for-' + identifierType.fieldName);
-    return {
-      identifierInput,
-      identifierSourceSelectInput,
-    };
-  };
-
-  it('exists', async () => {
-    const { identifierInput, identifierSourceSelectInput } = await setupIdentifierInput(openmrsID);
-    expect(identifierInput.type).toBe('text');
-    expect(identifierSourceSelectInput.type).toBe('select-one');
-  });
-
-  it('has correct props for identifier source select input', async () => {
-    const { identifierSourceSelectInput } = await setupIdentifierInput(openmrsID);
-    expect(identifierSourceSelectInput.childElementCount).toBe(3);
-    expect(identifierSourceSelectInput.value).toBe('Generator 1 for OpenMRS ID');
-  });
-
-  it('has correct props for identifier input', async () => {
-    const { identifierInput } = await setupIdentifierInput(openmrsID);
-    expect(identifierInput.placeholder).toBe('Auto-generated');
-    expect(identifierInput.disabled).toBe(true);
-  });
-
-  it('text input should not be disabled if manual entry is enabled', async () => {
-    // setup
-    openmrsID.identifierSources[0].autoGenerationOption.manualEntryEnabled = true;
-    // replay
-    const { identifierInput } = await setupIdentifierInput(openmrsID);
-    expect(identifierInput.placeholder).toBe('Auto-generated');
-    expect(identifierInput.disabled).toBe(false);
-  });
-
-  it('should not render select widget if auto-entry is false', async () => {
-    // setup
-    openmrsID.identifierSources = [
-      {
-        uuid: '691eed12-c0f1-11e2-94be-8c13b969e334',
-        name: 'Generator 1 for OpenMRS ID',
-        autoGenerationOption: {
-          manualEntryEnabled: true,
-          automaticGenerationEnabled: false,
-        },
-      },
-    ];
-    // replay
-    const { identifierInput, identifierSourceSelectInput } = await setupIdentifierInput(openmrsID);
-    expect(identifierInput.placeholder).toBe('Enter identifier');
-    expect(identifierInput.disabled).toBe(false);
-    expect(identifierSourceSelectInput).toBe(undefined);
-  });
-});