@heartlandone/vega-sandbox-pr-1457-26ca806e919492b9064caacdcb37782f4b5aeb1c 2.25.0

package/dist/collection/helpers/validator/test/rules/max-number-rule.test.js

@@ -0,0 +1,97 @@
+import { MaxNumberRule } from '../../rules/max-number-rule';
+test('return result as expect if input can evaluate', () => {
+  const rule = new MaxNumberRule({ maxValue: 0 });
+  const stringInput = rule.canEvaluate('3');
+  expect(stringInput).toEqual(true);
+  const numberInput = rule.canEvaluate(3);
+  expect(numberInput).toEqual(true);
+  const booleanInput = rule.canEvaluate([3]);
+  expect(booleanInput).toEqual(true);
+  const statusInput = rule.canEvaluate(3, {
+    touched: true,
+    modified: true,
+    disabled: false,
+    visible: true,
+  });
+  expect(statusInput).toEqual(true);
+});
+test('return result as expect if input can not evaluate', () => {
+  const rule = new MaxNumberRule({ maxValue: 0 });
+  const stringInput = rule.canEvaluate([1, 2, 3]);
+  expect(stringInput).toEqual(false);
+});
+test('throw error as expect if input can not evaluate', () => {
+  const rule = new MaxNumberRule({ maxValue: 0 });
+  const props = [1, 2];
+  const testFunction = () => {
+    rule.evaluate(props);
+  };
+  expect(testFunction).toThrow();
+});
+test('return evaluate result as expect if input type is number and value greater than max', () => {
+  const rule = new MaxNumberRule({ maxValue: 2 });
+  const stringInput = rule.evaluate(3);
+  expect(stringInput).toEqual({
+    isValid: false,
+    message: 'The maximum input value is 2',
+  });
+});
+test('return evaluate result as expect if input type is number and value less than max', () => {
+  const rule = new MaxNumberRule({ maxValue: 2 });
+  const stringInput = rule.evaluate(0);
+  expect(stringInput).toEqual({
+    isValid: true,
+    message: '',
+  });
+});
+test('return evaluate result as expect if input max value less than default MAX_VALUE', () => {
+  const rule = new MaxNumberRule({ maxValue: null });
+  const stringInput = rule.evaluate(1.79e308);
+  expect(stringInput).toEqual({
+    isValid: true,
+    message: '',
+  });
+});
+test('return evaluate result as expect if input max value greater than default MAX_VALUE', () => {
+  const rule = new MaxNumberRule({ maxValue: null });
+  const stringInput = rule.evaluate(1.79e309);
+  expect(stringInput).toEqual({
+    isValid: false,
+    message: 'The maximum input value is 1.7976931348623157e+308',
+  });
+});
+test('return evaluate result as expect if not set config', () => {
+  const rule = new MaxNumberRule(null);
+  const stringInput = rule.evaluate(1.79e309);
+  expect(stringInput).toEqual({
+    isValid: false,
+    message: 'The maximum input value is 1.7976931348623157e+308',
+  });
+});
+test('should not show error message if status is disabled or invisible', () => {
+  const rule = new MaxNumberRule({ maxValue: 0 });
+  expect(rule.shouldShowError({
+    touched: true,
+    modified: true,
+    disabled: true,
+    visible: false,
+  })).toEqual(false);
+});
+test('should show error message if status is not disabled or invisible', () => {
+  const rule = new MaxNumberRule({ maxValue: 0 });
+  expect(rule.shouldShowError({
+    touched: true,
+    modified: true,
+    disabled: false,
+    visible: true,
+  })).toEqual(true);
+});
+test('should not show error message if status is not touched or not modified', () => {
+  const rule = new MaxNumberRule({ maxValue: 0 });
+  expect(rule.shouldShowError({
+    touched: false,
+    modified: false,
+    disabled: false,
+    visible: true,
+  })).toEqual(false);
+});

package/dist/collection/helpers/validator/test/rules/max-string-length-rule.test.js

