Chai 对 Promise 的断言

Chai as Promised使用流利的语言扩展了Chai，用于断言有关承诺的事实。

而不是手动将您的期望连接到承诺的已完成和被拒绝的处理程序：

doSomethingAsync().then(
    function (result) {
        result.should.equal("foo");
        done();
    },
    function (err) {
       done(err);
    }
);

你可以编写代码来表达你真正的意思：

return doSomethingAsync().should.eventually.equal("foo");

或者，如果您遇到return不可取的情况（例如样式考虑）或不可能的情况（例如，测试框架不允许返回承诺以表示异步测试完成），那么您可以使用以下解决方法（done()由测试提供的地方）框架）：

doSomethingAsync().should.eventually.equal("foo").notify(done);

注意事项：要么return或者notify(done) 必须与承诺的断言使用。这可能与项目或团队使用的现有断言格式略有不同。那些其他断言可能是同步的，因此不需要特殊处理。

如何使用

`should`/`expect`界面

Chai as Promised 提供的最强大的扩展是eventually属性。有了它，您可以将任何现有的 Chai 断言转换为一个根据承诺执行的断言：

(2 + 2).should.equal(4);
 
// becomes
return Promise.resolve(2 + 2).should.eventually.equal(4);
 
 
expect({ foo: "bar" }).to.have.property("foo");
 
// becomes
return expect(Promise.resolve({ foo: "bar" })).to.eventually.have.property("foo");

还有一些特定于 Promise 的扩展（也有通常的expect等价物）：

return promise.should.be.fulfilled;
return promise.should.eventually.deep.equal("foo");
return promise.should.become("foo"); // same as `.eventually.deep.equal`
return promise.should.be.rejected;
return promise.should.be.rejectedWith(Error); // other variants of Chai's `throw` assertion work too.

`assert` 界面

与should/expect接口一样，Chai as Promised 为提供了一个eventually扩展器chai.assert，允许在承诺上使用任何现有的 Chai 断言：

assert.equal(2 + 2, 4, "This had better be true");
 
// becomes
return assert.eventually.equal(Promise.resolve(2 + 2), 4, "This had better be true, eventually");

当然，还有特定于 Promise 的扩展：

return assert.isFulfilled(promise, "optional message");
 
return assert.becomes(promise, "foo", "optional message");
return assert.doesNotBecome(promise, "foo", "optional message");
 
return assert.isRejected(promise, "optional message");
return assert.isRejected(promise, Error, "optional message");
return assert.isRejected(promise, /error message matcher/, "optional message");

进度回调

Chai as Promised 对测试承诺进度回调没有任何内在支持。您想要测试的属性可能更适合像Sinon.JS这样的库，也许与Sinon-Chai结合使用：

var progressSpy = sinon.spy();
 
return promise.then(null, null, progressSpy).then(function () {
    progressSpy.should.have.been.calledWith("33%");
    progressSpy.should.have.been.calledWith("67%");
    progressSpy.should.have.been.calledThrice;
});

自定义输出承诺

默认情况下，由 Chai 作为 Promised 的断言返回的承诺是常规的 Chai 断言对象，使用then从输入承诺派生的单个方法进行扩展。要更改此行为，例如使用更有用的糖方法输出承诺，例如在大多数承诺库中找到的方法，您可以覆盖chaiAsPromised.transferPromiseness. 下面是一个转移 Qfinally和done方法的例子：

chaiAsPromised.transferPromiseness = function (assertion, promise) {
    assertion.then = promise.then.bind(promise); // this is all you get by default
    assertion.finally = promise.finally.bind(promise);
    assertion.done = promise.done.bind(promise);
};

将参数转换为断言者

Promised 允许的另一个高级自定义钩子 Chai 是，如果您想将参数转换为断言，可能是异步的。这是一个玩具示例：

chaiAsPromised.transformAsserterArgs = function (args) {
    return args.map(function (x) { return x + 1; });
}
 
