redux-form-validators/lib/__tests__/format-message.spec.js

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

"use strict";

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

var _validators = _interopRequireDefault(require("../validators"));

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

var formatMessage = global.ValidatorsFormatMessage;
describe('formatMessage', function () {
  it('should return the default value or id', function () {
    _assert["default"].strictEqual('foo', formatMessage({
      defaultMessage: 'foo',
      id: 'bar'
    }));

    _assert["default"].strictEqual('bar', formatMessage({
      id: 'bar'
    }));
  });
  it('should handle FormattedMessage obj', function () {
    _assert["default"].strictEqual('foo', formatMessage({
      props: {
        defaultMessage: 'foo',
        id: 'bar'
      }
    }));
  });
  it('should replace the vars', function () {
    _assert["default"].strictEqual('foo 1 2', formatMessage({
      defaultMessage: 'foo {bar} {foobar}',
      values: {
        bar: 1,
        foobar: 2
      }
    }));

    _assert["default"].strictEqual('foo 1', formatMessage({
      defaultMessage: 'foo {count, number}',
      values: {
        count: 1
      }
    }));

    _assert["default"].strictEqual('foo 1', formatMessage({
      defaultMessage: 'foo {count}',
      values: {
        count: 1
      }
    }));
  });
  it('should pluralize', function () {
    var msg = '{count, number} {count, plural, one {char} other {chars}}';

    _assert["default"].strictEqual('0 chars', formatMessage({
      defaultMessage: msg,
      values: {
        count: 0
      }
    }));

    _assert["default"].strictEqual('1 char', formatMessage({
      defaultMessage: msg,
      values: {
        count: 1
      }
    }));

    _assert["default"].strictEqual('9 chars', formatMessage({
      defaultMessage: msg,
      values: {
        count: 9
      }
    }));

    _assert["default"].strictEqual('1 char1 char', formatMessage({
      defaultMessage: msg + msg,
      values: {
        count: 1
      }
    }));

    msg = '{count, number} {count, plural, one {} other {chars}}';

    _assert["default"].strictEqual('1 ', formatMessage({
      defaultMessage: msg,
      values: {
        count: 1
      }
    }));

    msg = '{count, number} {count, plural, one {one} other {{size, number} chars}}';

    _assert["default"].strictEqual('1 one', formatMessage({
      defaultMessage: msg,
      values: {
        count: 1,
        size: 28
      }
    }));

    _assert["default"].strictEqual('2 28 chars', formatMessage({
      defaultMessage: msg,
      values: {
        count: 2,
        size: 28
      }
    }));
  });
  it("doesn't know how to pluralize", function () {
    var msg = '{count, number} {count, plural, one {} other {chars}}';

    _assert["default"].strictEqual(' chars', formatMessage({
      defaultMessage: msg,
      values: {}
    }));
  });
  it('should pluralize with given pluralRules', function () {
    var defaultPluralRules = _validators["default"].pluralRules;
    _validators["default"].pluralRules = {
      1: 'one',
      5: 'one',
      7: 'one',
      8: 'one',
      9: 'one',
      10: 'one',
      2: 'two',
      3: 'two',
      4: 'few',
      6: 'many'
    };
    var msg = '{count, plural, one {one} two {two_three} few {four} many {six} other {other}}';

    _assert["default"].strictEqual('other', formatMessage({
      defaultMessage: msg,
      values: {
        count: 0
      }
    }));

    _assert["default"].strictEqual('one', formatMessage({
      defaultMessage: msg,
      values: {
        count: 1
      }
    }));

    _assert["default"].strictEqual('two_three', formatMessage({
      defaultMessage: msg,
      values: {
        count: 2
      }
    }));

    _assert["default"].strictEqual('two_three', formatMessage({
      defaultMessage: msg,
      values: {
        count: 3
      }
    }));

    _assert["default"].strictEqual('four', formatMessage({
      defaultMessage: msg,
      values: {
        count: 4
      }
    }));

    _assert["default"].strictEqual('one', formatMessage({
      defaultMessage: msg,
      values: {
        count: 5
      }
    }));

    _assert["default"].strictEqual('six', formatMessage({
      defaultMessage: msg,
      values: {
        count: 6
      }
    }));

    _assert["default"].strictEqual('one', formatMessage({
      defaultMessage: msg,
      values: {
        count: 7
      }
    }));

    _assert["default"].strictEqual('one', formatMessage({
      defaultMessage: msg,
      values: {
        count: 8
      }
    }));

    _assert["default"].strictEqual('one', formatMessage({
      defaultMessage: msg,
      values: {
        count: 9
      }
    }));

    _assert["default"].strictEqual('one', formatMessage({
      defaultMessage: msg,
      values: {
        count: 10
      }
    }));

    _validators["default"].pluralRules = defaultPluralRules;
  });
});