feat(reporter): add output option to 'JSON' (#4607)

Co-authored-by: Juerg B <44573692+juergba@users.noreply.github.com>

Author: dorny

docs/index.md

@@ -1933,6 +1933,8 @@ Alias: `JSON`, `json`
 
 The JSON reporter outputs a single large JSON object when the tests have completed (failures or not).
 
+By default, it will output to the console. To write directly to a file, use `--reporter-option output=filename.json`.
+
 ![json reporter](images/reporter-json.png?withoutEnlargement&resize=920,9999){:class="screenshot" loading="lazy"}
 
 ### JSON Stream

example/config/.mocharc.js

@@ -33,7 +33,7 @@ module.exports = {
   parallel: false,
   recursive: false,
   reporter: 'spec',
-  'reporter-option': ['foo=bar', 'baz=quux'],
+  'reporter-option': ['foo=bar', 'baz=quux'], // array, not object
   require: '@babel/register',
   retries: 1,
   slow: '75',

example/config/.mocharc.yml

@@ -35,7 +35,7 @@ package: './package.json'
 parallel: false
 recursive: false
 reporter: 'spec'
-reporter-option:
+reporter-option: # array, not object
   - 'foo=bar'
   - 'baz=quux'
 require: '@babel/register'

lib/reporters/base.js

@@ -90,7 +90,7 @@ exports.colors = {
 
 exports.symbols = {
   ok: symbols.success,
-  err: symbols.err,
+  err: symbols.error,
   dot: '.',
   comma: ',',
   bang: '!'

lib/reporters/json.js

@@ -7,12 +7,16 @@
  */
 
 var Base = require('./base');
+var fs = require('fs');
+var path = require('path');
+const createUnsupportedError = require('../errors').createUnsupportedError;
+const utils = require('../utils');
 var constants = require('../runner').constants;
 var EVENT_TEST_PASS = constants.EVENT_TEST_PASS;
+var EVENT_TEST_PENDING = constants.EVENT_TEST_PENDING;
 var EVENT_TEST_FAIL = constants.EVENT_TEST_FAIL;
 var EVENT_TEST_END = constants.EVENT_TEST_END;
 var EVENT_RUN_END = constants.EVENT_RUN_END;
-var EVENT_TEST_PENDING = constants.EVENT_TEST_PENDING;
 
 /**
  * Expose `JSON`.
@@ -30,14 +34,22 @@ exports = module.exports = JSONReporter;
  * @param {Runner} runner - Instance triggers reporter actions.
  * @param {Object} [options] - runner options
  */
-function JSONReporter(runner, options) {
+function JSONReporter(runner, options = {}) {
   Base.call(this, runner, options);
 
   var self = this;
   var tests = [];
   var pending = [];
   var failures = [];
   var passes = [];
+  var output;
+
+  if (options.reporterOption && options.reporterOption.output) {
+    if (utils.isBrowser()) {
+      throw createUnsupportedError('file output not supported in browser');
+    }
+    output = options.reporterOption.output;
+  }
 
   runner.on(EVENT_TEST_END, function(test) {
     tests.push(test);
@@ -66,7 +78,20 @@ function JSONReporter(runner, options) {
 
     runner.testResults = obj;
 
-    process.stdout.write(JSON.stringify(obj, null, 2));
+    var json = JSON.stringify(obj, null, 2);
+    if (output) {
+      try {
+        fs.mkdirSync(path.dirname(output), {recursive: true});
+        fs.writeFileSync(output, json);
+      } catch (err) {
+        console.error(
+          `${Base.symbols.err} [mocha] writing output to "${output}" failed: ${err.message}\n`
+        );
+        process.stdout.write(json);
+      }
+    } else {
+      process.stdout.write(json);
+    }
   });
 }
 

test/reporters/json.spec.js

@@ -1,144 +1,233 @@
 'use strict';
 
+var fs = require('fs');
 var sinon = require('sinon');
+var JSONReporter = require('../../lib/reporters/json');
+var utils = require('../../lib/utils');
 var Mocha = require('../../');
 var Suite = Mocha.Suite;
 var Runner = Mocha.Runner;
 var Test = Mocha.Test;
 
 describe('JSON reporter', function() {
+  var mocha;
   var suite;
   var runner;
   var testTitle = 'json test 1';
   var testFile = 'someTest.spec.js';
   var noop = function() {};
 
   beforeEach(function() {
-    var mocha = new Mocha({
+    mocha = new Mocha({
       reporter: 'json'
     });
     suite = new Suite('JSON suite', 'root');
     runner = new Runner(suite);
-    var options = {};
-    /* eslint no-unused-vars: off */
-    var mochaReporter = new mocha._reporter(runner, options);
-  });
-
-  beforeEach(function() {
-    sinon.stub(process.stdout, 'write').callsFake(noop);
   });
 
   afterEach(function() {
     sinon.restore();
   });
 
-  it('should have 1 test failure', function(done) {
-    var error = {message: 'oh shit'};
+  describe('test results', function() {
+    beforeEach(function() {
+      var options = {};
+      /* eslint no-unused-vars: off */
+      var mochaReporter = new mocha._reporter(runner, options);
+    });
+
+    beforeEach(function() {
+      sinon.stub(process.stdout, 'write').callsFake(noop);
+    });
+
+    it('should have 1 test failure', function(done) {
+      var error = {message: 'oh shit'};
 
-    var test = new Test(testTitle, function(done) {
-      done(new Error(error.message));
+      var test = new Test(testTitle, function(done) {
+        done(new Error(error.message));
+      });
+
+      test.file = testFile;
+      suite.addTest(test);
+
+      runner.run(function(failureCount) {
+        sinon.restore();
+        expect(runner, 'to satisfy', {
+          testResults: {
+            failures: [
+              {
+                title: testTitle,
+                file: testFile,
+                err: {
+                  message: error.message
+                }
+              }
+            ]
+          }
+        });
+        expect(failureCount, 'to be', 1);
+        done();
+      });
     });
 
-    test.file = testFile;
-    suite.addTest(test);
-
-    runner.run(function(failureCount) {
-      sinon.restore();
-      expect(runner, 'to satisfy', {
-        testResults: {
-          failures: [
-            {
-              title: testTitle,
-              file: testFile,
-              err: {
-                message: error.message
+    it('should have 1 test pending', function(done) {
+      var test = new Test(testTitle);
+      test.file = testFile;
+      suite.addTest(test);
+
+      runner.run(function(failureCount) {
+        sinon.restore();
+        expect(runner, 'to satisfy', {
+          testResults: {
+            pending: [
+              {
+                title: testTitle,
+                file: testFile
               }
-            }
-          ]
-        }
+            ]
+          }
+        });
+        expect(failureCount, 'to be', 0);
+        done();
       });
-      expect(failureCount, 'to be', 1);
-      done();
     });
-  });
 
-  it('should have 1 test pending', function(done) {
-    var test = new Test(testTitle);
-    test.file = testFile;
-    suite.addTest(test);
-
-    runner.run(function(failureCount) {
-      sinon.restore();
-      expect(runner, 'to satisfy', {
-        testResults: {
-          pending: [
-            {
-              title: testTitle,
-              file: testFile
-            }
-          ]
-        }
+    it('should have 1 test pass', function(done) {
+      const test = new Test(testTitle, () => {});
+
+      test.file = testFile;
+      suite.addTest(test);
+
+      runner.run(function(failureCount) {
+        sinon.restore();
+        expect(runner, 'to satisfy', {
+          testResults: {
+            passes: [
+              {
+                title: testTitle,
+                file: testFile,
+                speed: /(slow|medium|fast)/
+              }
+            ]
+          }
+        });
+        expect(failureCount, 'to be', 0);
+        done();
       });
-      expect(failureCount, 'to be', 0);
-      done();
     });
-  });
 
-  it('should have 1 test pass', function(done) {
-    const test = new Test(testTitle, () => {});
-
-    test.file = testFile;
-    suite.addTest(test);
-
-    runner.run(function(failureCount) {
-      expect(runner, 'to satisfy', {
-        testResults: {
-          passes: [
-            {
-              title: testTitle,
-              file: testFile,
-              speed: /(slow|medium|fast)/
-            }
-          ]
-        }
+    it('should handle circular objects in errors', function(done) {
+      var testTitle = 'json test 1';
+      function CircleError() {
+        this.message = 'oh shit';
+        this.circular = this;
+      }
+      var error = new CircleError();
+
+      var test = new Test(testTitle, function(done) {
+        throw error;
+      });
+
+      test.file = testFile;
+      suite.addTest(test);
+
+      runner.run(function(failureCount) {
+        sinon.restore();
+        expect(runner, 'to satisfy', {
+          testResults: {
+            failures: [
+              {
+                title: testTitle,
+                file: testFile,
+                err: {
+                  message: error.message
+                }
+              }
+            ]
+          }
+        });
+        expect(failureCount, 'to be', 1);
+        done();
       });
-      expect(failureCount, 'to be', 0);
-      done();
     });
   });
 
-  it('should handle circular objects in errors', function(done) {
-    var testTitle = 'json test 1';
-    function CircleError() {
-      this.message = 'oh shit';
-      this.circular = this;
-    }
-    var error = new CircleError();
+  describe('when "reporterOption.output" is provided', function() {
+    var expectedDirName = 'reports';
+    var expectedFileName = 'reports/test-results.json';
+    var options = {
+      reporterOption: {
+        output: expectedFileName
+      }
+    };
+
+    beforeEach(function() {
+      /* eslint no-unused-vars: off */
+      var mochaReporter = new mocha._reporter(runner, options);
+    });
 
-    var test = new Test(testTitle, function(done) {
-      throw error;
+    beforeEach(function() {
+      // Add one test to suite to avoid assertions against empty test results
+      var test = new Test(testTitle, () => {});
+      test.file = testFile;
+      suite.addTest(test);
     });
 
-    test.file = testFile;
-    suite.addTest(test);
-
-    runner.run(function(failureCount) {
-      sinon.restore();
-      expect(runner, 'to satisfy', {
-        testResults: {
-          failures: [
-            {
-              title: testTitle,
-              file: testFile,
-              err: {
-                message: error.message
-              }
-            }
-          ]
-        }
+    it('should write test results to file', function(done) {
+      const fsMkdirSync = sinon.stub(fs, 'mkdirSync');
+      const fsWriteFileSync = sinon.stub(fs, 'writeFileSync');
+
+      fsWriteFileSync.callsFake(function(filename, content) {
+        const expectedJson = JSON.stringify(runner.testResults, null, 2);
+        expect(expectedFileName, 'to be', filename);
+        expect(content, 'to be', expectedJson);
       });
-      expect(failureCount, 'to be', 1);
-      done();
+
+      runner.run(function() {
+        expect(
+          fsMkdirSync.calledWith(expectedDirName, {recursive: true}),
+          'to be true'
+        );
+        expect(fsWriteFileSync.calledOnce, 'to be true');
+        done();
+      });
+    });
+
+    it('should warn and write test results to console', function(done) {
+      const fsMkdirSync = sinon.stub(fs, 'mkdirSync');
+      const fsWriteFileSync = sinon.stub(fs, 'writeFileSync');
+
+      fsWriteFileSync.throws('unable to write file');
+
+      const outLog = [];
+      const fake = chunk => outLog.push(chunk);
+      sinon.stub(process.stderr, 'write').callsFake(fake);
+      sinon.stub(process.stdout, 'write').callsFake(fake);
+
+      runner.run(function() {
+        sinon.restore();
+        expect(
+          fsMkdirSync.calledWith(expectedDirName, {recursive: true}),
+          'to be true'
+        );
+        expect(fsWriteFileSync.calledOnce, 'to be true');
+        expect(
+          outLog[0],
+          'to contain',
+          `[mocha] writing output to "${expectedFileName}" failed:`
+        );
+        expect(outLog[1], 'to match', /"fullTitle": "JSON suite json test 1"/);
+        done();
+      });
+    });
+
+    it('should throw "unsupported error" in browser', function() {
+      sinon.stub(utils, 'isBrowser').callsFake(() => true);
+      expect(
+        () => new JSONReporter(runner, options),
+        'to throw',
+        'file output not supported in browser'
+      );
     });
   });
 });