测试函数内部是否有未处理的承诺拒绝

testing if something inside the function has an unhandled promise rejection

我正在使用 mocha 和 chai 进行测试。

我有一个函数,它接受另一个函数并环绕它,并在调用 .call() 方法时在做一些其他事情的同时调用它。

像这样:

let tracker = trackerFactory({
  watchFunction: somefunction
})

tracker.call() //does some things, calls somefunction, does more things...

现在我正在尝试测试它以处理调用 returns 拒绝承诺的函数。

it("handles a rejection by the watched function", (done) => {
  let tracker = trackerFactory({
    watchFunction: () => {
      Promise.reject(new Error("random error"))
    }
  })

  expect(function() {
    tracker.call();
  }).to.not.throw("random error");

  done();
})

最终,这个测试应该会通过,但我正在做 TDD,所以我还没有实现处理拒绝的机制。问题是,这个测试无论如何都会通过,即使节点显示警告:

    ✓ handles a rejection by the watched function
(node:4347) UnhandledPromiseRejectionWarning: Unhandled promise rejection (rejection id: 1): Error: random error
(node:4347) [DEP0018] DeprecationWarning: Unhandled promise rejections are deprecated. In the future, promise rejections that are not handled will terminate the Node.js process with a non-zero exit code.

所以我的问题是,如何测试显示此警告的案例?或者,换句话说,我如何测试函数内部是否有未处理的拒绝?

即使使用 TDD,因为您知道测试是针对 promise 拒绝的,所以您可以从 watchFunction 实现 promise 拒绝,如下所示:

 return new Promise(function (resolve, reject) {
        if (true)
            resolve();
        else
          // throw new Error("Promise rejected")
            reject();
    }); 

它只是一个尚未实现的承诺模板,很像 throw new MethodNotImplemented 异常。

然后在测试中,像这样处理 promise 拒绝,

it("handles Promise rejection",async ()=>{
    await watchFunction().then(function () {
     console.log("Promise Resolved");
}).catch((error)=>{
    console.log("Promise rejected")
   // assert.equal(error.message,"Promise rejected")
})

这是我最终所做的,我对这个解决方案感到非常满意:

我使用 chai-as-promised 并将我的测试代码编辑成这样:

it("handles a rejection by the watched function", () => {
  let tracker = trackerFactory({
    watchFunction: () => {
      return Promise.reject(new Error("random error"))
    }
  })

  return tracker.call().should.be.fulfilled;
})

如果 tracker.call() 不是 return Promise,或者如果它 return 是一个未解决的 Promise。