tra-analysis/website/functions/node_modules/call-me-maybe/test/maybeTest.js
2019-01-06 13:14:45 -06:00

138 lines
3.8 KiB
JavaScript

"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"))
})
})
})