co.validation 2.7.2 → 3.0.0

package/lib/__tests__/component.valueValidation.js

@@ -1,923 +0,0 @@
-"use strict";
-
-var _ = require("..");
-
-describe('createValidation', () => {
-  it('supports any', () => {
-    expect((0, _.createValidation)({
-      type: 'any'
-    })('')).toEqual({
-      data: '',
-      errors: undefined
-    });
-    expect((0, _.createValidation)({
-      type: 'any'
-    })(5)).toEqual({
-      data: 5,
-      errors: undefined
-    });
-  });
-  it('supports required', () => {
-    expect((0, _.createValidation)({
-      type: 'required'
-    })('')).toEqual({
-      data: undefined,
-      errors: ['Required']
-    });
-    expect((0, _.createValidation)({
-      type: 'required',
-      getMessage: () => 'Required Field'
-    })('')).toEqual({
-      data: undefined,
-      errors: ['Required Field']
-    });
-    expect((0, _.createValidation)({
-      type: 'required',
-      getMessage: () => 'Required'
-    })('a')).toEqual({
-      data: 'a',
-      errors: undefined
-    });
-    expect((0, _.createValidation)({
-      type: 'required',
-      getMessage: () => 'Required'
-    })(5)).toEqual({
-      data: 5,
-      errors: undefined
-    });
-    expect((0, _.createValidation)({
-      type: 'required',
-      getMessage: () => 'Required'
-    })(0)).toEqual({
-      data: 0,
-      errors: undefined
-    });
-    expect((0, _.createValidation)({
-      type: 'required',
-      getMessage: () => 'Required'
-    })(false)).toEqual({
-      data: false,
-      errors: undefined
-    });
-  });
-  it('supports custom', () => {
-    const biggerThanX = (value, allValues) => {
-      if (value < allValues.x) {
-        throw 'bigger';
-      }
-
-      return value;
-    };
-
-    expect((0, _.createValidation)({
-      type: 'custom',
-      validator: biggerThanX
-    })(5, {
-      x: 10
-    })).toEqual({
-      data: undefined,
-      errors: ['Error']
-    });
-    expect((0, _.createValidation)({
-      type: 'custom',
-      validator: biggerThanX,
-      getMessage: bigger => bigger
-    })(5, {
-      x: 10
-    })).toEqual({
-      data: undefined,
-      errors: ['bigger']
-    });
-    expect((0, _.createValidation)({
-      type: 'custom',
-      validator: biggerThanX,
-      getMessage: () => 'Required'
-    })(50, {
-      x: 10
-    })).toEqual({
-      data: 50,
-      errors: undefined
-    });
-  });
-  it('supports equals', () => {
-    expect((0, _.createValidation)({
-      type: 'equals',
-      to: '123'
-    })('1234')).toEqual({
-      data: undefined,
-      errors: ['Must be equal to 123']
-    });
-    expect((0, _.createValidation)({
-      type: 'equals',
-      to: 123
-    })('123')).toEqual({
-      data: undefined,
-      errors: ['Must be equal to 123']
-    });
-    expect((0, _.createValidation)({
-      type: 'equals',
-      to: true
-    })(1)).toEqual({
-      data: undefined,
-      errors: ['Must be equal to true']
-    });
-    expect((0, _.createValidation)({
-      type: 'equals',
-      to: '123',
-      getMessage: to => to
-    })('1234')).toEqual({
-      data: undefined,
-      errors: ['123']
-    });
-    expect((0, _.createValidation)({
-      type: 'equals',
-      to: '123'
-    })('123')).toEqual({
-      data: '123',
-      errors: undefined
-    });
-    expect((0, _.createValidation)({
-      type: 'equals',
-      to: 123
-    })(123)).toEqual({
-      data: 123,
-      errors: undefined
-    });
-    expect((0, _.createValidation)({
-      type: 'equals',
-      to: true
-    })(true)).toEqual({
-      data: true,
-      errors: undefined
-    });
-    expect((0, _.createValidation)({
-      type: 'equals',
-      to: false
-    })(false)).toEqual({
-      data: false,
-      errors: undefined
-    });
-  });
-  it('supports equalsToField', () => {
-    expect((0, _.createValidation)({
-      type: 'equalsToField',
-      field: 'otherField'
-    })('1234', {
-      otherField: '123'
-    })).toEqual({
-      data: undefined,
-      errors: ['Must be equal to otherField']
-    });
-    expect((0, _.createValidation)({
-      type: 'equalsToField',
-      field: 'otherField'
-    })(null, {
-      otherField: '123'
-    })).toEqual({
-      data: undefined,
-      errors: ['Must be equal to otherField']
-    });
-    expect((0, _.createValidation)({
-      type: 'equalsToField',
-      field: 'otherField'
-    })('123', {
-      otherField: 123
-    })).toEqual({
-      data: undefined,
-      errors: ['Must be equal to otherField']
-    });
-    expect((0, _.createValidation)({
-      type: 'equalsToField',
-      field: 'otherField'
-    })(1, {
-      otherField: true
-    })).toEqual({
-      data: undefined,
-      errors: ['Must be equal to otherField']
-    });
-    expect((0, _.createValidation)({
-      type: 'equalsToField',
-      field: 'otherField',
-      getMessage: to => to
-    })('1234', {
-      otherField: '123'
-    })).toEqual({
-      data: undefined,
-      errors: ['otherField']
-    });
-    expect((0, _.createValidation)({
-      type: 'equalsToField',
-      field: 'otherField'
-    })('123', {
-      otherField: '123'
-    })).toEqual({
-      data: '123',
-      errors: undefined
-    });
-    expect((0, _.createValidation)({
-      type: 'equalsToField',
-      field: 'otherField'
-    })(123, {
-      otherField: 123
-    })).toEqual({
-      data: 123,
-      errors: undefined
-    });
-    expect((0, _.createValidation)({
-      type: 'equalsToField',
-      field: 'otherField'
-    })(true, {
-      otherField: true
-    })).toEqual({
-      data: true,
-      errors: undefined
-    });
-    expect((0, _.createValidation)({
-      type: 'equalsToField',
-      field: 'otherField'
-    })(false, {
-      otherField: false
-    })).toEqual({
-      data: false,
-      errors: undefined
-    });
-  });
-  it('supports regex', () => {
-    expect((0, _.createValidation)({
-      type: 'regex',
-      regex: /^[0-9]*$/i
-    })('1234a')).toEqual({
-      data: undefined,
-      errors: ['Invalid format']
-    });
-    expect((0, _.createValidation)({
-      type: 'regex',
-      regex: /^[0-9]*$/i
-    })('123 ')).toEqual({
-      data: undefined,
-      errors: ['Invalid format']
-    });
-    expect((0, _.createValidation)({
-      type: 'regex',
-      regex: /^[0-9]*$/i
-    })(1)).toEqual({
-      data: 1,
-      errors: undefined
-    });
-    expect((0, _.createValidation)({
-      type: 'regex',
-      regex: /^[0-9]*$/i,
-      getMessage: to => 'test'
-    })('1234a')).toEqual({
-      data: undefined,
-      errors: ['test']
-    });
-    expect((0, _.createValidation)({
-      type: 'regex',
-      regex: /^[0-9]*$/i
-    })('123')).toEqual({
-      data: '123',
-      errors: undefined
-    });
-  });
-  it('supports maxLength', () => {
-    expect((0, _.createValidation)({
-      type: 'maxLength',
-      max: 3
-    })('1234')).toEqual({
-      data: undefined,
-      errors: ['Maximum number of characters - 3']
-    });
-    expect((0, _.createValidation)({
-      type: 'maxLength',
-      max: 3,
-      getMessage: max => max
-    })('1234')).toEqual({
-      data: undefined,
-      errors: ['3']
-    });
-    expect((0, _.createValidation)({
-      type: 'maxLength',
-      max: 3,
-      getMessage: max => max
-    })('123')).toEqual({
-      data: '123',
-      errors: undefined
-    });
-    expect((0, _.createValidation)({
-      type: 'maxLength',
-      max: 3,
-      getMessage: max => max
-    })('12')).toEqual({
-      data: '12',
-      errors: undefined
-    });
-  });
-  it('supports maxLength with emoji', () => {
-    expect((0, _.createValidation)({
-      type: 'maxLength',
-      max: 4,
-      getMessage: max => max
-    })('❤️123')).toEqual({
-      data: '❤️123',
-      errors: undefined
-    });
-    expect((0, _.createValidation)({
-      type: 'maxLength',
-      max: 3
-    })('❤️123')).toEqual({
-      data: undefined,
-      errors: ['Maximum number of characters - 3']
-    });
-  });
-  it('supports minLength', () => {
-    expect((0, _.createValidation)({
-      type: 'minLength',
-      min: 3,
-      getMessage: min => min
-    })('1234')).toEqual({
-      data: '1234',
-      errors: undefined
-    });
-    expect((0, _.createValidation)({
-      type: 'minLength',
-      min: 3,
-      getMessage: min => min
-    })('123')).toEqual({
-      data: '123',
-      errors: undefined
-    });
-    expect((0, _.createValidation)({
-      type: 'minLength',
-      min: 3,
-      getMessage: min => min
-    })('12')).toEqual({
-      data: undefined,
-      errors: ['3']
-    });
-    expect((0, _.createValidation)({
-      type: 'minLength',
-      min: 3
-    })('12')).toEqual({
-      data: undefined,
-      errors: ['Minimum number of characters - 3']
-    });
-  });
-  it('supports minLength with emoji', () => {
-    expect((0, _.createValidation)({
-      type: 'minLength',
-      min: 3,
-      getMessage: min => min
-    })('❤️')).toEqual({
-      data: undefined,
-      errors: ['3']
-    });
-    expect((0, _.createValidation)({
-      type: 'minLength',
-      min: 3
-    })('❤️1')).toEqual({
-      data: undefined,
-      errors: ['Minimum number of characters - 3']
-    });
-    expect((0, _.createValidation)({
-      type: 'minLength',
-      min: 3
-    })('❤️123')).toEqual({
-      data: '❤️123',
-      errors: undefined
-    });
-  });
-  it('supports number', () => {
-    expect((0, _.createValidation)({
-      type: 'number'
-    })('1234')).toEqual({
-      data: 1234,
-      errors: undefined
-    });
-    expect((0, _.createValidation)({
-      type: 'number'
-    })('1234,5')).toEqual({
-      data: 1234.5,
-      errors: undefined
-    });
-    expect((0, _.createValidation)({
-      type: 'number'
-    })('1234.5')).toEqual({
-      data: 1234.5,
-      errors: undefined
-    });
-    expect((0, _.createValidation)({
-      type: 'number'
-    })(123)).toEqual({
-      data: 123,
-      errors: undefined
-    });
-    expect((0, _.createValidation)({
-      type: 'number'
-    })(null)).toEqual({
-      data: null,
-      errors: undefined
-    });
-    expect((0, _.createValidation)({
-      type: 'number'
-    })(undefined)).toEqual({
-      data: undefined,
-      errors: undefined
-    });
-    expect((0, _.createValidation)({
-      type: 'number'
-    })('')).toEqual({
-      data: null
-    });
-    expect((0, _.createValidation)({
-      type: 'number',
-      getMessage: () => 'Number'
-    })('12x')).toEqual({
-      data: undefined,
-      errors: ['Number']
-    });
-    expect((0, _.createValidation)({
-      type: 'number'
-    })('12x')).toEqual({
-      data: undefined,
-      errors: ['Must be a number']
-    });
-  });
-  it('supports minValue', () => {
-    expect((0, _.createValidation)({
-      type: 'minValue',
-      min: 1
-    })('')).toEqual({
-      data: null
-    });
-    expect((0, _.createValidation)({
-      type: 'minValue',
-      min: 1
-    })(0)).toEqual({
-      data: undefined,
-      errors: ['Must be at least 1']
-    });
-    expect((0, _.createValidation)({
-      type: 'minValue',
-      min: 1
-    })(-1)).toEqual({
-      data: undefined,
-      errors: ['Must be at least 1']
-    });
-    expect((0, _.createValidation)({
-      type: 'minValue',
-      min: 3,
-      getMessage: () => 'MinValue'
-    })(123)).toEqual({
-      data: 123,
-      errors: undefined
-    });
-    expect((0, _.createValidation)({
-      type: 'minValue',
-      min: 233,
-      getMessage: () => 'MinValue'
-    })(123)).toEqual({
-      data: undefined,
-      errors: ['MinValue']
-    });
-    expect((0, _.createValidation)({
-      type: 'minValue',
-      min: 333
-    })(22)).toEqual({
-      data: undefined,
-      errors: ['Must be at least 333']
-    });
-  });
-  it('supports maxValue', () => {
-    expect((0, _.createValidation)({
-      type: 'maxValue',
-      max: 10
-    })('')).toEqual({
-      data: null
-    });
-    expect((0, _.createValidation)({
-      type: 'maxValue',
-      max: 10
-    })(11)).toEqual({
-      data: undefined,
-      errors: ['Must be not more than 10']
-    });
-    expect((0, _.createValidation)({
-      type: 'maxValue',
-      max: 10
-    })(15)).toEqual({
-      data: undefined,
-      errors: ['Must be not more than 10']
-    });
-    expect((0, _.createValidation)({
-      type: 'maxValue',
-      max: 50,
-      getMessage: () => 'MaxValue'
-    })(25)).toEqual({
-      data: 25,
-      errors: undefined
-    });
-    expect((0, _.createValidation)({
-      type: 'maxValue',
-      max: 5,
-      getMessage: () => 'MaxValue'
-    })(10)).toEqual({
-      data: undefined,
-      errors: ['MaxValue']
-    });
-    expect((0, _.createValidation)({
-      type: 'maxValue',
-      max: 100
-    })(200)).toEqual({
-      data: undefined,
-      errors: ['Must be not more than 100']
-    });
-  });
-  it('supports string', () => {
-    expect((0, _.createValidation)({
-      type: 'string',
-      getMessage: () => 'String'
-    })('1234')).toEqual({
-      data: '1234',
-      errors: undefined
-    });
-    expect((0, _.createValidation)({
-      type: 'string',
-      getMessage: () => 'String'
-    })('o ya !')).toEqual({
-      data: 'o ya !',
-      errors: undefined
-    });
-    expect((0, _.createValidation)({
-      type: 'string',
-      getMessage: () => 'String'
-    })(12)).toEqual({
-      data: undefined,
-      errors: ['String']
-    });
-    expect((0, _.createValidation)({
-      type: 'string'
-    })(true)).toEqual({
-      data: undefined,
-      errors: ['Must be a string']
-    });
-  });
-  it('supports boolean', () => {
-    expect((0, _.createValidation)({
-      type: 'boolean',
-      getMessage: () => 'Boolean'
-    })(undefined)).toEqual({
-      data: undefined,
-      errors: undefined
-    });
-    expect((0, _.createValidation)({
-      type: 'boolean',
-      getMessage: () => 'Boolean'
-    })(true)).toEqual({
-      data: true,
-      errors: undefined
-    });
-    expect((0, _.createValidation)({
-      type: 'boolean',
-      getMessage: () => 'Boolean'
-    })(false)).toEqual({
-      data: false,
-      errors: undefined
-    });
-    expect((0, _.createValidation)({
-      type: 'boolean',
-      getMessage: () => 'Boolean'
-    })('true')).toEqual({
-      data: true,
-      errors: undefined
-    });
-    expect((0, _.createValidation)({
-      type: 'boolean',
-      getMessage: () => 'Boolean'
-    })('false')).toEqual({
-      data: false,
-      errors: undefined
-    });
-    expect((0, _.createValidation)({
-      type: 'boolean',
-      getMessage: () => 'Boolean'
-    })('FAlse')).toEqual({
-      data: false,
-      errors: undefined
-    });
-    expect((0, _.createValidation)({
-      type: 'boolean',
-      getMessage: () => 'Boolean'
-    })('truec')).toEqual({
-      data: undefined,
-      errors: ['Boolean']
-    });
-    expect((0, _.createValidation)({
-      type: 'boolean',
-      getMessage: () => 'Boolean'
-    })(0)).toEqual({
-      data: undefined,
-      errors: ['Boolean']
-    });
-    expect((0, _.createValidation)({
-      type: 'boolean'
-    })('truec')).toEqual({
-      data: undefined,
-      errors: ['Must be a boolean']
-    });
-  });
-  it('supports email', () => {
-    expect((0, _.createValidation)({
-      type: 'email',
-      getMessage: () => 'Wrong email'
-    })('test@test.com')).toEqual({
-      data: 'test@test.com',
-      errors: undefined
-    });
-    expect((0, _.createValidation)({
-      type: 'email',
-      getMessage: () => 'Wrong email'
-    })('email')).toEqual({
-      data: undefined,
-      errors: ['Wrong email']
-    });
-    expect((0, _.createValidation)({
-      type: 'email',
-      getMessage: () => 'Wrong email'
-    })('email@')).toEqual({
-      data: undefined,
-      errors: ['Wrong email']
-    });
-    expect((0, _.createValidation)({
-      type: 'email',
-      getMessage: () => 'Wrong email'
-    })('email@.com')).toEqual({
-      data: undefined,
-      errors: ['Wrong email']
-    });
-    expect((0, _.createValidation)({
-      type: 'email'
-    })('email@.com')).toEqual({
-      data: undefined,
-      errors: ['Invalid email format']
-    });
-    expect((0, _.createValidation)({
-      type: 'email'
-    })('email.@mail.com')).toEqual({
-      data: undefined,
-      errors: ['Invalid email format']
-    });
-  });
-  it('supports alphanumeric', () => {
-    expect((0, _.createValidation)({
-      type: 'alphanumeric',
-      getMessage: () => 'alphanumeric'
-    })('te123Aa')).toEqual({
-      data: 'te123Aa',
-      errors: undefined
-    });
-    expect((0, _.createValidation)({
-      type: 'alphanumeric',
-      getMessage: () => 'alphanumeric'
-    })('asd_')).toEqual({
-      data: undefined,
-      errors: ['alphanumeric']
-    });
-    expect((0, _.createValidation)({
-      type: 'alphanumeric'
-    })('Aa 1')).toEqual({
-      data: undefined,
-      errors: ['Only alphanumeric characters']
-    });
-  });
-  it('supports alphanumeric', () => {
-    expect((0, _.createValidation)({
-      type: 'alphanumeric',
-      getMessage: () => 'alphanumeric'
-    })('te123Aa')).toEqual({
-      data: 'te123Aa',
-      errors: undefined
-    });
-    expect((0, _.createValidation)({
-      type: 'alphanumeric',
-      getMessage: () => 'alphanumeric'
-    })('asd_')).toEqual({
-      data: undefined,
-      errors: ['alphanumeric']
-    });
-    expect((0, _.createValidation)({
-      type: 'alphanumeric'
-    })('Aa 1')).toEqual({
-      data: undefined,
-      errors: ['Only alphanumeric characters']
-    });
-  });
-  it('supports oneOf', () => {
-    expect((0, _.createValidation)({
-      type: 'oneOf',
-      validators: [{
-        type: 'equals',
-        to: 1,
-        getMessage: to => to
-      }, {
-        type: 'equals',
-        to: 2,
-        getMessage: to => to
-      }]
-    })('3')).toEqual({
-      data: undefined,
-      errors: ['1', '2']
-    });
-    expect((0, _.createValidation)({
-      type: 'oneOf',
-      validators: [{
-        type: 'equals',
-        to: 1,
-        getMessage: to => to
-      }, {
-        type: 'equals',
-        to: 2,
-        getMessage: to => to
-      }]
-    })(1)).toEqual({
-      data: 1,
-      errors: undefined
-    });
-    expect((0, _.createValidation)({
-      type: 'oneOf',
-      validators: [{
-        type: 'number',
-        getMessage: () => 'Number'
-      }, {
-        type: 'email',
-        getMessage: () => 'Email'
-      }]
-    })('xz')).toEqual({
-      data: undefined,
-      errors: ['Number', 'Email']
-    });
-    expect((0, _.createValidation)({
-      type: 'oneOf',
-      validators: [{
-        type: 'number',
-        getMessage: () => 'Number'
-      }, {
-        type: 'email',
-        getMessage: () => 'Email'
-      }]
-    })('123')).toEqual({
-      data: 123,
-      errors: undefined
-    });
-    expect((0, _.createValidation)({
-      type: 'oneOf',
-      validators: [{
-        type: 'number',
-        getMessage: () => 'Number'
-      }, {
-        type: 'email',
-        getMessage: () => 'Email'
-      }]
-    })('test@test.com')).toEqual({
-      data: 'test@test.com',
-      errors: undefined
-    });
-  });
-  it('supports all', () => {
-    expect((0, _.createValidation)({
-      type: 'all',
-      validators: [{
-        type: 'email',
-        getMessage: () => 'Email'
-      }, {
-        type: 'maxLength',
-        max: 1,
-        getMessage: () => 'MaxLength'
-      }]
-    })('xz')).toEqual({
-      data: undefined,
-      errors: ['Email', 'MaxLength']
-    });
-    expect((0, _.createValidation)({
-      type: 'all',
-      validators: [{
-        type: 'number',
-        getMessage: () => 'Number'
-      }, {
-        type: 'maxValue',
-        max: 11,
-        getMessage: () => 'MaxValue'
-      }]
-    })('12')).toEqual({
-      data: undefined,
-      errors: ['MaxValue']
-    });
-    expect((0, _.createValidation)({
-      type: 'all',
-      validators: [{
-        type: 'email',
-        getMessage: () => 'Email'
-      }, {
-        type: 'maxLength',
-        max: 1,
-        getMessage: () => 'MaxLength'
-      }]
-    })('x')).toEqual({
-      data: undefined,
-      errors: ['Email']
-    });
-    expect((0, _.createValidation)({
-      type: 'all',
-      validators: [{
-        type: 'number',
-        getMessage: () => 'Number'
-      }, {
-        type: 'maxValue',
-        max: 1,
-        getMessage: () => 'MaxValue'
-      }]
-    })('1')).toEqual({
-      data: 1,
-      errors: undefined
-    });
-  });
-  it('supports nesting of all/oneOf', () => {
-    expect((0, _.createValidation)({
-      type: 'all',
-      validators: [{
-        type: 'oneOf',
-        validators: [{
-          type: 'number',
-          getMessage: () => 'Number'
-        }, {
-          type: 'email',
-          getMessage: () => 'Email'
-        }]
-      }, {
-        type: 'maxLength',
-        max: 1,
-        getMessage: () => 'MaxLength'
-      }]
-    })('xz')).toEqual({
-      data: undefined,
-      errors: ['Number', 'Email', 'MaxLength']
-    });
-    expect((0, _.createValidation)({
-      type: 'all',
-      validators: [{
-        type: 'oneOf',
-        validators: [{
-          type: 'number',
-          getMessage: () => 'Number'
-        }, {
-          type: 'email',
-          getMessage: () => 'Email'
-        }]
-      }, {
-        type: 'maxLength',
-        max: 15,
-        getMessage: () => 'MaxLength'
-      }]
-    })('test@test.com')).toEqual({
-      data: 'test@test.com',
-      errors: undefined
-    });
-  });
-  it('can handle login validation', () => {
-    const loginValidation = (0, _.createValidation)({
-      type: 'all',
-      validators: [{
-        type: 'required',
-        getMessage: () => 'Required'
-      }, {
-        type: 'oneOf',
-        validators: [{
-          type: 'all',
-          validators: [{
-            type: 'alphanumeric',
-            getMessage: () => 'AlphaNumeric'
-          }, {
-            type: 'minLength',
-            min: 3,
-            getMessage: () => '{min}'
-          }]
-        }, {
-          type: 'email',
-          getMessage: () => 'Email'
-        }]
-      }]
-    });
-    expect(loginValidation('')).toEqual({
-      data: undefined,
-      errors: ['Required']
-    });
-    expect(loginValidation('aa')).toEqual({
-      data: undefined,
-      errors: ['3', 'Email']
-    });
-    expect(loginValidation('aa3')).toEqual({
-      data: 'aa3',
-      errors: undefined
-    });
-  });
-});