虽然循环不是随机生成数据

Question

I'm creating API tests with async-await using Supertest and Mocha.

In the accountsData.js file I created a function to generate random test accounts.

In the accountsHelper.js file I created a function to create unlimited accounts using a while loop

When I run tests on the post_accounts.js file, the first account is created successfully, but from the second account, the data generated in the accountsData.js file is already repeated.

Why isn't data randomly generated when I create more than one account using data from the accountsData.js file?

accountsData.js

const casual = require('casual');


function randomAccount() {
  return {
    'email': casual.email,
    'password': '123456',
  };
}

module.exports = {
  randomAccount,
};

accountsHelper.js

const request = require('supertest');
const commonData = require('../data/commonData');

/* eslint-disable no-console */

const accountList = [];
let counterAccounts;


module.exports = {

  async createAccount(account, accountsToCreate = 2, validateResponse = true) {
    counterAccounts = 0;
    while (counterAccounts < accountsToCreate) {
      try {
        const res = await request(commonData.environment.staging)
          .post(commonData.endpoint.accounts)
          .send(account);
        if (validateResponse === true) {
          if (res.status === commonData.statusCode.ok) {
            accountList.push(res.body);
          } else {
            throw new Error('Email already exists\n\n' + JSON.stringify(res.body, null, ' '));
          }
        } else {
          return res.body;
        }
      } catch (err) {
        console.log(err);
      }
      counterAccounts++;
    }
    return accountList;
  },
};

post_accounts.js

const accountsData = require('../../data/accountsData');
const accountsHelper = require('../../helpers/accountsHelper');
const account = accountsData.randomAccount();

describe('Create accounts with email and password', () => {
  context('valid accounts', () => {
    it('should create an account successfully', async() => {
      const res = await accountsHelper.createAccount(account);
      // eslint-disable-next-line no-console
      console.log(res);
    });
  });
});

API response:

  Create accounts with email and password
    valid accounts
Error: Email already exists

{
 "error": {
  "statusCode": 422,
  "name": "ValidationError",
  "message": "The `account` instance is not valid. Details: `email` Email already exists (value: \"Lemuel.Lynch@Susan.net\").",
  "details": {
   "context": "account",
   "codes": {
    "email": [
     "uniqueness"
    ]
   },
   "messages": {
    "email": [
     "Email already exists"
    ]
   }
  }
 }
}
    at Object.createAccount (/Users/rafael/Desktop/projects/services/test/helpers/accountsHelper.js:24:19)
    at process._tickCallback (internal/process/next_tick.js:68:7)
[ { 'privacy-terms': false,
    'created-date': '2019-08-24T10:00:34.094Z',
    admin: false,
    isQueued: false,
    lastReleaseAttempt: '1970-01-01T00:00:00.000Z',
    'agreed-to-rules': { agreed: false },
    email: 'Lemuel.Lynch@Susan.net',
    id: '5d610ac213c07d752ae53d91' } ]
      ✓ should create an account successfully (2243ms)


  1 passing (2s)

Answer 1

The code that you posted doesn't correspond to the code that you're describing in prose.

However, I tested your accountsData.js file, in the way that your words (but not your code) say that you're using it, and it works fine.

// main.js

const { createPerson } = require(__dirname + '/accountsData')

console.log(createPerson())
console.log(createPerson())
console.log(createPerson())
console.log(createPerson())
console.log(createPerson())

Output from running it once:

$ node main.js
{ email: 'Anne_Ebert@Macie.com', password: '123456' }
{ email: 'Manley.Lindgren@Kshlerin.info', password: '123456' }
{ email: 'McClure_Thurman@Zboncak.net', password: '123456' }
{ email: 'Breitenberg.Alexander@Savannah.com', password: '123456' }
{ email: 'Keely.Mann@Stark.io', password: '123456' }

And again:

$ node main.js
{ email: 'Destany_Herman@Penelope.net', password: '123456' }
{ email: 'Narciso_Roob@gmail.com', password: '123456' }
{ email: 'Burnice_Rice@yahoo.com', password: '123456' }
{ email: 'Roma_Nolan@yahoo.com', password: '123456' }
{ email: 'Lilla_Beier@yahoo.com', password: '123456' }

Nothing in the code that you posted is actually requiring or using accountsData.js . If you change your code to use it, I think you'll see, like I do, that it works.

Answer 2

Problem is, you are generating the random account and storing it in a variable ' post_accounts.js(line 3) '. So, when you create an account, you are using the same payload to create multiple accounts, which obviously throws an error.

I just modified the accountHelper to properly handle your scenario. Hope this helps.

Note: The code is not tested, I just wrote it from my mind. Please test and let me know if it works.

// accountsHelper.js

const request = require('supertest');
const commonData = require('../data/commonData');
const accountsData = require('../../data/accountsData');
/* eslint-disable no-console */

const accountList = [];

module.exports = {

  async createAccount(account, accountsToCreate = 1, validateResponse = true) {
    // creates an array of length passed in accountsToCreate param
    return (await Promise.all(Array(accountsToCreate)
      .fill()
      .map(async () => {
        try {
          const res = await request(commonData.environment.staging)
            .post(commonData.endpoint.accounts)
            // takes account if passed or generates a random account
            .send(account || accountsData.randomAccount());

          // validates and throw error if validateResponse is true
          if (validateResponse === true && (res.status !== commonData.statusCode.ok)) {
            throw new Error(
              'Email already exists\n\n' +
              JSON.stringify(res.body, null, ' ')
            );
          }

          // return response body by default
          return res.body;
        } catch (e) {
          console.error(e);
          // return null if the create account service errors out, just to make sure the all other create account call doesnt fail
          return null;
        }
      })))
      // filter out the null(error) responses
      .filter(acc => acc);
  }
};


//post_accounts.js

const accountsHelper = require('../../helpers/accountsHelper');
const accountsData = require('../../data/accountsData');

const GENERATE_RANDOM_ACCOUNT = null;

describe('Create accounts with email and password', () => {
  context('valid accounts', () => {
    it('should create an account successfully', async () => {
      const result = await accountsHelper.createAccount();

      expect(result.length).toEquals(1);
    });

    it('should create 2 accounts successfully', async () => {
      const result = await accountsHelper.createAccount(GENERATE_RANDOM_ACCOUNT, 2);

      expect(result.length).toEquals(2);
    });

    it('should not create duplicate accounts', async () => {
      const account = accountsData.randomAccount();
      // here we are trying to create same account twice
      const result = await accountsHelper.createAccount(account, 2);

      // expected result should be one as the second attempt will fail with duplicate account
      expect(result.length).toEquals(1);
    });
  });
});