使用 Mocha 混合同步和异步测试

Question

我有一个函数，它计算一些东西，通过回调通知用户一些事件：

function returnAndCallback(callback) {
  callback(5);  // not always invoked
  return 3;
}

使用 Mocha 和 Should.js，我编写了这个测试：

describe('mixing sync and async code', function() {
  it('should test callback AND return value', function(done) {
    returnAndCallback(function(value) {
      value.should.be.eql(5);
      done();
    }).should.be.eql(4);
  });
});

这会成功，因为测试在调用done() 时结束。看来，我可以编写一个同步测试并检查返回值，也可以编写一个异步测试并检查回调。

不能像这样使用同步测试：

describe('mixing sync and async code', function() {
  it('should test callback AND return value', function() {
    returnAndCallback(function(value) {
      should.be.eql('difficult to get result');
    }).should.be.eql(3);
  });
});

... 因为我想断言回调被调用。如果从不调用回调，则此测试将成功。

如何测试回调是否使用正确的值和返回正确的值？

复制测试是我看到的唯一选择。

编辑：我注意到，我在这里错误地使用了异步一词。回调只是将可选操作注入到函数中的一种方式，该函数可以转换对象。所有代码都是同步的，但控制流有时会分支到回调中，我希望能够识别这一点。

这是另一种可能的测试方法：

describe('mixing sync and async code', function() {
  it('should test callback AND return value', function() {
    let callbackValue;

    returnAndCallback(function(value) {
      callbackValue = value;
    }).should.be.eql(3);

    callbackValue.should.be.eql(5);
  });
});

但由于额外的变量，仍然不够优雅。

Answer 1

首先，请注意done() 意味着同步测试； Mocha 的默认设置是异步运行测试。如果您想测试 异步 函数（在回调函数中返回值的函数）的“返回”值，请通过done() 同步运行它们。

接下来，您不能从异步函数返回值。这两种行为是互斥的：

function returnAndCallback(callback) {
  callback(5);  // not always invoked
  return 3;
}

您只想执行回调。

在我看来，您希望有时会传递一个回调，但并非总是如此。在这种情况下，我会分离函数测试（我认为您需要在任何地方使用done()，以保持测试的同步性质）并检查函数本身内部的回调。

既然我们已经弄清楚了，既然你想断言回调被调用，我们需要建立一些基线假设：

• A)回调应该是一个函数
• B) 应使用包含值的参数调用回调

你想测试这两个东西。 A) 很容易证明：你正在编写回调函数作为测试的一部分，所以如果你通过了null 或undefined，当然测试会失败，但这不是这个测试的重点。下面是你如何证明 A) 和 B)：

function optionalAsync(callback) {
  if (typeof callback === 'function') {
    callback(4)
  } else {
    return 3
  }
}

describe('optional async function', function() {
  it('should return 4 when a callback is passed', function(done) {
    optionalAsync(function(value) {
        should(value).be.eql(4)
        done()
    })
  })
  it('should return 3 when no callback is passed', function(done) {
    optionalAsync().should.be.eql(3)
    done()
  })
})

这有点奇怪，但考虑到您的用例，检查这两种可能性确实有意义。我相信你也可以稍微减少代码占用空间，但我建议保持这种方式，以便在你搁置一年而忘记你所做的事情时保持可读性；）

现在，如果您仍然希望选择一个函数同步运行，您可以通过阻塞事件循环来做到这一点：https://stackoverflow.com/a/22334347/1214800。

但是你为什么想要呢？

省去在固有的非阻塞、异步平台中处理同步操作的麻烦，并使用回调编写所有内容（甚至是非 IO 阻塞操作）：

function optionallyLongRunningOp(obj, callback) {
  if (typeof callback === 'function') {
    validateObject(obj, function(err, result) {
       // not always long-running; may invoke the long-running branch of your control-flow
       callback(err, result)
    })
  } else {
    throw new Error("You didn't pass a callback function!")
  }
}

describe('possibly long-running op async function', function() {
  it('should return 4 when control flow A is entered', function(done) {
    obj.useControlFlow = "A"
    validateObject(obj, function(err, result) {
        // this is a slow return
        should(result.value).be.eql(4)
        done()
    })
  it('should return 3 when control flow B is entered', function(done) {
    obj.useControlFlow = "B"
    validateObject(obj, function(err, result) {
        // this is a quick return
        should(result.value).be.eql(3)
        done()
    })
  })
})

这是您的答案，所有内容都作为回调（甚至是短操作）：

var doLongRunnignOp = function(cb) {
    var didNotify = true
    cb(didNotify)
}

function doubleAndNotifyEven(num, cb) {
  if (num % 2 == 0) {
    doLongRunnignOp(function(didNotify) {
      cb(num)
      // did notify
    })
  } else {
    cb(2 * num)
    // instant return, did not notify
  }
}

describe('checking return value and callback execution', function() {
  it('should double and report given an even number', function() {
    doubleAndNotifyEven(2, function(value) {
      should(value).be.eql(2)
    })
  })

  it('should double and not report anything given an odd number', function() {
    doubleAndNotifyEven(3, function(value) {
      should(value).be.eql(6)
    })
  })
})

Answer 2

这是解决此问题的另一种方法。它只是在要确保回调执行的测试中添加了额外的代码行。

let should = require('should');

function doubleAndNotifyEven(num, reportEven) {
  if (num % 2 == 0) {
    reportEven(num);
  }

  return 2 * num;
}

function mandatoryCallback(callback) {
  mandatoryCallback.numCalled = 0;
  return function () {
    mandatoryCallback.numCalled++;
    return callback.apply(this, arguments);
  };
}

describe('checking return value and callback execution', function() {
  it('should double and report given an even number', function() {
    doubleAndNotifyEven(2, mandatoryCallback(function(value) {
      should(value).be.eql(2);
    })).should.be.eql(4);

    should(mandatoryCallback.numCalled).greaterThan(0);
  });

  it('should double and not report anything given an odd number', function() {
    doubleAndNotifyEven(3, function(value) {
      throw new Error('Wrong report!');
    }).should.be.eql(6);
  });
});

还请注意sinon 做了类似的事情。