d7ef127be2
This mostly isolates the implementations for both of these. Now, everything here calls the method itself, not any of the external methods. Few driveby fixes as well: 1. Git now ignores archive/ again (it's a build artifact, and can be removed when updating `master`) 2. Since I had to rewrite most of the Deferred implementation, the new version passes one of the skipped tests, so it is now enabled.
288 lines
8.4 KiB
JavaScript
288 lines
8.4 KiB
JavaScript
describe("m.deferred()", function () {
|
|
"use strict"
|
|
|
|
// Let unchecked exceptions bubble up in order to allow meaningful error
|
|
// messages in common cases like null reference exceptions due to typos.
|
|
// An unchecked exception is defined as an object that is a subclass of
|
|
// Error (but not a direct instance of Error itself) - basically anything
|
|
// that can be thrown without an explicit `throw` keyword and that we'd
|
|
// never want to programmatically manipulate. In other words, an unchecked
|
|
// error is one where we only care about its line number and where the only
|
|
// reasonable way to deal with it is to change the buggy source code that
|
|
// caused the error to be thrown in the first place.
|
|
//
|
|
// By contrast, a checked exception is defined as anything that is
|
|
// explicitly thrown via the `throw` keyword and that can be
|
|
// programmatically handled, for example to display a validation error
|
|
// message on the UI. If an exception is a subclass of Error for whatever
|
|
// reason, but it is meant to be handled as a checked exception (i.e.
|
|
// follow the rejection rules for A+), it can be rethrown as an instance
|
|
// of Error.
|
|
//
|
|
// This implementation deviates from the Promises/A+ spec in two ways:
|
|
//
|
|
// 1) A+ requires the `then` callback to be called asynchronously (this
|
|
// requires a setImmediate polyfill, which cannot be implemented in a
|
|
// reasonable way for Mithril's purpose - the possible polyfills are
|
|
// either too big or too slow). This implementation calls the `then`
|
|
// callback synchronously.
|
|
// 2) A+ swallows exceptions in a unrethrowable way, i.e. it's not possible
|
|
// to see default error messages on the console for runtime errors thrown
|
|
// from within a promise chain. This throws such checked exceptions.
|
|
|
|
it("exists", function () {
|
|
expect(m.deferred).to.be.a("function")
|
|
})
|
|
|
|
it("resolves values", function () {
|
|
var value = m.prop()
|
|
var deferred = m.deferred()
|
|
|
|
deferred.promise.then(value)
|
|
deferred.resolve("test")
|
|
|
|
expect(value()).to.equal("test")
|
|
})
|
|
|
|
it("resolves values returned in `then` method", function () {
|
|
var value = m.prop()
|
|
var deferred = m.deferred()
|
|
|
|
deferred.promise
|
|
.then(function () { return "foo" })
|
|
.then(value)
|
|
deferred.resolve("test")
|
|
|
|
expect(value()).to.equal("foo")
|
|
})
|
|
|
|
it("passes rejections through second `then` handler", function () {
|
|
var obj = {}
|
|
var value1 = m.prop(obj)
|
|
var value2 = m.prop(obj)
|
|
var deferred = m.deferred()
|
|
|
|
deferred.promise.then(value1, value2)
|
|
deferred.reject("test")
|
|
|
|
expect(value1()).to.equal(obj)
|
|
expect(value2()).to.equal("test")
|
|
})
|
|
|
|
it("passes rejections through `catch`", function () {
|
|
var value = m.prop()
|
|
var deferred = m.deferred()
|
|
|
|
deferred.promise.catch(value)
|
|
deferred.reject("test")
|
|
|
|
expect(value()).to.equal("test")
|
|
})
|
|
|
|
it("can resolve from a `then` rejection handler", function () {
|
|
var value = m.prop()
|
|
var deferred = m.deferred()
|
|
|
|
deferred.promise
|
|
.then(null, function () { return "foo" })
|
|
.then(value)
|
|
deferred.reject("test")
|
|
|
|
expect(value()).to.equal("foo")
|
|
})
|
|
|
|
it("can resolve from a `catch`", function () {
|
|
var value = m.prop()
|
|
var deferred = m.deferred()
|
|
|
|
deferred.promise
|
|
.catch(function () { return "foo" })
|
|
.then(value)
|
|
deferred.reject("test")
|
|
|
|
expect(value()).to.equal("foo")
|
|
})
|
|
|
|
it("can reject by throwing an `Error`", function () {
|
|
var value1 = m.prop()
|
|
var value2 = m.prop()
|
|
var deferred = m.deferred()
|
|
|
|
deferred.promise
|
|
.then(function () { throw new Error() })
|
|
.then(value1, value2)
|
|
deferred.resolve("test")
|
|
|
|
expect(value1()).to.not.exist
|
|
expect(value2()).to.be.an("error")
|
|
})
|
|
|
|
it("synchronously throws subclasses of Errors on creation", function () {
|
|
expect(function () {
|
|
m.deferred().reject(new TypeError())
|
|
}).to.throw()
|
|
})
|
|
|
|
it("synchronously throws subclasses of Errors thrown from its `then` fufill handler", function () { // eslint-disable-line
|
|
expect(function () {
|
|
var deferred = m.deferred()
|
|
deferred.promise.then(function () { throw new TypeError() })
|
|
deferred.resolve()
|
|
}).to.throw()
|
|
})
|
|
|
|
it("synchronously throws subclasses of Errors thrown from its `then` rejection handler", function () { // eslint-disable-line
|
|
expect(function () {
|
|
var deferred = m.deferred()
|
|
deferred.promise.then(null, function () { throw new TypeError() })
|
|
deferred.reject("test")
|
|
}).to.throw()
|
|
})
|
|
|
|
it("synchronously throws subclasses of Errors thrown from its `catch` method", function () { // eslint-disable-line
|
|
expect(function () {
|
|
var deferred = m.deferred()
|
|
deferred.promise.catch(function () { throw new TypeError() })
|
|
deferred.reject("test")
|
|
}).to.throw()
|
|
})
|
|
|
|
it("unwraps other thenables, and returns the correct values in the chain", function () { // eslint-disable-line
|
|
var deferred1 = m.deferred()
|
|
var deferred2 = m.deferred()
|
|
var value1, value2
|
|
deferred1.promise.then(function (data) {
|
|
value1 = data
|
|
return deferred2.promise
|
|
}).then(function (data) {
|
|
value2 = data
|
|
})
|
|
deferred1.resolve(1)
|
|
deferred2.resolve(2)
|
|
expect(value1).to.equal(1)
|
|
expect(value2).to.equal(2)
|
|
})
|
|
|
|
// https://github.com/lhorie/mithril.js/issues/80
|
|
it("propogates returns with `then` after being resolved", function () {
|
|
var deferred = m.deferred()
|
|
var value = m.prop()
|
|
deferred.resolve(1)
|
|
deferred.promise.then(value)
|
|
expect(value()).to.equal(1)
|
|
})
|
|
|
|
// https://github.com/lhorie/mithril.js/issues/80
|
|
it("propogates errors with `then` after being rejected", function () {
|
|
var deferred = m.deferred()
|
|
var value = m.prop()
|
|
deferred.reject(1)
|
|
deferred.promise.then(null, value)
|
|
expect(value()).to.equal(1)
|
|
})
|
|
|
|
// https://github.com/lhorie/mithril.js/issues/80
|
|
it("can only be resolved once before being chained", function () {
|
|
var deferred = m.deferred()
|
|
var value = m.prop()
|
|
deferred.resolve(1)
|
|
deferred.resolve(2)
|
|
deferred.promise.then(value)
|
|
expect(value()).to.equal(1)
|
|
})
|
|
|
|
// https://github.com/lhorie/mithril.js/issues/80
|
|
it("can only be resolved once after being chained", function () {
|
|
var deferred = m.deferred()
|
|
var value = m.prop()
|
|
deferred.promise.then(value)
|
|
deferred.resolve(1)
|
|
deferred.resolve(2)
|
|
expect(value()).to.equal(1)
|
|
})
|
|
|
|
// https://github.com/lhorie/mithril.js/issues/80
|
|
it("can't be rejected after being resolved", function () {
|
|
var deferred = m.deferred()
|
|
var value1 = m.prop()
|
|
var value2 = m.prop()
|
|
deferred.promise.then(value1, value2)
|
|
deferred.resolve(1)
|
|
deferred.reject(2)
|
|
expect(value1()).to.equal(1)
|
|
expect(value2()).to.not.exist
|
|
})
|
|
|
|
// https://github.com/lhorie/mithril.js/issues/80
|
|
it("can't be resolved after being rejected", function () {
|
|
var deferred = m.deferred()
|
|
var value1 = m.prop()
|
|
var value2 = m.prop()
|
|
deferred.promise.then(value1, value2)
|
|
deferred.reject(1)
|
|
deferred.resolve(2)
|
|
expect(value1()).to.not.exist
|
|
expect(value2()).to.equal(1)
|
|
})
|
|
|
|
// https://github.com/lhorie/mithril.js/issues/80
|
|
it("can only be rejected once before being chained", function () {
|
|
var deferred = m.deferred()
|
|
var value = m.prop()
|
|
deferred.reject(1)
|
|
deferred.reject(2)
|
|
deferred.promise.then(null, value)
|
|
expect(value()).to.equal(1)
|
|
})
|
|
|
|
// https://github.com/lhorie/mithril.js/issues/80
|
|
it("can only be rejected once after being chained", function () {
|
|
var deferred = m.deferred()
|
|
var value = m.prop()
|
|
deferred.promise.then(null, value)
|
|
deferred.reject(1)
|
|
deferred.reject(2)
|
|
expect(value()).to.equal(1)
|
|
})
|
|
|
|
// https://github.com/lhorie/mithril.js/issues/85
|
|
it("calls resolution handler when resolved with `undefined`", function () {
|
|
var deferred = m.deferred()
|
|
var value
|
|
deferred.resolve()
|
|
deferred.promise.then(function () {
|
|
value = 1
|
|
})
|
|
expect(value).to.equal(1)
|
|
})
|
|
|
|
// https://github.com/lhorie/mithril.js/issues/85
|
|
it("calls rejection handler when rejected with `undefined`", function () {
|
|
var deferred = m.deferred()
|
|
var value
|
|
deferred.reject()
|
|
deferred.promise.then(null, function () {
|
|
value = 1
|
|
})
|
|
expect(value).to.equal(1)
|
|
})
|
|
|
|
it("immediately resolves promise with `resolve` method", function () {
|
|
var deferred = m.deferred()
|
|
deferred.resolve(1)
|
|
expect(deferred.promise()).to.equal(1)
|
|
})
|
|
|
|
it("gets chained promise value when called", function () {
|
|
var deferred = m.deferred()
|
|
var promise = deferred.promise.then(function (data) { return data + 1 })
|
|
deferred.resolve(1)
|
|
expect(promise()).to.equal(2)
|
|
})
|
|
|
|
it("returns `undefined` from call if it's rejected", function () {
|
|
var deferred = m.deferred()
|
|
deferred.reject(1)
|
|
expect(deferred.promise()).to.be.undefined
|
|
})
|
|
})
|