@zohodesk/library-platform 1.1.9-exp.1 → 1.1.10

package/es/library/behaviours/field-validation/frameworks/ui/__tests__/URLFieldValidation.test.js

@@ -0,0 +1,108 @@
+import { VALIDATE_FIELD, FIELD_VALIDATION_RESULT } from "../../../../../../bc/field-validation/Constants";
+import FieldValidationBehaviourFactory from "../FieldValidationBehaviourFactory";
+import { validations } from "../../utils/FormBasicValidationAdaptor";
+import FieldTypes from "../../../../../../bc/field-validation/FieldTypes";
+describe('URL FieldValidationBehaviour', () => {
+  let behaviour;
+  let state;
+  let updateState;
+  let dispatch;
+  beforeEach(() => {
+    behaviour = FieldValidationBehaviourFactory.create();
+    state = {
+      properties: {
+        validations
+      }
+    };
+    updateState = jest.fn();
+    dispatch = jest.fn();
+  });
+  it('should validate URL mandatory field and return error', () => {
+    const field = {
+      id: 'url',
+      type: FieldTypes.URL,
+      required: true
+    };
+    const event = {
+      state,
+      updateState,
+      action: {
+        type: VALIDATE_FIELD,
+        payload: {
+          field,
+          value: ''
+        }
+      },
+      dispatch
+    };
+    behaviour.eventHandlers[VALIDATE_FIELD](event);
+    expect(dispatch).toHaveBeenCalledWith({
+      type: FIELD_VALIDATION_RESULT,
+      payload: {
+        validationResult: {
+          isValid: false,
+          message: 'This field is required.'
+        },
+        field
+      }
+    });
+  });
+  it('should validate valid URL and return true', () => {
+    const field = {
+      id: 'url',
+      type: FieldTypes.URL
+    };
+    const event = {
+      state,
+      updateState,
+      action: {
+        type: VALIDATE_FIELD,
+        payload: {
+          field,
+          value: 'http://example.com'
+        }
+      },
+      dispatch
+    };
+    behaviour.eventHandlers[VALIDATE_FIELD](event);
+    expect(dispatch).toHaveBeenCalledWith({
+      type: FIELD_VALIDATION_RESULT,
+      payload: {
+        validationResult: {
+          isValid: true,
+          message: ''
+        },
+        field
+      }
+    });
+  });
+  xit('should validate invalid URL and return false', () => {
+    const field = {
+      id: 'url',
+      type: FieldTypes.URL
+    };
+    const event = {
+      state,
+      updateState,
+      action: {
+        type: VALIDATE_FIELD,
+        payload: {
+          field,
+          value: 'invalid-url'
+        }
+      },
+      dispatch
+    };
+    behaviour.eventHandlers[VALIDATE_FIELD](event);
+    expect(dispatch).toHaveBeenCalledWith({
+      type: FIELD_VALIDATION_RESULT,
+      payload: {
+        validationResult: {
+          isValid: false,
+          message: 'Invalid URL format'
+        },
+        field
+      }
+    });
+  });
+});

package/es/library/behaviours/field-validation/frameworks/utils/FormBasicValidationAdaptor.js

