summaryrefslogtreecommitdiff
path: root/test/parallel.js
diff options
context:
space:
mode:
Diffstat (limited to 'test/parallel.js')
-rw-r--r--test/parallel.js353
1 files changed, 353 insertions, 0 deletions
diff --git a/test/parallel.js b/test/parallel.js
new file mode 100644
index 0000000..2b07822
--- /dev/null
+++ b/test/parallel.js
@@ -0,0 +1,353 @@
+var async = require('../lib');
+var expect = require('chai').expect;
+var assert = require('assert');
+var getFunctionsObject = require('./support/get_function_object');
+
+describe('parallel', function() {
+
+ it('parallel', function(done) {
+ var call_order = [];
+ async.parallel([
+ function(callback){
+ setTimeout(function(){
+ call_order.push(1);
+ callback(null, 1);
+ }, 50);
+ },
+ function(callback){
+ setTimeout(function(){
+ call_order.push(2);
+ callback(null, 2);
+ }, 100);
+ },
+ function(callback){
+ setTimeout(function(){
+ call_order.push(3);
+ callback(null, 3,3);
+ }, 25);
+ }
+ ],
+ function(err, results){
+ assert(err === null, err + " passed instead of 'null'");
+ expect(call_order).to.eql([3,1,2]);
+ expect(results).to.eql([1,2,[3,3]]);
+ done();
+ });
+ });
+
+ it('parallel empty array', function(done) {
+ async.parallel([], function(err, results){
+ assert(err === null, err + " passed instead of 'null'");
+ expect(results).to.eql([]);
+ done();
+ });
+ });
+
+ it('parallel error', function(done) {
+ async.parallel([
+ function(callback){
+ callback('error', 1);
+ },
+ function(callback){
+ callback('error2', 2);
+ }
+ ],
+ function(err){
+ expect(err).to.equal('error');
+ });
+ setTimeout(done, 100);
+ });
+
+ it('parallel no callback', function(done) {
+ async.parallel([
+ function(callback){callback();},
+ function(callback){callback(); done();},
+ ]);
+ });
+
+ it('parallel object', function(done) {
+ var call_order = [];
+ async.parallel(getFunctionsObject(call_order), function(err, results){
+ expect(err).to.equal(null);
+ expect(call_order).to.eql([3,1,2]);
+ expect(results).to.eql({
+ one: 1,
+ two: 2,
+ three: [3,3]
+ });
+ done();
+ });
+ });
+
+ // Issue 10 on github: https://github.com/caolan/async/issues#issue/10
+ it('paralel falsy return values', function(done) {
+ function taskFalse(callback) {
+ async.nextTick(function() {
+ callback(null, false);
+ });
+ }
+ function taskUndefined(callback) {
+ async.nextTick(function() {
+ callback(null, undefined);
+ });
+ }
+ function taskEmpty(callback) {
+ async.nextTick(function() {
+ callback(null);
+ });
+ }
+ function taskNull(callback) {
+ async.nextTick(function() {
+ callback(null, null);
+ });
+ }
+ async.parallel(
+ [taskFalse, taskUndefined, taskEmpty, taskNull],
+ function(err, results) {
+ expect(results.length).to.equal(4);
+ assert.strictEqual(results[0], false);
+ assert.strictEqual(results[1], undefined);
+ assert.strictEqual(results[2], undefined);
+ assert.strictEqual(results[3], null);
+ done();
+ }
+ );
+ });
+
+
+ it('parallel limit', function(done) {
+ var call_order = [];
+ async.parallelLimit([
+ function(callback){
+ setTimeout(function(){
+ call_order.push(1);
+ callback(null, 1);
+ }, 50);
+ },
+ function(callback){
+ setTimeout(function(){
+ call_order.push(2);
+ callback(null, 2);
+ }, 100);
+ },
+ function(callback){
+ setTimeout(function(){
+ call_order.push(3);
+ callback(null, 3,3);
+ }, 25);
+ }
+ ],
+ 2,
+ function(err, results){
+ assert(err === null, err + " passed instead of 'null'");
+ expect(call_order).to.eql([1,3,2]);
+ expect(results).to.eql([1,2,[3,3]]);
+ done();
+ });
+ });
+
+ it('parallel limit empty array', function(done) {
+ async.parallelLimit([], 2, function(err, results){
+ assert(err === null, err + " passed instead of 'null'");
+ expect(results).to.eql([]);
+ done();
+ });
+ });
+
+ it('parallel limit error', function(done) {
+ async.parallelLimit([
+ function(callback){
+ callback('error', 1);
+ },
+ function(callback){
+ callback('error2', 2);
+ }
+ ],
+ 1,
+ function(err){
+ expect(err).to.equal('error');
+ });
+ setTimeout(done, 100);
+ });
+
+ it('parallel limit no callback', function(done) {
+ async.parallelLimit([
+ function(callback){callback();},
+ function(callback){callback(); done();},
+ ], 1);
+ });
+
+ it('parallel limit object', function(done) {
+ var call_order = [];
+ async.parallelLimit(getFunctionsObject(call_order), 2, function(err, results){
+ expect(err).to.equal(null);
+ expect(call_order).to.eql([1,3,2]);
+ expect(results).to.eql({
+ one: 1,
+ two: 2,
+ three: [3,3]
+ });
+ done();
+ });
+ });
+
+ it('parallel call in another context @nycinvalid @nodeonly', function(done) {
+ var vm = require('vm');
+ var sandbox = {
+ async: async,
+ done: done
+ };
+
+ var fn = "(" + (function () {
+ async.parallel([function (callback) {
+ callback();
+ }], function (err) {
+ if (err) {
+ return done(err);
+ }
+ done();
+ });
+ }).toString() + "())";
+
+ vm.runInNewContext(fn, sandbox);
+ });
+
+ it('parallel error with reflect', function(done) {
+ async.parallel([
+ async.reflect(function(callback){
+ callback('error', 1);
+ }),
+ async.reflect(function(callback){
+ callback('error2', 2);
+ }),
+ async.reflect(function(callback){
+ callback(null, 2);
+ })
+ ],
+ function(err, results){
+ assert(err === null, err + " passed instead of 'null'");
+ expect(results).to.eql([
+ { error: 'error' },
+ { error: 'error2' },
+ { value: 2 }
+ ]);
+ done();
+ });
+ });
+
+ it('parallel object with reflect all (values and errors)', function(done) {
+ var tasks = {
+ one: function(callback) {
+ setTimeout(function() {
+ callback(null, 'one');
+ }, 200);
+ },
+ two: function(callback) {
+ callback('two');
+ },
+ three: function(callback) {
+ setTimeout(function() {
+ callback(null, 'three');
+ }, 100);
+ }
+ };
+
+ async.parallel(async.reflectAll(tasks), function(err, results) {
+ expect(results).to.eql({
+ one: { value: 'one' },
+ two: { error: 'two' },
+ three: { value: 'three' }
+ });
+ done();
+ })
+ });
+
+ it('parallel empty object with reflect all', function(done) {
+ var tasks = {};
+
+ async.parallel(async.reflectAll(tasks), function(err, results) {
+ expect(results).to.eql({});
+ done();
+ })
+ });
+
+ it('parallel empty object with reflect all (errors)', function(done) {
+ var tasks = {
+ one: function(callback) {
+ callback('one');
+ },
+ two: function(callback) {
+ callback('two');
+ },
+ three: function(callback) {
+ callback('three');
+ }
+ };
+
+ async.parallel(async.reflectAll(tasks), function(err, results) {
+ expect(results).to.eql({
+ one: { error: 'one' },
+ two: { error: 'two' },
+ three: { error: 'three' }
+ });
+ done();
+ })
+ });
+
+ it('parallel empty object with reflect all (values)', function(done) {
+ var tasks = {
+ one: function(callback) {
+ callback(null, 'one');
+ },
+ two: function(callback) {
+ callback(null, 'two');
+ },
+ three: function(callback) {
+ callback(null, 'three');
+ }
+ };
+
+ async.parallel(async.reflectAll(tasks), function(err, results) {
+ expect(results).to.eql({
+ one: { value: 'one' },
+ two: { value: 'two' },
+ three: { value: 'three' }
+ });
+ done();
+ })
+ });
+
+ it('parallel does not continue replenishing after error', function(done) {
+ var started = 0;
+ var arr = [
+ funcToCall,
+ funcToCall,
+ funcToCall,
+ funcToCall,
+ funcToCall,
+ funcToCall,
+ funcToCall,
+ funcToCall,
+ funcToCall,
+ ];
+ var delay = 10;
+ var limit = 3;
+ var maxTime = 10 * arr.length;
+ function funcToCall(callback) {
+ started ++;
+ if (started === 3) {
+ return callback(new Error ("Test Error"));
+ }
+ setTimeout(function(){
+ callback();
+ }, delay);
+ }
+
+ async.parallelLimit(arr, limit, function(){});
+
+ setTimeout(function(){
+ expect(started).to.equal(3);
+ done();
+ }, maxTime);
+ });
+});
View Lorry Controller Status