Remove util.callInSeries

The hand-rolled `util.callInSeries` method was added without realising
that the `async` library was already in use in the library.

This change removes our custom method, and simply uses the appropriate
`async` functions instead.

We also add a utility `errorHandler` function that will call `done` in a
test if an error occurs, but not otherwise, which is useful when using
callback methods in a fire-and-forget fashion.

Author: Alec Gibson

test/client/doc.js

@@ -1,6 +1,6 @@
 var Backend = require('../../lib/backend');
 var expect = require('chai').expect;
-var util = require('../util');
+var async = require('async');
 
 describe('Doc', function() {
   beforeEach(function() {
@@ -319,26 +319,24 @@ describe('Doc', function() {
     });
 
     it('rolls the doc back to a usable state', function(done) {
-      util.callInSeries([
+      async.series([
         function(next) {
           doc.submitOp(invalidOp, function(error) {
-            expect(error).instanceOf(Error);
+            expect(error).to.be.instanceOf(Error);
             next();
           });
         },
-        function(next) {
-          doc.whenNothingPending(next);
-        },
+        doc.whenNothingPending.bind(doc),
         function(next) {
           expect(doc.data).to.eql({name: 'Scooby'});
-          doc.submitOp(validOp, next);
+          next();
         },
+        doc.submitOp.bind(doc, validOp),
         function(next) {
           expect(doc.data).to.eql({name: 'Scooby', snacks: true});
           next();
-        },
-        done
-      ]);
+        }
+      ], done);
     });
 
     it('rescues an irreversible op collision', function(done) {
@@ -366,29 +364,18 @@ describe('Doc', function() {
         }
       });
 
-      util.callInSeries([
-        function(next) {
-          doc1.create({colours: ['white']}, next);
-        },
-        function(next) {
-          doc1.whenNothingPending(next);
-        },
-        function(next) {
-          doc2.fetch(next);
-        },
-        function(next) {
-          doc2.whenNothingPending(next);
-        },
+      async.series([
+        doc1.create.bind(doc1, {colours: ['white']}),
+        doc1.whenNothingPending.bind(doc1),
+        doc2.fetch.bind(doc2),
+        doc2.whenNothingPending.bind(doc2),
         // Both documents start off at the same v1 state, with colours as a list
         function(next) {
           expect(doc1.data).to.eql({colours: ['white']});
           expect(doc2.data).to.eql({colours: ['white']});
           next();
         },
-        // doc1 successfully submits an op which changes our list into a string in v2
-        function(next) {
-          doc1.submitOp({p: ['colours'], oi: 'white,black'}, next);
-        },
+        doc1.submitOp.bind(doc1, {p: ['colours'], oi: 'white,black'}),
         // This next step is a little fiddly. We abuse the middleware to pause the op submission and
         // ensure that we get this repeatable sequence of events:
         // 1. doc2 is still on v1, where 'colours' is a list (but it's a string in v2)
@@ -416,9 +403,8 @@ describe('Doc', function() {
           expect(doc1.data).to.eql({colours: 'white,black'});
           expect(doc2.data).to.eql(doc1.data);
           doc2.submitOp({p: ['colours'], oi: 'white,black,red'}, next);
-        },
-        done
-      ]);
+        }
+      ], done);
     });
   });
 });

test/client/snapshot-timestamp-request.js

@@ -1,10 +1,10 @@
 var Backend = require('../../lib/backend');
 var expect = require('chai').expect;
-var util = require('../util');
 var lolex = require('lolex');
 var MemoryDb = require('../../lib/db/memory');
 var MemoryMilestoneDb = require('../../lib/milestone-db/memory');
 var sinon = require('sinon');
