@zohodesk/library-platform 1.1.1 → 1.1.2

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

@@ -0,0 +1,171 @@
+import FieldValidationBehaviourFactory from "../FieldValidationBehaviourFactory";
+import ValidationsEnum from "../../../domain/interfaces/ValidationsEnum";
+import { VALIDATE_FIELD, FIELD_VALIDATION_RESULT } from "../../../../../../bc/field-validation/Constants";
+import FieldTypes from "../../../../../../bc/field-validation/FieldTypes";
+describe('FieldValidationBehaviour', () => {
+  let behaviour;
+  let state;
+  let updateState;
+  let dispatch;
+  beforeEach(() => {
+    behaviour = FieldValidationBehaviourFactory.create();
+    state = {
+      properties: {
+        validations: {
+          [ValidationsEnum.mandatory]: value => {
+            if (!value) {
+              return {
+                isValid: false,
+                message: 'This field is required'
+              };
+            }
+
+            return {
+              isValid: true,
+              message: ''
+            };
+          },
+          [ValidationsEnum.email]: value => {
+            if (!value.includes('@')) {
+              return {
+                isValid: false,
+                message: 'Invalid email format'
+              };
+            }
+
+            return {
+              isValid: true,
+              message: ''
+            };
+          }
+        }
+      }
+    };
+    updateState = jest.fn();
+    dispatch = jest.fn();
+  });
+  it('should validate field and dispatch result with errors for invalid input', () => {
+    const field = {
+      id: 'email',
+      type: FieldTypes.Email
+    };
+    const event = {
+      state,
+      updateState,
+      action: {
+        type: VALIDATE_FIELD,
+        payload: {
+          field,
+          value: 'invalid-email'
+        }
+      },
+      dispatch
+    };
+    behaviour.eventHandlers[VALIDATE_FIELD](event);
+    expect(dispatch).toHaveBeenCalledWith({
+      type: FIELD_VALIDATION_RESULT,
+      payload: {
+        validationResult: {
+          isValid: false,
+          message: 'Invalid email format'
+        },
+        field
+      }
+    });
+  });
+  it('should validate field and dispatch result with no errors for valid input', () => {
+    const field = {
+      id: 'email',
+      type: FieldTypes.Email
+    };
+    const event = {
+      state,
+      updateState,
+      action: {
+        type: VALIDATE_FIELD,
+        payload: {
+          field,
+          value: 'test@email.com'
+        }
+      },
+      dispatch
+    };
+    behaviour.eventHandlers[VALIDATE_FIELD](event);
+    expect(dispatch).toHaveBeenCalledWith({
+      type: FIELD_VALIDATION_RESULT,
+      payload: {
+        validationResult: {
+          isValid: true,
+          message: ''
+        },
+        field
+      }
+    });
+  });
+  it('should return same reference metadata dispatch with result when errors for invalid input', () => {
+    const metadata = {};
+    const field = {
+      id: 'email',
+      type: FieldTypes.Email
+    };
+    const event = {
+      state,
+      updateState,
+      action: {
+        type: VALIDATE_FIELD,
+        payload: {
+          field,
+          value: 'invalid-email'
+        },
+        metadata
+      },
+      dispatch
+    };
+    behaviour.eventHandlers[VALIDATE_FIELD](event);
+    expect(dispatch).toHaveBeenCalledWith({
+      type: FIELD_VALIDATION_RESULT,
+      payload: {
+        validationResult: {
+          isValid: false,
+          message: 'Invalid email format'
+        },
+        field
+      },
+      metadata
+    });
+    expect(dispatch.mock.calls[0][0].metadata).toBe(metadata);
+  });
+  it('should return same reference metadata dispatch with result when no errors for valid input', () => {
+    const metadata = {};
+    const field = {
+      id: 'email',
+      type: FieldTypes.Email
+    };
+    const event = {
+      state,
+      updateState,
+      action: {
+        type: VALIDATE_FIELD,
+        payload: {
+          field,
+          value: 'test@email.com'
+        },
+        metadata
+      },
+      dispatch
+    };
+    behaviour.eventHandlers[VALIDATE_FIELD](event);
+    expect(dispatch).toHaveBeenCalledWith({
+      type: FIELD_VALIDATION_RESULT,
+      payload: {
+        validationResult: {
+          isValid: true,
+          message: ''
+        },
+        field
+      },
+      metadata
+    });
+    expect(dispatch.mock.calls[0][0].metadata).toBe(metadata);
+  });
+});

