mocha done() 和异步等待的矛盾问题

Question

我有以下测试用例：

it("should pass the test", async function (done) {
        await asyncFunction();
        true.should.eq(true);
        done();
    });

运行它断言：

错误：解决方法被过度指定。指定回调或 返回一个承诺；不是两者兼而有之。

如果我删除 done(); 语句，它会断言：

错误：超过 2000 毫秒的超时。对于异步测试和钩子，确保 “完成（）”被调用；如果返回一个 Promise，请确保它解析。

如何解决这个悖论？

Answer 1

您还需要删除done 参数，而不仅仅是对其的调用。像 Mocha 这样的测试框架会查看函数的参数列表（或至少是它的参数），以了解您使用的是 done 还是类似的。

使用 Mocha 3.5.3，这对我有用（必须将 true.should.be(true) 更改为 assert.ok(true)，因为前者会出错）：

const assert = require('assert');

function asyncFunction() {
    return new Promise(resolve => {
        setTimeout(resolve, 10);
    });
}

describe('Container', function() {
  describe('Foo', function() {
    it("should pass the test", async function () {
        await asyncFunction();
        assert.ok(true);
    });
  });
});

但是如果我添加done:

describe('Container', function() {
  describe('Foo', function() {
    it("should pass the test", async function (done) {  // <==== Here
        await asyncFunction();
        assert.ok(true);
    });
  });
});

...然后我得到

错误：超过 2000 毫秒的超时。对于异步测试和钩子，确保调用了“done()”；如果返回 Promise，请确保它已解决。

Answer 2

从中删除 done 作为参数对我有用！而是只使用期望/应该。示例如下：

getResponse(unitData, function callBack(unit, error, data){ try {
    return request.post(unit, function (err, resp) {
        if (!err && resp.statusCode === 200) {
            if (resp.body.error) {
                return callback(obj, JSON.stringify(resp.body.error), null); 
            }
            return callback(obj, null, resp); 
        } else {
            if (err == null) {  
                err = { statusCode: resp.statusCode, error: 'Error occured.' };
            }
            return callback(obj, err, null); 
        }
    });
} catch (err) {
    return callback(obj, err, null);
}}

之前：

it('receives successful response', async (done) => { 
const getSomeData = await getResponse(unitData, function callBack(unit, error, data){ 
    expect(data.statusCode).to.be.equal(200); 
    done(); 
}) })

之后（工作）：

it('receives successful response', async () => { 
const getSomeData = await getResponse(unitData, function callBack(unit, error, data){
     expect(data.statusCode).to.be.equal(200); 
}) })

Answer 3

有些情况下你需要在 mocha 中使用async/await + done 函数。

例如，在我的socket.io 单元测试用例之一中，我必须使用异步函数调用 db 函数并测试作为回调函数的套接字事件处理程序：

context("on INIT_CHAT", ()=> {
  it("should create a room", async (done) => {
    const user = await factory.create("User");
    socket.emit("INIT_CHAT", user);
    
    socket.on("JOIN_CHAT", async (roomId) => {
       const room = await ChatRoom.findByPk(roomId);
       expect(room).to.exist;
       // then I need to close a test case here
       done();
    });
  });
});

这将导致与 OP 中完全相同的错误：

错误：解决方法被过度指定。指定回调或返回 Promise；不是两者都有。

我的解决方法：

我只是将整个测试代码封装在一个 Promise 生成器中：

context("on INIT_CHAT", ()=> {
  it("should create a room", async () => {
    const asyncWrapper = () => {
      return new Promise(async (resolve) => {
        const user = await factory.create("User");
        socket.emit("INIT_CHAT", user);
        socket.on("JOIN_CHAT", async (roomId) => {
          const room = await ChatRoom.findByPk(roomId);
          expect(room).to.exist;
          resolve(true);
        });
      });
    });
    await asyncWrapper();
  });
});