0.1.0

Author: danielstjules

README.md

@@ -14,87 +14,59 @@ npm install --save mocha.parallel
 
 ``` javascript
 /**
- * Builds the test suite dynamically to allow for parallel execution of the
- * individual specs. While each spec is ran in parallel, specs resolve in
- * series, leading to deterministic output. Expects an array of names,
- * arguments, and a function that returns a Promise.
+ * Generates a suite for parallel execution of individual specs. While each
+ * spec is ran in parallel, specs resolve in series, leading to deterministic
+ * output. Compatible with both callbacks and promises. Supports before/after
+ * hooks, but not afterEach/beforeEach hooks, nor nested suites.
  *
  * @example
- * parallel(['test1', 'test2'], [[1, 2], [2, 4]], function(x, expected) {
- *   return Promise.delay(100).then(function() {
- *     assert.equal(x + x, res);
+ * parallel('setTimeout', function() {
+ *   it('test1', function(done) {
+ *     setTimeout(done, 500);
+ *   });
+ *   it('test2', function(done) {
+ *     setTimeout(done, 500);
  *   });
  * });
  *
- * @param {string[]} names Names to assign the specs
- * @param {*[]}      args  Arguments to pass to the function
- * @param {}               A function returning a promise
+ * @param {string}   name
+ * @param {function} fn
  */
 ```
 
 ## Examples
 
-Rather than taking 3.5s, the specs below run in parallel, completing in just
-over 900ms.
+Rather than taking 1.5s, the specs below run in parallel, completing in just
+over 500ms.
 
 ``` javascript
 var parallel = require('../index.js');
 var Promise  = require('bluebird');
 
-describe('delays', function() {
-  var args = [500, 600, 700, 800, 900];
-  parallel(args, args, function(arg) {
-    return Promise.delay(arg);
+parallel('delays', function() {
+  it('test1', function(done) {
+    setTimeout(done, 500);
   });
-});
-```
-
-```
-  delays
-    ✓ 500 (497ms)
-    ✓ 600 (99ms)
-    ✓ 700 (98ms)
-    ✓ 800 (99ms)
-    ✓ 900 (99ms)
-
-
-  5 passing (902ms)
-```
 
-An example of passing multiple arguments
-
-``` javascript
-var parallel = require('../index.js');
-var Promise  = require('bluebird');
-var assert   = require('assert');
-
-describe('multiplications', function() {
-  var args = [
-    [1, 1, 1],
-    [2, 2, 4],
-    [3, 3, 9],
-    [4, 4, 16]
-  ];
-
-  var names = args.map(function(val) {
-    return val[0] + ' + ' + val[1] + ' = ' + val[2];
+  it('test2', function(done) {
+    setTimeout(done, 500);
   });
 
-  parallel(names, args, function(x, y, res) {
-    return Promise.delay(100).then(function() {
-      assert.equal(x * y, res)
-    });
+  it('test3', function() {
+    return Promise.delay(500);
   });
 });
 ```
 
 ```
-  multiplications
-    ✓ 1 + 1 = 1 (101ms)
-    ✓ 2 + 2 = 4
-    ✓ 3 + 3 = 9
-    ✓ 4 + 4 = 16
+  ✓ test1 (506ms)
+  ✓ test2
+  ✓ test3
 
-
-  4 passing (110ms)
+  3 passing (516ms)
 ```
+
+## Caveats
+
+Debugging parallel execution can be more difficult as exceptions may be thrown
+from any of the running specs.

fixtures/delay.js

@@ -1,9 +1,16 @@
 var parallel = require('../index.js');
 var Promise  = require('bluebird');
 
