@zohodesk/library-platform 1.1.1 → 1.1.2-exp.0

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

@@ -0,0 +1,170 @@
+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('TextArea 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 TextArea mandatory field and return error', () => {
+    const field = {
+      id: 'textarea',
+      type: FieldTypes.TextArea,
+      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 TextArea mandatory field with empty space and return error', () => {
+    const field = {
+      id: 'textarea',
+      type: FieldTypes.TextArea,
+      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 TextArea valid value and return no error', () => {
+    const field = {
+      id: 'textarea',
+      type: FieldTypes.TextArea,
+      required: true
+    };
+    const event = {
+      state,
+      updateState,
+      action: {
+        type: VALIDATE_FIELD,
+        payload: {
+          field,
+          value: 'Sample Text'
+        }
+      },
+      dispatch
+    };
+    behaviour.eventHandlers[VALIDATE_FIELD](event);
+    expect(dispatch).toHaveBeenCalledWith({
+      type: FIELD_VALIDATION_RESULT,
+      payload: {
+        validationResult: {
+          isValid: true,
+          message: ''
+        },
+        field
+      }
+    });
+  });
+  it('should validate TextArea max length and return error', () => {
+    const field = {
+      id: 'textarea',
+      type: FieldTypes.TextArea,
+      maxLength: 10
+    };
+    const event = {
+      state,
+      updateState,
+      action: {
+        type: VALIDATE_FIELD,
+        payload: {
+          field,
+          value: 'This text is too long'
+        }
+      },
+      dispatch
+    };
+    behaviour.eventHandlers[VALIDATE_FIELD](event);
+    expect(dispatch).toHaveBeenCalledWith({
+      type: FIELD_VALIDATION_RESULT,
+      payload: {
+        validationResult: {
+          isValid: false,
+          message: 'Field exceeds max length'
+        },
+        field
+      }
+    });
+  });
+  it('should validate TextArea valid max length and return no error', () => {
+    const field = {
+      id: 'textarea',
+      type: FieldTypes.TextArea,
+      maxLength: 20
+    };
+    const event = {
+      state,
+      updateState,
+      action: {
+        type: VALIDATE_FIELD,
+        payload: {
+          field,
+          value: 'Sample Text'
+        }
+      },
+      dispatch
+    };
+    behaviour.eventHandlers[VALIDATE_FIELD](event);
+    expect(dispatch).toHaveBeenCalledWith({
+      type: FIELD_VALIDATION_RESULT,
+      payload: {
+        validationResult: {
+          isValid: true,
+          message: ''
+        },
+        field
+      }
+    });
+  });
+});

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

@@ -0,0 +1,170 @@
+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('TextBox 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 TextBox mandatory field and return error', () => {
+    const field = {
+      id: 'text',
+      type: FieldTypes.TextBox,
+      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 TextBox mandatory field with empty space and return error', () => {
+    const field = {
+      id: 'text',
+      type: FieldTypes.TextBox,
+      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 TextBox valid value and return no error', () => {
+    const field = {
+      id: 'text',
+      type: FieldTypes.TextBox,
+      required: true
+    };
+    const event = {
+      state,
+      updateState,
+      action: {
+        type: VALIDATE_FIELD,
+        payload: {
+          field,
+          value: 'Sample Text'
+        }
+      },
+      dispatch
+    };
+    behaviour.eventHandlers[VALIDATE_FIELD](event);
+    expect(dispatch).toHaveBeenCalledWith({
+      type: FIELD_VALIDATION_RESULT,
+      payload: {
+        validationResult: {
+          isValid: true,
+          message: ''
+        },
+        field
+      }
+    });
+  });
+  it('should validate TextBox max length and return error', () => {
+    const field = {
+      id: 'text',
+      type: FieldTypes.TextBox,
+      maxLength: 10
+    };
+    const event = {
+      state,
+      updateState,
+      action: {
+        type: VALIDATE_FIELD,
+        payload: {
+          field,
+          value: 'This text is too long'
+        }
+      },
+      dispatch
+    };
+    behaviour.eventHandlers[VALIDATE_FIELD](event);
+    expect(dispatch).toHaveBeenCalledWith({
+      type: FIELD_VALIDATION_RESULT,
+      payload: {
+        validationResult: {
+          isValid: false,
+          message: 'Field exceeds max length'
+        },
+        field
+      }
+    });
+  });
+  it('should validate TextBox valid max length and return no error', () => {
+    const field = {
+      id: 'text',
+      type: FieldTypes.TextBox,
+      maxLength: 20
+    };
+    const event = {
+      state,
+      updateState,
+      action: {
+        type: VALIDATE_FIELD,
+        payload: {
+          field,
+          value: 'Sample Text'
+        }
+      },
+      dispatch
+    };
+    behaviour.eventHandlers[VALIDATE_FIELD](event);
+    expect(dispatch).toHaveBeenCalledWith({
+      type: FIELD_VALIDATION_RESULT,
+      payload: {
+        validationResult: {
+          isValid: true,
+          message: ''
+        },
+        field
+      }
+    });
+  });
+});

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
+  };
+}