How to use mocker-data-generator - 4 common examples

const mocker = require('mocker-data-generator').default(),
    EVENT_MOCK_SCHEMA = require('./mockSchema/events.schema'),
    USER_MOCK_SCHEMA = require('./mockSchema/users.schema'),
    CAMP_MOCK_SCHEMA = require('./mockSchema/camps.schema'),
    SUPPLIER_MOCK_SCHEMA = require('./mockSchema/suppliers.schema'),
    utils = require('../util/utils');

const generate = async (scale) => {
    if (scale > 30) {
        return Promise.reject('This scale is not yet supported');
    }
    const campCount = scale * 50;
    return new Promise(async (resolve, reject) => {
        // TODO - Currently only create single event - need to think about increment with `MIDBURN` text.
        await utils.preventPkErrors([EVENT_MOCK_SCHEMA, USER_MOCK_SCHEMA, CAMP_MOCK_SCHEMA, SUPPLIER_MOCK_SCHEMA]);
        mocker
            .schema(EVENT_MOCK_SCHEMA.NAME, EVENT_MOCK_SCHEMA.STRUCTURE, scale * 2)

const mockData = async ({
  template = null,
  templates = null,
  total = 10,
  name = null,
  args = {},
  path = null,
  hiddenFields = [],
}: MockDataArguments): Promise => {
  /* eslint-disable no-param-reassign */
  const m = mocker();

  try {
    if (template) {
      // single schema
      if (typeof template !== 'function' && Object.keys(tpl).indexOf(template) === -1) {
        throw new Error('That template does not exist');
      }

      if (hiddenFields.length) args.hiddenFields = hiddenFields;
      const modelName = name || (typeof template === 'string' && template) || 'data';
      const processedTemplate = processTemplate(template, args);

      m.schema(modelName, processedTemplate, total);
    } else if (templates) {
      // multiple schemas
      templates.forEach((tmpl: any, i: number): void => {

it('between formats will default to 01 January, 1970 UTC if start is missing', (done) => {
        const endDate = moment().add(2, 'h');
        const newDate = new Date(0);
        const opConfig = { format: 'isoBetween', end: endDate.format(), date_key: 'created' };
        const resultSchema = schema(opConfig);

        mocker()
            .schema('schema', resultSchema, 1)
            .build()
            .then((data) => {
                const finalResult = data.schema[0];
                expect(new Date(finalResult.created)).toBeLessThan(new Date(endDate.format()));
                expect(new Date(finalResult.created)).toBeGreaterThan(newDate);
                done();
            })
            .catch((err) => {
                fail(err);
                done();
            });
    });

if (opConfig.stress_test) {
            return mocker()
                .schema('schema', dataSchema, 1)
                .build()
                .then((dataObj) => {
                    const results = [];
                    const data = dataObj.schema[0];
                    for (let i = 0; i < msg; i += 1) {
                        results.push(data);
                    }
                    return results;
                })
                .catch(err => Promise.reject(`could not generate data error: ${parseError(err)}`));
        }

        return mocker()
            .schema('schema', dataSchema, msg)
            .build()
            .then(dataObj => dataObj.schema)
            .catch(err => Promise.reject(`could not generate data error: ${parseError(err)}`));
    };
}