move mocha_tests/ to test/

1 files changed, 194 insertions, 0 deletions

diff --git a/test/series.js b/test/series.js
new file mode 100644
index 0000000..7d737fa
--- /dev/null
+++ b/test/series.js
@@ -0,0 +1,194 @@
+var async = require('../lib');
+var expect = require('chai').expect;
+var assert = require('assert');
+var getFunctionsObject = require('./support/get_function_object');
+
+describe('series', function() {
+    it('series', function(done) {
+        var call_order = [];
+        async.series([
+            function(callback){
+                setTimeout(function(){
+                    call_order.push(1);
+                    callback(null, 1);
+                }, 25);
+            },
+            function(callback){
+                setTimeout(function(){
+                    call_order.push(2);
+                    callback(null, 2);
+                }, 50);
+            },
+            function(callback){
+                setTimeout(function(){
+                    call_order.push(3);
+                    callback(null, 3,3);
+                }, 15);
+            }
+        ],
+        function(err, results){
+            assert(err === null, err + " passed instead of 'null'");
+            expect(results).to.eql([1,2,[3,3]]);
+            expect(call_order).to.eql([1,2,3]);
+            done();
+        });
+    });
+
+    it('with reflect', function(done) {
+        var call_order = [];
+        async.series([
+            async.reflect(function(callback){
+                setTimeout(function(){
+                    call_order.push(1);
+                    callback(null, 1);
+                }, 25);
+            }),
+            async.reflect(function(callback){
+                setTimeout(function(){
+                    call_order.push(2);
+                    callback(null, 2);
+                }, 50);
+            }),
+            async.reflect(function(callback){
+                setTimeout(function(){
+                    call_order.push(3);
+                    callback(null, 3,3);
+                }, 15);
+            })
+        ],
+        function(err, results){
+            assert(err === null, err + " passed instead of 'null'");
+            expect(results).to.eql([
+                { value: 1 },
+                { value: 2 },
+                { value: [3,3] }
+            ]);
+            expect(call_order).to.eql([1,2,3]);
+            done();
+        });
+    });
+
+    it('empty array', function(done) {
+        async.series([], function(err, results){
+            expect(err).to.equal(null);
+            expect(results).to.eql([]);
+            done();
+        });
+    });
+
+    it('error', function(done) {
+        async.series([
+            function(callback){
+                callback('error', 1);
+            },
+            function(callback){
+                assert(false, 'should not be called');
+                callback('error2', 2);
+            }
+        ],
+        function(err){
+            expect(err).to.equal('error');
+        });
+        setTimeout(done, 100);
+    });
+
+    it('error with reflect', function(done) {
+        async.series([
+            async.reflect(function(callback){
+                callback('error', 1);
+            }),
+            async.reflect(function(callback){
+                callback('error2', 2);
+            }),
+            async.reflect(function(callback){
+                callback(null, 1);
+            })
+        ],
+        function(err, results){
+            assert(err === null, err + " passed instead of 'null'");
+            expect(results).to.eql([
+                { error: 'error' },
+                { error: 'error2' },
+                { value: 1 }
+            ]);
+            done();
+        });
+    });
+
+    it('no callback', function(done) {
+        async.series([
+            function(callback){callback();},
+            function(callback){callback(); done();},
+        ]);
+    });
+
+    it('object', function(done) {
+        var call_order = [];
+        async.series(getFunctionsObject(call_order), function(err, results){
+            expect(err).to.equal(null);
+            expect(results).to.eql({
+                one: 1,
+                two: 2,
+                three: [3,3]
+            });
+            expect(call_order).to.eql([1,2,3]);
+            done();
+        });
+    });
+
+    it('call in another context @nycinvalid @nodeonly', function(done) {
+        var vm = require('vm');
+        var sandbox = {
+            async: async,
+            done: done
+        };
+
+        var fn = "(" + (function () {
+            async.series([function (callback) {
+                callback();
+            }], function (err) {
+                if (err) {
+                    return done(err);
+                }
+                done();
+            });
+        }).toString() + "())";
+
+        vm.runInNewContext(fn, sandbox);
+    });
+
+    // Issue 10 on github: https://github.com/caolan/async/issues#issue/10
+    it('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.series(
+            [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();
+            }
+        );
+    });
+});