(test) O3-3940: Add test coverage for the useEvaluateFormFieldExpressions hook

src/hooks/useEvaluateFormFieldExpressions.test.ts

@@ -0,0 +1,254 @@
+import { renderHook, act } from '@testing-library/react';
+import { useEvaluateFormFieldExpressions } from './useEvaluateFormFieldExpressions';
+import { type FormProcessorContextProps, type FormField } from '../types';
+import { evaluateExpression } from '../utils/expression-runner';
+import { evalConditionalRequired, evaluateConditionalAnswered, evaluateHide } from '../utils/form-helper';
+import { isEmpty } from '../validators/form-validator';
+
+// ---- MOCK DEPENDENCIES ----
+
+// Mock utility functions so we can control their behavior in tests
+jest.mock('../utils/expression-runner', () => ({
+  evaluateExpression: jest.fn(),
+}));
+jest.mock('../utils/form-helper', () => ({
+  evalConditionalRequired: jest.fn(),
+  evaluateConditionalAnswered: jest.fn(),
+  evaluateHide: jest.fn(),
+  isPageContentVisible: jest.fn(), // assume handled inside hook
+}));
+jest.mock('../validators/form-validator', () => ({
+  isEmpty: jest.fn(),
+}));
+jest.mock('../utils/common-utils', () => ({
+  updateFormSectionReferences: jest.fn((formJson) => formJson), // identity for simplicity
+}));
+
+// ---- TEST SUITE ----
+describe('useEvaluateFormFieldExpressions', () => {
+  // Mock form values that simulate user input
+  const mockFormValues = { field1: 'value1' };
+
+  // Minimal viable field with conditional expressions on required/readonly/etc.
+  const mockField: FormField = {
+    type: 'text',
+    id: 'field1',
+    required: true,
+    readonly: 'someExpression', // dynamic readonly field
+    questionOptions: {
+      answers: [
+        {
+          label: 'Yes',
+          value: 'yes',
+          hide: { hideWhenExpression: 'answerHideExpr' },
+          disable: { disableWhenExpression: 'answerDisableExpr', isDisabled: false },
+        },
+      ],
+      rendering: 'repeating',
+      repeatOptions: { limitExpression: 'limitExpr' },
+    },
+    validators: [{ type: 'conditionalAnswered' }],
+    meta: {},
+  };
+
+  // Mock context simulating a full form setup
+  const mockProcessorContext: FormProcessorContextProps = {
+    formJson: {
+      name: 'testForm',
+      pages: [
+        {
+          label: 'Page 1',
+          hide: { hideWhenExpression: 'pageHideExpr' },
+          sections: [
+            {
+              label: 'Section 1',
+              hide: { hideWhenExpression: 'sectionHideExpr' },
+              isExpanded: 'false',
+              questions: [mockField],
+            },
+          ],
+        },
+      ],
+      processor: undefined,
+      uuid: 'test uuid 0',
+      referencedForms: [],
+      encounterType: 'test encounter type',
+    },
+    formFields: [mockField],
+    patient: {},
+    sessionMode: 'enter',
+    visit: undefined,
+    sessionDate: undefined,
+    location: undefined,
+    currentProvider: undefined,
+    layoutType: 'phone',
+    processor: undefined,
+  };
+
+  // ---- SETUP/TEARDOWN ----
+
+  beforeEach(() => {
+    // Control mock return values before each test
+    (evaluateExpression as jest.Mock).mockReturnValue(true);
+    (evalConditionalRequired as jest.Mock).mockReturnValue(true);
+    (evaluateConditionalAnswered as jest.Mock).mockImplementation(() => {});
+    (evaluateHide as jest.Mock).mockImplementation((node) => {
+      node.value.isHidden = true;
+    });
+    (isEmpty as jest.Mock).mockReturnValue(false);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  // ---- MAIN TEST CASE ----
+  it('evaluates all expressions correctly and updates form state', async () => {
+    const { result } = renderHook(() =>
+      useEvaluateFormFieldExpressions(mockFormValues, mockProcessorContext),
+    );
+
+    // Wait for useEffect to run
+    await act(async () => {
+      await Promise.resolve();
+    });
+
+    const [evaluatedField] = result.current.evaluatedFields;
+
+    // Field-level assertions
+    expect(evaluatedField.isHidden).toBe(false);
+    expect(evaluatedField.isRequired).toBe(true);
+    expect(evaluatedField.isDisabled).toBe(false);
+    expect(evaluatedField.readonly).toBe(true);
+
+    // Answer-level assertions
+    expect(evaluatedField.questionOptions.answers?.[0].isHidden).toBe(true);
+    expect(evaluatedField.questionOptions.answers?.[0].disable.isDisabled).toBe(true);
+    expect(evaluatedField.questionOptions.repeatOptions?.limit).toBe(true);
+
+    // Overall form assertions
+    expect(result.current.evaluatedFormJson).toEqual(mockProcessorContext.formJson);
+    expect(result.current.evaluatedPagesVisibility).toBe(true);
+  });
+
+  // ---- EDGE CASES ----
+  describe('useEvaluateFormFieldExpressions edge cases', () => {
+    beforeEach(() => {
+      (evaluateExpression as jest.Mock).mockReturnValue(true);
+      (evalConditionalRequired as jest.Mock).mockReturnValue(true);
+      (evaluateConditionalAnswered as jest.Mock).mockImplementation(() => {});
+      (evaluateHide as jest.Mock).mockImplementation((node) => {
+        node.value.isHidden = true;
+      });
+      (isEmpty as jest.Mock).mockReturnValue(false);
+    });
+
+    afterEach(() => {
+      jest.clearAllMocks();
+    });
+
+    it('handles empty formFields gracefully', () => {
+      const processorContextEmptyFields: FormProcessorContextProps = {
+        ...mockProcessorContext,
+        formFields: [],
+      };
+
+      const { result } = renderHook(() =>
+        useEvaluateFormFieldExpressions(mockFormValues, processorContextEmptyFields),
+      );
+
+      expect(result.current.evaluatedFields).toEqual([]);
+      expect(result.current.evaluatedFormJson).toEqual(mockProcessorContext.formJson);
+    });
+
+    it('correctly evaluates when no hide expression is provided', () => {
+      const fieldNoHide: FormField = {
+        id: 'field3',
+        type: 'obs',
+        questionOptions: { rendering: null },
+      };
+      const contextNoHide = {
+        ...mockProcessorContext,
+        formFields: [fieldNoHide],
+      };
+
+      const { result } = renderHook(() =>
+        useEvaluateFormFieldExpressions(mockFormValues, contextNoHide),
+      );
+
+      expect(result.current.evaluatedFields[0].isHidden).toBe(false);
+    });
+
+    it('handles readonly expressions that are boolean strings as boolean strings', () => {
+      const fieldWithReadonlyTrue: FormField = {
+        id: 'field5',
+        type: 'obs',
+        questionOptions: { rendering: null },
+        readonly: 'true', // should remain a string
+      };
+
+      const contextReadonlyTrue = {
+        ...mockProcessorContext,
+        formFields: [fieldWithReadonlyTrue],
+      };
+
+      const { result } = renderHook(() =>
+        useEvaluateFormFieldExpressions(mockFormValues, contextReadonlyTrue),
+      );
+
+      expect(result.current.evaluatedFields[0].readonly).toBe('true');
+    });
+
+    it('handles readonly expressions that are non-boolean strings', () => {
+      const fieldWithReadonlyExpr: FormField = {
+        id: 'field6',
+        type: 'obs',
+        questionOptions: { rendering: null },
+        readonly: 'someExpression',
+        meta: {},
+      };
+
+      const contextReadonlyExpr = {
+        ...mockProcessorContext,
+        formFields: [fieldWithReadonlyExpr],
+      };
+
+      (evaluateExpression as jest.Mock).mockReturnValueOnce(false);
+
+      const { result } = renderHook(() =>
+        useEvaluateFormFieldExpressions(mockFormValues, contextReadonlyExpr),
+      );
+
+      expect(result.current.evaluatedFields[0].meta.readonlyExpression).toBe('someExpression');
+      expect(result.current.evaluatedFields[0].readonly).toBe(false);
+    });
+
+    it('handles answers without hide or disable expressions', () => {
+      const fieldWithSimpleAnswers: FormField = {
+        id: 'field7',
+        type: 'testType',
+        questionOptions: {
+          answers: [
+            { label: 'Option 1', value: 'opt1' },
+            { label: 'Option 2', value: 'opt2' },
+          ],
+          rendering: 'radio',
+        },
+      };
+
+      const contextSimpleAnswers = {
+        ...mockProcessorContext,
+        formFields: [fieldWithSimpleAnswers],
+      };
+
+      (isEmpty as jest.Mock).mockReturnValue(true); // simulate no hide/disable logic
+
+      const { result } = renderHook(() =>
+        useEvaluateFormFieldExpressions(mockFormValues, contextSimpleAnswers),
+      );
+
+      expect(result.current.evaluatedFields[0].questionOptions.answers[0].isHidden).toBeUndefined();
+      expect(result.current.evaluatedFields[0].questionOptions.answers[0].disable).toBeUndefined();
+    });
+  });
+});