@heartlandone/vega-sandbox-pr-1520-a229ce0611c7d8c9884a7af1466ecb6a43e7f28d 2.27.0

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: { key: 'The minimum input length is {0}', args: [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);
+});

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

@@ -0,0 +1,82 @@
+import { TimeRangeRequiredRule } from '../../rules/time-range-required-rule';
+test('return result as expect if input can evaluate', () => {
+  const rule = new TimeRangeRequiredRule({ timeFormat: '24-hour' });
+  expect(rule.canEvaluate(['', ''])).toEqual(true);
+  expect(rule.canEvaluate(['01:03', '01:04'])).toEqual(true);
+  expect(rule.canEvaluate(undefined)).toEqual(true);
+  expect(rule.canEvaluate(null)).toEqual(true);
+  expect(rule.canEvaluate([' ', ' '])).toEqual(true);
+  expect(rule.canEvaluate(['01:03', '02:03'], {
+    touched: true,
+    modified: true,
+    disabled: false,
+    visible: true,
+  })).toEqual(true);
+});
+test('return result as expect if input can not evaluate', () => {
+  const rule = new TimeRangeRequiredRule({ timeFormat: '24-hour' });
+  expect(rule.canEvaluate(123)).toEqual(false);
+  expect(rule.canEvaluate(false)).toEqual(false);
+  expect(rule.canEvaluate(['01:04', '02:04'], {
+    touched: true,
+    modified: true,
+    disabled: false,
+    visible: false,
+  })).toEqual(false);
+});
+test('return evaluate result as expect with 24-hour timeFormat', () => {
+  const rule = new TimeRangeRequiredRule({ timeFormat: '24-hour' });
+  expect(rule.evaluate(null)).toEqual({
+    isValid: false,
+    message: `This field is required`,
+  });
+  expect(rule.evaluate(undefined)).toEqual({
+    isValid: false,
+    message: `This field is required`,
+  });
+  expect(rule.evaluate(['', ''])).toEqual({
+    isValid: false,
+    message: `This field is required`,
+  });
+  expect(rule.evaluate(['01:02 AM', '01:02 PM'])).toEqual({
+    isValid: false,
+    message: `This field is required`,
+  });
+  expect(rule.evaluate(['01:02', '02:02'])).toEqual({
+    isValid: true,
+    message: '',
+  });
+});
+test('should not show error message if status is disabled or invisible', () => {
+  const rule = new TimeRangeRequiredRule({ timeFormat: '12-hour' });
+  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 TimeRangeRequiredRule({ timeFormat: '12-hour' });
+  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 TimeRangeRequiredRule({ timeFormat: '12-hour' });
+  expect(rule.shouldShowError({
+    touched: false,
+    modified: false,
+    disabled: false,
+    visible: true,
+  })).toEqual(false);
+});
+test('throw error as expect if set a error value', () => {
+  const rule = new TimeRangeRequiredRule({ timeFormat: '12-hour' });
+  expect(() => {
+    rule.evaluate('12:00');
+  }).toThrow('Invalid time value 12:00 for range mode');
+});

package/dist/collection/helpers/validator/test/rules/time-range-rule.test.js

