用mocha测试异步函数

您必须指定回调done作为提供给mocha的函数的参数，在本例中为it()函数。像这样：

describe('api', function() {
    it('should load a user', function(done) { // added "done" as parameter
        assert.doesNotThrow(function() {
            doRequest(options, function(res) {
                assert.equal(res, '{Object ... }'); // will not fail assert.doesNotThrow
                done(); // call "done()" the parameter
            }, function(err) {
                if (err) throw err; // will fail the assert.doesNotThrow
                done(); // call "done()" the parameter
            });
        });
    });
});

此外，doRequest(options, callback)的签名指定了两个参数，尽管在测试中调用它时提供了三个参数。

Mocha可能找不到doRequest(arg1,arg2,arg3)的方法。

它是否没有提供一些错误输出？也许你可以更改摩卡的选项来获得更多信息。

编辑：

如果是对的，第二个断言将与assert.doesNotThrow并行调用，而它应该只在成功回调中调用。

我已经修复了示例代码。

编辑2:

或者，为了简化错误处理（参见Dan M.的评论）：

describe('api', function() {
    it('should load a user', function(done) { // added "done" as parameter
        assert.doesNotThrow(function() {
            doRequest(options, function(res) {
                assert.equal(res, '{Object ... }'); // will not fail assert.doesNotThrow
                done(); // call "done()" the parameter
            }, done);
        });
    });
});

如果您有一个不支持回调的异步函数，或者如果您认为使用不必要的回调是……不必要的，那么您也可以将测试变成异步测试。

而不是：

it('should be able to do something', function () {});

简单操作：

it('should be able to do something', async function () {});
                                     ^^^^^

现在您可以使用await异步函数：

it('should be able to do something', async function () {
  this.timeout(40000);
  var result = await someComplexFunction();
  assert.isBelow(result, 3);
});

我在我的项目中为http客户端做了一个非常类似的测试。我把代码粘贴在这里，希望有用。这是客户端（我的nodejs服务器使用express，我使用promise进行错误处理）：

var http = require('http');
var querystring = require('querystring');
module.exports = {
  get: function(action, params, res, callback) {
    doPromiseRequest(action, querystring.stringify(params), callback, 'GET', 'application/json')
      .then((response) => callback(response))
      .catch((error) => {
        res.status(500);
        res.render('error', {layout: false, message: error.message, code: 500});
      });
  },
}
function doPromiseRequest(action, params, callback, method, contentType) {
    var options = {
      hostname: 'localhost',
      port: 3000,
      path: '/api/v1/' + action.toString(),
      method: method,
      headers: {
        'Content-Type': contentType,
        'Content-Length': Buffer.byteLength(params)
      }
    };
    return new Promise( (resolve, reject) => {
      var req = http.request(options, 
        function(response) {
          response.setEncoding('utf8');
          var data = '';
          response.on('data', function(chunk) {
            data += chunk;
          });
          response.on('end', function() {
            var parsedResponse;
            try {
              parsedResponse = JSON.parse(data);
            } catch(err) {
              reject({message: `Invalid response from hurricane for ${action}`});
              return;
            }
            if (parsedResponse.error)
              reject(parsedResponse.error);
            else
              resolve(parsedResponse);
          });
          response.on('error', function(err){
            console.log(err.message);
            reject(err);
          });
        });
      req.on('error', function(err) {
        console.log(err);
        reject({message: err.message});
      });
      req.write(params);
      req.end(); 
    });    
}

下面是测试：

var http = require('http');
var expect = require('chai').expect;
var sinon = require('sinon');
var PassThrough = require('stream').PassThrough;
describe('Hurricane Client tests', function() {
  before(function() {
    this.request = sinon.stub(http, 'request');
  });
  after(function() {
    http.request.restore();
  });
  it('should convert get result to object', function(done) {
    var expected = { hello: 'world' };
    var response = new PassThrough();
    response.statusCode = 200;
    response.headers = {}
    response.write(JSON.stringify(expected));
    response.end();
    var request = new PassThrough();
    this.request.callsArgWith(1, response).returns(request);
    client.get('any', {}, null, function(result) {
      expect(result).to.eql(expected);
      done();
    });
  });
});