diff options
author | Alexander Early <alexander.early@gmail.com> | 2018-06-02 18:35:23 -0700 |
---|---|---|
committer | Alexander Early <alexander.early@gmail.com> | 2018-06-02 18:35:32 -0700 |
commit | bd86f42a7d71552d9a502b50235ffc090a1b4a98 (patch) | |
tree | f5170115927ad4097f1a393d34b8a52f5c9bbfeb /test/es2017/asyncFunctions.js | |
parent | b149f7dcc7daba4d7bac5a313bdf6d1a85210cb1 (diff) | |
download | async-bd86f42a7d71552d9a502b50235ffc090a1b4a98.tar.gz |
move mocha_tests/ to test/
Diffstat (limited to 'test/es2017/asyncFunctions.js')
-rw-r--r-- | test/es2017/asyncFunctions.js | 702 |
1 files changed, 702 insertions, 0 deletions
diff --git a/test/es2017/asyncFunctions.js b/test/es2017/asyncFunctions.js new file mode 100644 index 0000000..1a93f4f --- /dev/null +++ b/test/es2017/asyncFunctions.js @@ -0,0 +1,702 @@ +var async = require('../../lib'); +const expect = require('chai').expect; +const assert = require('assert'); + + +module.exports = function () { + async function asyncIdentity(val) { + var res = await Promise.resolve(val); + return res; + } + + const input = [1, 2, 3]; + const inputObj = {a: 1, b: 2, c: 3}; + + it('should asyncify async functions', (done) => { + async.asyncify(asyncIdentity)(42, (err, val) => { + assert(val === 42); + done(err); + }) + }); + + it('should handle errors in async functions', (done) => { + async.asyncify(async function () { + throw new Error('thrown error') + })((err) => { + assert(err.message = 'thrown error'); + done(); + }) + }); + + /* + * Collections + */ + + it('should handle async functions in each', (done) => { + async.each(input, asyncIdentity, done); + }); + + it('should handle async functions in eachLimit', (done) => { + async.eachLimit(input, 2, asyncIdentity, done); + }); + + it('should handle async functions in eachSeries', (done) => { + async.eachSeries(input, asyncIdentity, done); + }); + + it('should handle async functions in eachOf', (done) => { + async.eachOf(input, asyncIdentity, done); + }); + + it('should handle async functions in eachOfLimit', (done) => { + async.eachOfLimit(input, 2, asyncIdentity, done); + }); + + it('should handle async functions in eachOfSeries', (done) => { + async.eachOfSeries(input, asyncIdentity, done); + }); + + it('should handle async functions in map', (done) => { + async.map(input, asyncIdentity, (err, result) => { + expect(result).to.eql(input); + done(err); + }); + }); + + it('should handle async functions in mapLimit', (done) => { + async.mapLimit(input, 2, asyncIdentity, (err, result) => { + expect(result).to.eql(input); + done(err); + }); + }); + + it('should handle async functions in mapSeries', (done) => { + async.mapSeries(input, asyncIdentity, (err, result) => { + expect(result).to.eql(input); + done(err); + }); + }); + + + it('should handle async functions in mapValues', (done) => { + async.mapValues(inputObj, asyncIdentity, (err, result) => { + expect(result).to.eql(inputObj); + done(err); + }); + }); + + it('should handle async functions in mapValuesLimit', (done) => { + async.mapValuesLimit(inputObj, 2, asyncIdentity, (err, result) => { + expect(result).to.eql(inputObj); + done(err); + }); + }); + + it('should handle async functions in mapValuesSeries', (done) => { + async.mapValuesSeries(inputObj, asyncIdentity, (err, result) => { + expect(result).to.eql(inputObj); + done(err); + }); + }); + + it('should handle async functions in filter', (done) => { + async.filter(input, asyncIdentity, (err, result) => { + expect(result).to.eql(input); + done(err); + }); + }); + + it('should handle async functions in filterLimit', (done) => { + async.filterLimit(input, 2, asyncIdentity, (err, result) => { + expect(result).to.eql(input); + done(err); + }); + }); + + it('should handle async functions in filterSeries', (done) => { + async.filterSeries(input, asyncIdentity, (err, result) => { + expect(result).to.eql(input); + done(err); + }); + }); + + it('should handle async functions in reject', (done) => { + async.reject(input, asyncIdentity, (err, result) => { + expect(result).to.eql([]); + done(err); + }); + }); + + it('should handle async functions in rejectLimit', (done) => { + async.rejectLimit(input, 2, asyncIdentity, (err, result) => { + expect(result).to.eql([]); + done(err); + }); + }); + + it('should handle async functions in rejectSeries', (done) => { + async.rejectSeries(input, asyncIdentity, (err, result) => { + expect(result).to.eql([]); + done(err); + }); + }); + + it('should handle async functions in every', (done) => { + async.every(input, asyncIdentity, (err, result) => { + expect(result).to.eql(true); + done(err); + }); + }); + + it('should handle async functions in everyLimit', (done) => { + async.everyLimit(input, 2, asyncIdentity, (err, result) => { + expect(result).to.eql(true); + done(err); + }); + }); + + it('should handle async functions in everySeries', (done) => { + async.everySeries(input, asyncIdentity, (err, result) => { + expect(result).to.eql(true); + done(err); + }); + }); + + it('should handle async functions in some', (done) => { + async.some(input, asyncIdentity, (err, result) => { + expect(result).to.eql(true); + done(err); + }); + }); + + it('should handle async functions in someLimit', (done) => { + async.someLimit(input, 2, asyncIdentity, (err, result) => { + expect(result).to.eql(true); + done(err); + }); + }); + + it('should handle async functions in someSeries', (done) => { + async.someSeries(input, asyncIdentity, (err, result) => { + expect(result).to.eql(true); + done(err); + }); + }); + + it('should handle async functions in groupBy', (done) => { + async.groupBy(input, asyncIdentity, (err, result) => { + expect(result).to.eql({1: [1], 2: [2], 3: [3]}); + done(err); + }); + }); + + it('should handle async functions in groupByLimit', (done) => { + async.groupByLimit(input, 2, asyncIdentity, (err, result) => { + expect(result).to.eql({1: [1], 2: [2], 3: [3]}); + done(err); + }); + }); + + it('should handle async functions in groupBySeries', (done) => { + async.groupBySeries(input, asyncIdentity, (err, result) => { + expect(result).to.eql({1: [1], 2: [2], 3: [3]}); + done(err); + }); + }); + + + it('should handle async functions in concat', (done) => { + async.concat(input, asyncIdentity, (err, result) => { + expect(result).to.eql(input); + done(err); + }); + }); + + it('should handle async functions in concatLimit', (done) => { + async.concatLimit(input, 2, asyncIdentity, (err, result) => { + expect(err).to.eql(null); + expect(result).to.eql(input); + done(err); + }); + }); + + it('should handle async functions in concatSeries', (done) => { + async.concatSeries(input, asyncIdentity, (err, result) => { + expect(result).to.eql(input); + done(err); + }); + }); + + it('should handle async functions in reduce', (done) => { + async.reduce(input, 0, async function (acc, val) { + var res = await Promise.resolve(acc + val); + return res; + }, + (err, result) => { + expect(result).to.eql(6); + done(err); + }); + }); + + it('should handle async functions in reduceRight', (done) => { + async.reduceRight(input, 0, async function (acc, val) { + var res = await Promise.resolve(acc + val); + return res; + }, + (err, result) => { + expect(result).to.eql(6); + done(err); + }); + }); + + it('should handle async functions in sortBy', (done) => { + async.sortBy([3, 2, 1], asyncIdentity, (err, result) => { + expect(result).to.eql(input); + done(err); + }); + }); + + it('should handle async functions in transform', (done) => { + async.transform(inputObj, async function (obj, val, key) { + obj[key] = await Promise.resolve(val); + }, (err, result) => { + expect(result).to.eql(inputObj); + done(err); + }); + }); + + /* + * Control Flow + */ + + it('should handle async functions in applyEach', (done) => { + async.applyEach([asyncIdentity, asyncIdentity])(input, (err, result) => { + expect(result).to.eql([input, input]); + done(err); + }); + }); + + it('should handle async functions in applyEachSeries', (done) => { + async.applyEachSeries([asyncIdentity, asyncIdentity])(input, (err, result) => { + expect(result).to.eql([input, input]); + done(err); + }); + }); + + it('should handle async functions in auto', (done) => { + async.auto({ + a: async function () { + return await Promise.resolve(1); + }, + b: async function () { + return await Promise.resolve(2); + }, + c: ['a', 'b', async function (results) { + return await Promise.resolve(results.a + results.b); + }] + }, (err, result) => { + expect(result).to.eql({a: 1, b: 2, c: 3}); + done(err); + }); + }); + + it('should handle async functions in autoInject', (done) => { + async.autoInject({ + a: async function () { + return await Promise.resolve(1); + }, + b: async function (a) { + return await Promise.resolve(a + 1); + }, + c: async (a, b) => { + return await Promise.resolve(a + b); + }, + d: async (c) => { + return await Promise.resolve(c + 1); + } + }, (err, result) => { + expect(result).to.eql({a: 1, b: 2, c: 3, d: 4}); + done(err); + }); + }); + + it('should handle async functions in autoInject (shorthand)', (done) => { + async.autoInject({ + async a() { + return await Promise.resolve(1); + }, + async b(a) { + return await Promise.resolve(a + 1); + }, + async c(a, b) { + return await Promise.resolve(a + b); + }, + async d(c) { + return await Promise.resolve(c + 1); + } + }, (err, result) => { + expect(result).to.eql({a: 1, b: 2, c: 3, d: 4}); + done(err); + }); + }); + + it('should handle async functions in cargo', (done) => { + var result = []; + var q = async.cargo(async function(val) { + result.push(await Promise.resolve(val)); + }, 2) + + q.drain = () => { + expect(result).to.eql([[1, 2], [3]]); + done(); + }; + + q.push(1); + q.push(2); + q.push(3); + }); + + it('should handle async functions in queue', (done) => { + var result = []; + var q = async.queue(async function(val) { + result.push(await Promise.resolve(val)); + }, 2) + + q.drain = () => { + expect(result).to.eql([1, 2, 3]); + done(); + }; + + q.push(1); + q.push(2); + q.push(3); + }); + + it('should handle async functions in priorityQueue', (done) => { + var result = []; + var q = async.priorityQueue(async function(val) { + result.push(await Promise.resolve(val)); + }, 2) + + q.drain = () => { + expect(result).to.eql([1, 2, 3]); + done(); + }; + + q.push(1); + q.push(2); + q.push(3); + }); + + it('should handle async functions in compose', (done) => { + async.compose( + async (a) => a + 1, + async (a) => a + 1, + async (a) => a + 1 + )(0, (err, result) => { + expect(result).to.equal(3); + done(err); + }); + }); + + it('should handle async functions in seq', (done) => { + async.seq( + async (a) => a + 1, + async (a) => a + 1, + async (a) => a + 1 + )(0, (err, result) => { + expect(result).to.equal(3); + done(err); + }); + }); + + it('should handle async functions in during', (done) => { + var val = 0; + async.during(async () => { + return val < 3; + }, + async () => { + val += 1; + return val; + }, done); + }); + + it('should handle async functions in doDuring', (done) => { + var val = 0; + async.doDuring(async () => { + val += 1; + return val; + }, + async (res) => { + return res < 3; + }, done); + }); + + it('should handle async functions in whilst', (done) => { + var val = 0; + async.whilst(() => val < 3, + async () => { + val += 1; + return val; + }, done); + }); + + it('should handle async functions in doWhilst', (done) => { + var val = 0; + async.doWhilst(async () => { + val += 1; + return val; + }, (res) => res < 3, done); + }); + + it('should handle async functions in until', (done) => { + var val = 0; + async.until(() => val > 3, + async () => { + val += 1; + return val; + }, done); + }); + + it('should handle async functions in doUntil', (done) => { + var val = 0; + async.doUntil(async () => { + val += 1; + return val; + }, (res) => res > 3, done); + }); + + it('should handle async functions in forever', (done) => { + var counter = 0; + async.forever(async () => { + counter += 1; + if (counter > 10) throw new Error('too big'); + },(err) => { + expect(err.message).to.equal('too big'); + done(); + }) + }); + + it('should handle async functions in parallel', (done) => { + async.parallel([ + async () => 1, + async () => 2, + async () => 3 + ], (err, result) => { + expect(result).to.eql([1, 2, 3]); + done(err); + }) + }); + + it('should handle async functions in parallel (object)', (done) => { + async.parallel({ + a: async () => 1, + b: async () => 2, + c: async () => 3 + }, (err, result) => { + expect(result).to.eql({a: 1, b: 2, c: 3}); + done(err); + }) + }); + + it('should handle async functions in parallelLimit', (done) => { + async.parallelLimit([ + async () => 1, + async () => 2, + async () => 3 + ], 2, (err, result) => { + expect(result).to.eql([1, 2, 3]); + done(err); + }) + }); + + it('should handle async functions in parallelLimit (object)', (done) => { + async.parallelLimit({ + a: async () => 1, + b: async () => 2, + c: async () => 3 + }, 2, (err, result) => { + expect(result).to.eql({a: 1, b: 2, c: 3}); + done(err); + }) + }); + + it('should handle async functions in series', (done) => { + async.series([ + async () => 1, + async () => 2, + async () => 3 + ], (err, result) => { + expect(result).to.eql([1, 2, 3]); + done(err); + }) + }); + + it('should handle async functions in series (object)', (done) => { + async.series({ + a: async () => 1, + b: async () => 2, + c: async () => 3 + }, (err, result) => { + expect(result).to.eql({a: 1, b: 2, c: 3}); + done(err); + }) + }); + + it('should handle async functions in race', (done) => { + async.race([ + async () => 1, + async () => 2, + async () => 3 + ], (err, result) => { + expect(result).to.eql(1); + done(err); + }) + }); + + it('should handle async functions in retry', (done) => { + var count = 0; + async.retry(4, async () => { + count += 1; + if (count < 3) throw new Error('fail'); + return count; + }, (err, result) => { + expect(result).to.eql(3); + done(err); + }) + }); + + it('should handle async functions in retryable', (done) => { + var count = 0; + async.retryable(4, async () => { + count += 1; + if (count < 3) throw new Error('fail'); + return count; + })((err, result) => { + expect(result).to.eql(3); + done(err); + }) + }); + + it('should handle async functions in times', (done) => { + var count = 0; + async.times(4, async () => { + count += 1; + return count; + }, (err, result) => { + expect(result).to.eql([1, 2, 3, 4]); + done(err); + }) + }); + + it('should handle async functions in timesLimit', (done) => { + var count = 0; + async.timesLimit(4, 2, async () => { + count += 1; + return count; + }, (err, result) => { + expect(result).to.eql([1, 2, 3, 4]); + done(err); + }) + }); + + it('should handle async functions in timesSeries', (done) => { + var count = 0; + async.timesSeries(4, async () => { + count += 1; + return count; + }, (err, result) => { + expect(result).to.eql([1, 2, 3, 4]); + done(err); + }) + }); + + it('should handle async functions in waterfall', (done) => { + async.waterfall([ + async () => 1, + async (a) => a + 1, + async (a) => [a, a + 1], + async ([a, b]) => a + b, + ], (err, result) => { + expect(result).to.eql(5); + done(err); + }) + }); + + it('should handle async functons in tryEach', (done) => { + async.tryEach([ + async () => { throw new Error('fail1'); }, + async () => { throw new Error('fail2'); }, + async () => 5, + async () => { throw new Error('shoult not get here'); } + ], (err, result) => { + expect(result).to.eql(5); + done(); + }) + }); + + /** + * Utils + */ + + it('should handle async functions in dir', (done) => { + async.dir(async (val) => val, 'foo'); + setTimeout(done); + }); + + it('should handle async functions in log', (done) => { + async.log(async (val) => val, 'foo'); + setTimeout(done); + }); + + it('should handle async functions in ensureAsync', () => { + var fn = async.ensureAsync(asyncIdentity); + assert(fn === asyncIdentity); + }); + + it('should handle async functions in memoize', (done) => { + var fn = async.memoize(asyncIdentity); + fn(1, () => { + fn(1, done); + }) + }); + + it('should handle async functions in reflect', (done) => { + var fn = async.reflect(asyncIdentity); + fn(1, (err, result) => { + expect(result).to.eql({value: 1}); + done(err); + }) + }); + + it('should handle async functions in reflect (error case)', (done) => { + var thrown; + var fn = async.reflect(async () => { + thrown = new Error('foo'); + throw thrown; + }); + fn(1, (err, result) => { + expect(result).to.eql({error: thrown}); + done(err); + }) + }); + + it('should handle async functions in timeout', (done) => { + var fn = async.timeout(asyncIdentity, 50); + fn(1, (err, result) => { + expect(result).to.eql(1); + done(err); + }) + }); + + it('should handle async functions in timeout (error case)', (done) => { + var fn = async.timeout(async (val) => { + await new Promise((resolve) => setTimeout(resolve, 100)); + return val; + }, 50); + fn(1, (err) => { + expect(err.message).to.match(/timed out/); + done(); + }) + }); +} |