@@ -0,0 +1,67 @@
+import { TimeRangeRule } from '../../rules/time-range-rule';
+describe('TimeRangeRule', () => {
+  test('return true if input can be evaluated', () => {
+    const rule = new TimeRangeRule({ timeFormat: '24-hour' });
+    expect(rule.canEvaluate(['01:01', '02:02'])).toEqual(true);
+    expect(rule.canEvaluate(['01:01', '02:02'], {
+      touched: true,
+      modified: true,
+      disabled: false,
+      visible: true,
+    })).toEqual(true);
+  });
+  test('return false if input can not be evaluated', () => {
+    const rule = new TimeRangeRule({ timeFormat: '24-hour' });
+    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', ''])).toEqual(false);
+  });
+  test('return true if start time is before than end time', () => {
+    const rule = new TimeRangeRule({ timeFormat: '24-hour' });
+    expect(rule.evaluate(['05:02', '05:15'])).toEqual({ isValid: true, message: '' });
+  });
+  test('return false if start time is not before than end time', () => {
+    const rule = new TimeRangeRule({ timeFormat: '24-hour' });
+    expect(rule.evaluate(['05:15', '05:10'])).toEqual({
+      isValid: false,
+      message: 'The end time should be later than start time',
+    });
+  });
+  test('throw error if set an unexpected type of input', () => {
+    const rule = new TimeRangeRule({ timeFormat: '24-hour' });
+    expect(() => {
+      rule.evaluate(['', '']);
+    }).toThrow('Unexpected type of input: object: ');
+  });
+  test('should not show error message if status is disabled or invisible', () => {
+    const rule = new TimeRangeRule({ timeFormat: '24-hour' });
+    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 TimeRangeRule({ timeFormat: '24-hour' });
+    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 TimeRangeRule({ timeFormat: '24-hour' });
+    expect(rule.shouldShowError({
+      touched: false,
+      modified: false,
+      disabled: false,
+      visible: true,
+    })).toEqual(false);
+  });
+});

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

@@ -0,0 +1,116 @@
+import { TimeRequiredRule } from '../../rules/time-required-rule';
+test('return result as expect if input can evaluate', () => {
+  const rule = new TimeRequiredRule({ timeFormat: '24-hour' });
+  expect(rule.canEvaluate('')).toEqual(true);
+  expect(rule.canEvaluate('01:03')).toEqual(true);
+  expect(rule.canEvaluate(undefined)).toEqual(true);
+  expect(rule.canEvaluate(null)).toEqual(true);
+  expect(rule.canEvaluate(' ')).toEqual(true);
+  expect(rule.canEvaluate('01:03', {
+    touched: true,
+    modified: true,
+    disabled: false,
+    visible: true,
+  })).toEqual(true);
+});
+test('return result as expect if input can not evaluate', () => {
+  const rule = new TimeRequiredRule({ timeFormat: '24-hour' });
+  expect(rule.canEvaluate(123)).toEqual(false);
+  expect(rule.canEvaluate(false)).toEqual(false);
+  expect(rule.canEvaluate([])).toEqual(false);
+  expect(rule.canEvaluate(['01:02'])).toEqual(false);
+  expect(rule.canEvaluate('01:04', {
+    touched: true,
+    modified: true,
+    disabled: false,
+    visible: false,
+  })).toEqual(false);
+});
+test('return evaluate result as expect with 24-hour timeFormat', () => {
+  const rule = new TimeRequiredRule({ timeFormat: '24-hour' });
+  expect(rule.evaluate(null)).toEqual({
+    isValid: false,
+    message: `This field is required`,
+  });
+  expect(rule.evaluate(undefined)).toEqual({
+    isValid: false,
+    message: `This field is required`,
+  });
+  expect(rule.evaluate('')).toEqual({
+    isValid: false,
+    message: `This field is required`,
+  });
+  expect(rule.evaluate('01:02 AM')).toEqual({
+    isValid: false,
+    message: `This field is required`,
+  });
+  expect(rule.evaluate('01:02')).toEqual({
+    isValid: true,
+    message: '',
+  });
+});
+test('return evaluate result as not expect with 24-hour timeFormat', () => {
+  const rule = new TimeRequiredRule({ timeFormat: '24-hour' });
+  expect(() => {
+    rule.evaluate([]);
+  }).toThrow('Invalid time value ');
+  expect(() => {
+    rule.evaluate(1);
+  }).toThrow('Invalid time value ');
+  expect(() => {
+    rule.evaluate(['1']);
+  }).toThrow('Invalid time value ');
+  expect(() => {
+    rule.evaluate(true);
+  }).toThrow('Invalid time value ');
+});
+test('return evaluate result as expect with 12-hour timeFormat', () => {
+  const rule = new TimeRequiredRule({ timeFormat: '12-hour' });
+  expect(rule.evaluate(null)).toEqual({
+    isValid: false,
+    message: `This field is required`,
+  });
+  expect(rule.evaluate(undefined)).toEqual({
+    isValid: false,
+    message: `This field is required`,
+  });
+  expect(rule.evaluate('')).toEqual({
+    isValid: false,
+    message: `This field is required`,
+  });
+  expect(rule.evaluate('01:02')).toEqual({
+    isValid: false,
+    message: 'This field is required',
+  });
+  expect(rule.evaluate('01:02 AM')).toEqual({
+    isValid: true,
+    message: '',
+  });
+});
+test('should not show error message if status is disabled or invisible', () => {
+  const rule = new TimeRequiredRule({ timeFormat: '12-hour' });
+  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 TimeRequiredRule({ timeFormat: '12-hour' });
+  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 TimeRequiredRule({ timeFormat: '12-hour' });
+  expect(rule.shouldShowError({
+    touched: false,
+    modified: false,
+    disabled: false,
+    visible: true,
+  })).toEqual(false);
+});

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

