redux-form-validators/lib/__tests__/file.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_FILE = 'form.errors.file';
var ERROR_ACCEPT = 'form.errors.fileAccept';
var ERROR_TOO_BIG = 'form.errors.fileTooBig';
var ERROR_TOO_FEW = 'form.errors.fileTooFew';
var ERROR_TOO_MANY = 'form.errors.fileTooMany';
var ERROR_TOO_SMALL = 'form.errors.fileTooSmall';
var SIZE_UNITS = {
  B: 1,
  KB: 1024,
  MB: 1048576,
  GB: 1073741824,
  TB: 1099511627776,
  PB: 1125899906842624,
  EB: 1152921504606847000
};

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

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

    _assert["default"].strictEqual(ERROR_FILE, test({}));

    _assert["default"].strictEqual(ERROR_FILE, test([]));
  });
  it('should be invalid when `value` is a File with a bad type', function () {
    _assert["default"].strictEqual(ERROR_ACCEPT, test(new File({
      type: 'audio/mp3',
      name: 'foo.bar'
    }), {
      accept: 'mp3,bar'
    }));

    _assert["default"].strictEqual(ERROR_ACCEPT, test(new File({
      type: 'audio/mp3',
      name: '.htaccess'
    }), {
      accept: '.htaccess'
    }));

    _assert["default"].strictEqual(ERROR_ACCEPT, test(new FileList([{
      type: 'video/mp4',
      name: 'foo.bar'
    }]), {
      accept: '.mp4'
    }));

    _assert["default"].strictEqual(ERROR_ACCEPT, test(new FileList([{
      type: 'video/mp4',
      name: 'foo.jpeg'
    }]), {
      accept: '.jp*g'
    }));

    _assert["default"].strictEqual(ERROR_ACCEPT, test(new FileList([{
      type: 'jpeg',
      name: 'foo.bar'
    }, {
      type: 'imag/png',
      name: 'foo.zip'
    }]), {
      accept: 'audio/*, .foo'
    }));

    _assert["default"].strictEqual(ERROR_ACCEPT, test(new FileList([{
      type: 'jpeg',
      name: 'foo.bar'
    }, {
      type: 'imag/png',
      name: 'foo.zip'
    }]), {
      accept: 'audio/*, .zip'
    }));

    _assert["default"].strictEqual(ERROR_ACCEPT, test(new FileList([{
      type: 'application/zip',
      name: 'foo.bar'
    }]), {
      accept: '.application,foo.bar,.zip,application/gzip'
    }));
  });
  it("should be invalid when `value` doesn't contain the right amount of files", function () {
    _assert["default"].strictEqual(ERROR_TOO_FEW, test(new File(), {
      minFiles: 2
    }));

    _assert["default"].strictEqual(ERROR_TOO_FEW, test(new File({
      name: 'foo'
    }), {
      minFiles: 2
    }));

    _assert["default"].strictEqual(ERROR_TOO_FEW, test(new FileList({
      length: 0
    })));

    _assert["default"].strictEqual(ERROR_TOO_FEW, test(new FileList({
      length: 0
    }), {
      minFiles: 1
    }));

    _assert["default"].strictEqual(ERROR_TOO_FEW, test(new FileList({
      length: 1
    }), {
      minFiles: 2
    }));

    _assert["default"].strictEqual(ERROR_TOO_FEW, test(new FileList([{}]), {
      minFiles: 2
    }));

    _assert["default"].strictEqual(ERROR_TOO_MANY, test(new File(), {
      maxFiles: 0
    }));

    _assert["default"].strictEqual(ERROR_TOO_MANY, test(new FileList([{
      name: 'foo'
    }, {}]), {
      maxFiles: 1
    }));
  });
  it('should be invalid when `value` is a File with a bad size', function () {
    _assert["default"].ok(!test(new File({
      size: 1024
    }), {
      minSize: 512
    }));

    Object.keys(SIZE_UNITS).forEach(function (unit) {
      var size = SIZE_UNITS[unit];
      var size1 = size - (size > 1125899906842624 ? 1000 : 1);

      _assert["default"].strictEqual(ERROR_TOO_SMALL, test(new File({
        size: size1
      }), {
        minSize: size
      }));

      _assert["default"].strictEqual(ERROR_TOO_SMALL, test(new FileList([{
        size: size1
      }]), {
        minSize: size
      }));

      _assert["default"].strictEqual(ERROR_TOO_SMALL, test(new FileList([{
        size: size1
      }]), {
        minSize: '1' + unit
      }));

      _assert["default"].strictEqual(ERROR_TOO_SMALL, test(new FileList([{
        size: size1
      }]), {
        minSize: '1 ' + unit
      }));

      _assert["default"].strictEqual(ERROR_TOO_SMALL, test(new FileList([{
        size: size1
      }]), {
        minSize: '1. ' + unit
      }));

      _assert["default"].strictEqual(ERROR_TOO_SMALL, test(new FileList([{
        size: size1
      }]), {
        minSize: '1.0001 ' + unit
      }));

      _assert["default"].strictEqual(ERROR_TOO_SMALL, test(new FileList([{
        size: size1
      }]), {
        minSize: '1.0001' + unit
      }));

      var size2 = size + (size > 1125899906842624 ? 1000 : 1);

      _assert["default"].strictEqual(ERROR_TOO_BIG, test(new File({
        size: size2
      }), {
        maxSize: size
      }));

      _assert["default"].strictEqual(ERROR_TOO_BIG, test(new FileList([{
        size: size2
      }]), {
        maxSize: size
      }));

      _assert["default"].strictEqual(ERROR_TOO_BIG, test(new FileList([{
        size: size2
      }]), {
        maxSize: '1' + unit
      }));

      _assert["default"].strictEqual(ERROR_TOO_BIG, test(new FileList([{
        size: size2
      }]), {
        maxSize: '1 ' + unit
      }));

      _assert["default"].strictEqual(ERROR_TOO_BIG, test(new FileList([{
        size: size2
      }]), {
        maxSize: '1. ' + unit
      }));

      _assert["default"].strictEqual(ERROR_TOO_BIG, test(new FileList([{
        size: size2
      }]), {
        maxSize: '0.9999 ' + unit
      }));

      _assert["default"].strictEqual(ERROR_TOO_BIG, test(new FileList([{
        size: size2
      }]), {
        maxSize: '0.9999' + unit
      }));
    });
  });
  it('should output an error if an error occurs parsing minSize or maxSize', function () {
    test(new File(), {
      minSize: 'abc'
    });

    _assert["default"].ok(console.__lastErrorIncludes('size') && console.__lastErrorIncludes('unknown'));

    test(new File(), {
      maxSize: '5MKB'
    });

    _assert["default"].ok(console.__lastErrorIncludes('size') && console.__lastErrorIncludes('unknown'));
  });
  it('should be valid when `value` is a valid FileList/File', function () {
    _assert["default"].ok(!test(new FileList([new File()])));

    _assert["default"].ok(!test(new FileList([{}])));

    _assert["default"].ok(!test([new File()]));

    _assert["default"].ok(!test(new File()));
  });
  it('should be valid when `value` is a File with a correct type', function () {
    _assert["default"].ok(!test(new File({
      type: 'audio/mp3',
      name: 'foo.bar'
    }), {
      accept: '.bar'
    }));

    _assert["default"].ok(!test(new File({
      type: 'audio/mp3',
      name: 'foo.bar'
    }), {
      accept: '.zip,    .bar '
    }));

    _assert["default"].ok(!test(new File({
      type: 'audio/mp3',
      name: 'foo.bar'
    }), {
      accept: 'audio/mp3'
    }));

    _assert["default"].ok(!test(new File({
      type: 'audio/mp3',
      name: 'foo.bar'
    }), {
      accept: '.zip,audio/mp3'
    }));

    _assert["default"].ok(!test(new FileList([{
      type: 'video/mp4',
      name: 'foo.bar'
    }]), {
      accept: 'video/*'
    }));

    _assert["default"].ok(!test(new FileList([{
      type: 'application/zip',
      name: 'foo.bar'
    }]), {
      accept: 'application*'
    }));

    _assert["default"].ok(!test(new FileList([{
      type: 'application/zip',
      name: 'foo.bar'
    }]), {
      accept: 'application/*'
    }));

    _assert["default"].ok(!test(new FileList([{
      type: 'application/pdf',
      name: 'foo.bar'
    }]), {
      accept: '*pdf'
    }));

    _assert["default"].ok(!test(new FileList([{
      type: 'application/x-pdf',
      name: 'foo.bar'
    }]), {
      accept: '*pdf'
    }));

    _assert["default"].ok(!test(new FileList([{
      type: 'abc',
      name: 'foo.jpg'
    }, {
      type: 'abc',
      name: 'foo.png'
    }]), {
      accept: '.gif, .jpg,.png'
    }));
  });
  it('should be valid when `value` contain the right amount of files', function () {
    _assert["default"].ok(!test(new File(), {
      minFiles: 1
    }));

    _assert["default"].ok(!test(new File(), {
      maxFiles: 1
    }));

    _assert["default"].ok(!test(new FileList(), {
      minFiles: 0
    }));

    _assert["default"].ok(!test(new FileList({
      length: 0
    }), {
      minFiles: 0
    }));

    _assert["default"].ok(!test(new FileList({
      length: 2
    }), {
      minFiles: 2
    }));

    _assert["default"].ok(!test(new FileList({
      length: 3
    }), {
      minFiles: 2
    }));

    _assert["default"].ok(!test(new FileList([{}, {}]), {
      minFiles: 2
    }));

    _assert["default"].ok(!test(new FileList([{}, {}, {}]), {
      minFiles: 2
    }));

    _assert["default"].ok(!test(new FileList({
      length: 2
    }), {
      maxFiles: 2
    }));

    _assert["default"].ok(!test(new FileList({
      length: 2
    }), {
      maxFiles: 3
    }));

    _assert["default"].ok(!test(new FileList([{}, {}]), {
      maxFiles: 2
    }));

    _assert["default"].ok(!test(new FileList([{}, {}]), {
      maxFiles: 3
    }));

    _assert["default"].ok(!test(new FileList([{}, {}, {}]), {
      maxFiles: -1
    }));
  });
  it('should be valid when `value` is a File with the correct size', function () {
    _assert["default"].ok(!test(new File({
      size: 1024
    }), {
      minSize: 512
    }));

    Object.keys(SIZE_UNITS).forEach(function (unit) {
      var size = SIZE_UNITS[unit];

      _assert["default"].ok(!test(new File({
        size: size
      }), {
        minSize: size
      }));

      _assert["default"].ok(!test(new FileList([{
        size: size
      }]), {
        minSize: size
      }));

      _assert["default"].ok(!test(new FileList([{
        size: size
      }]), {
        minSize: size - 1
      }));

      _assert["default"].ok(!test(new FileList([{
        size: size
      }]), {
        minSize: '1' + unit
      }));

      _assert["default"].ok(!test(new FileList([{
        size: size
      }]), {
        minSize: '1 ' + unit
      }));

      _assert["default"].ok(!test(new FileList([{
        size: size
      }]), {
        minSize: '1. ' + unit
      }));

      _assert["default"].ok(!test(new FileList([{
        size: size
      }]), {
        minSize: '0.99 ' + unit
      }));

      _assert["default"].ok(!test(new FileList([{
        size: size
      }]), {
        minSize: '0.99' + unit
      }));

      _assert["default"].ok(!test(new File({
        size: size
      }), {
        maxSize: size
      }));

      _assert["default"].ok(!test(new FileList([{
        size: size
      }]), {
        maxSize: size
      }));

      _assert["default"].ok(!test(new FileList([{
        size: size
      }]), {
        maxSize: size + 1
      }));

      _assert["default"].ok(!test(new FileList([{
        size: size
      }]), {
        maxSize: '1' + unit
      }));

      _assert["default"].ok(!test(new FileList([{
        size: size
      }]), {
        maxSize: '1 ' + unit
      }));

      _assert["default"].ok(!test(new FileList([{
        size: size
      }]), {
        maxSize: '1. ' + unit
      }));

      _assert["default"].ok(!test(new FileList([{
        size: size
      }]), {
        maxSize: '1.01 ' + unit
      }));

      _assert["default"].ok(!test(new FileList([{
        size: size
      }]), {
        maxSize: '1.01' + unit
      }));

      _assert["default"].ok(!test(new FileList([{
        size: size
      }]), {
        minSize: size,
        maxSize: size
      }));

      _assert["default"].ok(!test(new FileList([{
        size: size
      }]), {
        minSize: size - 1,
        maxSize: size + 1
      }));
    });
  });
  it('should use formatSize', function () {
    var formatMessage = _index["default"].formatMessage;
    var defaultValue = _index["default"].formatSize;
    var unitMap = {
      B: 'octets',
      KB: 'Ko'
    };
    _index["default"].formatMessage = ValidatorsFormatMessage;

    _index["default"].formatSize = function (size, unit) {
      return size + ' ' + unitMap[unit];
    };

    _assert["default"].strictEqual('2 octets', (0, _index.file)({
      msg: '{size}',
      minSize: '2B'
    })(new File({
      size: 1
    })));

    _assert["default"].strictEqual('1 Ko', (0, _index.file)({
      msg: '{size}',
      minSize: '1KB'
    })(new File({
      size: 1
    })));

    _assert["default"].strictEqual('1024 octets', (0, _index.file)({
      msg: '{size}',
      minSize: 1024
    })(new File({
      size: 1
    })));

    _index["default"].formatSize = defaultValue;
    _index["default"].formatMessage = formatMessage;
  });
  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_FILE + '2', test({}));

    _assert["default"].strictEqual(ERROR_ACCEPT + '2', test(new FileList([{
      type: 'video/mp4',
      name: 'foo'
    }]), {
      accept: '.zip'
    }));

    _assert["default"].strictEqual(ERROR_TOO_BIG + '2', test(new FileList([{
      size: 2
    }]), {
      maxSize: 1
    }));

    _assert["default"].strictEqual(ERROR_TOO_FEW + '2', test(new FileList([{}]), {
      minFiles: 2
    }));

    _assert["default"].strictEqual(ERROR_TOO_MANY + '2', test(new FileList([{}, {}]), {
      maxFiles: 1
    }));

    _assert["default"].strictEqual(ERROR_TOO_SMALL + '2', test(new FileList([{
      size: 1
    }]), {
      minSize: 2
    }));

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