@@ -0,0 +1,228 @@
+// @ts-ignore
+import { fieldValidate } from "./formValidate";
+import ValidationsEnum from "../../domain/interfaces/ValidationsEnum";
+export const validations = {
+  // NOTE: special validations
+  [ValidationsEnum.mandatory]: mandatory,
+  [ValidationsEnum.maxLength]: maxLength,
+  [ValidationsEnum.decimalPlaces]: decimalPlaces,
+  // NOTE: type based validations
+  [ValidationsEnum.text]: text,
+  [ValidationsEnum.textArea]: textArea,
+  [ValidationsEnum.email]: email,
+  [ValidationsEnum.phone]: phone,
+  [ValidationsEnum.integer]: integer,
+  [ValidationsEnum.decimal]: decimal,
+  [ValidationsEnum.date]: date,
+  [ValidationsEnum.dateTime]: dateTime,
+  [ValidationsEnum.boolean]: boolean,
+  [ValidationsEnum.multiSelect]: multiSelect,
+  [ValidationsEnum.picklist]: picklist,
+  [ValidationsEnum.percent]: percent,
+  [ValidationsEnum.currency]: currency,
+  [ValidationsEnum.url]: url
+};
+
+function mandatory(value, _ref) {
+  let {
+    type
+  } = _ref;
+  const fieldDetails = {
+    type,
+    isMandatory: true
+  };
+  const result = fieldValidate(value, fieldDetails);
+  return {
+    isValid: !result.isError,
+    message: 'This field is required.'
+  };
+}
+
+function maxLength(value, _ref2) {
+  let {
+    maxLength
+  } = _ref2;
+  const fieldDetails = {
+    type: 'Text',
+    maxLength
+  };
+  const result = fieldValidate(value, fieldDetails);
+  return {
+    isValid: !result.isError,
+    message: 'Field exceeds max length'
+  };
+}
+
+function decimalPlaces(value, _ref3) {
+  let {
+    decimalPlaces
+  } = _ref3;
+  const fieldDetails = {
+    type: 'Decimal',
+    decimalPlaces
+  };
+  const result = fieldValidate(value, fieldDetails);
+  return {
+    isValid: !result.isError,
+    message: 'Invalid decimal places'
+  };
+}
+
+function text(value) {
+  const fieldDetails = {
+    type: 'Text'
+  };
+  const result = fieldValidate(value, fieldDetails);
+  return {
+    isValid: !result.isError,
+    message: result.message
+  };
+}
+
+function textArea(value) {
+  const fieldDetails = {
+    type: 'Textarea'
+  };
+  const result = fieldValidate(value, fieldDetails);
+  return {
+    isValid: !result.isError,
+    message: result.message
+  };
+}
+
+function email(value) {
+  const fieldDetails = {
+    type: 'Email'
+  };
+  const result = fieldValidate(value, fieldDetails);
+  return {
+    isValid: !result.isError,
+    message: 'Invalid email format'
+  };
+}
+
+function phone(value) {
+  const fieldDetails = {
+    type: 'Phone'
+  };
+  const result = fieldValidate(value, fieldDetails);
+  return {
+    isValid: !result.isError,
+    message: 'Invalid phone number format'
+  };
+}
+
+function integer(value) {
+  const fieldDetails = {
+    type: 'Number'
+  };
+  const result = fieldValidate(value, fieldDetails);
+  return {
+    isValid: !result.isError,
+    message: 'Invalid integer format'
+  };
+}
+
+function decimal(value) {
+  // NOTE: for Decimal, decimalPlaces is must in fieldValidate. So we handled in adaptor side
+  const fieldDetails = {
+    type: 'Decimal',
+    decimalPlaces: 1000
+  };
+  const result = fieldValidate(value, fieldDetails);
+  return {
+    isValid: !result.isError,
+    message: 'Invalid decimal format'
+  };
+}
+
+function date(value) {
+  const fieldDetails = {
+    type: 'Date'
+  };
+  const result = fieldValidate(value, fieldDetails); // NOTE: data field returns true even for invalid date format
+
+  return {
+    isValid: !result.isError,
+    message: 'Invalid date format'
+  };
+}
+
+function dateTime(value) {
+  const fieldDetails = {
+    type: 'DateTime'
+  };
+  const result = fieldValidate(value, fieldDetails); // NOTE: data field returns true even for invalid date time format
+
+  return {
+    isValid: !result.isError,
+    message: 'Invalid datetime format'
+  };
+}
+
+function boolean(value) {
+  const fieldDetails = {
+    type: 'Boolean'
+  };
+  const result = fieldValidate(value, fieldDetails); // NOTE: need to fix invalid value
+
+  return {
+    isValid: !result.isError,
+    message: 'Invalid boolean format'
+  };
+}
+
+function multiSelect(value) {
+  const fieldDetails = {
+    type: 'Multiselect'
+  };
+  const result = fieldValidate(value, fieldDetails);
+  return {
+    isValid: !result.isError,
+    message: result.message
+  };
+}
+
+function picklist(value) {
+  const fieldDetails = {
+    type: 'Picklist'
+  };
+  const result = fieldValidate(value, fieldDetails);
+  return {
+    isValid: !result.isError,
+    message: result.message
+  };
+}
+
+function percent(value) {
+  const fieldDetails = {
+    type: 'Percent'
+  };
+  const result = fieldValidate(value, fieldDetails);
+  return {
+    isValid: !result.isError,
+    message: "Invalid percent value"
+  };
+}
+
+function currency(value) {
+  const fieldDetails = {
+    type: 'Currency'
+  };
+  const result = fieldValidate(value, fieldDetails);
+  return {
+    isValid: !result.isError,
+    message: result.message
+  };
+}
+
+function url(value) {
+  const fieldDetails = {
+    type: 'URL'
+  };
+  const result = fieldValidate(value, fieldDetails);
+  return {
+    isValid: !result.isError,
+    message: result.message
+  };
+}

package/es/library/behaviours/field-validation/frameworks/utils/__tests__/formValidate.test.js

