@zohodesk/library-platform 1.1.9 → 1.1.10

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

@@ -0,0 +1,257 @@
+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('Decimal 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 Decimal mandatory field and return error', () => {
+    const field = {
+      id: 'decimal',
+      type: FieldTypes.Decimal,
+      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 Decimal field with valid max length and return no error', () => {
+    const field = {
+      id: 'decimal',
+      type: FieldTypes.Decimal,
+      maxLength: 10
+    };
+    const event = {
+      state,
+      updateState,
+      action: {
+        type: VALIDATE_FIELD,
+        payload: {
+          field,
+          value: '100.35'
+        }
+      },
+      dispatch
+    };
+    behaviour.eventHandlers[VALIDATE_FIELD](event);
+    expect(dispatch).toHaveBeenCalledWith({
+      type: FIELD_VALIDATION_RESULT,
+      payload: {
+        validationResult: {
+          isValid: true,
+          message: ''
+        },
+        field
+      }
+    });
+  });
+  it('should validate Decimal field with invalid max length and return error', () => {
+    const field = {
+      id: 'decimal',
+      type: FieldTypes.Decimal,
+      maxLength: 10
+    };
+    const event = {
+      state,
+      updateState,
+      action: {
+        type: VALIDATE_FIELD,
+        payload: {
+          field,
+          value: '10000000000.73'
+        }
+      },
+      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 valid decimal and return true', () => {
+    const field = {
+      id: 'decimal',
+      type: FieldTypes.Decimal
+    };
+    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: true,
+          message: ''
+        },
+        field
+      }
+    });
+  });
+  it('should validate invalid decimal points and return false', () => {
+    const field = {
+      id: 'decimal',
+      type: FieldTypes.Decimal
+    };
+    const event = {
+      state,
+      updateState,
+      action: {
+        type: VALIDATE_FIELD,
+        payload: {
+          field,
+          value: '123.45.67'
+        }
+      },
+      dispatch
+    };
+    behaviour.eventHandlers[VALIDATE_FIELD](event);
+    expect(dispatch).toHaveBeenCalledWith({
+      type: FIELD_VALIDATION_RESULT,
+      payload: {
+        validationResult: {
+          isValid: false,
+          message: 'Invalid decimal format'
+        },
+        field
+      }
+    });
+  });
+  it('should validate invalid decimal and return false', () => {
+    const field = {
+      id: 'decimal',
+      type: FieldTypes.Decimal
+    };
+    const event = {
+      state,
+      updateState,
+      action: {
+        type: VALIDATE_FIELD,
+        payload: {
+          field,
+          value: 'abcd'
+        }
+      },
+      dispatch
+    };
+    behaviour.eventHandlers[VALIDATE_FIELD](event);
+    expect(dispatch).toHaveBeenCalledWith({
+      type: FIELD_VALIDATION_RESULT,
+      payload: {
+        validationResult: {
+          isValid: false,
+          message: 'Invalid decimal format'
+        },
+        field
+      }
+    });
+  });
+  it('should validate valid decimal places and return true', () => {
+    const field = {
+      id: 'decimal',
+      type: FieldTypes.Decimal,
+      decimalPlaces: 2
+    };
+    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: true,
+          message: ''
+        },
+        field
+      }
+    });
+  });
+  it('should validate invalid decimal places and return false', () => {
+    const field = {
+      id: 'decimal',
+      type: FieldTypes.Decimal,
+      decimalPlaces: 2
+    };
+    const event = {
+      state,
+      updateState,
+      action: {
+        type: VALIDATE_FIELD,
+        payload: {
+          field,
+          value: '123.456'
+        }
+      },
+      dispatch
+    };
+    behaviour.eventHandlers[VALIDATE_FIELD](event);
+    expect(dispatch).toHaveBeenCalledWith({
+      type: FIELD_VALIDATION_RESULT,
+      payload: {
+        validationResult: {
+          isValid: false,
+          message: 'Invalid decimal places'
+        },
+        field
+      }
+    });
+  });
+});

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

@@ -0,0 +1,139 @@
+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('Email 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 Email mandatory field and return error', () => {
+    const field = {
+      id: 'text',
+      type: FieldTypes.Email,
+      // type: "Text",
+      // mandatory: true
+      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 Email empty string and return true', () => {
+    const field = {
+      id: 'text',
+      type: FieldTypes.Email
+    };
+    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: true,
+          message: ''
+        },
+        field
+      }
+    });
+  });
+  it('should validate valid email and return true', () => {
+    const field = {
+      id: 'email',
+      type: FieldTypes.Email
+    };
+    const event = {
+      state,
+      updateState,
+      action: {
+        type: VALIDATE_FIELD,
+        payload: {
+          field,
+          value: 'test@example.com'
+        }
+      },
+      dispatch
+    };
+    behaviour.eventHandlers[VALIDATE_FIELD](event);
+    expect(dispatch).toHaveBeenCalledWith({
+      type: FIELD_VALIDATION_RESULT,
+      payload: {
+        validationResult: {
+          isValid: true,
+          message: ''
+        },
+        field
+      }
+    });
+  });
+  it('should validate invalid email and return false', () => {
+    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
+      }
+    });
+  });
+});

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