Promise.resolve(2).should.eventually.equal(2); // will now fail!
Promise.resolve(3).should.eventually.equal(2); // will now pass!

转换甚至可以是异步的，直接返回数组而不是数组的承诺。一个例子可能是使用Promise.all这样的承诺数组成为一个数组的承诺。如果你这样做，那么你可以使用断言将承诺与其他承诺进行比较：

// This will normally fail, since within() only works on numbers.
Promise.resolve(2).should.eventually.be.within(Promise.resolve(1), Promise.resolve(6));
 
chaiAsPromised.transformAsserterArgs = function (args) {
    return Promise.all(args);
};
 
// But now it will pass, since we transformed the array of promises for numbers into
// (a promise for) an array of numbers
Promise.resolve(2).should.eventually.be.within(Promise.resolve(1), Promise.resolve(6));

兼容性

Chai as Promised 与遵循Promises/A+ 规范的所有承诺兼容。

值得注意的是，jQuery 的 promises 不符合 jQuery 3.0 之前的规范，并且 Chai as Promised 不能与它们一起使用。特别是，作为柴许大量使用了标准的相变行为的then，它的jQuery <3.0不支持。

Angular promises 有一个特殊的消化周期来处理它们，并且需要额外的设置代码来处理 Chai 作为 Promised。

使用非承诺友好的测试运行器

一些测试运行器（例如 Jasmine、QUnit 或 tap/tape）无法使用返回的 promise 来表示异步测试完成。如果可能的话，我建议改用那些可以做到的，例如Mocha、Buster或blue-tape。但如果这不是一个选择，Chai as Promised 仍然可以满足您的需求。只要您的测试框架采用回调指示异步测试运行何时结束，Chai as Promised 就可以通过其notify方法适应这种情况，如下所示：

it("should be fulfilled", function (done) {
    promise.should.be.fulfilled.and.notify(done);
});
 
it("should be rejected", function (done) {
    otherPromise.should.be.rejected.and.notify(done);
});

在这些示例中，如果不满足条件，则测试运行器将收到形式为的错误"expected promise to be fulfilled but it was rejected with [Error: error message]"，或"expected promise to be rejected but it was fulfilled."

还有另一种形式notify在某些情况下很有用，例如在承诺完成后进行断言。例如：

it("should change the state", function (done) {
    otherState.should.equal("before");
    promise.should.be.fulfilled.then(function () {
        otherState.should.equal("after");
    }).should.notify(done);
});

注意如何.notify(done)直接挂在.should，而不是出现在承诺断言之后。这表明 Chai as Promised 应该将完成或拒绝直接传递给测试框架。因此，"expected promise to be fulfilled…"如果promise被拒绝，上面的代码将失败并返回 Chai as Promised 错误 ( ) ，但expected "before" to equal "after"如果otherState没有改变，则将失败并返回一个简单的 Chai 错误 ( ) 。

多重承诺断言

要对多个Promise.allPromise执行断言，请使用将多个 Chai 组合为 Promised 断言：

it("should all be well", function () {
    return Promise.all([
        promiseA.should.become("happy"),
        promiseB.should.eventually.have.property("fun times"),
        promiseC.should.be.rejectedWith(TypeError, "only joyful types are allowed")
    ]);
});

这会将单个承诺断言的任何失败传递给测试框架，而不是将它们包装在"expected promise to be fulfilled…"消息中，如果你这样做了就会发生return Promise.all([…]).should.be.fulfilled。如果您不能使用return，则使用.should.notify(done)，类似于前面的示例。

安装和设置

节点

做一个npm install chai-as-promised起床和运行。然后：

var chai = require("chai");
var chaiAsPromised = require("chai-as-promised");
 
chai.use(chaiAsPromised);
 
// Then either:
var expect = chai.expect;
// or:
var assert = chai.assert;
// or:
chai.should();
// according to your preference of assertion style