package/es/library/behaviours/field-validation/frameworks/ui/__tests__/IntegerFieldValidation.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('Integer 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 Integer mandatory field and return error', () => {
+    const field = {
+      id: 'integer',
+      type: FieldTypes.Integer,
+      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 integer and return true', () => {
+    const field = {
+      id: 'integer',
+      type: FieldTypes.Integer
+    };
+    const event = {
+      state,
+      updateState,
+      action: {
+        type: VALIDATE_FIELD,
+        payload: {
+          field,
+          value: '123'
+        }
+      },
+      dispatch
+    };
+    behaviour.eventHandlers[VALIDATE_FIELD](event);
+    expect(dispatch).toHaveBeenCalledWith({
+      type: FIELD_VALIDATION_RESULT,
+      payload: {
+        validationResult: {
+          isValid: true,
+          message: ''
+        },
+        field
+      }
+    });
+  });
+  it('should validate invalid integer and return false', () => {
+    const field = {
+      id: 'integer',
+      type: FieldTypes.Integer
+    };
+    const event = {
+      state,
+      updateState,
+      action: {
+        type: VALIDATE_FIELD,
+        payload: {
+          field,
+          value: '123.45'
+        }
+      },
+      dispatch
+    };
+    behaviour.eventHandlers[VALIDATE_FIELD](event);
+    expect(dispatch).toHaveBeenCalledWith({
+      type: FIELD_VALIDATION_RESULT,
+      payload: {
+        validationResult: {
+          isValid: false,
+          message: 'Invalid integer format'
+        },
+        field
+      }
+    });
+  });
+  it('should validate Integer field with valid max length and return no error', () => {
+    const field = {
+      id: 'integer',
+      type: FieldTypes.Integer,
+      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 Integer field with invalid max length and return error', () => {
+    const field = {
+      id: 'integer',
+      type: FieldTypes.Integer,
+      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__/LookUpFieldValidation.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('LookUp 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 LookUp mandatory field and return error', () => {
+    const field = {
+      id: 'lookup',
+      type: FieldTypes.LookUp,
+      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 be valid LookUp when value is selected and return true', () => {
+    const field = {
+      id: 'lookup',
+      type: FieldTypes.LookUp
+    };
+    const event = {
+      state,
+      updateState,
+      action: {
+        type: VALIDATE_FIELD,
+        payload: {
+          field,
+          value: 'selectedValue'
+        }
+      },
+      dispatch
+    };
+    behaviour.eventHandlers[VALIDATE_FIELD](event);
+    expect(dispatch).toHaveBeenCalledWith({
+      type: FIELD_VALIDATION_RESULT,
+      payload: {
+        validationResult: {
+          isValid: true,
+          message: ''
+        },
+        field
+      }
+    });
+  });
+  xit('should validate invalid LookUp and return false', () => {
+    const field = {
+      id: 'lookup',
+      type: FieldTypes.LookUp
+    };
+    const event = {
+      state,
+      updateState,
+      action: {
+        type: VALIDATE_FIELD,
+        payload: {
+          field,
+          value: 'invalid'
+        }
+      },
+      dispatch
+    };
+    behaviour.eventHandlers[VALIDATE_FIELD](event);
+    expect(dispatch).toHaveBeenCalledWith({
+      type: FIELD_VALIDATION_RESULT,
+      payload: {
+        validationResult: {
+          isValid: false,
+          message: 'Invalid LookUp format'
+        },
+        field
+      }
+    });
+  });
+});

package/es/library/behaviours/field-validation/frameworks/ui/__tests__/MultiSelectFieldValidation.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('MultiSelect 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 MultiSelect mandatory field and return error', () => {
+    const field = {
+      id: 'multiSelect',
+      type: FieldTypes.MultiSelect,
+      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 MultiSelect and return true', () => {
+    const field = {
+      id: 'multiSelect',
+      type: FieldTypes.MultiSelect
+    };
+    const event = {
+      state,
+      updateState,
+      action: {
+        type: VALIDATE_FIELD,
+        payload: {
+          field,
+          value: ['option1', 'option2']
+        }
+      },
+      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__/PercentFieldValidation.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('Percent 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 Percent mandatory field and return error', () => {
+    const field = {
+      id: 'percent',
+      type: FieldTypes.Percent,
+      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 Percent and return true', () => {
+    const field = {
+      id: 'percent',
+      type: FieldTypes.Percent
+    };
+    const event = {
+      state,
+      updateState,
+      action: {
+        type: VALIDATE_FIELD,
+        payload: {
+          field,
+          value: '50'
+        }
+      },
+      dispatch
+    };
+    behaviour.eventHandlers[VALIDATE_FIELD](event);
+    expect(dispatch).toHaveBeenCalledWith({
+      type: FIELD_VALIDATION_RESULT,
+      payload: {
+        validationResult: {
+          isValid: true,
+          message: ''
+        },
+        field
+      }
+    });
+  });
+  it('should validate invalid Percent and return false', () => {
+    const field = {
+      id: 'percent',
+      type: FieldTypes.Percent
+    };
+    const event = {
+      state,
+      updateState,
+      action: {
+        type: VALIDATE_FIELD,
+        payload: {
+          field,
+          value: 'dsd'
+        }
+      },
+      dispatch
+    };
+    behaviour.eventHandlers[VALIDATE_FIELD](event);
+    expect(dispatch).toHaveBeenCalledWith({
+      type: FIELD_VALIDATION_RESULT,
+      payload: {
+        validationResult: {
+          isValid: false,
+          message: 'Invalid percent value'
+        },
+        field
+      }
+    });
+  });
+});