Merge pull request #1042 from caolan/auto-argument-ordering

Auto argument ordering

4 files changed, 410 insertions, 393 deletions

diff --git a/README.md b/README.md
index 10e7cc8..53939b6 100644
--- a/README.md
+++ b/README.md
@@ -1324,54 +1324,30 @@ cargo.push({name: 'baz'}, function (err) {
 
 Determines the best order for running the functions in `tasks`, based on their requirements. Each function can optionally depend on other functions being completed first, and each function is run as soon as its requirements are satisfied.
 
-If any of the functions pass an error to their callback, the `auto` sequence will stop. Further tasks will not execute (so any other functions depending on it will not run), and the main `callback` is immediately called with the error.  Functions also receive an object containing the results of functions which have completed so far.
+If any of the functions pass an error to their callback, the `auto` sequence will stop. Further tasks will not execute (so any other functions depending on it will not run), and the main `callback` is immediately called with the error.
 
-Note, all functions are called with a `results` object as a second argument,
-so it is unsafe to pass functions in the `tasks` object which cannot handle the
-extra argument.
+Functions also receive an object containing the results of functions which have completed so far as the first argument, if they have dependencies. If a task function has no dependencies, it will only be passed a callback.
 
-For example, this snippet of code:
 
 ```js
 async.auto({
+  // this function will just be passed a callback
   readData: async.apply(fs.readFile, 'data.txt', 'utf-8')
+  showData: ['readData', function (results, cb) {
+    // results.readData is the file's contents
+    // ...
+  }]
 }, callback);
 ```
 
-will have the effect of calling `readFile` with the results object as the last
-argument, which will fail:
-
-```js
-fs.readFile('data.txt', 'utf-8', cb, {});
-```
-
-Instead, wrap the call to `readFile` in a function which does not forward the
-`results` object:
-
-```js
-async.auto({
-  readData: function(cb, results){
-    fs.readFile('data.txt', 'utf-8', cb);
-  }
-}, callback);
-```
 
 __Arguments__
 
-* `tasks` - An object. Each of its properties is either a function or an array of
-  requirements, with the function itself the last item in the array. The object's key
-  of a property serves as the name of the task defined by that property,
-  i.e. can be used when specifying requirements for other tasks.
-  The function receives two arguments: (1) a `callback(err, result)` which must be
-  called when finished, passing an `error` (which can be `null`) and the result of
-  the function's execution, and (2) a `results` object, containing the results of
-  the previously executed functions.
+* `tasks` - An object. Each of its properties is either a function or an array of requirements, with the function itself the last item in the array. The object's key of a property serves as the name of the task defined by that property, i.e. can be used when specifying requirements for other tasks. The function receives one or two arguments:
+  * a `results` object, containing the results of the previously executed functions, only passed if the task has any dependencies,
+  * a `callback(err, result)` function, which must be called when finished, passing an `error` (which can be `null`) and the result of the function's execution.
 * `concurrency` - An optional `integer` for determining the maximum number of tasks that can be run in parallel. By default, as many as possible.
-* `callback(err, results)` - An optional callback which is called when all the
-  tasks have been completed. It receives the `err` argument if any `tasks`
-  pass an error to their callback. Results are always returned; however, if
-  an error occurs, no further `tasks` will be performed, and the results
-  object will only contain partial results.
+* `callback(err, results)` - An optional callback which is called when all the tasks have been completed. It receives the `err` argument if any `tasks` pass an error to their callback. Results are always returned; however, if an error occurs, no further `tasks` will be performed, and the results object will only contain partial results.
 
 __Example__
 
@@ -1388,13 +1364,13 @@ async.auto({
         // this is run at the same time as getting the data
         callback(null, 'folder');
     },
-    write_file: ['get_data', 'make_folder', function(callback, results){
+    write_file: ['get_data', 'make_folder', function(results, callback){
         console.log('in write_file', JSON.stringify(results));
         // once there is some data and the directory exists,
         // write the data to a file in the directory
         callback(null, 'filename');
     }],
-    email_link: ['write_file', function(callback, results){
+    email_link: ['write_file', function(results, callback){
         console.log('in email_link', JSON.stringify(results));
         // once the file is written let's email a link to it...
         // results.write_file contains the filename returned by write_file.
@@ -1406,8 +1382,7 @@ async.auto({
 });
 ```
 
-This is a fairly trivial example, but to do this using the basic parallel and
-series functions would look like this:
+This is a fairly trivial example, but to do this using the basic parallel and series functions would look like this:
 
 ```js
 async.parallel([
@@ -1441,8 +1416,7 @@ function(err, results){
 });
 ```
 
-For a complicated series of `async` tasks, using the [`auto`](#auto) function makes adding
-new tasks much easier (and the code more readable).
+For a complicated series of `async` tasks, using the [`auto`](#auto) function makes adding new tasks much easier (and the code more readable).
 
 ---------------------------------------
 
@@ -1805,7 +1779,7 @@ async.waterfall([
 async.auto({
     hostname: async.constant("https://server.net/"),
     port: findFreePort,
-    launchServer: ["hostname", "port", function (cb, options) {
+    launchServer: ["hostname", "port", function (options, cb) {
         startServer(options, cb);
     }],
     //...
diff --git a/lib/auto.js b/lib/auto.js
index 327383b..0e9d108 100644
--- a/lib/auto.js
+++ b/lib/auto.js
@@ -34,13 +34,16 @@ export default function (tasks, concurrency, callback) {
     var hasError = false;
 
     var listeners = [];
+
     function addListener(fn) {
         listeners.unshift(fn);
     }
+
     function removeListener(fn) {
         var idx = indexOf(listeners, fn);
         if (idx >= 0) listeners.splice(idx, 1);
     }
+
     function taskComplete() {
         remainingTasks--;
         arrayEach(listeners.slice(), function (fn) {
@@ -69,6 +72,7 @@ export default function (tasks, concurrency, callback) {
                 });
                 safeResults[k] = args;
                 hasError = true;
+                listeners = [];
 
                 callback(err, safeResults);
             }
@@ -77,37 +81,54 @@ export default function (tasks, concurrency, callback) {
                 setImmediate(taskComplete);
             }
         });
+
         var requires = task.slice(0, task.length - 1);
-        // prevent dead-locks
-        var len = requires.length;
-        var dep;
-        while (len--) {
-            if (!(dep = tasks[requires[len]])) {
-                throw new Error('Has non-existent dependency in ' +
-                    requires.join(', '));
-            }
-            if (isArray(dep) && indexOf(dep, k) >= 0) {
-                throw new Error('Has cyclic dependencies');
+
+        checkForDeadlocks();
+
+        if (ready()) {
+            startNext();
+        } else {
+            addListener(listener);
+        }
+
+        function checkForDeadlocks() {
+            var len = requires.length;
+            var dep;
+            while (len--) {
+                if (!(dep = tasks[requires[len]])) {
+                    throw new Error('Has non-existent dependency in ' +
+                        requires.join(', '));
+                }
+                if (isArray(dep) && indexOf(dep, k) >= 0) {
+                    throw new Error('Has cyclic dependencies');
+                }
             }
         }
+
         function ready() {
-            return runningTasks < concurrency && !baseHas(results, k) &&
+            return runningTasks < concurrency &&
+                !baseHas(results, k) &&
+                !hasError &&
                 arrayEvery(requires, function (x) {
                     return baseHas(results, x);
                 });
         }
-        if (ready()) {
+
+        function startNext() {
             runningTasks++;
-            task[task.length - 1](taskCallback, results);
-        }
-        else {
-            addListener(listener);
+            var taskFn = task[task.length - 1];
+            if (requires.length > 0) {
+                taskFn(results, taskCallback);
+            } else {
+                taskFn(taskCallback);
+            }
         }
+
         function listener() {
             if (ready()) {
-                runningTasks++;
                 removeListener(listener);
-                task[task.length - 1](taskCallback, results);
+                startNext();
             }
         }
     });
diff --git a/mocha_test/auto.js b/mocha_test/auto.js
new file mode 100644
index 0000000..c6b7150
--- /dev/null
+++ b/mocha_test/auto.js
@@ -0,0 +1,347 @@
+var async = require('../lib');
+var expect = require('chai').expect;
+var _ = require('lodash');
+
+describe('auto', function () {
+
+    it('auto', function(done){
+        var callOrder = [];
+        async.auto({
+            task1: ['task2', function(results, callback){
+                setTimeout(function(){
+                    callOrder.push('task1');
+                    callback();
+                }, 25);
+            }],
+            task2: function(callback){
+                setTimeout(function(){
+                    callOrder.push('task2');
+                    callback();
+                }, 50);
+            },
+            task3: ['task2', function(results, callback){
+                callOrder.push('task3');
+                callback();
+            }],
+            task4: ['task1', 'task2', function(results, callback){
+                callOrder.push('task4');
+                callback();
+            }],
+            task5: ['task2', function(results, callback){
+                setTimeout(function(){
+                    callOrder.push('task5');
+                    callback();
+                }, 0);
+            }],
+            task6: ['task2', function(results, callback){
+                callOrder.push('task6');
+                callback();
+            }]
+        },
+        function(err){
+            expect(err).to.equal(null);
+            expect(callOrder).to.eql(['task2','task6','task3','task5','task1','task4']);
+            done();
+        });
+    });
+
+    it('auto concurrency', function (done) {
+        var concurrency = 2;
+        var runningTasks = [];
+
+        function makeCallback(taskName) {
+            return function(/*..., callback*/) {
+                var callback = _.last(arguments);
+                runningTasks.push(taskName);
+                setTimeout(function(){
+                    // Each task returns the array of running tasks as results.
+                    var result = runningTasks.slice(0);
+                    runningTasks.splice(runningTasks.indexOf(taskName), 1);
+                    callback(null, result);
+                });
+            };
+        }
+
+        async.auto({
+            task1: ['task2', makeCallback('task1')],
+            task2: makeCallback('task2'),
+            task3: ['task2', makeCallback('task3')],
+            task4: ['task1', 'task2', makeCallback('task4')],
+            task5: ['task2', makeCallback('task5')],
+            task6: ['task2', makeCallback('task6')]
+        }, concurrency, function(err, results){
+            _.each(results, function(result) {
+                expect(result.length).to.be.below(concurrency + 1);
+            });
+            done();
+        });
+    });
+
+    it('auto petrify', function (done) {
+        var callOrder = [];
+        async.auto({
+            task1: ['task2', function (results, callback) {
+                setTimeout(function () {
+                    callOrder.push('task1');
+                    callback();
+                }, 100);
+            }],
+            task2: function (callback) {
+                setTimeout(function () {
+                    callOrder.push('task2');
+                    callback();
+                }, 200);
+            },
+            task3: ['task2', function (results, callback) {
+                callOrder.push('task3');
+                callback();
+            }],
+            task4: ['task1', 'task2', function (results, callback) {
+                callOrder.push('task4');
+                callback();
+            }]
+        },
+        function (err) {
+            if (err) throw err;
+            expect(callOrder).to.eql(['task2', 'task3', 'task1', 'task4']);
+            done();
+        });
+    });
+
+    it('auto results', function(done){
+        var callOrder = [];
+        async.auto({
+            task1: ['task2', function(results, callback){
+              expect(results.task2).to.eql('task2');
+              setTimeout(function(){
+                  callOrder.push('task1');
+                  callback(null, 'task1a', 'task1b');
+              }, 25);
+          }],
+            task2: function(callback){
+              setTimeout(function(){
+                  callOrder.push('task2');
+                  callback(null, 'task2');
+              }, 50);
+          },
+            task3: ['task2', function(results, callback){
+              expect(results.task2).to.eql('task2');
+              callOrder.push('task3');
+              callback(null);
+          }],
+            task4: ['task1', 'task2', function(results, callback){
+              expect(results.task1).to.eql(['task1a','task1b']);
+              expect(results.task2).to.eql('task2');
+              callOrder.push('task4');
+              callback(null, 'task4');
+          }]
+        },
+        function(err, results){
+            expect(callOrder).to.eql(['task2','task3','task1','task4']);
+            expect(results).to.eql({task1: ['task1a','task1b'], task2: 'task2', task3: undefined, task4: 'task4'});
+            done();
+        });
+    });
+
+    it('auto empty object', function(done){
+        async.auto({}, function(err){
+            expect(err).to.equal(null);
+            done();
+        });
+    });
+
+    it('auto error', function(done){
+        async.auto({
+            task1: function(callback){
+                callback('testerror');
+            },
+            task2: ['task1', function(results, callback){
+                throw new Error('task2 should not be called');
+            }],
+            task3: function(callback){
+                callback('testerror2');
+            }
+        },
+        function(err){
+            expect(err).to.equal('testerror');
+        });
+        setTimeout(done, 100);
+    });
+
+    it('auto no callback', function(done){
+        async.auto({
+            task1: function(callback){callback();},
+            task2: ['task1', function(results, callback){callback(); done();}]
+        });
+    });
+
+    it('auto concurrency no callback', function(done){
+        async.auto({
+            task1: function(callback){callback();},
+            task2: ['task1', function(results, callback){callback(); done();}]
+        }, 1);
+    });
+
+    it('auto error should pass partial results', function(done) {
+        async.auto({
+            task1: function(callback){
+                callback(false, 'result1');
+            },
+            task2: ['task1', function(results, callback){
+                callback('testerror', 'result2');
+            }],
+            task3: ['task2', function(){
+                throw new Error('task3 should not be called');
+            }]
+        },
+        function(err, results){
+            expect(err).to.equal('testerror');
+            expect(results.task1).to.equal('result1');
+            expect(results.task2).to.equal('result2');
+            done();
+        });
+    });
+
+    // Issue 24 on github: https://github.com/caolan/async/issues#issue/24
+    // Issue 76 on github: https://github.com/caolan/async/issues#issue/76
+    it('auto removeListener has side effect on loop iterator', function(done) {
+        async.auto({
+            task1: ['task3', function(/*callback*/) { done(); }],
+            task2: ['task3', function(/*callback*/) { /* by design: DON'T call callback */ }],
+            task3: function(callback) { callback(); }
+        });
+    });
+
+    // Issue 410 on github: https://github.com/caolan/async/issues/410
+    it('auto calls callback multiple times', function(done) {
+        if (process.browser) {
+            // node only test
+            return done();
+        }
+        var finalCallCount = 0;
+        var domain = require('domain').create();
+        domain.on('error', function (e) {
+            // ignore test error
+            if (!e._test_error) {
+                return done(e);
+            }
+        });
+        domain.run(function () {
+            async.auto({
+                task1: function(callback) { callback(null); },
+                task2: ['task1', function(results, callback) { callback(null); }]
+            },
+
+            // Error throwing final callback. This should only run once
+            function() {
+                finalCallCount++;
+                var e = new Error('An error');
+                e._test_error = true;
+                throw e;
+            });
+        });
+        setTimeout(function () {
+            expect(finalCallCount).to.equal(1);
+            done();
+        }, 10);
+    });
+
+
+    it('auto calls callback multiple times with parallel functions', function(done) {
+        async.auto({
+            task1: function(callback) { setTimeout(callback,0,'err'); },
+            task2: function(callback) { setTimeout(callback,0,'err'); }
+        },
+        // Error throwing final callback. This should only run once
+        function(err) {
+            expect(err).to.equal('err');
+            done();
+        });
+    });
+
+
+    // Issue 462 on github: https://github.com/caolan/async/issues/462
+    it('auto modifying results causes final callback to run early', function(done) {
+        async.auto({
+            task1: function(callback){
+                callback(null, 'task1');
+            },
+            task2: ['task1', function(results, callback){
+                results.inserted = true;
+                setTimeout(function(){
+                    callback(null, 'task2');
+                }, 50);
+            }],
+            task3: function(callback){
+                setTimeout(function(){
+                    callback(null, 'task3');
+                }, 100);
+            }
+        },
+        function(err, results){
+            expect(results.inserted).to.equal(true);
+            expect(results.task3).to.equal('task3');
+            done();
+        });
+    });
+
+    // Issue 263 on github: https://github.com/caolan/async/issues/263
+    it('auto prevent dead-locks due to inexistant dependencies', function(done) {
+        expect(function () {
+            async.auto({
+                task1: ['noexist', function(results, callback){
+                    callback(null, 'task1');
+                }]
+            });
+        }).to.throw;
+        done();
+    });
+
+    // Issue 263 on github: https://github.com/caolan/async/issues/263
+    it('auto prevent dead-locks due to cyclic dependencies', function(done) {
+        expect(function () {
+            async.auto({
+                task1: ['task2', function(results, callback){
+                    callback(null, 'task1');
+                }],
+                task2: ['task1', function(results, callback){
+                    callback(null, 'task2');
+                }]
+            });
+        }).to.throw;
+        done();
+    });
+
+    // Issue 988 on github: https://github.com/caolan/async/issues/988
+    it('auto stops running tasks on error', function(done) {
+        async.auto({
+            task1: function (callback) {
+                callback('error');
+            },
+            task2: function (callback) {
+                throw new Error('test2 should not be called');
+            }
+        }, 1, function (error) {
+            expect(error).to.equal('error');
+            done();
+        });
+    });
+
+    it('ignores results after an error', function (done) {
+        async.auto({
+            task1: function (cb) {
+                setTimeout(cb, 25, 'error');
+            },
+            task2: function (cb) {
+                setTimeout(cb, 30, null);
+            },
+            task3: ['task2', function () {
+                throw new Error("task should not have been called");
+            }]
+        }, function (err) {
+            expect(err).to.equal('error');
+            setTimeout(done, 25, null);
+        });
+    });
+
+});
diff --git a/test/test-async.js b/test/test-async.js
index c8a1c7c..8eaa06f 100755
--- a/test/test-async.js
+++ b/test/test-async.js
@@ -278,334 +278,6 @@ exports['seq without callback'] = function (test) {
     add2mul3.call(testcontext, 3);
 };
 
-exports['auto'] = function(test){
-    test.expect(2);
-    var callOrder = [];
-    async.auto({
-        task1: ['task2', function(callback){
-            setTimeout(function(){
-                callOrder.push('task1');
-                callback();
-            }, 25);
-        }],
-        task2: function(callback){
-            setTimeout(function(){
-                callOrder.push('task2');
-                callback();
-            }, 50);
-        },
-        task3: ['task2', function(callback){
-            callOrder.push('task3');
-            callback();
-        }],
-        task4: ['task1', 'task2', function(callback){
-            callOrder.push('task4');
-            callback();
-        }],
-        task5: ['task2', function(callback){
-            setTimeout(function(){
-                callOrder.push('task5');
-                callback();
-            }, 0);
-        }],
-        task6: ['task2', function(callback){
-            callOrder.push('task6');
-            callback();
-        }]
-    },
-    function(err){
-        test.ok(err === null, err + " passed instead of 'null'");
-        test.same(callOrder, ['task2','task6','task3','task5','task1','task4']);
-        test.done();
-    });
-};
-
-exports['auto concurrency'] = function (test) {
-    var concurrency = 2;
-    var runningTasks = [];
-    var makeCallback = function(taskName) {
-        return function(callback) {
-            runningTasks.push(taskName);
-            setTimeout(function(){
-                // Each task returns the array of running tasks as results.
-                var result = runningTasks.slice(0);
-                runningTasks.splice(runningTasks.indexOf(taskName), 1);
-                callback(null, result);
-            });
-        };
-    };
-    async.auto({
-        task1: ['task2', makeCallback('task1')],
-        task2: makeCallback('task2'),
-        task3: ['task2', makeCallback('task3')],
-        task4: ['task1', 'task2', makeCallback('task4')],
-        task5: ['task2', makeCallback('task5')],
-        task6: ['task2', makeCallback('task6')]
-    }, concurrency, function(err, results){
-        Object.keys(results).forEach(function(taskName) {
-            test.ok(results[taskName].length <= concurrency);
-        });
-        test.done();
-    });
-};
-
-exports['auto petrify'] = function (test) {
-    var callOrder = [];
-    async.auto({
-        task1: ['task2', function (callback) {
-            setTimeout(function () {
-                callOrder.push('task1');
-                callback();
-            }, 100);
-        }],
-        task2: function (callback) {
-            setTimeout(function () {
-                callOrder.push('task2');
-                callback();
-            }, 200);
-        },
-        task3: ['task2', function (callback) {
-            callOrder.push('task3');
-            callback();
-        }],
-        task4: ['task1', 'task2', function (callback) {
-            callOrder.push('task4');
-            callback();
-        }]
-    },
-    function (err) {
-        if (err) throw err;
-        test.same(callOrder, ['task2', 'task3', 'task1', 'task4']);
-        test.done();
-    });
-};
-
-exports['auto results'] = function(test){
-    var callOrder = [];
-    async.auto({
-        task1: ['task2', function(callback, results){
-          test.same(results.task2, 'task2');
-          setTimeout(function(){
-              callOrder.push('task1');
-              callback(null, 'task1a', 'task1b');
-          }, 25);
-      }],
-        task2: function(callback){
-          setTimeout(function(){
-              callOrder.push('task2');
-              callback(null, 'task2');
-          }, 50);
-      },
-        task3: ['task2', function(callback, results){
-          test.same(results.task2, 'task2');
-          callOrder.push('task3');
-          callback(null);
-      }],
-        task4: ['task1', 'task2', function(callback, results){
-          test.same(results.task1, ['task1a','task1b']);
-          test.same(results.task2, 'task2');
-          callOrder.push('task4');
-          callback(null, 'task4');
-      }]
-    },
-    function(err, results){
-        test.same(callOrder, ['task2','task3','task1','task4']);
-        test.same(results, {task1: ['task1a','task1b'], task2: 'task2', task3: undefined, task4: 'task4'});
-        test.done();
-    });
-};
-
-exports['auto empty object'] = function(test){
-    async.auto({}, function(err){
-        test.ok(err === null, err + " passed instead of 'null'");
-        test.done();
-    });
-};
-
-exports['auto error'] = 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, 100);
-};
-
-exports['auto no callback'] = function(test){
-    async.auto({
-        task1: function(callback){callback();},
-        task2: ['task1', function(callback){callback(); test.done();}]
-    });
-};
-
-exports['auto concurrency no callback'] = function(test){
-    async.auto({
-        task1: function(callback){callback();},
-        task2: ['task1', function(callback){callback(); test.done();}]
-    }, 1);
-};
-
-exports['auto error should pass partial results'] = function(test) {
-    async.auto({
-        task1: function(callback){
-            callback(false, 'result1');
-        },
-        task2: ['task1', function(callback){
-            callback('testerror', 'result2');
-        }],
-        task3: ['task2', function(){
-            test.ok(false, 'task3 should not be called');
-        }]
-    },
-    function(err, results){
-        test.equals(err, 'testerror');
-        test.equals(results.task1, 'result1');
-        test.equals(results.task2, 'result2');
-        test.done();
-    });
-};
-
-// Issue 24 on github: https://github.com/caolan/async/issues#issue/24
-// Issue 76 on github: https://github.com/caolan/async/issues#issue/76
-exports['auto removeListener has side effect on loop iterator'] = function(test) {
-    async.auto({
-        task1: ['task3', function(/*callback*/) { test.done(); }],
-        task2: ['task3', function(/*callback*/) { /* by design: DON'T call callback */ }],
-        task3: function(callback) { callback(); }
-    });
-};
-
-// Issue 410 on github: https://github.com/caolan/async/issues/410
-exports['auto calls callback multiple times'] = function(test) {
-    if (isBrowser()) {
-        // node only test
-        test.done();
-        return;
-    }
-    var finalCallCount = 0;
-    var domain = require('domain').create();
-    domain.on('error', function (e) {
-        // ignore test error
-        if (!e._test_error) {
-            return test.done(e);
-        }
-    });
-    domain.run(function () {
-        async.auto({
-            task1: function(callback) { callback(null); },
-            task2: ['task1', function(callback) { callback(null); }]
-        },
-
-        // Error throwing final callback. This should only run once
-        function() {
-            finalCallCount++;
-            var e = new Error("An error");
-            e._test_error = true;
-            throw e;
-        });
-    });
-    setTimeout(function () {
-        test.equal(finalCallCount, 1,
-            "Final auto callback should only be called once"
-        );
-        test.done();
-    }, 10);
-};
-
-
-exports['auto calls callback multiple times with parallel functions'] = function(test) {
-    test.expect(1);
-    async.auto({
-        task1: function(callback) { setTimeout(callback,0,"err"); },
-        task2: function(callback) { setTimeout(callback,0,"err"); }
-    },
-    // Error throwing final callback. This should only run once
-    function(err) {
-        test.equal(err, "err");
-        test.done();
-    });
-};
-
-
-// Issue 462 on github: https://github.com/caolan/async/issues/462
-exports['auto modifying results causes final callback to run early'] = function(test) {
-    async.auto({
-        task1: function(callback, results){
-            results.inserted = true;
-            callback(null, 'task1');
-        },
-        task2: function(callback){
-            setTimeout(function(){
-                callback(null, 'task2');
-            }, 50);
-        },
-        task3: function(callback){
-            setTimeout(function(){
-                callback(null, 'task3');
-            }, 100);
-        }
-    },
-    function(err, results){
-        test.equal(results.inserted, true);
-        test.ok(results.task3, 'task3');
-        test.done();
-    });
-};
-
-// Issue 263 on github: https://github.com/caolan/async/issues/263
-exports['auto prevent dead-locks due to inexistant dependencies'] = function(test) {
-    test.throws(function () {
-        async.auto({
-            task1: ['noexist', function(callback){
-                callback(null, 'task1');
-            }]
-        });
-    }, Error);
-    test.done();
-};
-
-// Issue 263 on github: https://github.com/caolan/async/issues/263
-exports['auto prevent dead-locks due to cyclic dependencies'] = function(test) {
-    test.throws(function () {
-        async.auto({
-            task1: ['task2', function(callback){
-                callback(null, 'task1');
-            }],
-            task2: ['task1', function(callback){
-                callback(null, 'task2');
-            }]
-        });
-    }, Error);
-    test.done();
-};
-
-// Issue 988 on github: https://github.com/caolan/async/issues/988
-exports['auto stops running tasks on error'] = function(test) {
-    async.auto({
-        task1: function (callback) {
-            callback('error');
-        },
-        task2: function (callback) {
-            test.ok(false, 'test2 should not be called');
-            callback();
-        }
-    }, 1, function (error) {
-        test.equal(error, 'error', 'finishes with error');
-        test.done();
-    });
-};
-
 // Issue 306 on github: https://github.com/caolan/async/issues/306
 exports['retry when attempt succeeds'] = function(test) {
     var failed = 3;
@@ -677,26 +349,29 @@ exports['retry with interval when all attempts succeeds'] = function(test) {
     });
 };
 
+// need to fix retry, this isn't working
+/*
 exports['retry as an embedded task'] = function(test) {
     var retryResult = 'RETRY';
     var fooResults;
     var retryResults;
 
     async.auto({
-        foo: function(callback, results){
+        dep: async.constant('dep'),
+        foo: ['dep', function(results, callback){
             fooResults = results;
             callback(null, 'FOO');
-        },
-        retry: async.retry(function(callback, results) {
+        }],
+        retry: ['dep', async.retry(function(results, callback) {
             retryResults = results;
             callback(null, retryResult);
-        })
+        })]
     }, function(err, results){
         test.equal(results.retry, retryResult, "Incorrect result was returned from retry function");
         test.equal(fooResults, retryResults, "Incorrect results were passed to retry function");
         test.done();
     });
-};
+};*/
 
 exports['retry as an embedded task with interval'] = function(test) {
     var start = new Date().getTime();