@@ -0,0 +1,85 @@
+import { MaxStringLengthRule } from '../../rules/max-string-length-rule';
+test('return result as expect if input can evaluate', () => {
+  const rule = new MaxStringLengthRule({ maxStrLength: 0 });
+  const stringInput = rule.canEvaluate('string');
+  expect(stringInput).toEqual(true);
+  const statusInput = rule.canEvaluate('string', {
+    touched: true,
+    modified: true,
+    disabled: false,
+    visible: true,
+  });
+  expect(statusInput).toEqual(true);
+});
+test('return result as expect if input can not evaluate', () => {
+  const rule = new MaxStringLengthRule({ maxStrLength: 0 });
+  const stringInput = rule.canEvaluate([1, 2, 3]);
+  expect(stringInput).toEqual(false);
+});
+test('throw error as expect if input can not evaluate', () => {
+  const rule = new MaxStringLengthRule({ maxStrLength: 0 });
+  const props = [1, 2];
+  const testFunction = () => {
+    rule.evaluate(props);
+  };
+  expect(testFunction).toThrow();
+});
+test('return evaluate result as expect if input length greater than max', () => {
+  const rule = new MaxStringLengthRule({ maxStrLength: 2 });
+  const stringInput = rule.evaluate('hello');
+  expect(stringInput).toEqual({
+    isValid: false,
+    message: 'The maximum input length is 2',
+  });
+});
+test('return evaluate result as expect if input length less than max', () => {
+  const rule = new MaxStringLengthRule({ maxStrLength: 2 });
+  const stringInput = rule.evaluate('hi');
+  expect(stringInput).toEqual({
+    isValid: true,
+    message: '',
+  });
+});
+test('return evaluate result as expect if input max length not set', () => {
+  const rule = new MaxStringLengthRule({ maxStrLength: null });
+  const stringInput = rule.evaluate('hi');
+  expect(stringInput).toEqual({
+    isValid: true,
+    message: '',
+  });
+});
+test('return evaluate result as expect if config  not set', () => {
+  const rule = new MaxStringLengthRule(null);
+  const stringInput = rule.evaluate('hi');
+  expect(stringInput).toEqual({
+    isValid: true,
+    message: '',
+  });
+});
+test('should not show error message if status is disabled or invisible', () => {
+  const rule = new MaxStringLengthRule({ maxStrLength: 0 });
+  expect(rule.shouldShowError({
+    touched: true,
+    modified: true,
+    disabled: true,
+    visible: false,
+  })).toEqual(false);
+});
+test('should show error message if status is not disabled or invisible', () => {
+  const rule = new MaxStringLengthRule({ maxStrLength: 0 });
+  expect(rule.shouldShowError({
+    touched: true,
+    modified: true,
+    disabled: false,
+    visible: true,
+  })).toEqual(true);
+});
+test('should not show error message if status is not touched or not modified', () => {
+  const rule = new MaxStringLengthRule({ maxStrLength: 0 });
+  expect(rule.shouldShowError({
+    touched: false,
+    modified: false,
+    disabled: false,
+    visible: true,
+  })).toEqual(false);
+});

package/dist/collection/helpers/validator/test/rules/min-and-max-date-rule.test.js

