redux-form-validators/lib/__tests__/add-validator.spec.js

Simple validations with redux-form / react-final-form

"use strict";

var _assert = _interopRequireDefault(require("assert"));

var _index = _interopRequireWildcard(require("../index"));

var _helper = _interopRequireDefault(require("./helper"));

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj["default"] = obj; return newObj; } }

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }

var fooValidator = (0, _index.addValidator)({
  defaultMessage: 'form.errors.foo',
  validator: function validator(options, value) {
    return value === 'foo';
  }
});
var barValidator = (0, _index.addValidator)({
  validator: function validator(options, value, allValues) {
    return value === 'bar' && allValues['foobar'] === 'foobar';
  }
});
var invalidValidator = (0, _index.addValidator)({
  validator: function validator(options, value) {
    return options.invalid === 'valid';
  }
});
var digitValidator = (0, _index.addValidator)({
  validator: function validator(options, value, allValues) {
    if (options.digits !== value.replace(/[^0-9]/g, '').length) {
      return {
        id: 'form.errors.digits'
      };
    }
  }
});

function test(validator, value, params, allValues, props, name) {
  return (0, _helper["default"])(validator(params)(value, allValues, props, name));
}

describe('Validator: addValidator', function () {
  it('should be invalid', function () {
    _assert["default"].strictEqual('form.errors.foo', test(fooValidator, 'bar'));

    _assert["default"].strictEqual('form.errors.bar', test(barValidator, 'foo', {
      msg: 'form.errors.bar'
    }, {
      bar: 'foo'
    }));

    _assert["default"].strictEqual('form.errors.invalid', test(invalidValidator, '', {
      invalid: 'invalid'
    }));

    _assert["default"].strictEqual('form.errors.digits', test(digitValidator, '1 23', {
      digits: 4
    }));
  });
  it('should be valid', function () {
    _assert["default"].ok(!test(fooValidator, 'foo'));

    _assert["default"].ok(!test(fooValidator, '', {
      allowBlank: true
    }));

    _assert["default"].ok(!test(fooValidator, 'bar', {
      "if": function _if() {
        return false;
      }
    }));

    _assert["default"].ok(!test(fooValidator, 'bar', {
      unless: function unless() {
        return true;
      }
    }));

    _assert["default"].ok(!test(barValidator, 'bar', {}, {
      foobar: 'foobar'
    }));

    _assert["default"].ok(!test(invalidValidator, '', {
      invalid: 'valid'
    }));

    _assert["default"].ok(!test(digitValidator, '1 2 3 4', {
      digits: 4
    }));
  });
  it('should not use formatMessage when valid', function () {
    var defaultValue = _index["default"].formatMessage;
    /* istanbul ignore next */

    _index["default"].formatMessage = function (msg) {
      return msg.id;
    };

    _assert["default"].ok(!digitValidator({
      digits: 4
    })('1 2 3 4'));

    _index["default"].formatMessage = defaultValue;
  });
  it('should use formatMessage', function () {
    var defaultValue = _index["default"].formatMessage;

    _index["default"].formatMessage = function (msg) {
      return Object.assign({}, msg, {
        id: msg.id + '2'
      });
    };

    _assert["default"].strictEqual('form.errors.foo2', test(fooValidator, 'bar'));

    _index["default"].formatMessage = defaultValue;
  });
});