1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
|
"use strict"
var maybe = require("../")
var assert = require("assert")
var Promise = global.Promise || require("promise")
describe("maybe", function () {
it("should call the callback with result the promise is resolved to", function (done) {
var f = function f (cb) {
return maybe(cb, new Promise(function (resolve, reject) {
process.nextTick(function () {
return resolve("hi")
})
}))
}
f(function (err, result) {
assert.ifError(err, "no error")
assert.strictEqual(result, "hi")
return done()
})
})
it("should call the callback with the error the promise is rejected with", function (done) {
var f = function f (cb) {
return maybe(cb, new Promise(function (resolve, reject) {
process.nextTick(function () {
return reject(new Error("boom"))
})
}))
}
f(function (err, result) {
assert(err, "we got an error")
assert.strictEqual(result, undefined, "we got undefined result")
assert(err instanceof Error, "error is an Error")
assert.strictEqual(err.message, "boom", "error message is boom")
return done()
})
})
it("should return undefined when called with a callback", function () {
var f = function f (cb) {
return maybe(cb, new Promise(function (resolve, reject) {
//...
}))
}
var returnVal = f(function (err, result) {})
assert.strictEqual(returnVal, undefined, "returned val is undefined")
})
it("should return the same promise when no callback is provided", function () {
var p
var f = function f (cb) {
p = new Promise(function (resolve, reject) {
process.nextTick(function () {
return resolve("hi")
})
})
return maybe(cb, p)
}
var returnVal = f()
assert(p instanceof Promise, "returned val is a Promise")
assert.strictEqual(returnVal, p, "returned val is same obj (not a new Promise)")
})
it("should allow errors thrown in the callback to be uncaught", function (done) {
var mochaHandler
// Temporarily remove Mocha's global error handling so we can
// verify error is indeed uncaught by installing our own
// global error handler.
if (process.browser) {
mochaHandler = global.onerror
global.onerror = handleUncaughtException
}
else {
mochaHandler = process.listeners("uncaughtException").pop()
process.removeListener("uncaughtException", mochaHandler)
process.once("uncaughtException", handleUncaughtException)
}
var f = function f (cb) {
return maybe(cb, new Promise(function (resolve, reject) {
process.nextTick(function () {
return resolve("hi")
})
}))
}
f(function (err, result) {
throw new Error("yep")
})
function handleUncaughtException (err) {
// `err` is either an Error when running under Node, or a
// string if running under a browser.
var msg = err.message || err
assert(msg.match(/\byep\b/), "got expected error")
// Restore Mocha's global error handler.
if (process.browser) {
global.onerror = mochaHandler
}
else {
process.on("uncaughtException", mochaHandler)
}
done()
// Don't leak error to browser console
return true
}
})
it("should not let the callback be called more than once", function (done) {
var f = function f (cb) {
return maybe(cb, new Promise(function (resolve, reject) {
process.nextTick(function () {
resolve("foo")
})
}))
}
var called = 0
f(function (err, result) {
called++
assert(called <= 1, "called only once")
setTimeout(function () { done() }, 100)
return Promise.reject(new Error("bah"))
})
})
})
|
