chai-as-promised
Advanced tools
Comparing version 4.0.0 to 4.1.0
@@ -1,2 +0,2 @@ | ||
(function (chaiAsPromised) { | ||
(function () { | ||
"use strict"; | ||
@@ -15,344 +15,356 @@ | ||
} else { | ||
/*global self: false */ | ||
// Other environment (usually <script> tag): plug in to global chai instance directly. | ||
chai.use(chaiAsPromised); | ||
// Expose as a property of the global object so that consumers can configure the `transferPromiseness` property. | ||
self.chaiAsPromised = chaiAsPromised; | ||
} | ||
}(function chaiAsPromised(chai, utils) { | ||
"use strict"; | ||
var Assertion = chai.Assertion; | ||
var assert = chai.assert; | ||
chaiAsPromised.transferPromiseness = function (assertion, promise) { | ||
assertion.then = promise.then.bind(promise); | ||
}; | ||
function isJQueryPromise(thenable) { | ||
return typeof thenable.always === "function" && | ||
typeof thenable.done === "function" && | ||
typeof thenable.fail === "function" && | ||
typeof thenable.pipe === "function" && | ||
typeof thenable.progress === "function" && | ||
typeof thenable.state === "function"; | ||
} | ||
function chaiAsPromised(chai, utils) { | ||
var Assertion = chai.Assertion; | ||
var assert = chai.assert; | ||
function assertIsAboutPromise(assertion) { | ||
if (typeof assertion._obj.then !== "function") { | ||
throw new TypeError(utils.inspect(assertion._obj) + " is not a thenable."); | ||
function isJQueryPromise(thenable) { | ||
return typeof thenable.always === "function" && | ||
typeof thenable.done === "function" && | ||
typeof thenable.fail === "function" && | ||
typeof thenable.pipe === "function" && | ||
typeof thenable.progress === "function" && | ||
typeof thenable.state === "function"; | ||
} | ||
if (isJQueryPromise(assertion._obj)) { | ||
throw new TypeError("Chai as Promised is incompatible with jQuery's thenables, sorry! Please use a " + | ||
"Promises/A+ compatible library (see http://promisesaplus.com/)."); | ||
function assertIsAboutPromise(assertion) { | ||
if (typeof assertion._obj.then !== "function") { | ||
throw new TypeError(utils.inspect(assertion._obj) + " is not a thenable."); | ||
} | ||
if (isJQueryPromise(assertion._obj)) { | ||
throw new TypeError("Chai as Promised is incompatible with jQuery's thenables, sorry! Please use a " + | ||
"Promises/A+ compatible library (see http://promisesaplus.com/)."); | ||
} | ||
} | ||
} | ||
function method(name, asserter) { | ||
utils.addMethod(Assertion.prototype, name, function () { | ||
assertIsAboutPromise(this); | ||
return asserter.apply(this, arguments); | ||
}); | ||
} | ||
function method(name, asserter) { | ||
utils.addMethod(Assertion.prototype, name, function () { | ||
assertIsAboutPromise(this); | ||
return asserter.apply(this, arguments); | ||
}); | ||
} | ||
function property(name, asserter) { | ||
utils.addProperty(Assertion.prototype, name, function () { | ||
assertIsAboutPromise(this); | ||
return asserter.apply(this, arguments); | ||
}); | ||
} | ||
function property(name, asserter) { | ||
utils.addProperty(Assertion.prototype, name, function () { | ||
assertIsAboutPromise(this); | ||
return asserter.apply(this, arguments); | ||
}); | ||
} | ||
function doNotify(promise, done) { | ||
promise.then(function () { done(); }, done); | ||
} | ||
function doNotify(promise, done) { | ||
promise.then(function () { done(); }, done); | ||
} | ||
// These are for clarity and to bypass Chai refusing to allow `undefined` as actual when used with `assert`. | ||
function assertIfNegated(assertion, message, extra) { | ||
assertion.assert(true, null, message, extra.expected, extra.actual); | ||
} | ||
// These are for clarity and to bypass Chai refusing to allow `undefined` as actual when used with `assert`. | ||
function assertIfNegated(assertion, message, extra) { | ||
assertion.assert(true, null, message, extra.expected, extra.actual); | ||
} | ||
function assertIfNotNegated(assertion, message, extra) { | ||
assertion.assert(false, message, null, extra.expected, extra.actual); | ||
} | ||
function assertIfNotNegated(assertion, message, extra) { | ||
assertion.assert(false, message, null, extra.expected, extra.actual); | ||
} | ||
function getBasePromise(assertion) { | ||
// We need to chain subsequent asserters on top of ones in the chain already (consider | ||
// `eventually.have.property("foo").that.equals("bar")`), only running them after the existing ones pass. | ||
// So the first base-promise is `assertion._obj`, but after that we use the assertions themselves, i.e. | ||
// previously derived promises, to chain off of. | ||
return typeof assertion.then === "function" ? assertion : assertion._obj; | ||
} | ||
function getBasePromise(assertion) { | ||
// We need to chain subsequent asserters on top of ones in the chain already (consider | ||
// `eventually.have.property("foo").that.equals("bar")`), only running them after the existing ones pass. | ||
// So the first base-promise is `assertion._obj`, but after that we use the assertions themselves, i.e. | ||
// previously derived promises, to chain off of. | ||
return typeof assertion.then === "function" ? assertion : assertion._obj; | ||
} | ||
// Grab these first, before we modify `Assertion.prototype`. | ||
// Grab these first, before we modify `Assertion.prototype`. | ||
var propertyNames = Object.getOwnPropertyNames(Assertion.prototype); | ||
var propertyNames = Object.getOwnPropertyNames(Assertion.prototype); | ||
var propertyDescs = {}; | ||
propertyNames.forEach(function (name) { | ||
propertyDescs[name] = Object.getOwnPropertyDescriptor(Assertion.prototype, name); | ||
}); | ||
var propertyDescs = {}; | ||
propertyNames.forEach(function (name) { | ||
propertyDescs[name] = Object.getOwnPropertyDescriptor(Assertion.prototype, name); | ||
}); | ||
property("fulfilled", function () { | ||
var that = this; | ||
var derivedPromise = getBasePromise(that).then( | ||
function (value) { | ||
that._obj = value; | ||
assertIfNegated(that, | ||
"expected promise not to be fulfilled but it was fulfilled with #{act}", | ||
{ actual: value }); | ||
return value; | ||
}, | ||
function (reason) { | ||
assertIfNotNegated(that, | ||
"expected promise to be fulfilled but it was rejected with #{act}", | ||
{ actual: reason }); | ||
}); | ||
property("fulfilled", function () { | ||
var that = this; | ||
var derivedPromise = getBasePromise(that).then( | ||
function (value) { | ||
that._obj = value; | ||
assertIfNegated(that, | ||
"expected promise not to be fulfilled but it was fulfilled with #{act}", | ||
{ actual: value }); | ||
return value; | ||
}, | ||
function (reason) { | ||
assertIfNotNegated(that, | ||
"expected promise to be fulfilled but it was rejected with #{act}", | ||
{ actual: reason }); | ||
} | ||
); | ||
that.then = derivedPromise.then.bind(derivedPromise); | ||
}); | ||
chaiAsPromised.transferPromiseness(that, derivedPromise); | ||
}); | ||
property("rejected", function () { | ||
var that = this; | ||
var derivedPromise = getBasePromise(that).then( | ||
function (value) { | ||
that._obj = value; | ||
assertIfNotNegated(that, | ||
"expected promise to be rejected but it was fulfilled with #{act}", | ||
{ actual: value }); | ||
return value; | ||
}, | ||
function (reason) { | ||
assertIfNegated(that, | ||
"expected promise not to be rejected but it was rejected with #{act}", | ||
{ actual: reason }); | ||
property("rejected", function () { | ||
var that = this; | ||
var derivedPromise = getBasePromise(that).then( | ||
function (value) { | ||
that._obj = value; | ||
assertIfNotNegated(that, | ||
"expected promise to be rejected but it was fulfilled with #{act}", | ||
{ actual: value }); | ||
return value; | ||
}, | ||
function (reason) { | ||
assertIfNegated(that, | ||
"expected promise not to be rejected but it was rejected with #{act}", | ||
{ actual: reason }); | ||
// Return the reason, transforming this into a fulfillment, to allow further assertions, e.g. | ||
// `promise.should.be.rejected.and.eventually.equal("reason")`. | ||
return reason; | ||
} | ||
); | ||
// Return the reason, transforming this into a fulfillment, to allow further assertions, e.g. | ||
// `promise.should.be.rejected.and.eventually.equal("reason")`. | ||
return reason; | ||
} | ||
); | ||
that.then = derivedPromise.then.bind(derivedPromise); | ||
}); | ||
chaiAsPromised.transferPromiseness(that, derivedPromise); | ||
}); | ||
method("rejectedWith", function (Constructor, message) { | ||
var desiredReason = null; | ||
var constructorName = null; | ||
method("rejectedWith", function (Constructor, message) { | ||
var desiredReason = null; | ||
var constructorName = null; | ||
if (Constructor instanceof RegExp || typeof Constructor === "string") { | ||
message = Constructor; | ||
Constructor = null; | ||
} else if (Constructor && Constructor instanceof Error) { | ||
desiredReason = Constructor; | ||
Constructor = null; | ||
message = null; | ||
} else if (typeof Constructor === "function") { | ||
constructorName = (new Constructor()).name; | ||
} else { | ||
Constructor = null; | ||
} | ||
if (Constructor instanceof RegExp || typeof Constructor === "string") { | ||
message = Constructor; | ||
Constructor = null; | ||
} else if (Constructor && Constructor instanceof Error) { | ||
desiredReason = Constructor; | ||
Constructor = null; | ||
message = null; | ||
} else if (typeof Constructor === "function") { | ||
constructorName = (new Constructor()).name; | ||
} else { | ||
Constructor = null; | ||
} | ||
var that = this; | ||
var derivedPromise = getBasePromise(that).then( | ||
function (value) { | ||
var assertionMessage = null; | ||
var expected = null; | ||
var that = this; | ||
var derivedPromise = getBasePromise(that).then( | ||
function (value) { | ||
var assertionMessage = null; | ||
var expected = null; | ||
if (Constructor) { | ||
assertionMessage = "expected promise to be rejected with #{exp} but it was fulfilled with #{act}"; | ||
expected = constructorName; | ||
} else if (message) { | ||
var verb = message instanceof RegExp ? "matching" : "including"; | ||
assertionMessage = "expected promise to be rejected with an error " + verb + " #{exp} but it was " + | ||
"fulfilled with #{act}"; | ||
expected = message; | ||
} else if (desiredReason) { | ||
assertionMessage = "expected promise to be rejected with #{exp} but it was fulfilled with #{act}"; | ||
expected = desiredReason; | ||
} | ||
if (Constructor) { | ||
assertionMessage = "expected promise to be rejected with #{exp} but it was fulfilled with " + | ||
"#{act}"; | ||
expected = constructorName; | ||
} else if (message) { | ||
var verb = message instanceof RegExp ? "matching" : "including"; | ||
assertionMessage = "expected promise to be rejected with an error " + verb + " #{exp} but it " + | ||
"was fulfilled with #{act}"; | ||
expected = message; | ||
} else if (desiredReason) { | ||
assertionMessage = "expected promise to be rejected with #{exp} but it was fulfilled with " + | ||
"#{act}"; | ||
expected = desiredReason; | ||
} | ||
that._obj = value; | ||
that._obj = value; | ||
assertIfNotNegated(that, assertionMessage, { expected: expected, actual: value }); | ||
}, | ||
function (reason) { | ||
if (Constructor) { | ||
that.assert(reason instanceof Constructor, | ||
"expected promise to be rejected with #{exp} but it was rejected with #{act}", | ||
"expected promise not to be rejected with #{exp} but it was rejected with #{act}", | ||
constructorName, | ||
reason); | ||
} | ||
assertIfNotNegated(that, assertionMessage, { expected: expected, actual: value }); | ||
}, | ||
function (reason) { | ||
if (Constructor) { | ||
that.assert(reason instanceof Constructor, | ||
"expected promise to be rejected with #{exp} but it was rejected with #{act}", | ||
"expected promise not to be rejected with #{exp} but it was rejected with #{act}", | ||
constructorName, | ||
reason); | ||
} | ||
var reasonMessage = utils.type(reason) === "object" && "message" in reason ? | ||
reason.message : | ||
"" + reason; | ||
if (message && reasonMessage !== null && reasonMessage !== undefined) { | ||
if (message instanceof RegExp) { | ||
that.assert(message.test(reasonMessage), | ||
"expected promise to be rejected with an error matching #{exp} but got #{act}", | ||
"expected promise not to be rejected with an error matching #{exp}", | ||
message, | ||
reasonMessage); | ||
var reasonMessage = utils.type(reason) === "object" && "message" in reason ? | ||
reason.message : | ||
"" + reason; | ||
if (message && reasonMessage !== null && reasonMessage !== undefined) { | ||
if (message instanceof RegExp) { | ||
that.assert(message.test(reasonMessage), | ||
"expected promise to be rejected with an error matching #{exp} but got #{act}", | ||
"expected promise not to be rejected with an error matching #{exp}", | ||
message, | ||
reasonMessage); | ||
} | ||
if (typeof message === "string") { | ||
that.assert(reasonMessage.indexOf(message) !== -1, | ||
"expected promise to be rejected with an error including #{exp} but got #{act}", | ||
"expected promise not to be rejected with an error including #{exp}", | ||
message, | ||
reasonMessage); | ||
} | ||
} | ||
if (typeof message === "string") { | ||
that.assert(reasonMessage.indexOf(message) !== -1, | ||
"expected promise to be rejected with an error including #{exp} but got #{act}", | ||
"expected promise not to be rejected with an error including #{exp}", | ||
message, | ||
reasonMessage); | ||
if (desiredReason) { | ||
that.assert(reason === desiredReason, | ||
"expected promise to be rejected with #{exp} but it was rejected with #{act}", | ||
"expected promise not to be rejected with #{exp}", | ||
desiredReason, | ||
reason); | ||
} | ||
} | ||
); | ||
if (desiredReason) { | ||
that.assert(reason === desiredReason, | ||
"expected promise to be rejected with #{exp} but it was rejected with #{act}", | ||
"expected promise not to be rejected with #{exp}", | ||
desiredReason, | ||
reason); | ||
} | ||
} | ||
); | ||
chaiAsPromised.transferPromiseness(that, derivedPromise); | ||
}); | ||
that.then = derivedPromise.then.bind(derivedPromise); | ||
}); | ||
property("eventually", function () { | ||
utils.flag(this, "eventually", true); | ||
}); | ||
property("eventually", function () { | ||
utils.flag(this, "eventually", true); | ||
}); | ||
method("notify", function (done) { | ||
doNotify(getBasePromise(this), done); | ||
}); | ||
method("notify", function (done) { | ||
doNotify(getBasePromise(this), done); | ||
}); | ||
method("become", function (value) { | ||
return this.eventually.deep.equal(value); | ||
}); | ||
method("become", function (value) { | ||
return this.eventually.deep.equal(value); | ||
}); | ||
//////// | ||
// `eventually` | ||
//////// | ||
// `eventually` | ||
// We need to be careful not to trigger any getters, thus `Object.getOwnPropertyDescriptor` usage. | ||
var methodNames = propertyNames.filter(function (name) { | ||
return name !== "assert" && typeof propertyDescs[name].value === "function"; | ||
}); | ||
// We need to be careful not to trigger any getters, thus `Object.getOwnPropertyDescriptor` usage. | ||
var methodNames = propertyNames.filter(function (name) { | ||
return name !== "assert" && typeof propertyDescs[name].value === "function"; | ||
}); | ||
methodNames.forEach(function (methodName) { | ||
Assertion.overwriteMethod(methodName, function (originalMethod) { | ||
return function () { | ||
doAsserterAsyncAndAddThen(originalMethod, this, arguments); | ||
}; | ||
}); | ||
}); | ||
methodNames.forEach(function (methodName) { | ||
Assertion.overwriteMethod(methodName, function (originalMethod) { | ||
return function () { | ||
doAsserterAsyncAndAddThen(originalMethod, this, arguments); | ||
}; | ||
var getterNames = propertyNames.filter(function (name) { | ||
return name !== "_obj" && typeof propertyDescs[name].get === "function"; | ||
}); | ||
}); | ||
var getterNames = propertyNames.filter(function (name) { | ||
return name !== "_obj" && typeof propertyDescs[name].get === "function"; | ||
}); | ||
getterNames.forEach(function (getterName) { | ||
var propertyDesc = propertyDescs[getterName]; | ||
getterNames.forEach(function (getterName) { | ||
var propertyDesc = propertyDescs[getterName]; | ||
// Chainable methods are things like `an`, which can work both for `.should.be.an.instanceOf` and as | ||
// `should.be.an("object")`. We need to handle those specially. | ||
var isChainableMethod = false; | ||
try { | ||
isChainableMethod = typeof propertyDesc.get.call({}) === "function"; | ||
} catch (e) { } | ||
// Chainable methods are things like `an`, which can work both for `.should.be.an.instanceOf` and as | ||
// `should.be.an("object")`. We need to handle those specially. | ||
var isChainableMethod = false; | ||
try { | ||
isChainableMethod = typeof propertyDesc.get.call({}) === "function"; | ||
} catch (e) { } | ||
if (isChainableMethod) { | ||
Assertion.addChainableMethod( | ||
getterName, | ||
function () { | ||
var assertion = this; | ||
function originalMethod() { | ||
return propertyDesc.get.call(assertion).apply(assertion, arguments); | ||
} | ||
doAsserterAsyncAndAddThen(originalMethod, this, arguments); | ||
}, | ||
function () { | ||
var originalGetter = propertyDesc.get; | ||
doAsserterAsyncAndAddThen(originalGetter, this); | ||
} | ||
); | ||
} else { | ||
Assertion.overwriteProperty(getterName, function (originalGetter) { | ||
return function () { | ||
doAsserterAsyncAndAddThen(originalGetter, this); | ||
}; | ||
}); | ||
} | ||
}); | ||
if (isChainableMethod) { | ||
Assertion.addChainableMethod( | ||
getterName, | ||
function () { | ||
var assertion = this; | ||
function originalMethod() { | ||
return propertyDesc.get.call(assertion).apply(assertion, arguments); | ||
} | ||
doAsserterAsyncAndAddThen(originalMethod, this, arguments); | ||
}, | ||
function () { | ||
var originalGetter = propertyDesc.get; | ||
doAsserterAsyncAndAddThen(originalGetter, this); | ||
} | ||
); | ||
} else { | ||
Assertion.overwriteProperty(getterName, function (originalGetter) { | ||
return function () { | ||
doAsserterAsyncAndAddThen(originalGetter, this); | ||
}; | ||
function doAsserterAsyncAndAddThen(asserter, assertion, args) { | ||
// Since we're intercepting all methods/properties, we need to just pass through if they don't want | ||
// `eventually`, or if we've already fulfilled the promise (see below). | ||
if (!utils.flag(assertion, "eventually")) { | ||
return asserter.apply(assertion, args); | ||
} | ||
var derivedPromise = getBasePromise(assertion).then(function (value) { | ||
// Set up the environment for the asserter to actually run: `_obj` should be the fulfillment value, and | ||
// now that we have the value, we're no longer in "eventually" mode, so we won't run any of this code, | ||
// just the base Chai code that we get to via the short-circuit above. | ||
assertion._obj = value; | ||
utils.flag(assertion, "eventually", false); | ||
asserter.apply(assertion, args); | ||
// Because asserters, for example `property`, can change the value of `_obj` (i.e. change the "object" | ||
// flag), we need to communicate this value change to subsequent chained asserters. Since we build a | ||
// promise chain paralleling the asserter chain, we can use it to communicate such changes. | ||
return assertion._obj; | ||
}); | ||
} | ||
}); | ||
function doAsserterAsyncAndAddThen(asserter, assertion, args) { | ||
// Since we're intercepting all methods/properties, we need to just pass through if they don't want | ||
// `eventually`, or if we've already fulfilled the promise (see below). | ||
if (!utils.flag(assertion, "eventually")) { | ||
return asserter.apply(assertion, args); | ||
chaiAsPromised.transferPromiseness(assertion, derivedPromise); | ||
} | ||
var derivedPromise = getBasePromise(assertion).then(function (value) { | ||
// Set up the environment for the asserter to actually run: `_obj` should be the fulfillment value, and | ||
// now that we have the value, we're no longer in "eventually" mode, so we won't run any of this code, just | ||
// the base Chai code that we get to via the short-circuit above. | ||
assertion._obj = value; | ||
utils.flag(assertion, "eventually", false); | ||
asserter.apply(assertion, args); | ||
// Because asserters, for example `property`, can change the value of `_obj` (i.e. change the "object" | ||
// flag), we need to communicate this value change to subsequent chained asserters. Since we build a | ||
// promise chain paralleling the asserter chain, we can use it to communicate such changes. | ||
return assertion._obj; | ||
/////// | ||
// Now use the `Assertion` framework to build an `assert` interface. | ||
var originalAssertMethods = Object.getOwnPropertyNames(assert).filter(function (propName) { | ||
return typeof assert[propName] === "function"; | ||
}); | ||
assertion.then = derivedPromise.then.bind(derivedPromise); | ||
} | ||
assert.isFulfilled = function (promise, message) { | ||
return (new Assertion(promise, message)).to.be.fulfilled; | ||
}; | ||
/////// | ||
// Now use the `Assertion` framework to build an `assert` interface. | ||
var originalAssertMethods = Object.getOwnPropertyNames(assert).filter(function (propName) { | ||
return typeof assert[propName] === "function"; | ||
}); | ||
assert.isRejected = function (promise, toTestAgainst, message) { | ||
if (typeof toTestAgainst === "string") { | ||
message = toTestAgainst; | ||
toTestAgainst = undefined; | ||
} | ||
assert.isFulfilled = function (promise, message) { | ||
return (new Assertion(promise, message)).to.be.fulfilled; | ||
}; | ||
var assertion = (new Assertion(promise, message)); | ||
return toTestAgainst !== undefined ? assertion.to.be.rejectedWith(toTestAgainst) : assertion.to.be.rejected; | ||
}; | ||
assert.isRejected = function (promise, toTestAgainst, message) { | ||
if (typeof toTestAgainst === "string") { | ||
message = toTestAgainst; | ||
toTestAgainst = undefined; | ||
} | ||
assert.becomes = function (promise, value) { | ||
return assert.eventually.deepEqual(promise, value); | ||
}; | ||
var assertion = (new Assertion(promise, message)); | ||
return toTestAgainst !== undefined ? assertion.to.be.rejectedWith(toTestAgainst) : assertion.to.be.rejected; | ||
}; | ||
assert.doesNotBecome = function (promise, value) { | ||
return assert.eventually.notDeepEqual(promise, value); | ||
}; | ||
assert.becomes = function (promise, value) { | ||
return assert.eventually.deepEqual(promise, value); | ||
}; | ||
assert.eventually = {}; | ||
originalAssertMethods.forEach(function (assertMethodName) { | ||
assert.eventually[assertMethodName] = function (promise) { | ||
var otherArgs = Array.prototype.slice.call(arguments, 1); | ||
assert.doesNotBecome = function (promise, value) { | ||
return assert.eventually.notDeepEqual(promise, value); | ||
}; | ||
var customRejectionHandler; | ||
var message = arguments[assert[assertMethodName].length - 1]; | ||
if (typeof message === "string") { | ||
customRejectionHandler = function (reason) { | ||
throw new chai.AssertionError(message + "\n\nOriginal reason: " + utils.inspect(reason)); | ||
}; | ||
} | ||
assert.eventually = {}; | ||
originalAssertMethods.forEach(function (assertMethodName) { | ||
assert.eventually[assertMethodName] = function (promise) { | ||
var otherArgs = Array.prototype.slice.call(arguments, 1); | ||
var returnedPromise = promise.then( | ||
function (fulfillmentValue) { | ||
return assert[assertMethodName].apply(assert, [fulfillmentValue].concat(otherArgs)); | ||
}, | ||
customRejectionHandler | ||
); | ||
var customRejectionHandler; | ||
var message = arguments[assert[assertMethodName].length - 1]; | ||
if (typeof message === "string") { | ||
customRejectionHandler = function (reason) { | ||
throw new chai.AssertionError(message + "\n\nOriginal reason: " + utils.inspect(reason)); | ||
returnedPromise.notify = function (done) { | ||
doNotify(returnedPromise, done); | ||
}; | ||
} | ||
var returnedPromise = promise.then( | ||
function (fulfillmentValue) { | ||
return assert[assertMethodName].apply(assert, [fulfillmentValue].concat(otherArgs)); | ||
}, | ||
customRejectionHandler | ||
); | ||
returnedPromise.notify = function (done) { | ||
doNotify(returnedPromise, done); | ||
return returnedPromise; | ||
}; | ||
return returnedPromise; | ||
}; | ||
}); | ||
})); | ||
}); | ||
} | ||
}()); |
@@ -11,3 +11,3 @@ { | ||
], | ||
"version": "4.0.0", | ||
"version": "4.1.0", | ||
"author": "Domenic Denicola <domenic@domenicdenicola.com> (http://domenicdenicola.com)", | ||
@@ -32,8 +32,8 @@ "license": "WTFPL", | ||
"devDependencies": { | ||
"chai": "~1.8.0", | ||
"chai": "~1.8.1", | ||
"coffee-script": "~1.6.3", | ||
"cover": "~0.2.8", | ||
"ecstatic": "~0.4.9", | ||
"ecstatic": "~0.4.12", | ||
"glob": "~3.2.6", | ||
"jshint": "~2.1.11", | ||
"jshint": "~2.3.0", | ||
"mocha": "~1.13.0", | ||
@@ -40,0 +40,0 @@ "opener": "~1.3", |
@@ -161,2 +161,17 @@ <a href="http://promises-aplus.github.com/promises-spec"> | ||
### Customizing Output Promises | ||
By default, the promises returned by Chai as Promised's assertions are regular Chai assertion objects, extended with | ||
a single `then` method derived from the input promise. To change this behavior, for instance to output a promise with | ||
more useful sugar methods such as are found in most promise libraries, you can override | ||
`chaiAsPromised.transferPromiseness`. Here's an example that transfer's Q's `finally` and `done` methods: | ||
```js | ||
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); | ||
}; | ||
``` | ||
### Compatibility | ||
@@ -163,0 +178,0 @@ |
Major refactor
Supply chain riskPackage has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.
Found 1 instance in 1 package
26659
313
236
0