Javascript 摩卡：如何声明拒绝承诺？

我试图让Mocha显示错误，并在我的节点代码上声明一个被拒绝的承诺-…而不是显示一个导致我的异步函数被拒绝的异常的

未处理PromisejectionWarning

我已经搜索并尝试了很多建议来处理摩卡咖啡中的警告和拒绝承诺，但没有一个对我有效。对许多人来说，这似乎是一个反复出现的话题，也是一个非常令人困惑的话题

我正试图通过以下方式做到这一点：

• 使用lambda函数

• 不使用

  done

• 使用简单的断言（我不喜欢

  expect

  和

  should

  ）

• 通过try/catch处理错误（我不喜欢chained

  .then

  和

  .catch

  ；如果使用

  ，我更不喜欢它。then（res，err）

  ）

比如：

it('should give an error', 
  async ()=> {
    try{
      await generateException()
      assert(true)
    } catch(err) {
      console.err(err)
      assert ??? // how to 'assert' a promise rejection?
    }
  }
)

如果不可避免地使用任何我不太喜欢的东西，好吧。但与我想要的更接近的解决方案是什么

---

此外，我不明白为什么被拒绝的承诺不会像我所期望的那样在try/catch中被捕获，因为这正是使用

wait

（使异步代码像同步代码一样工作）的目的所在。例如，使用chai进行断言

const chai = require('chai');
const expect = chai.expect;

describe('test', function () {

  function generateException() {
    throw new Error('test error');
  }


  it('should give an error', async ()=> {
    try {
      await generateException();
      expect(true).to.be.false;
    } catch(err) {
      console.log(err.message);
      expect(err.message).to.equal('test error');
    }
  })
})

使用

Promise.reject（）

与使用

抛出新错误（）

的方式似乎有所不同。当函数

generateeexception

抛出错误时，测试工作正常。 但是，如果它是

Promise.reject（）

，它永远不会到达catch块

如果您执行类似于

let result=wait generateeexception（）的操作

如果

geenerateException

函数使用promise-reject，您将看到这是您预期的错误

如果你愿意，你可以把承诺和等待连在一起

function generateException() {
  return new Promise(reject => {
   return reject(new Error('Promise Rejected');
})

it('should give an error', async ()=> {
  await generateException().catch(error => {
    expect(error.message).to.equal('Promise Rejected');

  })
});

---

阅读的部分内容可能会有所帮助。

使用mocha单元测试

断言节点模块： 我的建议是：

const assert = require('assert');

const PromiseFail = async (proms) => await assertPromise(proms, false);
const PromiseSucced = async (proms) => await assertPromise(proms);
const assertPromise = async (prom, succed = true) => {
    succed = succed ? true : false;
    try {
        prom = Array.isArray(prom) ? prom : [prom];
        await Promise.all(prom);
        assert.strictEqual(true, succed);
    }
    catch (ex) { assert.notStrictEqual(true, succed, ex); }
}

测试时：

describe('unit test', () => {
 it('test 1', async () => {
        await PromiseSucced(Promise.resolve(1))
        await PromiseSucced([Promise.resolve(2), Promise.resolve(3)])
        const promise4 = new Promise((resolve, reject) => {
            setTimeout(reject, 100, 'foo');
        });
        await PromiseFail(promise4)
    });
})

---

我想我（和许多其他人）正在努力理解“为什么？！”一个承诺。拒绝（）永远不会到达捕获块。。。可能会对此有所帮助。但本文实际上在“选项1”中说，try/catch应该捕获错误。。。那么，为什么不也以摩卡咖啡为例呢？