resolves #2149, #1257: Make TAP reporter conform to TAP13

lib/reporters/tap.js

@@ -7,6 +7,7 @@
  */
 
 var Base = require('./base');
+var inherits = require('../utils').inherits;
 
 /**
  * Expose `TAP`.
@@ -24,46 +25,47 @@ exports = module.exports = TAP;
  * @api public
  * @param {Runner} runner
  */
-function TAP(runner) {
+function TAP(runner, options) {
   Base.call(this, runner);
 
+  var self = this;
   var n = 1;
-  var passes = 0;
-  var failures = 0;
+
+  var tapSpec = '12';
+  if (options && options.reporterOptions) {
+    if (options.reporterOptions.spec) {
+      tapSpec = options.reporterOptions.spec;
+    }
+  }
+
+  if (tapSpec === '13') {
+    this.producer = new TAP13Producer();
+  } else {
+    this.producer = new TAP12Producer();
+  }
 
   runner.on('start', function() {
-    var total = runner.grepTotal(runner.suite);
-    console.log('%d..%d', 1, total);
+    self.producer.writeStart(runner);
   });
 
   runner.on('test end', function() {
     ++n;
   });
 
   runner.on('pending', function(test) {
-    console.log('ok %d %s # SKIP -', n, title(test));
+    self.producer.writePending(n, test);
   });
 
   runner.on('pass', function(test) {
-    passes++;
-    console.log('ok %d %s', n, title(test));
+    self.producer.writePass(n, test);
   });
 
   runner.on('fail', function(test, err) {
-    failures++;
-    console.log('not ok %d %s', n, title(test));
-    if (err.message) {
-      console.log(err.message.replace(/^/gm, '  '));
-    }
-    if (err.stack) {
-      console.log(err.stack.replace(/^/gm, '  '));
-    }
+    self.producer.writeFail(n, test, err);
   });
 
   runner.once('end', function() {
-    console.log('# tests ' + (passes + failures));
-    console.log('# pass ' + passes);
-    console.log('# fail ' + failures);
+    self.producer.writeEnd(runner);
   });
 }
 
@@ -77,3 +79,95 @@ function TAP(runner) {
 function title(test) {
   return test.fullTitle().replace(/#/g, '');
 }
+
+/**
+ * Inherit from `Base.prototype`.
+ */
+inherits(TAP, Base);
+
+/**
+ * Initialize a new `TAPProducer`. Should only be used as a base class.
+ *
+ * @private
+ * @class
+ * @api private
+ */
+function TAPProducer() {}
+
+TAPProducer.prototype.writePending = function(n, test) {
+  console.log('ok %d %s # SKIP -', n, title(test));
+};
+
+TAPProducer.prototype.writePass = function(n, test) {
+  console.log('ok %d %s', n, title(test));
+};
+
+TAPProducer.prototype.writeEnd = function(runner) {
+  console.log('# tests ' + (runner.stats.passes + runner.stats.failures));
+  console.log('# pass ' + runner.stats.passes);
+  console.log('# fail ' + runner.stats.failures);
+};
+
+/**
+ * Initialize a new `TAP12Producer` which will produce output conforming to the TAP12 spec.
+ *
+ * @private
+ * @class
+ * @api private
+ */
+function TAP12Producer() {}
+
+TAP12Producer.prototype.writeStart = function(runner) {
+  var total = runner.grepTotal(runner.suite);
+  console.log('%d..%d', 1, total);
+};
+
+TAP12Producer.prototype.writeFail = function(n, test, err) {
+  console.log('not ok %d %s', n, title(test));
+  if (err.message) {
+    console.log(err.message.replace(/^/gm, '  '));
+  }
+  if (err.stack) {
+    console.log(err.stack.replace(/^/gm, '  '));
+  }
+};
+
+inherits(TAP12Producer, TAPProducer);
+
+/**
+ * Initialize a new `TAP13Producer` which will produce output conforming to the TAP13 spec.
+ *
+ * @private
+ * @class
+ * @api private
+ */
+function TAP13Producer() {}
+
+TAP13Producer.prototype.yamlIndent = function(level) {
+  return Array(level + 1).join('  ');
+};
+
+TAP13Producer.prototype.writeStart = function(runner) {
+  console.log('TAP version 13');
+  var total = runner.grepTotal(runner.suite);
+  console.log('%d..%d', 1, total);
+};
+
+TAP13Producer.prototype.writeFail = function(n, test, err) {
+  console.log('not ok %d %s', n, title(test));
+  var emitYamlBlock = err.message != null || err.stack != null;
+  if (emitYamlBlock) {
+    console.log(this.yamlIndent(1) + '---');
+    if (err.message) {
+      console.log(this.yamlIndent(2) + 'message: |-');
+      console.log(err.message.replace(/^/gm, this.yamlIndent(3)));
+    }
+    if (err.stack) {
+      console.log(this.yamlIndent(2) + 'stack: |-');
+      console.log(err.stack.replace(/^/gm, this.yamlIndent(3)));
+    }
+    console.log(this.yamlIndent(1) + '...');
+  }
+};
+
+inherits(TAP13Producer, TAPProducer);

test/integration/fixtures/reporters.fixture.js

@@ -0,0 +1,63 @@
+'use strict';
+
+/**
+ * This file generates a wide range of output to test reporter functionality.
+ */
+
+describe('Animals', function() {
+
+  it('should consume organic material', function(done) { done(); });
+  it('should breathe oxygen', function(done) {
+    // we're a jellyfish
+    var actualBreathe = 'nothing';
+    var expectedBreathe = 'oxygen';
+    expect(actualBreathe, 'to equal', expectedBreathe);
+    done();
+  });
+  it('should be able to move', function(done) { done(); });
+  it('should reproduce sexually', function(done) { done(); });
+  it('should grow from a hollow sphere of cells', function(done) { done(); });
+
+  describe('Vertebrates', function() {
+    describe('Mammals', function() {
+      it('should give birth to live young', function(done) {
+        var expectedMammal = {
+          consumesMaterial: 'organic',
+          breathe: 'oxygen',
+          reproduction: {
+            type: 'sexually',
+            spawnType: 'live',
+          }
+        };
+        var platypus = JSON.parse(JSON.stringify(expectedMammal));
+        platypus['reproduction']['spawnType'] = 'hard-shelled egg';
+
+        expect(platypus, 'to equal', expectedMammal);
+        done();
+      });
+
+      describe('Blue Whale', function() {
+        it('should be the largest of all mammals', function(done) { done(); });
+        it('should have a body in some shade of blue', function(done) {
+          var bodyColor = 'blueish_grey';
+          var shadesOfBlue = ['cyan', 'light_blue', 'blue', 'indigo'];
+          expect(bodyColor, 'to be one of', shadesOfBlue);
+
+          done();
+        });
+      });
+    });
+    describe('Birds', function() {
+      it('should have feathers', function(done) { done(); });
+      it('should lay hard-shelled eggs', function(done) { done(); });
+    });
+  });
+
+  describe('Tardigrades', function() {
+    it('should answer to "water bear"', function(done) { done(); });
+    it('should be able to survive global mass extinction events', function(done) {
+      throw new Error("How do we even test for this without causing one?")
+      done();
+    });
+  });
+});

test/integration/reporters.spec.js

@@ -99,4 +99,135 @@ describe('reporters', function() {
       });
     });
   });