-describe('delays', function() {
-  var args = [500, 600, 700, 800, 900];
-  parallel(args, args, function(arg) {
-    return Promise.delay(arg);
+parallel('delays', function() {
+  it('test1', function(done) {
+    setTimeout(done, 500);
+  });
+
+  it('test2', function(done) {
+    setTimeout(done, 500);
+  });
+
+  it('test3', function() {
+    return Promise.delay(500);
   });
 });

fixtures/index.js

@@ -1,7 +1,7 @@
 var path = require('path');
 
 var absolutePaths = {};
-var fixtures = ['delay', 'multipleArgs'];
+var fixtures = ['delay'];
 
 fixtures.forEach(function(fixture) {
   absolutePaths[fixture] = path.resolve(__dirname, fixture + '.js');

fixtures/multipleArgs.js

@@ -1,30 +1,55 @@
+var Promise = require('bluebird');
+
 /**
- * Builds the test suite dynamically to allow for parallel execution of the
- * individual specs. While each spec is ran in parallel, specs resolve in
- * series, leading to deterministic output. Expects an array of names,
- * arguments, and a function that returns a Promise.
+ * Generates a suite for parallel execution of individual specs. While each
+ * spec is ran in parallel, specs resolve in series, leading to deterministic
+ * output. Compatible with both callbacks and promises. Supports before/after
+ * hooks, but not afterEach/beforeEach hooks, nor nested suites.
  *
  * @example
- * parallel(['test1', 'test2'], [[1, 2], [2, 4]], function(x, expected) {
- *   return Promise.delay(100).then(function() {
- *     assert.equal(x + x, res);
+ * parallel('setTimeout', function() {
+ *   it('test1', function(done) {
+ *     setTimeout(done, 500);
+ *   });
+ *   it('test2', function(done) {
+ *     setTimeout(done, 500);
  *   });
  * });
  *
- * @param {string[]} names Names to assign the specs
- * @param {*[]}      args  Arguments to pass to the function
- * @param {}               A function returning a promise
+ * @param {string}   name
+ * @param {function} fn
  */
-module.exports = function parallel(names, args, fn) {
-  args.map(function(arg) {
-    if (arg instanceof Array) {
-      return fn.apply(fn, arg);
-    } else {
-      return fn(arg);
-    }
-  }).forEach(function(promise, i) {
-    it(names[i], function() {
-      return promise;
+module.exports = function parallel(name, fn) {
+  var specs = [];
+  var hooks = {};
+  var original = it;
+
+  it = function it(name, fn) {
+    var promise = new Promise(function(resolve, reject) {
+      // Use timeout to prioritize hook execution
+      setTimeout(function() {
+        var res = fn(function(err) {
+          if (err) return reject(err);
+          resolve();
+        });
+
+        // Using promises rather than callbacks
+        if (res && res.then) resolve(res);
+      });
+    });
+
+    specs.push({
+      name: name,
+      promise: promise
+    });
+  };
+
+  describe(name, fn);
+  it = original;
+
+  specs.forEach(function(spec) {
+    it(spec.name, function() {
+      return spec.promise;
     });
   });
 };

index.js

@@ -1,6 +1,6 @@
 {
   "name": "mocha.parallel",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "description": "Run async mocha specs in parallel",
   "main": "index.js",
   "scripts": {
@@ -24,7 +24,9 @@
   },
   "homepage": "https://github.com/danielstjules/mocha.parallel",
   "devDependencies": {
-    "bluebird": "^2.9.34",
     "mocha": "^2.2.5"
+  },
+  "dependencies": {
+    "bluebird": "^2.9.34"
   }
 }

package.json

@@ -11,37 +11,19 @@ describe('parallel', function() {
       if (err) return done(err);
 
       assert(!stderr.length);
-      assert(stdout.indexOf('5 passing') !== -1);
+      assert(stdout.indexOf('3 passing') !== -1);
 
-      ['500', '600', '700', '800', '900'].forEach(function(delay) {
-        var line = '✓ ' + delay;
+      [
+        '✓ test1',
+        '✓ test2',
+        '✓ test3'
+      ].forEach(function(line) {
         assert(stdout.indexOf(line) !== -1);
       });
 
       // Specs should run in under 1s
-      var timeStr = stdout.split('5 passing (')[1].split(')')[0];
-      assert(parseInt(timeStr, 10) < 1000);
-
-      done();
-    });
-  });
-
-  it('can pass multiple arguments', function(done) {
-    var cmd = './node_modules/.bin/mocha ' + fixtures.multipleArgs;
-    exec(cmd, function(err, stdout, stderr) {
-      if (err) return done(err);
-
-      assert(!stderr.length);
-      assert(stdout.indexOf('4 passing') !== -1);
-
-      [
-        '✓ 1 + 1 = 1',
-        '✓ 2 + 2 = 4',
-        '✓ 3 + 3 = 9',
-        '✓ 4 + 4 = 16'
-      ].forEach(function(line) {
-        assert(stdout.indexOf(line) !== -1);
-      })
+      var timeStr = stdout.match(/passing \((\d+)ms\)/)[1];
+      assert(parseInt(timeStr, 10) < 600);
 
       done();
     });