@@ -0,0 +1,72 @@
+import { ToggleSwitchRequiredRule } from '../../rules/toggle-switch-required-rule';
+test('return result as expect with input', () => {
+  const rule = new ToggleSwitchRequiredRule();
+  const stringInput = rule.canEvaluate('string');
+  expect(stringInput).toEqual(false);
+  const numberInput = rule.canEvaluate(123);
+  expect(numberInput).toEqual(false);
+  const booleanInput = rule.canEvaluate(false);
+  expect(booleanInput).toEqual(true);
+  const statusInput = rule.canEvaluate(true, {
+    touched: true,
+    modified: true,
+    disabled: false,
+    visible: true,
+  });
+  expect(statusInput).toEqual(true);
+  const nullInput = rule.canEvaluate(null);
+  expect(nullInput).toEqual(true);
+  const undefinedInput = rule.canEvaluate(undefined);
+  expect(undefinedInput).toEqual(true);
+});
+test('return evaluate result as expect if input is true', () => {
+  const rule = new ToggleSwitchRequiredRule();
+  const booleanInput = rule.evaluate(true);
+  expect(booleanInput).toEqual({
+    isValid: true,
+    message: '',
+  });
+});
+test('return evaluate result as expect if input is false', () => {
+  const rule = new ToggleSwitchRequiredRule();
+  const booleanInput = rule.evaluate(false);
+  expect(booleanInput).toEqual({
+    isValid: false,
+    message: 'This field is required',
+  });
+});
+test('return evaluate result as expect if input is null', () => {
+  const rule = new ToggleSwitchRequiredRule();
+  const nullInput = rule.evaluate(null);
+  expect(nullInput).toEqual({
+    isValid: false,
+    message: 'This field is required',
+  });
+});
+test('should not show error message if status is disabled or invisible', () => {
+  const rule = new ToggleSwitchRequiredRule();
+  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 ToggleSwitchRequiredRule();
+  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 ToggleSwitchRequiredRule();
+  expect(rule.shouldShowError({
+    touched: false,
+    modified: false,
+    disabled: false,
+    visible: true,
+  })).toEqual(false);
+});

package/dist/collection/helpers/validator/test/rules/valid-credit-card-number-rule.test.js

