How to use the faker.lorem function in faker

await token.mint(accounts[0], denormalizeBalance(100), {from: accounts[0]});
  console.log('Mining tokens 2');
  await token.mint(accounts[1], denormalizeBalance(200), {from: accounts[0]});
  console.log('Mining tokens 3');
  await token.mint(accounts[2], denormalizeBalance(300), {from: accounts[0]});

  for(let i = 0; i < 9; i++) {
    console.log('Generating event ' + i);

    const category = faker.random.arrayElement([1, 2, 3]);
    const locale = faker.random.arrayElement(['en'/*, 'ru', 'kz'*/]);
    const startDate = Math.floor((new Date()).getTime() / 1000) + 1260; // parseInt(faker.date.future(0.1).getTime()/1000);
    const endDate = startDate + 10;
    const bidType = faker.lorem.words();

    const tags = [faker.lorem.word(), faker.lorem.word(), faker.lorem.word()];
    const results = [{description: 'result_description_1', coefficient: 0}, {description: 'result_description_2', coefficient: 0}, {description: 'result_description_3', coefficient: 0}];

    const deposit = denormalizeBalance(faker.random.number({min: 10, max: 100}));

    const bytes = serializeEvent({
      name: faker.lorem.sentence(),  // name
      description: faker.lorem.sentence(),  // description
      deposit: deposit,  // deposit
      bidType: bidType,
      category: category,
      locale: locale,
      startDate: startDate,
      endDate: endDate,
      sourceUrl: faker.internet.url(),  // sourceUrl
      tags: tags,
      results: results,

describe('Higher-order component', () => {
	const name = faker.lorem.word();

	const baseComponent = getComponent();
	baseComponent.displayName = name;

	const hoc = Textdomain({}, '')(baseComponent);

	test('is React Component', () => {
		expect(Component.isPrototypeOf(hoc)).toBeTruthy();
	});

	test('has proper display name', () => {
		expect(hoc.displayName).toBe(`WithGettext(${name})`);
	});

	test('has childContextTypes', () => {
		expect(hoc.childContextTypes).toEqual({

const createTransfer = (user, sourceAccountId) => {
   const transfer = new Transfer({
      type: faker.random.arrayElement(['normal', 'turbo']),
      payeeName: `${faker.name.firstName()} ${faker.name.lastName()}`,
      date: faker.date.between('2020-01-01', '2020-12-31'),
      amount: faker.finance.amount(1, 2500, 2),
      status: faker.random.arrayElement(['planned', 'done']),
      reference: faker.lorem.words(3).substring(0, 20),
      sourceAccountId,
      sender: user._id,
      recipient: mongoose.Types.ObjectId()
   });

   return transfer.save();
};

return {
    id: `id_${index}`,
    avartar: faker.image.avatar(),
    county: faker.address.county(),
    email: faker.internet.email(),
    title: faker.name.prefix(),
    firstName: faker.name.firstName(),
    lastName: faker.name.lastName(),
    street: faker.address.streetName(),
    zipCode: faker.address.zipCode(),
    date: faker.date.past().toLocaleDateString(),
    bs: faker.company.bs(),
    catchPhrase: faker.company.catchPhrase(),
    companyName: faker.company.companyName(),
    words: faker.lorem.words(),
    sentence: faker.lorem.sentence()
  };
}

export const getBrokerLoaderData: () => Broker = () => ({
  name: faker.lorem.word(),
  description: faker.lorem.words(11),
  logo: "",
  terms: faker.lorem.word(),
  assets: faker.lorem.word(),
  fee: faker.random.number(),
  leverageMin: faker.random.number(),
  leverageMax: faker.random.number(),
  accountTypes: [
    {
      id: faker.lorem.word(),
      name: faker.lorem.word(),
      description: faker.lorem.words(11),
      type: "MetaTrader4",
      leverages: [10],
      currencies: ["GVT"],
      minimumDepositsAmount: {},

import faker from "faker";
import { getWalletBaseLoaderData } from "shared/components/wallet/components/wallet-loader";
import { getRandomInteger } from "shared/utils/helpers";

import { FundWithdrawInfoResponse } from "./fund-withdraw.types";

export const FundWithdrawLoaderData: FundWithdrawInfoResponse = {
  withdrawInfo: {
    exitFee: getRandomInteger(0, 100),
    title: faker.lorem.word(),
    availableToWithdraw: getRandomInteger(0, 100),
    rate: getRandomInteger(0, 100)
  },
  wallets: [getWalletBaseLoaderData()]
};

const seedProblems = () => db.Promise.map(Array(...Array(200)).map(_ => ({
  name: faker.lorem.words(),
  description: faker.lorem.sentence(),
  difficulty: ['easy', 'medium', 'hard'][rand(2)],
  organization_name: organizations[rand(organizations.length - 1)].name,
  author_id: rand(11, 60)
})), problem => db.model('problems').create(problem));

api.loadSource(({ addContentType, slugify }) => {
    const contentType = addContentType({
      typeName: options.typeName,
      route: options.route
    })

    for (let i = 0; i < options.numNodes; i++) {
      const random = faker.random.number({ min: 3, max: 6 })
      const title = faker.lorem.sentence(random).slice(0, -1)

      contentType.addNode({
        title,
        id: faker.random.uuid(),
        slug: slugify(title),
        date: faker.date.past(10),
        excerpt: faker.lorem.sentences(2),
        content: faker.lorem.paragraphs(10),
        author: faker.name.findName(),
        thumbnail: faker.image.people(),
        email: faker.internet.exampleEmail(),
        avatar: faker.image.avatar()
      })
    }
  })
}

stories.add("Icon with action", () => (
  <div>
    
  </div>
));

const firstPosition: number = 0;

      if (index >= firstPosition) {
        return this.parseRamlValue(faker[key][PROPERTIES_NAME[key][index]](), type);
      }

      if (key.toLowerCase() === field.toLowerCase()) {
        return this.parseRamlValue(faker[key][PROPERTIES_NAME[key][firstPosition]](), type);
      }
    }

    if (field === 'id' || field === '_id') {
      return this.generateId(type);
    }

    return this.parseRamlValue(faker.lorem.word(), type);
  }