@@ -0,0 +1,284 @@
+// import { fieldValidate, validator } from '../../utils/fieldValidate';
+import { fieldValidate } from "../formValidate";
+describe('fieldValidate', () => {
+  test('Validate empty string', () => {
+    const fieldDetails = {
+      type: 'Text',
+      isMandatory: true
+    };
+    const result = fieldValidate('', fieldDetails);
+    expect(result.isError).toBe(true);
+    expect(result.message).toBe('crm.field.empty.check');
+  });
+  test('Validate non-empty string', () => {
+    const fieldDetails = {
+      type: 'Text',
+      isMandatory: true
+    };
+    const result = fieldValidate('test', fieldDetails);
+    expect(result.isError).toBe(false);
+  });
+  test('Validate empty array', () => {
+    const fieldDetails = {
+      type: 'Multiselect',
+      isMandatory: true
+    };
+    const result = fieldValidate([], fieldDetails);
+    expect(result.isError).toBe(true);
+    expect(result.message).toBe('crm.field.empty.check');
+  });
+  test('Validate non-empty array', () => {
+    const fieldDetails = {
+      type: 'Multiselect',
+      isMandatory: true
+    };
+    const result = fieldValidate(['item'], fieldDetails);
+    expect(result.isError).toBe(false);
+  });
+  test('Validate empty object', () => {
+    const fieldDetails = {
+      type: 'Object',
+      isMandatory: true
+    };
+    const result = fieldValidate({}, fieldDetails);
+    expect(result.isError).toBe(true);
+    expect(result.message).toBe('crm.field.empty.check');
+  });
+  test('Validate non-empty object', () => {
+    const fieldDetails = {
+      type: 'Object',
+      isMandatory: true
+    };
+    const result = fieldValidate({
+      key: 'value'
+    }, fieldDetails);
+    expect(result.isError).toBe(false);
+  });
+  test('Validate valid email', () => {
+    const fieldDetails = {
+      type: 'Email'
+    };
+    const result = fieldValidate('test@example.com', fieldDetails);
+    expect(result.isError).toBe(false);
+  });
+  test('Validate invalid email', () => {
+    const fieldDetails = {
+      type: 'Email'
+    };
+    const result = fieldValidate('invalid-email', fieldDetails);
+    expect(result.isError).toBe(true);
+    expect(result.message).toBe('crm.field.valid.check');
+  });
+  test('Validate valid phone number', () => {
+    const fieldDetails = {
+      type: 'Phone'
+    };
+    const result = fieldValidate('+1234567890', fieldDetails);
+    expect(result.isError).toBe(false);
+  });
+  test('Validate invalid phone number', () => {
+    const fieldDetails = {
+      type: 'Phone'
+    };
+    const result = fieldValidate('***-***-****', fieldDetails);
+    expect(result.isError).toBe(true);
+    expect(result.message).toBe('crm.field.valid.check');
+  });
+  test('Validate valid integer', () => {
+    const fieldDetails = {
+      type: 'Number'
+    };
+    const result = fieldValidate(123, fieldDetails);
+    expect(result.isError).toBe(false);
+  });
+  test('Validate invalid integer', () => {
+    const fieldDetails = {
+      type: 'Number'
+    };
+    const result = fieldValidate('123.45', fieldDetails);
+    expect(result.isError).toBe(true);
+    expect(result.message).toBe('crm.field.valid.check');
+  });
+  test('Validate valid decimal', () => {
+    const fieldDetails = {
+      type: 'Decimal',
+      decimalPlaces: 2
+    }; // NOTE: as per formValidate.js, the decimalPlaces is must for Decimal Field
+
+    const result = fieldValidate(123.45, fieldDetails);
+    expect(result.isError).toBe(false);
+  });
+  test('Validate invalid decimal', () => {
+    const fieldDetails = {
+      type: 'Decimal'
+    };
+    const result = fieldValidate('invalid-decimal', fieldDetails);
+    expect(result.isError).toBe(true);
+    expect(result.message).toBe('crm.field.valid.check');
+  });
+  test('Validate valid date', () => {
+    const fieldDetails = {
+      type: 'Date'
+    };
+    const result = fieldValidate('2025-02-11T00:00:00Z', fieldDetails);
+    expect(result.isError).toBe(false);
+  });
+  test.skip('Validate invalid date', () => {
+    const fieldDetails = {
+      type: 'Date'
+    };
+    const result = fieldValidate('invalid-date', fieldDetails);
+    expect(result.isError).toBe(true);
+    expect(result.message).toBe('crm.field.valid.check');
+  });
+  test('Validate mandatory field', () => {
+    const fieldDetails = {
+      type: 'Text',
+      isMandatory: true
+    };
+    const result = fieldValidate('', fieldDetails);
+    expect(result.isError).toBe(true);
+    expect(result.message).toBe('crm.field.empty.check');
+  });
+  test('Validate field with max length', () => {
+    const fieldDetails = {
+      type: 'Text',
+      maxLength: 3
+    };
+    const result = fieldValidate('test', fieldDetails);
+    expect(result.isError).toBe(true);
+    expect(result.message).toBe('support.form.more.than.max.length');
+  });
+  test('Validate field with valid length', () => {
+    const fieldDetails = {
+      type: 'Text',
+      maxLength: 5
+    };
+    const result = fieldValidate('test', fieldDetails);
+    expect(result.isError).toBe(false);
+  });
+  test('Validate valid decimal places', () => {
+    const fieldDetails = {
+      type: 'Decimal',
+      decimalPlaces: 2
+    };
+    const result = fieldValidate(123.45, fieldDetails);
+    expect(result.isError).toBe(false);
+  });
+  test('Validate invalid decimal places', () => {
+    const fieldDetails = {
+      type: 'Decimal',
+      decimalPlaces: 2
+    };
+    const result = fieldValidate(123.456, fieldDetails);
+    expect(result.isError).toBe(true);
+    expect(result.message).toBe('support.form.decimal.places.length.error.message');
+  });
+  test('Validate empty multi-select', () => {
+    const fieldDetails = {
+      type: 'Multiselect',
+      isMandatory: true
+    };
+    const result = fieldValidate([], fieldDetails);
+    expect(result.isError).toBe(true);
+    expect(result.message).toBe('crm.field.empty.check');
+  });
+  test('Validate non-empty multi-select', () => {
+    const fieldDetails = {
+      type: 'Multiselect',
+      isMandatory: true
+    };
+    const result = fieldValidate(['item'], fieldDetails);
+    expect(result.isError).toBe(false);
+  });
+  test('Validate empty multi-select with -None- value', () => {
+    const fieldDetails = {
+      type: 'Multiselect',
+      isMandatory: true
+    };
+    const result = fieldValidate(['-None-'], fieldDetails);
+    expect(result.isError).toBe(true);
+    expect(result.message).toBe('crm.field.empty.check');
+  });
+  test('Validate non-empty multi-select with -None- value', () => {
+    const fieldDetails = {
+      type: 'Multiselect',
+      isMandatory: true
+    };
+    const result = fieldValidate(['item', '-None-'], fieldDetails);
+    expect(result.isError).toBe(false);
+  });
+  test('Validate empty picklist', () => {
+    const fieldDetails = {
+      type: 'Picklist',
+      isMandatory: true
+    };
+    const result = fieldValidate('', fieldDetails);
+    expect(result.isError).toBe(true);
+    expect(result.message).toBe('crm.field.empty.check');
+  });
+  test('Validate non-empty picklist', () => {
+    const fieldDetails = {
+      type: 'Picklist',
+      isMandatory: true
+    };
+    const result = fieldValidate('item', fieldDetails);
+    expect(result.isError).toBe(false);
+  });
+  test('Validate empty picklist with -None- value', () => {
+    const fieldDetails = {
+      type: 'Picklist',
+      isMandatory: true
+    };
+    const result = fieldValidate('-None-', fieldDetails);
+    expect(result.isError).toBe(true);
+    expect(result.message).toBe('crm.field.empty.check');
+  });
+  test('Validate non-empty picklist with -None- value', () => {
+    const fieldDetails = {
+      type: 'Picklist',
+      isMandatory: true
+    };
+    const result = fieldValidate('item', fieldDetails);
+    expect(result.isError).toBe(false);
+  });
+  test('Validate empty boolean field', () => {
+    const fieldDetails = {
+      type: 'Boolean',
+      isMandatory: true
+    };
+    const result = fieldValidate(false, fieldDetails);
+    expect(result.isError).toBe(true);
+    expect(result.message).toBe('crm.field.empty.check');
+  });
+  test('Validate valid website', () => {
+    const fieldDetails = {
+      type: 'URL'
+    };
+    const result = fieldValidate('htt' + 'p://example.com', fieldDetails);
+    expect(result.isError).toBe(false);
+  });
+  test.skip('Validate invalid website', () => {
+    const fieldDetails = {
+      type: 'URL'
+    };
+    const result = fieldValidate('invalid-url', fieldDetails);
+    expect(result.isError).toBe(true);
+    expect(result.message).toBe('crm.field.valid.check');
+  });
+  test('Validate valid URL', () => {
+    const fieldDetails = {
+      type: 'URL'
+    };
+    const result = fieldValidate('htt' + 'p://example.com', fieldDetails);
+    expect(result.isError).toBe(false);
+  });
+  test.skip('Validate invalid URL', () => {
+    const fieldDetails = {
+      type: 'URL'
+    };
+    const result = fieldValidate('invalid-url', fieldDetails);
+    expect(result.isError).toBe(true);
+    expect(result.message).toBe('crm.field.valid.check');
+  });
+});