@@ -0,0 +1,79 @@
+import { ValidCreditCardNumberRule } from '../../rules/valid-credit-card-number-rule';
+test('should return result as expect if input can evaluate', () => {
+  const rule = new ValidCreditCardNumberRule();
+  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('should return result as expect if input can not evaluate', () => {
+  const rule = new ValidCreditCardNumberRule();
+  const stringInput = rule.canEvaluate(12);
+  expect(stringInput).toEqual(false);
+});
+test('should throw error as expect if input can not evaluate', () => {
+  const rule = new ValidCreditCardNumberRule();
+  const props = 2;
+  const testFunction = () => {
+    rule.evaluate(props);
+  };
+  expect(testFunction).toThrow();
+});
+test('should return result as expect if input is invalid', () => {
+  const rule = new ValidCreditCardNumberRule();
+  let stringInput = rule.evaluate('24234 234234 234');
+  expect(stringInput).toEqual({
+    isValid: false,
+    message: 'Credit card number is invalid',
+  });
+  stringInput = rule.evaluate('4263982640269298');
+  expect(stringInput).toEqual({
+    isValid: false,
+    message: 'Credit card number is invalid',
+  });
+});
+test('should return evaluate result as expect if input is valid', () => {
+  const rule = new ValidCreditCardNumberRule();
+  let stringInput = rule.evaluate('4111 1111 1111 1111');
+  expect(stringInput).toEqual({
+    isValid: true,
+    message: '',
+  });
+  stringInput = rule.evaluate('4263982640269299');
+  expect(stringInput).toEqual({
+    isValid: true,
+    message: '',
+  });
+});
+test('should not show error message if status is disabled or invisible', () => {
+  const rule = new ValidCreditCardNumberRule();
+  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 ValidCreditCardNumberRule();
+  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 ValidCreditCardNumberRule();
+  expect(rule.shouldShowError({
+    touched: false,
+    modified: false,
+    disabled: false,
+    visible: true,
+  })).toEqual(false);
+});

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

@@ -0,0 +1,77 @@
+import { ValidPhoneNumberRule } from '../../rules/valid-phone-number-rule';
+describe('ValidPhoneNumberRule', () => {
+  test('return true if input can be evaluated', () => {
+    const rule = new ValidPhoneNumberRule(() => 'US');
+    expect(rule.canEvaluate('+13023334444')).toEqual(true);
+    expect(rule.canEvaluate('+13023334444', {
+      touched: true,
+      modified: true,
+      disabled: false,
+      visible: true,
+    })).toEqual(true);
+  });
+  test('return false if input can not be evaluated', () => {
+    const rule = new ValidPhoneNumberRule(() => 'US');
+    expect(rule.canEvaluate(false)).toEqual(false);
+    expect(rule.canEvaluate(123)).toEqual(false);
+    expect(rule.canEvaluate('+123', {
+      touched: true,
+      modified: true,
+      disabled: false,
+      visible: false,
+    })).toEqual(false);
+  });
+  test('return the valid evaluate result with phone numbers', () => {
+    const rule = new ValidPhoneNumberRule(() => 'US');
+    expect(rule.evaluate('+13023334444')).toEqual({
+      isValid: true,
+      message: ``,
+    });
+    expect(rule.evaluate('+13433111111')).toEqual({
+      isValid: false,
+      message: {
+        key: 'Phone number is valid but it belongs to country {0}, not country {1}',
+        args: ['CA', 'US'],
+      },
+    });
+    expect(rule.evaluate('+134331111')).toEqual({
+      isValid: false,
+      message: `Phone number is not valid`,
+    });
+    expect(rule.evaluate('1')).toEqual({
+      isValid: false,
+      message: `Phone number is not valid`,
+    });
+    expect(rule.evaluate('+123')).toEqual({
+      isValid: false,
+      message: `Phone number is not valid`,
+    });
+  });
+  test('should not show error message if status is disabled or invisible', () => {
+    const rule = new ValidPhoneNumberRule(() => 'US');
+    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 ValidPhoneNumberRule(() => 'US');
+    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 ValidPhoneNumberRule(() => 'US');
+    expect(rule.shouldShowError({
+      touched: false,
+      modified: false,
+      disabled: false,
+      visible: true,
+    })).toEqual(false);
+  });
+});