adding iterations array support, modifying JUNIT_REPORT_PATH feature to insert taskNum before .xml, adding docs

Author: grawk

.gitignore

@@ -26,4 +26,8 @@ node_modules
 
 
 # Webstorm IDE metadata directory
-.idea
+.idea
+
+# test report files
+test/report/*.xml*
+test/report/*.log

README.md

@@ -80,6 +80,53 @@ gulp.task('test-custom-mocha', function() {
 - flags: mocha flags (default: none)
 - liveOutput: print output direct to console
 - errorSummary: show error summary (default: true)
+- iterations: Array, see below
+
+### Iterations
+
+If you want to run parallel processes based on criteria other than files, use an iterations array.
+
+The iterations array should contain whatever "Options" (see above) you wish to override for a given iteration.
+
+The easiest to envision example would be:
+* your test suite names are annotated as: @groupA@, @groupB@, @groupC@, and so on
+* these groupings are spread across files, where a file may contain one or more suite of a given group
+* you want to spawn a mocha process for each grouping
+
+To achieve, you would specify an iterations array where each entry uses a different mocha grep. E.g. the task
+example "test-mocha-opts-parallel" in this project's `gulpfile.js`.
+
+```javascript
+gulp.task('test-mocha-opts-parallel', function () {
+    function setEnv(envs) {
+        var env = process.env;
+        env = _.clone(env);
+        env = _.merge(env, envs, {JUNIT_REPORT_PATH: path.resolve(__dirname, 'test/report/report.xml')});
+        return env;
+    }
+    var opts = {
+        concurrency: 3,
+        flags: {R: 'mocha-jenkins-reporter'},
+        iterations: [{
+            env: setEnv({NODE_ENV: 'groupa'}),
+            flags: {grep: "@groupA@"}
+        }, {
+            env: setEnv({NODE_ENV: 'groupb'}),
+            flags: {grep: "@groupB@"}
+        }, {
+            env: setEnv({NODE_ENV: 'groupc'}),
+            flags: {grep: "@groupC@"}
+        }]
+    };
+    var mocha = mochaStream(opts);
+    gulp.src('test/group/*-specs.js')
+        .pipe(mocha);
+});
+```
+
+Another use case might be if you are driving browser/device automation, and you want to run the same set of files
+in parallel on several browser/device combinations.
+
 ## Todo
 
 - concatenate mocha status at the end

gulpfile.js

@@ -2,14 +2,14 @@
 
 var gulp = require('gulp'),
   mochaStream = require('./lib').mochaStream,
-  mochaOptsStream = require('./lib').mochaOptsStream,
   SpawnMocha = require('./lib').SpawnMocha,
   _ = require('lodash'),
   through = require('through'),
   Q = require('q'),
   runSequence = Q.denodeify(require('run-sequence')),
   assert = require('assert'),
   File = require('vinyl'),
+  path = require('path'),
   from = require('from');
 
 function customMocha(opts) {
@@ -86,12 +86,6 @@ gulp.task('test-live-output', function () {
     .pipe(mocha);
 });
 
-gulp.task('test-mocha-opts-parallel', function () {
-  var mocha = mochaOptsStream({liveOutput: true, concurrency: 1});
-  gulp.src('test/*-specs.js')
-    .pipe(mocha);
-});
-
 gulp.task('test-live-output-with-file', function () {
   var mocha = mochaStream({
     liveOutput: true,
@@ -139,6 +133,32 @@ gulp.task('test-live-output-with-prepend', function () {
     .pipe(mocha);
 });
 
+gulp.task('test-mocha-opts-parallel', function () {
+  function setEnv(envs) {
+    var env = process.env;
+    env = _.clone(env);
+    env = _.merge(env, envs, {JUNIT_REPORT_PATH: path.resolve(__dirname, 'test/report/report.xml')});
+    return env;
+  }
+
+  var opts = {
+    concurrency: 3,
+    flags: {R: 'mocha-jenkins-reporter'},
+    iterations: [{
+      env: setEnv({NODE_ENV: 'groupa'}),
+      flags: {grep: "@groupA@"}
+    }, {
+      env: setEnv({NODE_ENV: 'groupb'}),
+      flags: {grep: "@groupB@"}
+    }, {
+      env: setEnv({NODE_ENV: 'groupc'}),
+      flags: {grep: "@groupC@"}
+    }]
+  };
+  var mocha = mochaStream(opts);
+  gulp.src('test/group/*-specs.js')
+    .pipe(mocha);
+});
 
 gulp.task('test', function () {
   return runSequence(
@@ -147,6 +167,7 @@ gulp.task('test', function () {
     'test-live-output',
     'test-live-output-with-prepend',
     'test-live-output-with-file',
-    'test-with-file'
+    'test-with-file',
+    'test-mocha-opts-parallel'
   );
 });

lib/index.js

@@ -2,22 +2,22 @@
 
 // Module Requirements
 var _ = require('lodash'),
-    proc = require('child_process'),
-    join = require('path').join,
-    async = require('async'),
-    util = require('util'),
-    EventEmitter = require('events').EventEmitter,
-    streamBuffers = require("stream-buffers"),
-    through = require('through'),
-    split = require('split'),
-    fs = require('fs');
+  proc = require('child_process'),
+  join = require('path').join,
+  async = require('async'),
+  util = require('util'),
+  EventEmitter = require('events').EventEmitter,
+  streamBuffers = require("stream-buffers"),
+  through = require('through'),
+  split = require('split'),
+  fs = require('fs');
 
 require('colors');
 
 function newStreamBuffer() {
   var stream = new streamBuffers.WritableStreamBuffer({
-      initialSize: (25 * 1024),
-      incrementAmount: (10 * 1024)
+    initialSize: (25 * 1024),
+    incrementAmount: (10 * 1024)
   });
   return stream;
 }
@@ -30,15 +30,20 @@ var SpawnMocha = function (opts) {
   });
   var queue = async.queue(function (task, done) {
     // Setup
+    var _opts = opts;
+    //merge iterationOpts, if any
+    if (task.iterationOpts) {
+      _opts = _.merge(opts, task.iterationOpts);
+    }
     var bin = _.isFunction(opts.bin) ? opts.bin() : opts.bin ||
-      join(__dirname, '..', 'node_modules', '.bin', 'mocha');
-    var env = _.isFunction(opts.env) ? opts.env() : opts.env || process.env;
+    join(__dirname, '..', 'node_modules', '.bin', 'mocha');
+    var env = _.isFunction(_opts.env) ? _opts.env() : _opts.env || process.env;
     env = _.clone(env);
 
     // Generate arguments
     var args = [];
-    _(opts.flags).each(function (val, key) {
-      if(_.isFunction(val)) val = val();
+    _(_opts.flags).each(function (val, key) {
+      if (_.isFunction(val)) val = val();
       args.push((key.length > 1 ? '--' : '-') + key);
       if (_.isString(val) || _.isNumber(val)) {
         args.push(val);
@@ -47,27 +52,26 @@ var SpawnMocha = function (opts) {
 
     var stdout = newStreamBuffer();
     var stderr = newStreamBuffer();
-    var fsStream = opts.fileOutput ?
-       fs.createWriteStream(opts.fileOutput, { flags: 'a', encoding: 'utf8' }) : null;
+    var fsStream = _opts.fileOutput ?
+      fs.createWriteStream(_opts.fileOutput, {flags: 'a', encoding: 'utf8'}) : null;
 
     // Split xunit test report in several files if required
-    if(env.JUNIT_REPORT_PATH) {
-      env.JUNIT_REPORT_PATH = env.JUNIT_REPORT_PATH + '.' + task.taskNum;
+    if (env.JUNIT_REPORT_PATH) {
+      env.JUNIT_REPORT_PATH = env.JUNIT_REPORT_PATH.replace(/xml$/, task.taskNum + '.xml');
     }
-    console.log('haoooooo', task.files);
     // Execute Mocha
     var child = proc.spawn(bin, args.concat(task.files), {env: env});
 
     if (opts.liveOutput) {
       child.stdout.pipe(split())
         .on('data', function (line) {
-          console.log((opts.liveOutputPrepend || '') + line);
+          console.log((_opts.liveOutputPrepend || '') + line);
         });
       child.stderr.pipe(split())
         .on('data', function (line) {
-          console.error((opts.liveOutputPrepend || '') + line);
+          console.error((_opts.liveOutputPrepend || '') + line);
         });
-      if(fsStream) {
+      if (fsStream) {
         child.stdout.pipe(fsStream);
         child.stderr.pipe(fsStream);
       }
@@ -77,25 +81,27 @@ var SpawnMocha = function (opts) {
     }
 
     // When done...
-    child.on('close', function(errCode) {
-      if(stdout.size()) {
+    child.on('close', function (errCode) {
+      if (stdout.size()) {
         var contentOut = stdout.getContentsAsString("utf8");
         console.log(contentOut);
-        if(fsStream) {
+        if (fsStream) {
           fsStream.write(contentOut + '\n', 'utf8');
         }
       }
-      if(stderr.size()) {
+      if (stderr.size()) {
         var contentErr = stdout.getContentsAsString("utf8");
         console.error(contentErr);
-        if(fsStream) {
+        if (fsStream) {
           fsStream.write(contentErr + '\n', 'utf8');
         }
       }
-      if(fsStream) { fsStream.close(); }
+      if (fsStream) {
+        fsStream.close();
+      }
 
       var err = null;
-      if(errCode && opts.errorSummary) {
+      if (errCode && opts.errorSummary) {
         err = new Error('Error for files: ' + task.files.join(', '));
         err.files = task.files;
         err.stderr = stderr.size() ? stderr.getContentsAsString("utf8") : '';
@@ -105,19 +111,19 @@ var SpawnMocha = function (opts) {
     });
   }, opts.concurrency || 1);
 
-  queue.drain = function() {
+  queue.drain = function () {
     _this.emit('end');
   };
 
   var taskNum = 0;
-  this.add = function(files) {
-    taskNum ++;
+  this.add = function (files, iterationOpts) {
+    taskNum++;
     if (!_.isArray(files)) {
       files = [files];
     }
-    var task = {taskNum: taskNum, files: files};
-    queue.push(task, function(err) {
-      if(err){
+    var task = {taskNum: taskNum, files: files, iterationOpts: iterationOpts || {}};
+    queue.push(task, function (err) {
+      if (err) {
         _this.emit('error', err, files);
       }
     });
@@ -128,46 +134,25 @@ util.inherits(SpawnMocha, EventEmitter);
 
 var mochaStream = function mocha(opts) {
   opts = opts || {};
-  var spawnMocha = new SpawnMocha(opts);
-  var stream = through(function write(file) {
-    spawnMocha.add(file.path);
-  }, function() {});
-  var errors = [];
-  spawnMocha.on('error', function(err) {
-    console.error(err.toString());
-    errors.push(err);
-  }).on('end', function() {
-    if(errors.length > 0) {
-      console.error('ERROR SUMMARY: ');
-      _(errors).each(function(err) {
-        console.error(err);
-        console.error(err.stack);
-      }).value();
-      stream.emit('error', "Some tests failed.");
-    }
-    stream.emit('end');
-  });
-  return stream;
-};
-
-var mochaOptsStream = function mocha(opts) {
   var files = [];
-  opts = opts || {};
   var spawnMocha = new SpawnMocha(opts);
   var stream = through(function write(file) {
-    //spawnMocha.add(file.path);
-    files.push(file.path);
-  }, function() {
-    spawnMocha.add(files);
+    (opts.iterations) ? files.push(file.path) : spawnMocha.add(file.path);
+  }, function () {
+    if (opts.iterations) {
+      opts.iterations.forEach(function (iteration) {
+        spawnMocha.add(files, iteration);
+      });
+    }
   });
   var errors = [];
-  spawnMocha.on('error', function(err) {
+  spawnMocha.on('error', function (err) {
     console.error(err.toString());
     errors.push(err);
-  }).on('end', function() {
-    if(errors.length > 0) {
+  }).on('end', function () {
+    if (errors.length > 0) {
       console.error('ERROR SUMMARY: ');
-      _(errors).each(function(err) {
+      _(errors).each(function (err) {
         console.error(err);
         console.error(err.stack);
       }).value();
@@ -177,8 +162,8 @@ var mochaOptsStream = function mocha(opts) {
   });
   return stream;
 };
+
 module.exports = {
   SpawnMocha: SpawnMocha,
-  mochaStream: mochaStream,
-  mochaOptsStream: mochaOptsStream
+  mochaStream: mochaStream
 };

package.json

@@ -39,6 +39,7 @@
     "fixture-stdout": "^0.2.1",
     "from": "^0.1.3",
     "gulp": "^3.8.8",
+    "mocha-jenkins-reporter": "^0.1.8",
     "q": "^1.1.2",
     "run-sequence": "^1.0.1",
     "vinyl": "^0.4.3"