redux-form-validators/lib/__tests__/email.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 ERROR_EMAIL = 'form.errors.email';
var ERROR_EMAIL_DOMAIN = 'form.errors.emailDomain';

function test(value, params) {
  return (0, _helper["default"])((0, _index.email)(params)(value));
}

describe('Validator: email', function () {
  it('should be invalid when `value` is not a valid email', function () {
    _assert["default"].strictEqual(ERROR_EMAIL, test(''));

    _assert["default"].strictEqual(ERROR_EMAIL, test('foo'));

    _assert["default"].strictEqual(ERROR_EMAIL, test('foo@bar'));

    _assert["default"].strictEqual(ERROR_EMAIL, test('f@b.'));
  });
  it('should be valid when `value` is a valid email', function () {
    _assert["default"].ok(!test('a@b.com'));

    _assert["default"].ok(!test('foo@bar.net'));
  });
  it('should be valid when the domain is an accepted domain', function () {
    _assert["default"].ok(!test('a@b.com', {
      domainWhitelist: ['a.com', 'b.com', 'c.com']
    }));

    _assert["default"].ok(!test('a@b.com', {
      domainWhitelist: ['B.com']
    }));

    _assert["default"].ok(!test('a@B.COM', {
      domainWhitelist: ['b.com']
    }));

    _assert["default"].ok(!test('a@b.com', {
      domainWhitelist: ['b.*']
    }));

    _assert["default"].ok(!test('a@b.com', {
      domainWhitelist: ['B.*']
    }));

    _assert["default"].ok(!test('a@B.COM', {
      domainWhitelist: ['b.*']
    }));

    _assert["default"].ok(!test('a@b.com', {
      domainWhitelist: ['*.com']
    }));

    _assert["default"].ok(!test('a@b.com', {
      domainWhitelist: ['*']
    }));

    _assert["default"].ok(!test('a@sub.stuff.com', {
      domainWhitelist: ['*.stuff.*']
    }));

    _assert["default"].ok(!test('a@b.com', {
      domainBlacklist: ['a.com', 'c.com', 'd.com']
    }));

    _assert["default"].ok(!test('a@b.com', {
      domainBlacklist: ['ab*.com', 'ba*.com']
    }));
  });
  it('should be invalid when the domain is not an accepted domain', function () {
    _assert["default"].strictEqual(ERROR_EMAIL_DOMAIN, test('a@b.com', {
      domainWhitelist: ['a.com', 'c.com', 'd.com']
    }));

    _assert["default"].strictEqual(ERROR_EMAIL_DOMAIN, test('a@b.com', {
      domainWhitelist: ['ab*.com', 'ba*.com']
    }));

    _assert["default"].strictEqual(ERROR_EMAIL_DOMAIN, test('a@b.com', {
      domainBlacklist: ['a.com', 'b.com', 'c.com']
    }));

    _assert["default"].strictEqual(ERROR_EMAIL_DOMAIN, test('a@b.com', {
      domainBlacklist: ['b.*']
    }));

    _assert["default"].strictEqual(ERROR_EMAIL_DOMAIN, test('a@b.com', {
      domainBlacklist: ['*.com']
    }));

    _assert["default"].strictEqual(ERROR_EMAIL_DOMAIN, test('a@b.com', {
      domainBlacklist: ['*']
    }));

    _assert["default"].strictEqual(ERROR_EMAIL_DOMAIN, test('a@sub.stuff.com', {
      domainBlacklist: ['*.stuff.*']
    }));
  });
  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(ERROR_EMAIL + '2', test('foo'));

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