0.0.1

Author: danielstjules

README.md

@@ -1,2 +1,90 @@
 # mocha.parallel
-Run async mocha specs in parallel
+
+Run async mocha specs in parallel.
+
+```
+/**
+ * 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.
+ *
+ * @example
+ * parallel(['test1', 'test2'], [[1, 2], [2, 4]], function(x, expected) {
+ *   return Promise.delay(100).then(function() {
+ *     assert.equal(x + x, res);
+ *   });
+ * });
+ *
+ * @param {string[]} names Names to assign the specs
+ * @param {*[]}      args  Arguments to pass to the function
+ * @param {}               A function returning a promise
+ */
+```
+
+## Examples
+
+Rather than taking 3.5s, the specs below run in parallel, completing in just
+over 900ms.
+
+``` 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);
+  });
+});
+```
+
+```
+  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];
+  });
+
+  parallel(names, args, function(x, y, res) {
+    return Promise.delay(100).then(function() {
+      assert.equal(x * y, res)
+    });
+  });
+});
+```
+
+```
+  multiplications
+    ✓ 1 + 1 = 1 (101ms)
+    ✓ 2 + 2 = 4
+    ✓ 3 + 3 = 9
+    ✓ 4 + 4 = 16
+
+
+  4 passing (110ms)
+```

fixtures/delay.js

@@ -0,0 +1,9 @@
+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);
+  });
+});

fixtures/index.js

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

fixtures/multipleArgs.js

@@ -0,0 +1,22 @@
+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];
+  });
+
+  parallel(names, args, function(x, y, res) {
+    return Promise.delay(100).then(function() {
+      assert.equal(x * y, res)
+    });
+  });
+});

index.js

@@ -0,0 +1,30 @@
+/**
+ * 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.
+ *
+ * @example
+ * parallel(['test1', 'test2'], [[1, 2], [2, 4]], function(x, expected) {
+ *   return Promise.delay(100).then(function() {
+ *     assert.equal(x + x, res);
+ *   });
+ * });
+ *
+ * @param {string[]} names Names to assign the specs
+ * @param {*[]}      args  Arguments to pass to the function
+ * @param {}               A function returning a promise
+ */
+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;
+    });
+  });
+};

package.json

@@ -0,0 +1,30 @@
+{
+  "name": "mocha.parallel",
+  "version": "0.0.1",
+  "description": "Run async mocha specs in parallel",
+  "main": "index.js",
+  "scripts": {
+    "test": "mocha test.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/danielstjules/mocha.parallel.git"
+  },
+  "keywords": [
+    "mocha",
+    "parallel",
+    "async",
+    "test",
+    "spec"
+  ],
+  "author": "Daniel St. Jules <danielst.jules@gmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/danielstjules/mocha.parallel/issues"
+  },
+  "homepage": "https://github.com/danielstjules/mocha.parallel",
+  "devDependencies": {
+    "bluebird": "^2.9.34",
+    "mocha": "^2.2.5"
+  }
+}

test.js

@@ -0,0 +1,49 @@
+var exec     = require('child_process').exec;
+var assert   = require('assert');
+var fixtures = require('./fixtures');
+
+describe('parallel', function() {
+  this.timeout(2000);
+
+  it('runs specs in parallel', function(done) {
+    var cmd = './node_modules/.bin/mocha ' + fixtures.delay;
+    exec(cmd, function(err, stdout, stderr) {
+      if (err) return done(err);
+
+      assert(!stderr.length);
+      assert(stdout.indexOf('5 passing') !== -1);
+
+      ['500', '600', '700', '800', '900'].forEach(function(delay) {
+        var line = '✓ ' + delay;
+        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);
+      })
+
+      done();
+    });
+  });
+});