+var async = require('async');
 
 describe('SnapshotTimestampRequest', function() {
   var backend;
@@ -70,112 +70,95 @@ describe('SnapshotTimestampRequest', function() {
 
     beforeEach(function(done) {
       var doc = backend.connect().get('books', 'time-machine');
-      util.callInSeries([
-        function(next) {
-          doc.create({title: 'The Time Machine'}, next);
-        },
+      async.series([
+        doc.create.bind(doc, {title: 'The Time Machine'}),
         function(next) {
           clock.tick(ONE_DAY);
           doc.submitOp({p: ['author'], oi: 'HG Wells'}, next);
         },
         function(next) {
           clock.tick(ONE_DAY);
           doc.submitOp({p: ['author'], od: 'HG Wells', oi: 'H.G. Wells'}, next);
-        },
-        done
-      ]);
+        }
+      ], done);
     });
 
     it('fetches the version at exactly day 1', function(done) {
-      util.callInSeries([
-        function(next) {
-          backend.connect().fetchSnapshotByTimestamp('books', 'time-machine', day1, next);
-        },
+      var connection = backend.connect();
+      async.waterfall([
+        connection.fetchSnapshotByTimestamp.bind(connection, 'books', 'time-machine', day1),
         function(snapshot, next) {
           expect(snapshot).to.eql(v1);
           next();
-        },
-        done
-      ]);
+        }
+      ], done);
     });
 
     it('fetches the version at exactly day 2', function(done) {
-      util.callInSeries([
-        function(next) {
-          backend.connect().fetchSnapshotByTimestamp('books', 'time-machine', day2, next);
-        },
+      var connection = backend.connect();
+      async.waterfall([
+        connection.fetchSnapshotByTimestamp.bind(connection, 'books', 'time-machine', day2),
         function(snapshot, next) {
           expect(snapshot).to.eql(v2);
           next();
-        },
-        done
-      ]);
+        }
+      ], done);
     });
 
     it('fetches the version at exactly day 3', function(done) {
-      util.callInSeries([
-        function(next) {
-          backend.connect().fetchSnapshotByTimestamp('books', 'time-machine', day3, next);
-        },
+      var connection = backend.connect();
+      async.waterfall([
+        connection.fetchSnapshotByTimestamp.bind(connection, 'books', 'time-machine', day3),
         function(snapshot, next) {
           expect(snapshot).to.eql(v3);
           next();
-        },
-        done
-      ]);
+        }
+      ], done);
     });
 
     it('fetches the day 2 version when asking for a time halfway between days 2 and 3', function(done) {
       var halfwayBetweenDays2and3 = (day2 + day3) * 0.5;
-      util.callInSeries([
-        function(next) {
-          backend.connect().fetchSnapshotByTimestamp('books', 'time-machine', halfwayBetweenDays2and3, next);
-        },
+      var connection = backend.connect();
+      async.waterfall([
+        connection.fetchSnapshotByTimestamp.bind(connection, 'books', 'time-machine', halfwayBetweenDays2and3),
         function(snapshot, next) {
           expect(snapshot).to.eql(v2);
           next();
-        },
-        done
-      ]);
+        }
+      ], done);
     });
 
     it('fetches the day 3 version when asking for a time after day 3', function(done) {
-      util.callInSeries([
-        function(next) {
-          backend.connect().fetchSnapshotByTimestamp('books', 'time-machine', day4, next);
-        },
+      var connection = backend.connect();
+      async.waterfall([
+        connection.fetchSnapshotByTimestamp.bind(connection, 'books', 'time-machine', day4),
         function(snapshot, next) {
           expect(snapshot).to.eql(v3);
           next();
-        },
-        done
-      ]);
+        }
+      ], done);
     });
 
     it('fetches the most recent version when not specifying a timestamp', function(done) {
-      util.callInSeries([
-        function(next) {
-          backend.connect().fetchSnapshotByTimestamp('books', 'time-machine', next);
-        },
+      var connection = backend.connect();
+      async.waterfall([
+        connection.fetchSnapshotByTimestamp.bind(connection, 'books', 'time-machine'),
         function(snapshot, next) {
           expect(snapshot).to.eql(v3);
           next();
-        },
-        done
-      ]);
+        }
+      ], done);
     });
 
     it('fetches an empty snapshot if the timestamp is before the document creation', function(done) {
-      util.callInSeries([
-        function(next) {
-          backend.connect().fetchSnapshotByTimestamp('books', 'time-machine', day0, next);
-        },
+      var connection = backend.connect();
+      async.waterfall([
+        connection.fetchSnapshotByTimestamp.bind(connection, 'books', 'time-machine', day0),
         function(snapshot, next) {
           expect(snapshot).to.eql(v0);
           next();
-        },
-        done
-      ]);
+        }
+      ], done);
     });
 
     it('throws if the timestamp is undefined', function() {
@@ -407,10 +390,8 @@ describe('SnapshotTimestampRequest', function() {
 
         var doc = backendWithMilestones.connect().get('books', 'mocking-bird');
 
-        util.callInSeries([
-          function(next) {
-            doc.create({title: 'To Kill a Mocking Bird'}, next);
-          },
+        async.series([
+          doc.create.bind(doc, {title: 'To Kill a Mocking Bird'}),
           function(next) {
             clock.tick(ONE_DAY);
             doc.submitOp({p: ['author'], oi: 'Harper Lea'}, next);
@@ -426,9 +407,8 @@ describe('SnapshotTimestampRequest', function() {
           function(next) {
             clock.tick(ONE_DAY);
             doc.submitOp({p: ['year'], od: 1959, oi: 1960}, next);
-          },
-          done
-        ]);
+          }
+        ], done);
       });
 
       it('fetches a snapshot between two milestones using the milestones', function(done) {

test/client/snapshot-version-request.js

@@ -3,7 +3,7 @@ var expect = require('chai').expect;
 var MemoryDb = require('../../lib/db/memory');
 var MemoryMilestoneDb = require('../../lib/milestone-db/memory');
 var sinon = require('sinon');
-var util = require('../util');
+var async = require('async');
 
 describe('SnapshotVersionRequest', function() {
   var backend;
@@ -419,16 +419,10 @@ describe('SnapshotVersionRequest', function() {
     it('fetches a snapshot using the milestone', function(done) {
       var doc = backendWithMilestones.connect().get('books', 'mocking-bird');
 
-      util.callInSeries([
-        function(next) {
-          doc.create({title: 'To Kill a Mocking Bird'}, next);
-        },
-        function(next) {
-          doc.submitOp({p: ['author'], oi: 'Harper Lea'}, next);
-        },
-        function(next) {
-          doc.submitOp({p: ['author'], od: 'Harper Lea', oi: 'Harper Lee'}, next);
-        },
+      async.waterfall([
+        doc.create.bind(doc, {title: 'To Kill a Mocking Bird'}),
+        doc.submitOp.bind(doc, {p: ['author'], oi: 'Harper Lea'}),
+        doc.submitOp.bind(doc, {p: ['author'], od: 'Harper Lea', oi: 'Harper Lee'}),
         function(next) {
           sinon.spy(milestoneDb, 'getMilestoneSnapshot');
           sinon.spy(db, 'getOps');
@@ -440,9 +434,8 @@ describe('SnapshotVersionRequest', function() {
           expect(snapshot.v).to.equal(3);
           expect(snapshot.data).to.eql({title: 'To Kill a Mocking Bird', author: 'Harper Lee'});
           next();
-        },
-        done
-      ]);
+        }
+      ], done);
     });
   });
 });