@@ -0,0 +1,174 @@
+import { MinAndMaxDateRule } from '../../rules/min-and-max-date-rule';
+describe('minAndMaxDateRule', () => {
+  test('return true if input can be evaluated', () => {
+    const rule = new MinAndMaxDateRule({});
+    expect(rule.canEvaluate('05/05/2022')).toEqual(true);
+    expect(rule.canEvaluate(['05/05/2022', '05/15/2022'])).toEqual(true);
+    expect(rule.canEvaluate('05/05/2022', {
+      touched: true,
+      modified: true,
+      disabled: false,
+      visible: true,
+    })).toEqual(true);
+  });
+  test('return false if input can not be evaluated', () => {
+    const rule = new MinAndMaxDateRule({});
+    expect(rule.canEvaluate('')).toEqual(false);
+    expect(rule.canEvaluate(null)).toEqual(false);
+    expect(rule.canEvaluate(undefined)).toEqual(false);
+    expect(rule.canEvaluate([])).toEqual(false);
+    expect(rule.canEvaluate([''])).toEqual(false);
+    expect(rule.canEvaluate(['', ''])).toEqual(false);
+    expect(rule.canEvaluate(['05/05/2022', ''])).toEqual(false);
+  });
+  test('return the valid evaluate result with minDate and maxDate', () => {
+    const minDate = '05/10/2022';
+    const maxDate = '05/20/2022';
+    const rule = new MinAndMaxDateRule({ minDate: minDate, maxDate: maxDate });
+    expect(rule.evaluate('05/15/2022')).toEqual({
+      isValid: true,
+      message: ``,
+    });
+    expect(rule.evaluate(minDate)).toEqual({
+      isValid: true,
+      message: ``,
+    });
+    expect(rule.evaluate(maxDate)).toEqual({
+      isValid: true,
+      message: ``,
+    });
+    expect(rule.evaluate(['05/15/2022', '05/18/2022'])).toEqual({
+      isValid: true,
+      message: ``,
+    });
+    expect(rule.evaluate([minDate, maxDate])).toEqual({
+      isValid: true,
+      message: ``,
+    });
+  });
+  test('return the valid evaluate result with maxDate', () => {
+    const maxDate = '05/20/2022';
+    const rule = new MinAndMaxDateRule({ maxDate: maxDate });
+    expect(rule.evaluate('05/15/2022')).toEqual({
+      isValid: true,
+      message: ``,
+    });
+    expect(rule.evaluate(maxDate)).toEqual({
+      isValid: true,
+      message: ``,
+    });
+  });
+  test('return the invalid evaluate result with maxDate', () => {
+    const maxDate = '05/20/2022';
+    const rule = new MinAndMaxDateRule({ maxDate: maxDate });
+    expect(rule.evaluate('05/22/2022')).toEqual({
+      isValid: false,
+      message: `The date should be earlier than ${maxDate}`,
+    });
+    expect(rule.evaluate(['05/25/2022', '05/28/2022'])).toEqual({
+      isValid: false,
+      message: `The start date should be earlier than ${maxDate}`,
+    });
+    expect(rule.evaluate(['05/11/2022', '05/25/2022'])).toEqual({
+      isValid: false,
+      message: `The end date should be earlier than ${maxDate}`,
+    });
+  });
+  test('return the valid evaluate result with minDate', () => {
+    const minDate = '05/20/2022';
+    const rule = new MinAndMaxDateRule({ minDate: minDate });
+    expect(rule.evaluate('05/22/2022')).toEqual({
+      isValid: true,
+      message: ``,
+    });
+    expect(rule.evaluate(minDate)).toEqual({
+      isValid: true,
+      message: ``,
+    });
+    expect(rule.evaluate(['05/22/2022', '05/25/2022'])).toEqual({
+      isValid: true,
+      message: ``,
+    });
+  });
+  test('return the invalid evaluate result with minDate', () => {
+    const minDate = '05/20/2022';
+    const rule = new MinAndMaxDateRule({ minDate: minDate });
+    expect(rule.evaluate('05/11/2022')).toEqual({
+      isValid: false,
+      message: `The date should be later than ${minDate}`,
+    });
+    expect(rule.evaluate(['05/12/2022', '05/22/2022'])).toEqual({
+      isValid: false,
+      message: `The start date should be later than ${minDate}`,
+    });
+  });
+  test('return the invalid evaluate result as expected', () => {
+    const minDate = '05/10/2022';
+    const maxDate = '05/20/2022';
+    const rule = new MinAndMaxDateRule({ minDate: minDate, maxDate: maxDate });
+    expect(rule.evaluate('05/01/2022')).toEqual({
+      isValid: false,
+      message: `The date should be later than ${minDate}`,
+    });
+    expect(rule.evaluate('05/25/2022')).toEqual({
+      isValid: false,
+      message: `The date should be earlier than ${maxDate}`,
+    });
+    expect(rule.evaluate(['05/01/2022', '05/03/2022'])).toEqual({
+      isValid: false,
+      message: `The start date should be later than ${minDate}`,
+    });
+    expect(rule.evaluate(['05/21/2022', '05/26/2022'])).toEqual({
+      isValid: false,
+      message: `The start date should be earlier than ${maxDate}`,
+    });
+    expect(rule.evaluate([minDate, '05/26/2022'])).toEqual({
+      isValid: false,
+      message: `The end date should be earlier than ${maxDate}`,
+    });
+  });
+  test('throw error as expected if set an unexpected type of input', () => {
+    const minDate = '05/10/2022';
+    const maxDate = '05/20/2022';
+    const rule = new MinAndMaxDateRule({ minDate: minDate, maxDate: maxDate });
+    expect(() => {
+      rule.evaluate(undefined);
+    }).toThrow('Unexpected type of input: undefined: undefined');
+    expect(() => {
+      rule.evaluate('');
+    }).toThrow('Unexpected type of input: string: ');
+    expect(() => {
+      rule.evaluate(['', '']);
+    }).toThrow('Unexpected type of input: object: ');
+  });
+  test('should not show error message if status is disabled or invisible', () => {
+    const minDate = '05/20/2022';
+    const rule = new MinAndMaxDateRule({ minDate: minDate });
+    expect(rule.shouldShowError({
+      touched: true,
+      modified: true,
+      disabled: true,
+      visible: false,
+    })).toEqual(false);
+  });
+  test('should show error message if status is not disabled or invisible', () => {
+    const minDate = '05/20/2022';
+    const rule = new MinAndMaxDateRule({ minDate: minDate });
+    expect(rule.shouldShowError({
+      touched: true,
+      modified: true,
+      disabled: false,
+      visible: true,
+    })).toEqual(true);
+  });
+  test('should not show error message if status is not touched or not modified', () => {
+    const minDate = '05/20/2022';
+    const rule = new MinAndMaxDateRule({ minDate: minDate });
+    expect(rule.shouldShowError({
+      touched: false,
+      modified: false,
+      disabled: false,
+      visible: true,
+    })).toEqual(false);
+  });
+});

