test-async.js

var async = require('async');


exports.testAuto = function(test){
    var callOrder = [];
    var testdata = [{test: 'test'}];
    async.auto({
        task1: ['task2', function(callback){
            setTimeout(function(){
                callOrder.push('task1');
                callback();
            }, 50);
        }],
        task2: function(callback){
            setTimeout(function(){
                callOrder.push('task2');
                callback();
            }, 100);
        },
        task3: ['task2', function(callback){
            callOrder.push('task3');
            callback();
        }],
        task4: ['task1', 'task2', function(callback){
            callOrder.push('task4');
            callback();
        }]
    },
    function(err){
        test.same(callOrder, ['task2','task3','task1','task4']);
        test.done();
    });
};

exports.testAutoError = function(test){
    test.expect(1);
    async.auto({
        task1: function(callback){
            callback('testerror');
        },
        task2: ['task1', function(callback){
            test.ok(false, 'task2 should not be called');
            callback();
        }],
        task3: function(callback){
            callback('testerror2');
        },
    },
    function(err){
        test.equals(err, 'testerror');
    });
    setTimeout(test.done, 200);
};

exports.testAutoNoCallback = function(test){
    async.auto({
        task1: function(callback){callback();},
        task2: ['task1', function(callback){callback(); test.done();}],
    });
};

exports.testWaterfall = function(test){
    test.expect(6);
    var call_order = [];
    async.waterfall([
        function(callback){
            call_order.push('fn1');
            process.nextTick(function(){callback('one', 'two');});
        },
        function(arg1, arg2, callback){
            call_order.push('fn2');
            test.equals(arg1, 'one');
            test.equals(arg2, 'two');
            setTimeout(function(){callback(arg1, arg2, 'three');}, 50);
        },
        function(arg1, arg2, arg3, callback){
            call_order.push('fn3');
            test.equals(arg1, 'one');
            test.equals(arg2, 'two');
            test.equals(arg3, 'three');
            callback('four');
        },
        function(arg4, callback){
            call_order.push('fn4');
            test.same(call_order, ['fn1','fn2','fn3','fn4']);
            callback('test');
        }
    ], function(err){
        test.done();
    });
};

exports.testWaterfallNoCallback = function(test){
    async.waterfall([
        function(callback){callback();},
        function(callback){callback(); test.done();},
    ]);
};

exports.testWaterfallAsync = function(test){
    var call_order = [];
    async.waterfall([
        function(callback){
            call_order.push(1);
            callback();
            call_order.push(2);
        },
        function(callback){
            call_order.push(3);
            callback();
        },
        function(){
            test.same(call_order, [1,2,3]);
            test.done();
        }
    ]);
};

exports.testWaterfallMultipleCallback = function(test){
    var call_order = [];
    var arr = [
        function(callback){
            call_order.push(1);
            // call the callback twice. this should call function 2 twice
            callback('one', 'two');
            callback('one', 'two');
        },
        function(arg1, arg2, callback){
            call_order.push(2);
            callback(arg1, arg2, 'three');
        },
        function(arg1, arg2, arg3, callback){
            call_order.push(3);
            callback('four');
        },
        function(arg4){
            call_order.push(4);
            arr[3] = function(){
                call_order.push(4);
                test.same(call_order, [1,2,2,3,3,4,4]);
                test.done();
            };
        }
    ];
    async.waterfall(arr);
};


exports.testParallel = function(test){
    async.parallel([
        function(callback){
            setTimeout(function(){callback(null, 1);}, 50);
        },
        function(callback){
            setTimeout(function(){callback(null, 2);}, 100);
        },
        function(callback){
            setTimeout(function(){callback(null, 3,3);}, 25);
        }
    ],
    function(err, results){
        test.equals(err, null);
        test.same(results, [[3,3],1,2]);
        test.done();
    });
};

exports.testParallelError = function(test){
    async.parallel([
        function(callback){
            callback('error', 1);
        },
        function(callback){
            callback('error2', 2);
        }
    ],
    function(err, results){
        test.equals(err, 'error');
    });
    setTimeout(test.done, 200);
};

exports.testParallelNoCallback = function(test){
    async.parallel([
        function(callback){callback();},
        function(callback){callback(); test.done();},
    ]);
};

exports.testSeries = function(test){
    async.series([
        function(callback){
            setTimeout(function(){callback(null, 1);}, 50);
        },
        function(callback){
            setTimeout(function(){callback(null, 2);}, 100);
        },
        function(callback){
            setTimeout(function(){callback(null, 3,3);}, 25);
        }
    ],
    function(err, results){
        test.equals(err, null);
        test.same(results, [1,2,[3,3]]);
        test.done();
    });
};

exports.testSeriesNoCallback = function(test){
    async.series([
        function(callback){callback();},
        function(callback){callback(); test.done();},
    ]);
};

exports.testIterator = function(test){
    var call_order = [];
    var iterator = async.iterator([
        function(){call_order.push(1);},
        function(arg1){
            test.equals(arg1, 'arg1');
            call_order.push(2);
        },
        function(arg1, arg2){
            test.equals(arg1, 'arg1');
            test.equals(arg2, 'arg2');
            call_order.push(3);
        },
    ]);
    iterator();
    test.same(call_order, [1]);
    var iterator2 = iterator();
    test.same(call_order, [1,1]);
    var iterator3 = iterator2('arg1');
    test.same(call_order, [1,1,2]);
    var iterator4 = iterator3('arg1', 'arg2');
    test.same(call_order, [1,1,2,3]);
    test.equals(iterator4, undefined);
    test.done();
};