+
+  describe('tap', function() {
+    var not = function(predicate) {
+      return function() {
+        return !predicate.apply(this, arguments);
+      };
+    };
+    var versionPredicate = function(line) {
+      return line.match(/^TAP version \d+$/) != null;
+    };
+    var planPredicate = function(line) {
+      return line.match(/^1\.\.\d+$/) != null;
+    };
+    var testLinePredicate = function(line) {
+      return line.match(/^not ok/) != null || line.match(/^ok/) != null;
+    };
+    var diagnosticPredicate = function(line) {
+      return line.match(/^#/) != null;
+    };
+    var bailOutPredicate = function(line) {
+      return line.match(/^Bail out!/) != null;
+    };
+    var anythingElsePredicate = function(line) {
+      return (
+        versionPredicate(line) === false &&
+        planPredicate(line) === false &&
+        testLinePredicate(line) === false &&
+        diagnosticPredicate(line) === false &&
+        bailOutPredicate(line) === false
+      );
+    };
+
+    describe('produces valid TAP v13 output', function() {
+      var runFixtureAndValidateOutput = function(fixture, expected) {
+        it('for ' + fixture, function(done) {
+          var args = ['--reporter=tap', '--reporter-options', 'spec=13'];
+          run(fixture, args, function(err, res) {
+            if (err) {
+              done(err);
+              return;
+            }
+
+            var expectedVersion = 13;
+            var expectedPlan = '1..' + expected.numTests;
+
+            var outputLines = res.output.split('\n');
+
+            // first line must be version line
+            expect(
+              outputLines[0],
+              'to equal',
+              'TAP version ' + expectedVersion
+            );
+
+            // plan must appear once
+            expect(outputLines, 'to contain', expectedPlan);
+            expect(
+              outputLines.filter(function(l) {
+                return l === expectedPlan;
+              }),
+              'to have length',
+              1
+            );
+            // plan cannot appear in middle of the output
+            var firstTestLine = outputLines.findIndex(testLinePredicate);
+            // there must be at least one test line
+            expect(firstTestLine, 'to be greater than', -1);
+            var lastTestLine =
+              outputLines.length -
+              1 -
+              outputLines
+                .slice()
+                .reverse()
+                .findIndex(testLinePredicate);
+            var planLine = outputLines.findIndex(function(line) {
+              return line === expectedPlan;
+            });
+            expect(
+              planLine < firstTestLine || planLine > lastTestLine,
+              'to equal',
+              true
+            );
+
+            done();
+          });
+        });
+      };
+
+      runFixtureAndValidateOutput('passing.fixture.js', {
+        numTests: 2
+      });
+      runFixtureAndValidateOutput('reporters.fixture.js', {
+        numTests: 12
+      });
+    });
+
+    it('places exceptions correctly in YAML blocks', function(done) {
+      var args = ['--reporter=tap', '--reporter-options', 'spec=13'];
+      run('reporters.fixture.js', args, function(err, res) {
+        if (err) {
+          done(err);
+          return;
+        }
+
+        var outputLines = res.output.split('\n');
+
+        for (var i = 0; i + 1 < outputLines.length; i++) {
+          if (
+            testLinePredicate(outputLines[i]) &&
+            testLinePredicate(outputLines[i + 1]) === false
+          ) {
+            var blockLinesStart = i + 1;
+            var blockLinesEnd =
+              i +
+              1 +
+              outputLines.slice(i + 1).findIndex(not(anythingElsePredicate));
+            var blockLines =
+              blockLinesEnd > blockLinesStart
+                ? outputLines.slice(blockLinesStart, blockLinesEnd)
+                : outputLines.slice(blockLinesStart);
+            i += blockLines.length;
+
+            expect(blockLines[0], 'to match', /^\s+---/);
+            expect(blockLines[blockLines.length - 1], 'to match', /^\s+\.\.\./);
+          }
+        }
+
+        done();
+      });
+    });
+  });
 });