package/dist/collection/helpers/validator/test/rules/min-number-rule.test.js

@@ -0,0 +1,97 @@
+import { MinNumberRule } from '../../rules/min-number-rule';
+test('return result as expect if input can evaluate', () => {
+  const rule = new MinNumberRule({ minValue: 0 });
+  const stringInput = rule.canEvaluate('3');
+  expect(stringInput).toEqual(true);
+  const numberInput = rule.canEvaluate(3);
+  expect(numberInput).toEqual(true);
+  const booleanInput = rule.canEvaluate([3]);
+  expect(booleanInput).toEqual(true);
+  const statusInput = rule.canEvaluate(3, {
+    touched: true,
+    modified: true,
+    disabled: false,
+    visible: true,
+  });
+  expect(statusInput).toEqual(true);
+});
+test('return result as expect if input can not evaluate', () => {
+  const rule = new MinNumberRule({ minValue: 0 });
+  const stringInput = rule.canEvaluate([1, 2, 3]);
+  expect(stringInput).toEqual(false);
+});
+test('throw error as expect if input can not evaluate', () => {
+  const rule = new MinNumberRule({ minValue: 0 });
+  const props = [1, 2];
+  const testFunction = () => {
+    rule.evaluate(props);
+  };
+  expect(testFunction).toThrow();
+});
+test('return evaluate result as expect if input type is number and value greater than min', () => {
+  const rule = new MinNumberRule({ minValue: 2 });
+  const stringInput = rule.evaluate(2);
+  expect(stringInput).toEqual({
+    isValid: true,
+    message: '',
+  });
+});
+test('return evaluate result as expect if input type is number and value less than min', () => {
+  const rule = new MinNumberRule({ minValue: 2 });
+  const stringInput = rule.evaluate(0);
+  expect(stringInput).toEqual({
+    isValid: false,
+    message: 'The minimum input value is 2',
+  });
+});
+test('return evaluate result as expect if input max value less than default MIN_VALUE', () => {
+  const rule = new MinNumberRule({ minValue: null });
+  const stringInput = rule.evaluate(-1);
+  expect(stringInput).toEqual({
+    isValid: false,
+    message: 'The minimum input value is 0',
+  });
+});
+test('return evaluate result as expect if input max value greater than default MIN_VALUE', () => {
+  const rule = new MinNumberRule({ minValue: null });
+  const stringInput = rule.evaluate(0);
+  expect(stringInput).toEqual({
+    isValid: true,
+    message: '',
+  });
+});
+test('return evaluate result as expect if config not set', () => {
+  const rule = new MinNumberRule(null);
+  const stringInput = rule.evaluate(0);
+  expect(stringInput).toEqual({
+    isValid: true,
+    message: '',
+  });
+});
+test('should not show error message if status is disabled or invisible', () => {
+  const rule = new MinNumberRule({ minValue: 0 });
+  expect(rule.shouldShowError({
+    touched: true,
+    modified: true,
+    disabled: true,
+    visible: false,
+  })).toEqual(false);
+});
+test('should show error message if status is not disabled or invisible', () => {
+  const rule = new MinNumberRule({ minValue: 0 });
+  expect(rule.shouldShowError({
+    touched: true,
+    modified: true,
+    disabled: false,
+    visible: true,
+  })).toEqual(true);
+});
+test('should not show error message if status is not touched or not modified', () => {
+  const rule = new MinNumberRule({ minValue: 0 });
+  expect(rule.shouldShowError({
+    touched: false,
+    modified: false,
+    disabled: false,
+    visible: true,
+  })).toEqual(false);
+});

