1

所以基本上我有我想要测试的函数，我们将调用函数 A。我想测试函数 B 是否在函数 A 内部被调用。问题是函数 B 在函数 A 内部通过已解析的 Promise 异步调用。这将导致 sinon 断言失败，因为测试将在函数 B 被调用之前完成！

这是一个工作代码场景。

const sinon = require('sinon');

describe('functionToBeTested', () => {
  it('someFunction is called', () => {
    // spy on the function we need to check if called
    const spy = sinon.spy(someClass.prototype, 'someFunction');
    // call the function being tested
    functionToBeTested();
    // check if spy was called
    sinon.assert.called(spy);
  });
});

class someClass {
  someFunction() {
    console.log('Hello');
  }
}

const somePromise = Promise.resolve();

function functionToBeTested() {
  const instance = new someClass();
  // some synchronous code here
  // if instance.someFunction() is called here the test will pass
  // .
  // .
  // .
  somePromise.then(() => {
    instance.someFunction();
    // the function is called and Hello is printed but the test will fail
  })
  // .
  // .
  // .
  // some synchronous code here
  // if instance.someFunction() is called here the test will pass
}
4

1 回答 1

2

你的例子有点不合常规。您有functionToBeTested它具有双重行为（同时同步和异步）。当您对该方法进行测试时，该行为应该事先众所周知并标准化，以便您可以相应地构建测试和断言。

这种情况下的问题是您尝试验证函数的行为是同步模式，尽管内部部分以即发即弃的方式工作 - 即不依赖于instance.someFunction()方法的结果.

如果functionToBeTested()返回了一个承诺 - 因此设计上是异步的，这对于您的测试场景来说很简单。但在这种情况下，您还需要一种非常规的测试方法。这意味着，如果您执行以下操作：

describe('functionToBeTested', () => {

    it('someFunction is called', (done) => {

        // spy on the function we need to check if called
        const spy = sinon.spy(SomeClass.prototype, 'someFunction');

        // call the function being tested
        functionToBeTested();

        setTimeout(() => {
            // check if spy was called
            sinon.assert.called(spy);
            done();
        }, 10);

    });
});

测试会通过。这里发生的事情是我们通过在回调中使用done参数来声明测试异步。此外，我们添加了一个计时器来模拟延迟，然后再检查是否调用了间谍。

由于“即发即弃”调用仅打印出一条消息，因此等待 10 毫秒就足够了。如果 promise 需要更长时间才能完成，则应调整等待时间。

如前所述，非常规的实现需要非常规的方法。我建议您重新考虑您的要求并重新设计解决方案。

于 2017-05-03T12:49:56.170 回答