Renée Kooi
6 years ago
committed by
GitHub
10 changed files with 1039 additions and 1 deletions
@ -0,0 +1,169 @@ |
|||
'use strict'; |
|||
|
|||
var test = require('tape'); |
|||
var callbackify = require('../../').callbackify; |
|||
|
|||
if (typeof Promise === 'undefined') { |
|||
console.log('no global Promise found, skipping callbackify tests'); |
|||
return; |
|||
} |
|||
|
|||
function after (n, cb) { |
|||
var i = 0; |
|||
return function () { |
|||
if (++i === n) cb(); |
|||
} |
|||
} |
|||
|
|||
var values = [ |
|||
'hello world', |
|||
null, |
|||
undefined, |
|||
false, |
|||
0, |
|||
{}, |
|||
{ key: 'value' }, |
|||
function ok() {}, |
|||
['array', 'with', 4, 'values'], |
|||
new Error('boo') |
|||
]; |
|||
if (typeof Symbol !== 'undefined') { |
|||
values.push(Symbol('I am a symbol')); |
|||
} |
|||
|
|||
test('util.callbackify resolution value is passed as second argument to callback', function (t) { |
|||
var end = after(values.length * 2, t.end); |
|||
// Test that the resolution value is passed as second argument to callback
|
|||
values.forEach(function(value) { |
|||
// Test Promise factory
|
|||
function promiseFn() { |
|||
return Promise.resolve(value); |
|||
} |
|||
|
|||
var cbPromiseFn = callbackify(promiseFn); |
|||
cbPromiseFn(function(err, ret) { |
|||
t.ifError(err); |
|||
t.strictEqual(ret, value, 'cb ' + typeof value); |
|||
end(); |
|||
}); |
|||
|
|||
// Test Thenable
|
|||
function thenableFn() { |
|||
return { |
|||
then: function(onRes, onRej) { |
|||
onRes(value); |
|||
} |
|||
}; |
|||
} |
|||
|
|||
var cbThenableFn = callbackify(thenableFn); |
|||
cbThenableFn(function(err, ret) { |
|||
t.ifError(err); |
|||
t.strictEqual(ret, value, 'thenable ' + typeof value); |
|||
end(); |
|||
}); |
|||
}); |
|||
}); |
|||
|
|||
test('util.callbackify rejection reason is passed as first argument to callback', function (t) { |
|||
var end = after(values.length * 2, t.end); |
|||
// Test that rejection reason is passed as first argument to callback
|
|||
values.forEach(function(value) { |
|||
// test a Promise factory
|
|||
function promiseFn() { |
|||
return Promise.reject(value); |
|||
} |
|||
|
|||
var cbPromiseFn = callbackify(promiseFn); |
|||
cbPromiseFn(function(err, ret) { |
|||
t.strictEqual(ret, undefined, 'cb ' + typeof value); |
|||
if (err instanceof Error) { |
|||
if ('reason' in err) { |
|||
t.ok(!value); |
|||
t.strictEqual(err.message, 'Promise was rejected with a falsy value'); |
|||
t.strictEqual(err.reason, value); |
|||
} else { |
|||
t.strictEqual(String(value).slice(-err.message.length), err.message); |
|||
} |
|||
} else { |
|||
t.strictEqual(err, value); |
|||
} |
|||
end(); |
|||
}); |
|||
|
|||
// Test Thenable
|
|||
function thenableFn() { |
|||
return { |
|||
then: function (onRes, onRej) { |
|||
onRej(value); |
|||
} |
|||
}; |
|||
} |
|||
|
|||
var cbThenableFn = callbackify(thenableFn); |
|||
cbThenableFn(function(err, ret) { |
|||
t.strictEqual(ret, undefined, 'thenable ' + typeof value); |
|||
if (err instanceof Error) { |
|||
if ('reason' in err) { |
|||
t.ok(!value); |
|||
t.strictEqual(err.message, 'Promise was rejected with a falsy value'); |
|||
t.strictEqual(err.reason, value); |
|||
} else { |
|||
t.strictEqual(String(value).slice(-err.message.length), err.message); |
|||
} |
|||
} else { |
|||
t.strictEqual(err, value); |
|||
} |
|||
end(); |
|||
}); |
|||
}); |
|||
}); |
|||
|
|||
test('util.callbackify arguments passed to callbackified function are passed to original', function (t) { |
|||
var end = after(values.length, t.end); |
|||
// Test that arguments passed to callbackified function are passed to original
|
|||
values.forEach(function(value) { |
|||
function promiseFn(arg) { |
|||
t.strictEqual(arg, value); |
|||
return Promise.resolve(arg); |
|||
} |
|||
|
|||
var cbPromiseFn = callbackify(promiseFn); |
|||
cbPromiseFn(value, function(err, ret) { |
|||
t.ifError(err); |
|||
t.strictEqual(ret, value); |
|||
end(); |
|||
}); |
|||
}); |
|||
}); |
|||
|
|||
test('util.callbackify `this` binding is the same for callbackified and original', function (t) { |
|||
var end = after(values.length, t.end); |
|||
// Test that `this` binding is the same for callbackified and original
|
|||
values.forEach(function(value) { |
|||
var iAmThis = { |
|||
fn: function(arg) { |
|||
t.strictEqual(this, iAmThis); |
|||
return Promise.resolve(arg); |
|||
}, |
|||
}; |
|||
iAmThis.cbFn = callbackify(iAmThis.fn); |
|||
iAmThis.cbFn(value, function(err, ret) { |
|||
t.ifError(err); |
|||
t.strictEqual(ret, value); |
|||
t.strictEqual(this, iAmThis); |
|||
end(); |
|||
}); |
|||
}); |
|||
}); |
|||
|
|||
test('util.callbackify non-function inputs throw', function (t) { |
|||
// Verify that non-function inputs throw.
|
|||
['foo', null, undefined, false, 0, {}, typeof Symbol !== 'undefined' ? Symbol() : undefined, []].forEach(function(value) { |
|||
t.throws( |
|||
function() { callbackify(value); }, |
|||
'The "original" argument must be of type Function' |
|||
); |
|||
}); |
|||
t.end(); |
|||
}); |
@ -1,2 +1,4 @@ |
|||
require('./inspect'); |
|||
require('./is'); |
|||
require('./promisify'); |
|||
require('./callbackify'); |
|||
|
@ -0,0 +1,205 @@ |
|||
var promisify = require('../../').promisify; |
|||
var test = require('tape'); |
|||
|
|||
var hasSymbol = typeof Symbol !== 'undefined'; |
|||
|
|||
if (typeof Promise === 'undefined') { |
|||
console.log('no global Promise found, skipping promisify tests'); |
|||
return; |
|||
} |
|||
|
|||
var callbacker = function (arg, cb) { |
|||
setTimeout(function () { |
|||
if (typeof arg === 'string') |
|||
cb(null, arg.toUpperCase()); |
|||
else cb(new TypeError('incorrect type')); |
|||
}, 5); |
|||
} |
|||
var promiser = promisify(callbacker); |
|||
|
|||
test('util.promisify resolves', function (t) { |
|||
var promise = promiser(__filename); |
|||
t.ok(promise instanceof Promise); |
|||
promise.then(function (value) { |
|||
t.deepEqual(value, __filename.toUpperCase()); |
|||
t.end(); |
|||
}); |
|||
}); |
|||
|
|||
test('util.promisify rejects', function (t) { |
|||
var promise = promiser(42); |
|||
promise.catch(function (error) { |
|||
t.equal(error.message, 'incorrect type'); |
|||
t.end(); |
|||
}); |
|||
}); |
|||
|
|||
test('util.promisify custom', { skip: !hasSymbol }, function (t) { |
|||
function fn() {} |
|||
function promisifedFn() {} |
|||
fn[promisify.custom] = promisifedFn; |
|||
t.strictEqual(promisify(fn), promisifedFn); |
|||
t.strictEqual(promisify(promisify(fn)), promisifedFn); |
|||
t.end(); |
|||
}); |
|||
|
|||
test('util.promisify custom of invalid type', { skip: !hasSymbol }, function (t) { |
|||
function fn2() {} |
|||
fn2[promisify.custom] = 42; |
|||
t.throws( |
|||
function () { promisify(fn2); }, |
|||
/must be of type Function/ |
|||
); |
|||
t.end(); |
|||
}); |
|||
|
|||
test('util.promisify multiple callback values', function (t) { |
|||
function fn5(callback) { |
|||
callback(null, 'foo', 'bar'); |
|||
} |
|||
promisify(fn5)().then(function (value) { |
|||
t.strictEqual(value, 'foo'); |
|||
t.end(); |
|||
}); |
|||
}); |
|||
|
|||
test('util.promisify no callback success value', function (t) { |
|||
function fn6(callback) { |
|||
callback(null); |
|||
} |
|||
promisify(fn6)().then(function (value) { |
|||
t.strictEqual(value, undefined); |
|||
t.end(); |
|||
}); |
|||
}); |
|||
|
|||
test('util.promisify no callback arguments at all', function (t) { |
|||
function fn7(callback) { |
|||
callback(); |
|||
} |
|||
promisify(fn7)().then(function (value) { |
|||
t.strictEqual(value, undefined); |
|||
t.end(); |
|||
}); |
|||
}); |
|||
|
|||
test('util.promisify passing arguments', function (t) { |
|||
function fn8(err, val, callback) { |
|||
callback(err, val); |
|||
} |
|||
promisify(fn8)(null, 42).then(function (value) { |
|||
t.strictEqual(value, 42); |
|||
t.end(); |
|||
}); |
|||
}); |
|||
|
|||
test('util.promisify passing arguments (rejects)', function (t) { |
|||
function fn9(err, val, callback) { |
|||
callback(err, val); |
|||
} |
|||
promisify(fn9)(new Error('oops'), null).catch(function (err) { |
|||
t.strictEqual(err.message, 'oops'); |
|||
t.end(); |
|||
}); |
|||
}); |
|||
|
|||
test('util.promisify chain', function (t) { |
|||
function fn9(err, val, callback) { |
|||
callback(err, val); |
|||
} |
|||
|
|||
|
|||
Promise.resolve() |
|||
.then(function () { return promisify(fn9)(null, 42); }) |
|||
.then(function (value) { |
|||
t.strictEqual(value, 42); |
|||
t.end(); |
|||
}); |
|||
}); |
|||
|
|||
test('util.promisify keeps correct `this`', function (t) { |
|||
var o = {}; |
|||
var fn10 = promisify(function(cb) { |
|||
|
|||
cb(null, this === o); |
|||
}); |
|||
|
|||
o.fn = fn10; |
|||
|
|||
o.fn().then(function(val) { |
|||
t.ok(val); |
|||
t.end(); |
|||
}); |
|||
}); |
|||
|
|||
test('util.promisify calling callback multiple times', function (t) { |
|||
var err = new Error('Should not have called the callback with the error.'); |
|||
var stack = err.stack; |
|||
|
|||
var fn11 = promisify(function(cb) { |
|||
cb(null); |
|||
cb(err); |
|||
}); |
|||
|
|||
Promise.resolve() |
|||
.then(function () { return fn11(); }) |
|||
.then(function () { return Promise.resolve(); }) |
|||
.then(function () { |
|||
t.strictEqual(stack, err.stack); |
|||
t.end(); |
|||
}); |
|||
}); |
|||
|
|||
// Can't do this without Symbol() unfortunately
|
|||
test('util.promisify promisifying a promisified function', { skip: !hasSymbol }, function (t) { |
|||
function c() { } |
|||
var a = promisify(function() { }); |
|||
var b = promisify(a); |
|||
t.notStrictEqual(c, a); |
|||
t.strictEqual(a, b); |
|||
t.end(); |
|||
}); |
|||
|
|||
test('util.promisify sync throw becomes rejection', function (t) { |
|||
var errToThrow; |
|||
var thrower = promisify(function(a, b, c, cb) { |
|||
errToThrow = new Error(); |
|||
throw errToThrow; |
|||
}); |
|||
thrower(1, 2, 3) |
|||
.then(t.fail) |
|||
.then(t.fail, function (e) { |
|||
t.strictEqual(e, errToThrow); |
|||
t.end(); |
|||
}); |
|||
}); |
|||
|
|||
test('util.promisify callback and sync throw', function (t) { |
|||
var err = new Error(); |
|||
|
|||
var a = promisify(function (cb) { cb(err) })(); |
|||
var b = promisify(function () { throw err; })(); |
|||
|
|||
Promise.all([ |
|||
a.then(t.fail, function(e) { |
|||
t.strictEqual(err, e); |
|||
}), |
|||
b.then(t.fail, function(e) { |
|||
t.strictEqual(err, e); |
|||
}) |
|||
]).then(function () { |
|||
t.end(); |
|||
}); |
|||
}); |
|||
|
|||
test('util.promisify throws for incorrect argument types', function (t) { |
|||
var array = [undefined, null, true, 0, 'str', {}, []]; |
|||
if (typeof Symbol !== 'undefined') array.push(Symbol()); |
|||
array.forEach(function (input) { |
|||
t.throws( |
|||
function () { promisify(input); }, |
|||
'The "original" argument must be of type Function' |
|||
); |
|||
}); |
|||
t.end(); |
|||
}); |
@ -0,0 +1,120 @@ |
|||
'use strict'; |
|||
|
|||
// Separate test file for tests using new syntax (async/await).
|
|||
|
|||
var common = require('./common'); |
|||
var assert = require('assert'); |
|||
var callbackify = require('../../').callbackify; |
|||
var execFile = require('child_process').execFile; |
|||
|
|||
var values = [ |
|||
'hello world', |
|||
null, |
|||
undefined, |
|||
false, |
|||
0, |
|||
{}, |
|||
{ key: 'value' }, |
|||
Symbol('I am a symbol'), |
|||
function ok() {}, |
|||
['array', 'with', 4, 'values'], |
|||
new Error('boo') |
|||
]; |
|||
|
|||
{ |
|||
// Test that the resolution value is passed as second argument to callback
|
|||
values.forEach(function(value) { |
|||
// Test and `async function`
|
|||
async function asyncFn() { |
|||
return value; |
|||
} |
|||
|
|||
var cbAsyncFn = callbackify(asyncFn); |
|||
cbAsyncFn(common.mustCall(function(err, ret) { |
|||
assert.ifError(err); |
|||
assert.strictEqual(ret, value); |
|||
})); |
|||
}); |
|||
} |
|||
|
|||
{ |
|||
// Test that rejection reason is passed as first argument to callback
|
|||
values.forEach(function(value) { |
|||
// Test an `async function`
|
|||
async function asyncFn() { |
|||
return Promise.reject(value); |
|||
} |
|||
|
|||
var cbAsyncFn = callbackify(asyncFn); |
|||
cbAsyncFn(common.mustCall(function (err, ret) { |
|||
assert.strictEqual(ret, undefined); |
|||
if (err instanceof Error) { |
|||
if ('reason' in err) { |
|||
assert(!value); |
|||
assert.strictEqual(err.message, 'Promise was rejected with a falsy value'); |
|||
assert.strictEqual(err.reason, value); |
|||
} else { |
|||
assert.strictEqual(String(value).endsWith(err.message), true); |
|||
} |
|||
} else { |
|||
assert.strictEqual(err, value); |
|||
} |
|||
})); |
|||
}); |
|||
} |
|||
|
|||
{ |
|||
// Test that arguments passed to callbackified function are passed to original
|
|||
values.forEach(function(value) { |
|||
async function asyncFn(arg) { |
|||
assert.strictEqual(arg, value); |
|||
return arg; |
|||
} |
|||
|
|||
var cbAsyncFn = callbackify(asyncFn); |
|||
cbAsyncFn(value, common.mustCall(function(err, ret) { |
|||
assert.ifError(err); |
|||
assert.strictEqual(ret, value); |
|||
})); |
|||
}); |
|||
} |
|||
|
|||
{ |
|||
// Test that `this` binding is the same for callbackified and original
|
|||
values.forEach(function(value) { |
|||
var iAmThat = { |
|||
async fn(arg) { |
|||
assert.strictEqual(this, iAmThat); |
|||
return arg; |
|||
}, |
|||
}; |
|||
iAmThat.cbFn = callbackify(iAmThat.fn); |
|||
iAmThat.cbFn(value, common.mustCall(function(err, ret) { |
|||
assert.ifError(err); |
|||
assert.strictEqual(ret, value); |
|||
assert.strictEqual(this, iAmThat); |
|||
})); |
|||
}); |
|||
} |
|||
|
|||
{ |
|||
async function asyncFn() { |
|||
return 42; |
|||
} |
|||
|
|||
var cb = callbackify(asyncFn); |
|||
var args = []; |
|||
|
|||
// Verify that the last argument to the callbackified function is a function.
|
|||
['foo', null, undefined, false, 0, {}, Symbol(), []].forEach(function(value) { |
|||
args.push(value); |
|||
common.expectsError(function() { |
|||
cb(...args); |
|||
}, { |
|||
code: 'ERR_INVALID_ARG_TYPE', |
|||
type: TypeError, |
|||
message: 'The last argument must be of type Function' |
|||
}); |
|||
}); |
|||
} |
|||
|
@ -0,0 +1,190 @@ |
|||
'use strict'; |
|||
|
|||
// This test checks that the semantics of `util.callbackify` are as described in
|
|||
// the API docs
|
|||
|
|||
var common = require('./common'); |
|||
var assert = require('assert'); |
|||
var callbackify = require('../../').callbackify; |
|||
var execFile = require('child_process').execFile; |
|||
|
|||
var values = [ |
|||
'hello world', |
|||
null, |
|||
undefined, |
|||
false, |
|||
0, |
|||
{}, |
|||
{ key: 'value' }, |
|||
function ok() {}, |
|||
['array', 'with', 4, 'values'], |
|||
new Error('boo') |
|||
]; |
|||
if (typeof Symbol !== 'undefined') { |
|||
values.push(Symbol('I am a symbol')); |
|||
} |
|||
|
|||
{ |
|||
// Test that the resolution value is passed as second argument to callback
|
|||
values.forEach(function(value) { |
|||
// Test Promise factory
|
|||
function promiseFn() { |
|||
return Promise.resolve(value); |
|||
} |
|||
|
|||
var cbPromiseFn = callbackify(promiseFn); |
|||
cbPromiseFn(common.mustCall(function(err, ret) { |
|||
assert.ifError(err); |
|||
assert.strictEqual(ret, value); |
|||
})); |
|||
|
|||
// Test Thenable
|
|||
function thenableFn() { |
|||
return { |
|||
then: function(onRes, onRej) { |
|||
onRes(value); |
|||
} |
|||
}; |
|||
} |
|||
|
|||
var cbThenableFn = callbackify(thenableFn); |
|||
cbThenableFn(common.mustCall(function(err, ret) { |
|||
assert.ifError(err); |
|||
assert.strictEqual(ret, value); |
|||
})); |
|||
}); |
|||
} |
|||
|
|||
{ |
|||
// Test that rejection reason is passed as first argument to callback
|
|||
values.forEach(function(value) { |
|||
// test a Promise factory
|
|||
function promiseFn() { |
|||
return Promise.reject(value); |
|||
} |
|||
|
|||
var cbPromiseFn = callbackify(promiseFn); |
|||
cbPromiseFn(common.mustCall(function(err, ret) { |
|||
assert.strictEqual(ret, undefined); |
|||
if (err instanceof Error) { |
|||
if ('reason' in err) { |
|||
assert(!value); |
|||
assert.strictEqual(err.message, 'Promise was rejected with a falsy value'); |
|||
assert.strictEqual(err.reason, value); |
|||
} else { |
|||
assert.strictEqual(String(value).endsWith(err.message), true); |
|||
} |
|||
} else { |
|||
assert.strictEqual(err, value); |
|||
} |
|||
})); |
|||
|
|||
// Test Thenable
|
|||
function thenableFn() { |
|||
return { |
|||
then: function (onRes, onRej) { |
|||
onRej(value); |
|||
} |
|||
}; |
|||
} |
|||
|
|||
var cbThenableFn = callbackify(thenableFn); |
|||
cbThenableFn(common.mustCall(function(err, ret) { |
|||
assert.strictEqual(ret, undefined); |
|||
if (err instanceof Error) { |
|||
if ('reason' in err) { |
|||
assert(!value); |
|||
assert.strictEqual(err.message, 'Promise was rejected with a falsy value'); |
|||
assert.strictEqual(err.reason, value); |
|||
} else { |
|||
assert.strictEqual(String(value).endsWith(err.message), true); |
|||
} |
|||
} else { |
|||
assert.strictEqual(err, value); |
|||
} |
|||
})); |
|||
}); |
|||
} |
|||
|
|||
{ |
|||
// Test that arguments passed to callbackified function are passed to original
|
|||
values.forEach(function(value) { |
|||
function promiseFn(arg) { |
|||
assert.strictEqual(arg, value); |
|||
return Promise.resolve(arg); |
|||
} |
|||
|
|||
var cbPromiseFn = callbackify(promiseFn); |
|||
cbPromiseFn(value, common.mustCall(function(err, ret) { |
|||
assert.ifError(err); |
|||
assert.strictEqual(ret, value); |
|||
})); |
|||
}); |
|||
} |
|||
|
|||
{ |
|||
// Test that `this` binding is the same for callbackified and original
|
|||
values.forEach(function(value) { |
|||
var iAmThis = { |
|||
fn: function(arg) { |
|||
assert.strictEqual(this, iAmThis); |
|||
return Promise.resolve(arg); |
|||
}, |
|||
}; |
|||
iAmThis.cbFn = callbackify(iAmThis.fn); |
|||
iAmThis.cbFn(value, common.mustCall(function(err, ret) { |
|||
assert.ifError(err); |
|||
assert.strictEqual(ret, value); |
|||
assert.strictEqual(this, iAmThis); |
|||
})); |
|||
}); |
|||
} |
|||
|
|||
// These tests are not necessary in the browser.
|
|||
if (false) { |
|||
// Test that callback that throws emits an `uncaughtException` event
|
|||
var fixture = fixtures.path('uncaught-exceptions', 'callbackify1.js'); |
|||
execFile( |
|||
process.execPath, |
|||
[fixture], |
|||
common.mustCall(function (err, stdout, stderr) { |
|||
assert.strictEqual(err.code, 1); |
|||
assert.strictEqual(Object.getPrototypeOf(err).name, 'Error'); |
|||
assert.strictEqual(stdout, ''); |
|||
var errLines = stderr.trim().split(/[\r\n]+/); |
|||
var errLine = errLines.find(function (l) { return /^Error/.exec(l) }); |
|||
assert.strictEqual(errLine, 'Error: ' + fixture); |
|||
}) |
|||
); |
|||
} |
|||
|
|||
if (false) { |
|||
// Test that handled `uncaughtException` works and passes rejection reason
|
|||
var fixture = fixtures.path('uncaught-exceptions', 'callbackify2.js'); |
|||
execFile( |
|||
process.execPath, |
|||
[fixture], |
|||
common.mustCall(function (err, stdout, stderr) { |
|||
assert.ifError(err); |
|||
assert.strictEqual(stdout.trim(), fixture); |
|||
assert.strictEqual(stderr, ''); |
|||
}) |
|||
); |
|||
} |
|||
|
|||
{ |
|||
// Verify that non-function inputs throw.
|
|||
['foo', null, undefined, false, 0, {}, typeof Symbol !== 'undefined' ? Symbol() : undefined, []].forEach(function(value) { |
|||
common.expectsError(function() { |
|||
callbackify(value); |
|||
}, { |
|||
code: 'ERR_INVALID_ARG_TYPE', |
|||
type: TypeError, |
|||
message: 'The "original" argument must be of type Function' |
|||
}); |
|||
}); |
|||
} |
|||
|
|||
if (require('is-async-supported')()) { |
|||
require('./callbackify-async'); |
|||
} |
@ -0,0 +1,31 @@ |
|||
var assert = require('assert'); |
|||
|
|||
var mustCalls = []; |
|||
var common = { |
|||
expectsError: function (fn, props) { |
|||
try { fn(); } |
|||
catch (err) { |
|||
if (props.type) assert.equal(err.constructor, props.type); |
|||
if (props.message) assert.equal(err.message, props.message); |
|||
return; |
|||
} |
|||
assert.fail('expected error'); |
|||
}, |
|||
mustCall: function (fn) { |
|||
function mustCall() { |
|||
mustCall.called = true |
|||
return fn.apply(this, arguments); |
|||
} |
|||
|
|||
mustCalls.push(mustCall); |
|||
return mustCall; |
|||
} |
|||
}; |
|||
|
|||
process.on('exit', function () { |
|||
mustCalls.forEach(function (mc) { |
|||
assert(mc.called); |
|||
}); |
|||
}); |
|||
|
|||
module.exports = common; |
@ -0,0 +1,201 @@ |
|||
var common = require('./common'); |
|||
var assert = require('assert'); |
|||
var fs = require('fs'); |
|||
var vm = require('vm'); |
|||
var promisify = require('../../util').promisify; |
|||
|
|||
if (typeof Promise === 'undefined') { |
|||
console.log('no global Promise found, skipping promisify tests'); |
|||
return; |
|||
} |
|||
|
|||
var stat = promisify(fs.stat); |
|||
|
|||
{ |
|||
var promise = stat(__filename); |
|||
assert(promise instanceof Promise); |
|||
promise.then(common.mustCall(function (value) { |
|||
assert.deepStrictEqual(value, fs.statSync(__filename)); |
|||
})); |
|||
} |
|||
|
|||
{ |
|||
var promise = stat('/dontexist'); |
|||
promise.catch(common.mustCall(function (error) { |
|||
assert(error.message.indexOf('ENOENT: no such file or directory, stat') !== -1); |
|||
})); |
|||
} |
|||
|
|||
{ |
|||
function fn() {} |
|||
function promisifedFn() {} |
|||
fn[promisify.custom] = promisifedFn; |
|||
assert.strictEqual(promisify(fn), promisifedFn); |
|||
assert.strictEqual(promisify(promisify(fn)), promisifedFn); |
|||
} |
|||
|
|||
{ |
|||
function fn2() {} |
|||
fn2[promisify.custom] = 42; |
|||
common.expectsError( |
|||
function () { promisify(fn2); }, |
|||
{ code: 'ERR_INVALID_ARG_TYPE', type: TypeError } |
|||
); |
|||
} |
|||
|
|||
// promisify args test disabled, it is an internal core API that is
|
|||
// not used anywhere anymore and this package does not implement it.
|
|||
if (false) { |
|||
var firstValue = 5; |
|||
var secondValue = 17; |
|||
|
|||
function fn3(callback) { |
|||
callback(null, firstValue, secondValue); |
|||
} |
|||
|
|||
fn3[customPromisifyArgs] = ['first', 'second']; |
|||
|
|||
promisify(fn3)().then(common.mustCall(function (obj) { |
|||
assert.deepStrictEqual(obj, { first: firstValue, second: secondValue }); |
|||
})); |
|||
} |
|||
|
|||
{ |
|||
var fn4 = vm.runInNewContext('(function() {})'); |
|||
assert.notStrictEqual(Object.getPrototypeOf(promisify(fn4)), |
|||
Function.prototype); |
|||
} |
|||
|
|||
{ |
|||
function fn5(callback) { |
|||
callback(null, 'foo', 'bar'); |
|||
} |
|||
promisify(fn5)().then(common.mustCall(function (value) { |
|||
assert.deepStrictEqual(value, 'foo'); |
|||
})); |
|||
} |
|||
|
|||
{ |
|||
function fn6(callback) { |
|||
callback(null); |
|||
} |
|||
promisify(fn6)().then(common.mustCall(function (value) { |
|||
assert.strictEqual(value, undefined); |
|||
})); |
|||
} |
|||
|
|||
{ |
|||
function fn7(callback) { |
|||
callback(); |
|||
} |
|||
promisify(fn7)().then(common.mustCall(function (value) { |
|||
assert.strictEqual(value, undefined); |
|||
})); |
|||
} |
|||
|
|||
{ |
|||
function fn8(err, val, callback) { |
|||
callback(err, val); |
|||
} |
|||
promisify(fn8)(null, 42).then(common.mustCall(function (value) { |
|||
assert.strictEqual(value, 42); |
|||
})); |
|||
} |
|||
|
|||
{ |
|||
function fn9(err, val, callback) { |
|||
callback(err, val); |
|||
} |
|||
promisify(fn9)(new Error('oops'), null).catch(common.mustCall(function (err) { |
|||
assert.strictEqual(err.message, 'oops'); |
|||
})); |
|||
} |
|||
|
|||
{ |
|||
function fn9(err, val, callback) { |
|||
callback(err, val); |
|||
} |
|||
|
|||
|
|||
Promise.resolve() |
|||
.then(function () { return promisify(fn9)(null, 42); }) |
|||
.then(function (value) { |
|||
assert.strictEqual(value, 42); |
|||
}); |
|||
} |
|||
|
|||
{ |
|||
var o = {}; |
|||
var fn10 = promisify(function(cb) { |
|||
|
|||
cb(null, this === o); |
|||
}); |
|||
|
|||
o.fn = fn10; |
|||
|
|||
o.fn().then(common.mustCall(function(val) { |
|||
assert(val); |
|||
})); |
|||
} |
|||
|
|||
(function () { |
|||
var err = new Error('Should not have called the callback with the error.'); |
|||
var stack = err.stack; |
|||
|
|||
var fn11 = promisify(function(cb) { |
|||
cb(null); |
|||
cb(err); |
|||
}); |
|||
|
|||
Promise.resolve() |
|||
.then(function () { return fn11(); }) |
|||
.then(function () { return Promise.resolve(); }) |
|||
.then(function () { |
|||
assert.strictEqual(stack, err.stack); |
|||
}); |
|||
})(); |
|||
|
|||
{ |
|||
function c() { } |
|||
var a = promisify(function() { }); |
|||
var b = promisify(a); |
|||
assert.notStrictEqual(c, a); |
|||
assert.strictEqual(a, b); |
|||
} |
|||
|
|||
{ |
|||
var errToThrow; |
|||
var thrower = promisify(function(a, b, c, cb) { |
|||
errToThrow = new Error(); |
|||
throw errToThrow; |
|||
}); |
|||
thrower(1, 2, 3) |
|||
.then(assert.fail) |
|||
.then(assert.fail, function (e) { assert.strictEqual(e, errToThrow); }); |
|||
} |
|||
|
|||
{ |
|||
var err = new Error(); |
|||
|
|||
var a = promisify(function (cb) { cb(err) })(); |
|||
var b = promisify(function () { throw err; })(); |
|||
|
|||
Promise.all([ |
|||
a.then(assert.fail, function(e) { |
|||
assert.strictEqual(err, e); |
|||
}), |
|||
b.then(assert.fail, function(e) { |
|||
assert.strictEqual(err, e); |
|||
}) |
|||
]); |
|||
} |
|||
|
|||
[undefined, null, true, 0, 'str', {}, [], Symbol()].forEach(function (input) { |
|||
common.expectsError( |
|||
function () { promisify(input); }, |
|||
{ |
|||
code: 'ERR_INVALID_ARG_TYPE', |
|||
type: TypeError, |
|||
message: 'The "original" argument must be of type Function' |
|||
}); |
|||
}); |
Loading…
Reference in new issue