package/dist/collection/helpers/validator/test/rules/min-string-length-rule.test.js

@@ -0,0 +1,85 @@
+import { MinStringLengthRule } from '../../rules/min-string-length-rule';
+test('return result as expect if input can evaluate', () => {
+  const rule = new MinStringLengthRule({ minStrLength: 2 });
+  const stringInput = rule.canEvaluate('string');
+  expect(stringInput).toEqual(true);
+  const statusInput = rule.canEvaluate('string', {
+    touched: true,
+    modified: true,
+    disabled: false,
+    visible: true,
+  });
+  expect(statusInput).toEqual(true);
+});
+test('return result as expect if input can not evaluate', () => {
+  const rule = new MinStringLengthRule({ minStrLength: 2 });
+  const stringInput = rule.canEvaluate(12);
+  expect(stringInput).toEqual(false);
+});
+test('throw error as expect if input can not evaluate', () => {
+  const rule = new MinStringLengthRule({ minStrLength: 2 });
+  const props = 2;
+  const testFunction = () => {
+    rule.evaluate(props);
+  };
+  expect(testFunction).toThrow();
+});
+test('return evaluate result as expect if input length less than min', () => {
+  const rule = new MinStringLengthRule({ minStrLength: 2 });
+  const stringInput = rule.evaluate('h');
+  expect(stringInput).toEqual({
+    isValid: false,
+    message: 'The minimum input length is 2',
+  });
+});
+test('return evaluate result as expect if input length greater than min', () => {
+  const rule = new MinStringLengthRule({ minStrLength: 2 });
+  const stringInput = rule.evaluate('hi');
+  expect(stringInput).toEqual({
+    isValid: true,
+    message: '',
+  });
+});
+test('return evaluate result as expect if input type is string and min not set', () => {
+  const rule = new MinStringLengthRule({ minStrLength: null });
+  const stringInput = rule.evaluate('');
+  expect(stringInput).toEqual({
+    isValid: true,
+    message: '',
+  });
+});
+test('return evaluate result as expect if config set', () => {
+  const rule = new MinStringLengthRule(null);
+  const stringInput = rule.evaluate('');
+  expect(stringInput).toEqual({
+    isValid: true,
+    message: '',
+  });
+});
+test('should not show error message if status is disabled or invisible', () => {
+  const rule = new MinStringLengthRule({ minStrLength: 2 });
+  expect(rule.shouldShowError({
+    touched: true,
+    modified: true,
+    disabled: true,
+    visible: false,
+  })).toEqual(false);
+});
+test('should show error message if status is not disabled or invisible', () => {
+  const rule = new MinStringLengthRule({ minStrLength: 2 });
+  expect(rule.shouldShowError({
+    touched: true,
+    modified: true,
+    disabled: false,
+    visible: true,
+  })).toEqual(true);
+});
+test('should not show error message if status is not touched or not modified', () => {
+  const rule = new MinStringLengthRule({ minStrLength: 2 });
+  expect(rule.shouldShowError({
+    touched: false,
+    modified: false,
+    disabled: false,
+    visible: true,
+  })).toEqual(false);
+});

