为什么使用.then（）的速度快3倍，然后等待测试？

Question

This could totally be me misunderstanding something about the way async/await works in Javascript, but I haven't figured it out yet.

I have a simple test that uses some helpers to generate mock data before actually running the test.

Here's the helper function:

async create(numCustomers, businessId, options) {

    options = _.assign({ type: 'customer' }, options);

    const customers = await Factory.createMany('user', options, numCustomers);

    return Promise.all(customers.map(async (c) => {
        await AccountHelper.create(businessId, c.get('id'));
        return c;
    }));
}

and here's two versions of the test:

async/await version:

const customers = await CustomerHelper.create(10, Constants.fakeBusinessId);

await Promise.all(customers.map(async (c) => {
    await PetHelper.create(1, c.get('id'));
}));

const res = await server.inject(request);
expect(res.statusCode).to.equal(200);

.then() version:

CustomerHelper.create(10, Constants.fakeBusinessId).then(async (customers) => {

    await Promise.all(customers.map(async (c) => {
        await PetHelper.create(1, c.get('id'));
    }));

    const res = await server.inject(request);
    expect(res.statusCode).to.equal(200);
});

The .then() version finishes in about 2 seconds, where the async/await version finishes in almost 7 seconds. Changing between these two forms seems to be the only variable.

I'm running Node 8.9.4 on OSX.

I appreciate any insights or education :)

Answer 1

Both methods should be roughly the same duration, as long as you are properly signaling your test framework that the test is done . (Either by returning a promise or calling the done callback, in most test frameworks)

If you do not signal the framework properly, then the test will exit before the async processing is finished (or even started, in many cases). Also, if your assertions / expectations wait for an asynchronous event, then they will not even be made, and a test with no assertions is (in most frameworks) a passing test. Because of this, async / await is becoming the preferred style for tests, because it is harder (though not impossible) to incorrectly signal the test framework (as your example illustrates).

Proper ways to signal a test framework the test is done (for mocha/jest style frameworks):

it('does async work with await', async function (){
  let result = await asyncWork()
  assertItWorked(result)
})

it('does async work with returned promise', function (){
  return asyncWork().then(function (result) {
    assertItWorked(result)
  })
})

it('does async work with promise and callback', function (done){
  asyncWork().then(function (result) {
    assertItWorked(result)
    done() // note that this method will timeout if it fails, instead of displaying the error message, but you still get a failure
  })
})

it('does async work with promise and chained callback', function (done){
  asyncWork().then(function (result) {
    assertItWorked(result)
  }).then(done)
})

Improper ways that almost look right:

it('does async work but does not wait', function (done){
  asyncWork().then(function (result) {
    assertItWorked(result)
  })
  done() // this gets called before async work is done, and no assertions are made
})

it('does async work with promise and chained callback, but calls callback too soon', function (done){
  asyncWork().then(function (result) {
    assertItWorked(result)
  }).then(done()) // this is effectively identical to the previous example, because done gets called immediately
})

also note that the async / await style fully catches thrown errors/rejections from asyncWork , although with more code the other styles could as well.