@zohodesk/library-platform 1.1.1 → 1.1.2

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

@@ -0,0 +1,168 @@
+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('Phone 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 Phone mandatory field and return error', () => {
+    const field = {
+      id: 'phone',
+      type: FieldTypes.Phone,
+      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 phone number and return true', () => {
+    const field = {
+      id: 'phone',
+      type: FieldTypes.Phone
+    };
+    const event = {
+      state,
+      updateState,
+      action: {
+        type: VALIDATE_FIELD,
+        payload: {
+          field,
+          value: '1234567890'
+        }
+      },
+      dispatch
+    };
+    behaviour.eventHandlers[VALIDATE_FIELD](event);
+    expect(dispatch).toHaveBeenCalledWith({
+      type: FIELD_VALIDATION_RESULT,
+      payload: {
+        validationResult: {
+          isValid: true,
+          message: ''
+        },
+        field
+      }
+    });
+  });
+  it('should validate invalid phone number and return false', () => {
+    const field = {
+      id: 'phone',
+      type: FieldTypes.Phone
+    };
+    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: 'Invalid phone number format'
+        },
+        field
+      }
+    });
+  });
+  it('should validate Phone field with valid max length and return no error', () => {
+    const field = {
+      id: 'phone',
+      type: FieldTypes.Phone,
+      maxLength: 10
+    };
+    const event = {
+      state,
+      updateState,
+      action: {
+        type: VALIDATE_FIELD,
+        payload: {
+          field,
+          value: '100234'
+        }
+      },
+      dispatch
+    };
+    behaviour.eventHandlers[VALIDATE_FIELD](event);
+    expect(dispatch).toHaveBeenCalledWith({
+      type: FIELD_VALIDATION_RESULT,
+      payload: {
+        validationResult: {
+          isValid: true,
+          message: ''
+        },
+        field
+      }
+    });
+  });
+  it('should validate Phone field with invalid max length and return error', () => {
+    const field = {
+      id: 'phone',
+      type: FieldTypes.Phone,
+      maxLength: 10
+    };
+    const event = {
+      state,
+      updateState,
+      action: {
+        type: VALIDATE_FIELD,
+        payload: {
+          field,
+          value: '192929292978'
+        }
+      },
+      dispatch
+    };
+    behaviour.eventHandlers[VALIDATE_FIELD](event);
+    expect(dispatch).toHaveBeenCalledWith({
+      type: FIELD_VALIDATION_RESULT,
+      payload: {
+        validationResult: {
+          isValid: false,
+          message: 'Field exceeds max length'
+        },
+        field
+      }
+    });
+  });
+});

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

@@ -0,0 +1,79 @@
+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('Picklist 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 Picklist mandatory field and return error', () => {
+    const field = {
+      id: 'picklist',
+      type: FieldTypes.Picklist,
+      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 Picklist and return true', () => {
+    const field = {
+      id: 'picklist',
+      type: FieldTypes.Picklist
+    };
+    const event = {
+      state,
+      updateState,
+      action: {
+        type: VALIDATE_FIELD,
+        payload: {
+          field,
+          value: 'option1'
+        }
+      },
+      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__/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
+      }
+    });
+  });
+});