exports.testIteratorNext = function(test){
    var call_order = [];
    var iterator = async.iterator([
        function(){call_order.push(1);},
        function(arg1){
            test.equals(arg1, 'arg1');
            call_order.push(2);
        },
        function(arg1, arg2){
            test.equals(arg1, 'arg1');
            test.equals(arg2, 'arg2');
            call_order.push(3);
        },
    ]);
    var fn = iterator.next();
    var iterator2 = fn('arg1');
    test.same(call_order, [2]);
    iterator2('arg1','arg2');
    test.same(call_order, [2,3]);
    test.equals(iterator2.next(), undefined);
    test.done();
};

exports.testForEach = function(test){
    var args = [];
    async.forEach([1,3,2], function(x, callback){
        setTimeout(function(){
            args.push(x);
            callback();
        }, x*50);
    }, function(err){
        test.same(args, [1,2,3]);
        test.done();
    });
};

exports.testForEachError = function(test){
    test.expect(1);
    async.forEach([1,2,3], function(x, callback){
        callback('error');
    }, function(err){
        test.equals(err, 'error');
    });
    setTimeout(test.done, 100);
};

exports.testForEachSeries = function(test){
    var args = [];
    async.forEachSeries([1,3,2], function(x, callback){
        setTimeout(function(){
            args.push(x);
            callback();
        }, x*50);
    }, function(err){
        test.same(args, [1,3,2]);
        test.done();
    });
};

exports.testForEachSeriesError = function(test){
    test.expect(2);
    var call_order = [];
    async.forEachSeries([1,2,3], function(x, callback){
        call_order.push(x);
        callback('error');
    }, function(err){
        test.same(call_order, [1]);
        test.equals(err, 'error');
    });
    setTimeout(test.done, 100);
};

exports.testMap = function(test){
    async.map([1,3,2], function(x, callback){
        setTimeout(function(){
            callback(null, x*2);
        }, x*50);
    }, function(err, results){
        test.same(results, [2,4,6]);
        test.done();
    });
};

exports.testMapError = function(test){
    test.expect(1);
    async.map([1,2,3], function(x, callback){
        callback('error');
    }, function(err, results){
        test.equals(err, 'error');
    });
    setTimeout(test.done, 100);
};

exports.testMapSeries = function(test){
    async.mapSeries([1,3,2], function(x, callback){
        setTimeout(function(){
            callback(null, x*2);
        }, x*50);
    }, function(err, results){
        test.same(results, [2,6,4]);
        test.done();
    });
};

exports.testMapSeriesError = function(test){
    test.expect(1);
    async.mapSeries([1,2,3], function(x, callback){
        callback('error');
    }, function(err, results){
        test.equals(err, 'error');
    });
    setTimeout(test.done, 100);
};

exports.testReduce = function(test){
    async.reduce([1,3,2], 0, function(a, x, callback){
        callback(null, a + x);
    }, function(err, result){
        test.equals(result, 6);
        test.done();
    });
};

exports.testReduceError = function(test){
    test.expect(1);
    async.reduce([1,2,3], 0, function(a, x, callback){
        callback('error');
    }, function(err, result){
        test.equals(err, 'error');
    });
    setTimeout(test.done, 100);
};

exports.testReduceSeries = function(test){
    async.reduceSeries([1,3,2], [], function(a, x, callback){
        callback(null, a.concat(x));
    }, function(err, result){
        test.same(result, [1,3,2]);
        test.done();
    });
};

exports.testReduceSeriesError = function(test){
    test.expect(1);
    async.reduceSeries([1,2,3], 0, function(a, x, callback){
        callback('error');
    }, function(err, result){
        test.equals(err, 'error');
    });
    setTimeout(test.done, 100);
};

exports.testFilter = function(test){
    async.filter([3,1,2], function(x, callback){
        setTimeout(function(){callback(x % 2);}, x*50);
    }, function(results){
        test.same(results, [1,3]);
        test.done();
    });
};

exports.testFilterSeries = function(test){
    async.filterSeries([3,1,2], function(x, callback){
        setTimeout(function(){callback(x % 2);}, x*50);
    }, function(results){
        test.same(results, [3,1]);
        test.done();
    });
};

exports.testSomeTrue = function(test){
    async.some([3,1,2], function(x, callback){
        process.nextTick(function(){
            callback(x === 1);
        });
    }, function(result){
        test.equals(result, true);
        test.done();
    });
};

exports.testSomeFalse = function(test){
    async.some([3,1,2], function(x, callback){
        process.nextTick(function(){
            callback(x === 10);
        });
    }, function(result){
        test.equals(result, false);
        test.done();
    });
};

exports.testSomeEarlyReturn = function(test){
    var call_order = [];
    async.some([1,2,3], function(x, callback){
        setTimeout(function(){
            call_order.push(x);
            callback(x === 1);
        }, x*50);
    }, function(result){
        call_order.push('callback');
    });
    setTimeout(function(){
        test.same(call_order, [1,'callback',2,3]);
        test.done();
    }, 200);
};

exports.testEveryTrue = function(test){
    async.every([1,2,3], function(x, callback){
        process.nextTick(function(){callback(true);});
    }, function(result){
        test.equals(result, true);
        test.done();
    });
};

exports.testEveryFalse = function(test){
    async.every([1,2,3], function(x, callback){
        process.nextTick(function(){callback(x % 2);});
    }, function(result){
        test.equals(result, false);
        test.done();
    });
};

exports.testEveryEarlyReturn = function(test){
    var call_order = [];
    async.every([1,2,3], function(x, callback){
        setTimeout(function(){
            call_order.push(x);
            callback(x === 1);
        }, x*50);
    }, function(result){
        call_order.push('callback');
    });
    setTimeout(function(){
        test.same(call_order, [1,2,'callback',3]);
        test.done();
    }, 200);
};