simpl-schema-mockdoc/dist/index.js

Allow to easily create mock document for jest from simpl-schema

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.getMockDoc = exports.clearMockValues = undefined;

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

var _faker = require('faker');

var _faker2 = _interopRequireDefault(_faker);

var _simplSchema = require('simpl-schema');

var _simplSchema2 = _interopRequireDefault(_simplSchema);

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

_simplSchema2.default.extendOptions(['mockValue']);

var getMockDoc = function getMockDoc(schema, prefix, addId) {
  var docPrefix = prefix || 'mock';
  var mockDoc = {};
  var seed = _lodash2.default.chain(docPrefix).split('').map(function (char) {
    return char.charCodeAt();
  }).sum().value();
  _faker2.default.seed(seed);

  if (process.env.NODE_ENV !== 'test' || !schema) {
    return mockDoc;
  }

  _lodash2.default.each(schema._schema, function (field, key) {
    var fieldValue = null;

    // If field defined by parent
    var currentMockValue = _lodash2.default.get(mockDoc, '' + key.replace('.$', '.0'));
    if (!_lodash2.default.isUndefined(currentMockValue, key)) {
      return;
    }

    var defField = _lodash2.default.get(field, 'type.definitions[0]') || field;

    try {
      if (!_lodash2.default.isUndefined(field.mockValue)) {
        fieldValue = field.mockValue;
      } else if (!_lodash2.default.isUndefined(field.defaultValue)) {
        fieldValue = field.defaultValue;
      } else if (!_lodash2.default.isUndefined(field.autoValue)) {
        fieldValue = field.autoValue.call({ operator: null });
      } else if (_lodash2.default.isArray(defField.allowedValues)) {
        fieldValue = defField.allowedValues[0];
      } else {
        throw new Error('Invalid');
      }
    } catch (err) {
      // Need 'defField' for field like: `key: Boolean`
      var fieldType = defField.type || defField;

      switch (fieldType) {
        case Date:
          fieldValue = new Date(_faker2.default.random.number() * 1000);
          break;

        case Number:
        case _simplSchema2.default.Integer:
          fieldValue = defField.min || defField.max || _faker2.default.random.number();
          break;

        case String:
          fieldValue = '' + docPrefix + _lodash2.default.upperFirst(_lodash2.default.camelCase(key));
          if (defField.regEx) {
            switch (String(defField.regEx)) {
              case String(String(_simplSchema2.default.RegEx.Email)):
              case String(String(_simplSchema2.default.RegEx.EmailWithTLD)):
                fieldValue = _faker2.default.internet.email();
                break;

              case String(_simplSchema2.default.RegEx.Domain):
              case String(_simplSchema2.default.RegEx.WeakDomain):
                fieldValue = '' + _faker2.default.internet.domainName() + _faker2.default.internet.domainWord();
                break;

              case String(_simplSchema2.default.RegEx.IP):
              case String(_simplSchema2.default.RegEx.IPv4):
                fieldValue = _faker2.default.internet.ip();
                break;

              case String(_simplSchema2.default.RegEx.IPv6):
                fieldValue = _faker2.default.internet.ipv6();
                break;

              case String(_simplSchema2.default.RegEx.Url):
                fieldValue = _faker2.default.internet.url();
                break;

              case String(_simplSchema2.default.RegEx.Id):
                fieldValue = _faker2.default.random.alphaNumeric(17);
                break;

              case String(_simplSchema2.default.RegEx.ZipCode):
                fieldValue = _faker2.default.address.zipCode();
                break;

              case String(_simplSchema2.default.RegEx.Phone):
                fieldValue = key.match(/mobile/i) ? _faker2.default.phone.phoneNumber('074## ######') : _faker2.default.phone.phoneNumber('012## ######');
                break;

              default:
                break;
            }
          }
          break;

        case Boolean:
          fieldValue = !_lodash2.default.isUndefined(defField.defaultValue) ? defField.defaultValue : _faker2.default.random.boolean();
          break;

        case Object:
          {
            fieldValue = {};
            break;
          }

        case Array:
          fieldValue = [];
          break;

        default:
          if (fieldType instanceof _simplSchema2.default || _lodash2.default.get(fieldType, '_schema')) {
            fieldValue = getMockDoc(fieldType, prefix);
          }
          break;
      }
    }

    _lodash2.default.set(mockDoc, key.replace('.$', '.0'), fieldValue);
  });

  if (addId) {
    mockDoc._id = _faker2.default.random.alphaNumeric(17);
  }

  return mockDoc;
};

var clearMockValues = function clearMockValues(schema) {
  if (process.env.NODE_ENV === 'test') {
    return schema;
  }

  _lodash2.default.each(schema._schema, function (field, key) {
    schema._schema[key] = _lodash2.default.omit(field, 'mockValue');
  });
  return schema;
};

exports.clearMockValues = clearMockValues;
exports.getMockDoc = getMockDoc;