package/dist/collection/helpers/validator/test/rules/required-field-rule.test.js

@@ -0,0 +1,115 @@
+import { RequiredFieldRule } from '../../rules/required-field-rule';
+test('return result as expect if input can evaluate', () => {
+  const rule = new RequiredFieldRule();
+  const stringInput = rule.canEvaluate('string');
+  expect(stringInput).toEqual(true);
+  const numberInput = rule.canEvaluate(123);
+  expect(numberInput).toEqual(true);
+  const booleanInput = rule.canEvaluate(false);
+  expect(booleanInput).toEqual(true);
+  const arrayInput = rule.canEvaluate(['apple', 'banana']);
+  expect(arrayInput).toEqual(true);
+  const statusInput = rule.canEvaluate('string', {
+    touched: true,
+    modified: true,
+    disabled: false,
+    visible: true,
+  });
+  expect(statusInput).toEqual(true);
+});
+test('return result as expect if input can not evaluate', () => {
+  const rule = new RequiredFieldRule();
+  const stringInput = rule.canEvaluate({ name: 'test' });
+  expect(stringInput).toEqual(false);
+});
+test('throw error as expect if input can not evaluate', () => {
+  const rule = new RequiredFieldRule();
+  const props = { name: 'test' };
+  const testFunction = () => {
+    rule.evaluate(props);
+  };
+  expect(testFunction).toThrow();
+});
+test('return evaluate result as expect if input type is number', () => {
+  const rule = new RequiredFieldRule();
+  const stringInput = rule.evaluate(2);
+  expect(stringInput).toEqual({
+    isValid: true,
+    message: '',
+  });
+});
+test('return evaluate result as expect if input type is boolean', () => {
+  const rule = new RequiredFieldRule();
+  const stringInput = rule.evaluate(true);
+  expect(stringInput).toEqual({
+    isValid: true,
+    message: '',
+  });
+});
+test('return evaluate result as expect if input type is string and length greater than 0', () => {
+  const rule = new RequiredFieldRule();
+  const stringInput = rule.evaluate('hi');
+  expect(stringInput).toEqual({
+    isValid: true,
+    message: '',
+  });
+});
+test('return evaluate result as expect if input type is string and length less than 0', () => {
+  const rule = new RequiredFieldRule();
+  const stringInput = rule.evaluate('');
+  expect(stringInput).toEqual({
+    isValid: false,
+    message: 'This field is required',
+  });
+});
+test('return evaluate result as expect if input type is array and length greater than 0', () => {
+  const rule = new RequiredFieldRule();
+  const arrayInput = rule.evaluate(['apple', 'banana']);
+  expect(arrayInput).toEqual({
+    isValid: true,
+    message: '',
+  });
+});
+test('return evaluate result as expect if input type is array and length less than 0', () => {
+  const rule = new RequiredFieldRule();
+  const arrayInput = rule.evaluate([]);
+  expect(arrayInput).toEqual({
+    isValid: false,
+    message: 'This field is required',
+  });
+});
+test('throw error as expect if input type is array and input can not evaluate', () => {
+  const rule = new RequiredFieldRule();
+  const props = [{ name: 'test1' }, { name: 'test2' }];
+  const testFunction = () => {
+    rule.evaluate(props);
+  };
+  expect(testFunction).toThrow();
+});
+test('should not show error message if status is disabled or invisible', () => {
+  const rule = new RequiredFieldRule();
+  expect(rule.shouldShowError({
+    touched: true,
+    modified: true,
+    disabled: true,
+    visible: false,
+  })).toEqual(false);
+});
+test('should show error message if status is not disabled or invisible', () => {
+  const rule = new RequiredFieldRule();
+  expect(rule.shouldShowError({
+    touched: true,
+    modified: true,
+    disabled: false,
+    visible: true,
+  })).toEqual(true);
+});
+test('should not show error message if status is not touched or not modified', () => {
+  const rule = new RequiredFieldRule();
+  expect(rule.shouldShowError({
+    touched: false,
+    modified: false,
+    disabled: false,
+    visible: true,
+  })).toEqual(false);
+});