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
|
var async = require('../../lib');
const {expect} = require('chai');
const {default: wrapAsync} = require('../../lib/internal/wrapAsync')
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('asyncify should not add an additional level of wrapping', () => {
const wrapped = wrapAsync(async.each)
let sameStack = false
wrapped([1], (val, cb) => cb(), () => {sameStack = true})
expect(sameStack).to.equal(true)
})
it('should throw as expected (async)', async () => {
try {
await async.each(input, async val => { throw new Error(val) });
} catch (e) {
var thrown = e
}
expect(thrown).to.be.an('error')
});
it('should throw as expected (callback)', async () => {
try {
await async.each(input, (val, cb) => { cb(new Error(val)) });
} catch (e) {
var thrown = e
}
expect(thrown).to.be.an('error')
});
/*
* Collections
*/
it('should return a Promise: each', async () => {
const calls = []
await async.each(input, async val => { calls.push(val) });
expect(calls).to.eql([1, 2, 3])
expect(async.each(input, asyncIdentity) instanceof Promise).to.equal(true)
});
it('should return a Promise: eachSeries', async () => {
const calls = []
await async.eachSeries(input, async val => { calls.push(val) });
expect(calls).to.eql([1, 2, 3])
});
it('should return a Promise: eachLimit', async () => {
const calls = []
await async.eachLimit(input, 1, async val => { calls.push(val) });
expect(calls).to.eql([1, 2, 3])
});
it('should return a Promise: eachOf', async () => {
const calls = []
await async.eachOf(inputObj, async (...args) => { calls.push(args) });
expect(calls).to.eql([[1, 'a'], [2, 'b'], [3, 'c']])
});
it('should return a Promise: eachOfSeries', async () => {
const calls = []
await async.eachOfSeries(inputObj, async (...args) => { calls.push(args) });
expect(calls).to.eql([[1, 'a'], [2, 'b'], [3, 'c']])
});
it('should return a Promise: eachOfLimit', async () => {
const calls = []
await async.eachOfLimit(inputObj, 1, async (...args) => { calls.push(args) });
expect(calls).to.eql([[1, 'a'], [2, 'b'], [3, 'c']])
});
};
|
