\n'
];
expect(stdout, 'to equal', expectedArray);
});
-
- it('should escape title and body where necessary', function() {
- var unescapedTitle = '' + expectedTitle + '
';
- var unescapedBody = '' + expectedBody + '
';
- test.title = unescapedTitle;
- test.body = unescapedBody;
-
- var expectedEscapedTitle =
- '<div>' + expectedTitle + '</div>';
- var expectedEscapedBody =
- '<div>' + expectedBody + '</div>';
- runner = createMockRunner('pass', EVENT_TEST_PASS, null, null, test);
+ it('should escape title where necessary', function() {
+ var suite = {
+ root: false,
+ title: unescapedTitle
+ };
+ expectedTitle = '<div>' + expectedTitle + '</div>';
+ runner = createMockRunner('suite', 'suite', null, null, suite);
var stdout = runReporter(this, runner, options);
var expectedArray = [
- ' - ' + expectedEscapedTitle + '
\n',
- ' ' + expectedEscapedBody + '
' + expectedTitle + '
\n',
+ ' \n'
];
expect(stdout, 'to equal', expectedArray);
});
});
-
- describe("on 'fail' event", function() {
- var expectedTitle = 'some tite';
- var expectedBody = 'some body';
- var expectedError = 'some error';
- var test = {
- title: expectedTitle,
- body: expectedBody,
- slow: function() {
- return '';
- }
+ describe('if suite root does exist', function() {
+ var suite = {
+ root: true
};
-
- it('should log html with indents, expected title, body, and error', function() {
- runner = createMockRunner(
- 'fail two args',
- EVENT_TEST_FAIL,
- null,
- null,
- test,
- expectedError
- );
+ it('should not log any html', function() {
+ runner = createMockRunner('suite', 'suite', null, null, suite);
var stdout = runReporter(this, runner, options);
- var expectedArray = [
- ' - ' + expectedTitle + '
\n',
- ' ' +
- expectedBody +
- '
- ' + expectedError + '
\n'
- ];
- expect(stdout, 'to equal', expectedArray);
+ expect(stdout, 'to be empty');
});
+ });
+ });
- it('should escape title, body, and error where necessary', function() {
- var unescapedTitle = '' + expectedTitle + '
';
- var unescapedBody = '' + expectedBody + '
';
- var unescapedError = '' + expectedError + '
';
- test.title = unescapedTitle;
- test.body = unescapedBody;
-
- var expectedEscapedTitle =
- '<div>' + expectedTitle + '</div>';
- var expectedEscapedBody =
- '<div>' + expectedBody + '</div>';
- var expectedEscapedError =
- '<div>' + expectedError + '</div>';
- runner = createMockRunner(
- 'fail two args',
- EVENT_TEST_FAIL,
- null,
- null,
- test,
- unescapedError
- );
+ describe('on suite end', function() {
+ describe('if suite root does not exist', function() {
+ var suite = {
+ root: false
+ };
+ it('should log expected html with indents', function() {
+ runner = createMockRunner('suite end', 'suite end', null, null, suite);
var stdout = runReporter(this, runner, options);
- var expectedArray = [
- ' - ' + expectedEscapedTitle + '
\n',
- ' ' +
- expectedEscapedBody +
- '
- ' + expectedEscapedError + '
\n'
- ];
+ var expectedArray = ['
\n', '\n'];
expect(stdout, 'to equal', expectedArray);
});
});
+ describe('if suite root does exist', function() {
+ var suite = {
+ root: true
+ };
+ it('should not log any html', function() {
+ runner = createMockRunner('suite end', 'suite end', null, null, suite);
+ var stdout = runReporter(this, runner, options);
+ expect(stdout, 'to be empty');
+ });
+ });
+ });
+
+ describe('on pass', function() {
+ var expectedTitle = 'some tite';
+ var expectedBody = 'some body';
+ var test = {
+ title: expectedTitle,
+ body: expectedBody,
+ slow: function() {
+ return '';
+ }
+ };
+ it('should log html with indents and expected title and body', function() {
+ runner = createMockRunner('pass', 'pass', null, null, test);
+ var stdout = runReporter(this, runner, options);
+ var expectedArray = [
+ ' - ' + expectedTitle + '
\n',
+ ' ' + expectedBody + '
' + expectedTitle + '
';
+ var unescapedBody = '' + expectedBody + '
';
+ test.title = unescapedTitle;
+ test.body = unescapedBody;
+
+ var expectedEscapedTitle =
+ '<div>' + expectedTitle + '</div>';
+ var expectedEscapedBody =
+ '<div>' + expectedBody + '</div>';
+ runner = createMockRunner('pass', 'pass', null, null, test);
+ var stdout = runReporter(this, runner, options);
+ var expectedArray = [
+ ' - ' + expectedEscapedTitle + '
\n',
+ ' ' + expectedEscapedBody + '
- ' + expectedTitle + '
\n',
+ ' ' +
+ expectedBody +
+ '
- ' + expectedError + '
\n'
+ ];
+ expect(stdout, 'to equal', expectedArray);
+ });
+ it('should escape title, body and error where necessary', function() {
+ var unescapedTitle = '' + expectedTitle + '
';
+ var unescapedBody = '' + expectedBody + '
';
+ var unescapedError = '' + expectedError + '
';
+ test.title = unescapedTitle;
+ test.body = unescapedBody;
+
+ var expectedEscapedTitle =
+ '<div>' + expectedTitle + '</div>';
+ var expectedEscapedBody =
+ '<div>' + expectedBody + '</div>';
+ var expectedEscapedError =
+ '<div>' + expectedError + '</div>';
+ runner = createMockRunner(
+ 'fail two args',
+ 'fail',
+ null,
+ null,
+ test,
+ unescapedError
+ );
+ var stdout = runReporter(this, runner, options);
+ var expectedArray = [
+ ' - ' + expectedEscapedTitle + '
\n',
+ ' ' +
+ expectedEscapedBody +
+ '
- ' + expectedEscapedError + '
\n'
+ ];
+ expect(stdout, 'to equal', expectedArray);
+ });
});
});
diff --git a/test/reporters/dot.spec.js b/test/reporters/dot.spec.js
index 4a23c7951e..472ec63d01 100644
--- a/test/reporters/dot.spec.js
+++ b/test/reporters/dot.spec.js
@@ -1,238 +1,155 @@
'use strict';
-var sinon = require('sinon');
-var events = require('../../').Runner.constants;
-var helpers = require('./helpers');
var reporters = require('../../').reporters;
-
-var Base = reporters.Base;
var Dot = reporters.Dot;
-var createMockRunner = helpers.createMockRunner;
-var makeRunReporter = helpers.createRunReporterFunction;
+var Base = reporters.Base;
-var EVENT_RUN_BEGIN = events.EVENT_RUN_BEGIN;
-var EVENT_RUN_END = events.EVENT_RUN_END;
-var EVENT_TEST_FAIL = events.EVENT_TEST_FAIL;
-var EVENT_TEST_PASS = events.EVENT_TEST_PASS;
-var EVENT_TEST_PENDING = events.EVENT_TEST_PENDING;
+var createMockRunner = require('./helpers.js').createMockRunner;
+var makeRunReporter = require('./helpers.js').createRunReporterFunction;
describe('Dot reporter', function() {
- var sandbox;
- var windowWidthStub;
+ var runner;
+ var useColors;
+ var windowWidth;
+ var color;
+ var options = {};
var runReporter = makeRunReporter(Dot);
- var noop = function() {};
beforeEach(function() {
- sandbox = sinon.createSandbox();
- windowWidthStub = sandbox.stub(Base.window, 'width').value(0);
- sandbox.stub(Base, 'useColors').value(false);
- sandbox.stub(Base, 'color').callsFake(function(type, str) {
+ useColors = Base.useColors;
+ windowWidth = Base.window.width;
+ color = Base.color;
+ Base.useColors = false;
+ Base.window.width = 0;
+ Base.color = function(type, str) {
return type.replace(/ /g, '-') + '_' + str;
- });
+ };
});
afterEach(function() {
- sandbox.restore();
+ Base.useColors = useColors;
+ Base.window.width = windowWidth;
+ Base.color = color;
+ runner = undefined;
});
- describe('event handlers', function() {
- describe("on 'start' event", function() {
- it('should write a newline', function() {
- var runner = createMockRunner('start', EVENT_RUN_BEGIN);
- var options = {};
- var stdout = runReporter({epilogue: noop}, runner, options);
- sandbox.restore();
-
- var expectedArray = ['\n'];
+ describe('on start', function() {
+ it('should write a newline', function() {
+ runner = createMockRunner('start', 'start');
+ var stdout = runReporter({epilogue: function() {}}, runner, options);
+ var expectedArray = ['\n'];
+ expect(stdout, 'to equal', expectedArray);
+ });
+ });
+ describe('on pending', function() {
+ describe('if window width is greater than 1', function() {
+ beforeEach(function() {
+ Base.window.width = 2;
+ });
+ it('should write a newline followed by a comma', function() {
+ runner = createMockRunner('pending', 'pending');
+ var stdout = runReporter({epilogue: function() {}}, runner, options);
+ var expectedArray = ['\n ', 'pending_' + Base.symbols.comma];
expect(stdout, 'to equal', expectedArray);
});
});
-
- describe("on 'pending' event", function() {
- describe('when window width is greater than 1', function() {
- beforeEach(function() {
- windowWidthStub.value(2);
- });
-
- it('should write a newline followed by a comma', function() {
- var runner = createMockRunner('pending', EVENT_TEST_PENDING);
- var options = {};
- var stdout = runReporter({epilogue: noop}, runner, options);
- sandbox.restore();
-
- var expectedArray = ['\n ', 'pending_' + Base.symbols.comma];
- expect(stdout, 'to equal', expectedArray);
- });
- });
-
- describe('when window width is less than or equal to 1', function() {
- it('should write a comma', function() {
- var runner = createMockRunner('pending', EVENT_TEST_PENDING);
- var options = {};
- var stdout = runReporter({epilogue: noop}, runner, options);
- sandbox.restore();
-
- var expectedArray = ['pending_' + Base.symbols.comma];
- expect(stdout, 'to equal', expectedArray);
- });
+ describe('if window width is equal to or less than 1', function() {
+ it('should write a comma', function() {
+ runner = createMockRunner('pending', 'pending');
+ var stdout = runReporter({epilogue: function() {}}, runner, options);
+ var expectedArray = ['pending_' + Base.symbols.comma];
+ expect(stdout, 'to equal', expectedArray);
});
});
-
- describe("on 'pass' event", function() {
- var test = {
- duration: 1,
- slow: function() {
- return 2;
- }
- };
-
- describe('when window width is greater than 1', function() {
- beforeEach(function() {
- windowWidthStub.value(2);
- });
-
- describe('when test speed is fast', function() {
- it('should write a newline followed by a dot', function() {
- var runner = createMockRunner(
- 'pass',
- EVENT_TEST_PASS,
- null,
- null,
- test
- );
- var options = {};
- var stdout = runReporter({epilogue: noop}, runner, options);
- sandbox.restore();
-
- expect(test.speed, 'to equal', 'fast');
- var expectedArray = ['\n ', 'fast_' + Base.symbols.dot];
- expect(stdout, 'to equal', expectedArray);
- });
- });
+ });
+ describe('on pass', function() {
+ var test = {
+ duration: 1,
+ slow: function() {
+ return 2;
+ }
+ };
+ describe('if window width is greater than 1', function() {
+ beforeEach(function() {
+ Base.window.width = 2;
});
-
- describe('when window width is less than or equal to 1', function() {
- describe('when test speed is fast', function() {
- it('should write a grey dot', function() {
- var runner = createMockRunner(
- 'pass',
- EVENT_TEST_PASS,
- null,
- null,
- test
- );
- var options = {};
- var stdout = runReporter({epilogue: noop}, runner, options);
- sandbox.restore();
-
- expect(test.speed, 'to equal', 'fast');
- var expectedArray = ['fast_' + Base.symbols.dot];
- expect(stdout, 'to equal', expectedArray);
- });
- });
-
- describe('when test speed is medium', function() {
- it('should write a yellow dot', function() {
- test.duration = 2;
- var runner = createMockRunner(
- 'pass',
- EVENT_TEST_PASS,
- null,
- null,
- test
- );
- var options = {};
- var stdout = runReporter({epilogue: noop}, runner, options);
- sandbox.restore();
-
- expect(test.speed, 'to equal', 'medium');
- var expectedArray = ['medium_' + Base.symbols.dot];
- expect(stdout, 'to equal', expectedArray);
- });
- });
-
- describe('when test speed is slow', function() {
- it('should write a bright yellow dot', function() {
- test.duration = 3;
- var runner = createMockRunner(
- 'pass',
- EVENT_TEST_PASS,
- null,
- null,
- test
- );
- var options = {};
- var stdout = runReporter({epilogue: noop}, runner, options);
- sandbox.restore();
-
- expect(test.speed, 'to equal', 'slow');
- var expectedArray = ['bright-yellow_' + Base.symbols.dot];
- expect(stdout, 'to equal', expectedArray);
- });
+ describe('if test speed is fast', function() {
+ it('should write a newline followed by a dot', function() {
+ runner = createMockRunner('pass', 'pass', null, null, test);
+ var stdout = runReporter({epilogue: function() {}}, runner, options);
+ expect(test.speed, 'to equal', 'fast');
+ var expectedArray = ['\n ', 'fast_' + Base.symbols.dot];
+ expect(stdout, 'to equal', expectedArray);
});
});
});
-
- describe("on 'fail' event", function() {
- var test = {
- test: {
- err: 'some error'
- }
- };
-
- describe('when window width is greater than 1', function() {
- beforeEach(function() {
- windowWidthStub.value(2);
+ describe('if window width is equal to or less than 1', function() {
+ describe('if test speed is fast', function() {
+ it('should write a grey dot', function() {
+ runner = createMockRunner('pass', 'pass', null, null, test);
+ var stdout = runReporter({epilogue: function() {}}, runner, options);
+ expect(test.speed, 'to equal', 'fast');
+ var expectedArray = ['fast_' + Base.symbols.dot];
+ expect(stdout, 'to equal', expectedArray);
});
-
- it('should write a newline followed by an exclamation mark', function() {
- var runner = createMockRunner(
- 'fail',
- EVENT_TEST_FAIL,
- null,
- null,
- test
- );
- var options = {};
- var stdout = runReporter({epilogue: noop}, runner, options);
- sandbox.restore();
-
- var expectedArray = ['\n ', 'fail_' + Base.symbols.bang];
+ });
+ describe('if test speed is medium', function() {
+ it('should write a yellow dot', function() {
+ test.duration = 2;
+ runner = createMockRunner('pass', 'pass', null, null, test);
+ var stdout = runReporter({epilogue: function() {}}, runner, options);
+ expect(test.speed, 'to equal', 'medium');
+ var expectedArray = ['medium_' + Base.symbols.dot];
expect(stdout, 'to equal', expectedArray);
});
});
-
- describe('when window width is less than or equal to 1', function() {
- it('should write an exclamation mark', function() {
- var runner = createMockRunner(
- 'fail',
- EVENT_TEST_FAIL,
- null,
- null,
- test
- );
- var options = {};
- var stdout = runReporter({epilogue: noop}, runner, options);
- sandbox.restore();
-
- var expectedArray = ['fail_' + Base.symbols.bang];
+ describe('if test speed is slow', function() {
+ it('should write a bright yellow dot', function() {
+ test.duration = 3;
+ runner = createMockRunner('pass', 'pass', null, null, test);
+ var stdout = runReporter({epilogue: function() {}}, runner, options);
+ expect(test.speed, 'to equal', 'slow');
+ var expectedArray = ['bright-yellow_' + Base.symbols.dot];
expect(stdout, 'to equal', expectedArray);
});
});
});
-
- describe("on 'end' event", function() {
- it('should call epilogue', function() {
- var runner = createMockRunner('end', EVENT_RUN_END);
- var fakeThis = {
- epilogue: sinon.stub()
- };
- var options = {};
- runReporter(fakeThis, runner, options);
- sandbox.restore();
-
- expect(fakeThis.epilogue.called, 'to be true');
+ });
+ describe('on fail', function() {
+ var test = {
+ test: {
+ err: 'some error'
+ }
+ };
+ describe('if window width is greater than 1', function() {
+ beforeEach(function() {
+ Base.window.width = 2;
+ });
+ it('should write a newline followed by an exclamation mark', function() {
+ runner = createMockRunner('fail', 'fail', null, null, test);
+ var stdout = runReporter({epilogue: function() {}}, runner, options);
+ var expectedArray = ['\n ', 'fail_' + Base.symbols.bang];
+ expect(stdout, 'to equal', expectedArray);
+ });
+ });
+ describe('if window width is equal to or less than 1', function() {
+ it('should write an exclamation mark', function() {
+ runner = createMockRunner('fail', 'fail', null, null, test);
+ var stdout = runReporter({epilogue: function() {}}, runner, options);
+ var expectedArray = ['fail_' + Base.symbols.bang];
+ expect(stdout, 'to equal', expectedArray);
});
});
});
+ describe('on end', function() {
+ it('should call the epilogue', function() {
+ runner = createMockRunner('end', 'end');
+ var epilogueCalled = false;
+ var epilogue = function() {
+ epilogueCalled = true;
+ };
+ runReporter({epilogue: epilogue}, runner, options);
+ expect(epilogueCalled, 'to be', true);
+ });
+ });
});
diff --git a/test/reporters/helpers.js b/test/reporters/helpers.js
index 76b3d79307..5cb21a53f2 100644
--- a/test/reporters/helpers.js
+++ b/test/reporters/helpers.js
@@ -1,22 +1,17 @@
'use strict';
-var sinon = require('sinon');
var errors = require('../../lib/errors');
-var createStatsCollector = require('../../lib/stats-collector');
-
var createUnsupportedError = errors.createUnsupportedError;
+/*
+ This function prevents the constant use of creating a runnerEvent.
+ runStr is the argument that defines the runnerEvent.
+ ifStr1 is one possible reporter argument, as is ifStr2, and ifStr3
+ arg1 and arg2 are the possible variables that need to be put into the
+ scope of this function for the tests to run properly.
+*/
+
+var createStatsCollector = require('../../lib/stats-collector');
-/**
- * Creates a mock runner object.
- *
- * @param {string} runStr - argument that defines the runnerEvent
- * @param {string} ifStr1 - runner event
- * @param {(string|null)} [ifStr2] - runner event
- * @param {(string|null)} [ifStr3] - runner event
- * @param {(*|null)} [arg1] - variable to be added to event handler's scope
- * @param {(*|null)} [arg2] - variable to be added to event handler's scope
- * @return {Object} mock runner instance
- */
function createMockRunner(runStr, ifStr1, ifStr2, ifStr3, arg1, arg2) {
var runnerFunction = createRunnerFunction(
runStr,
@@ -34,20 +29,6 @@ function createMockRunner(runStr, ifStr1, ifStr2, ifStr3, arg1, arg2) {
return mockRunner;
}
-/**
- * Creates an event handler function to be used by the runner.
- *
- * @description
- * Arguments 'ifStr1', 'ifStr2', and 'ifStr3' should be `Runner.constants`.
- *
- * @param {string} runStr - argument that defines the runnerEvent
- * @param {string} ifStr1 - runner event
- * @param {(string|null)} [ifStr2] - runner event
- * @param {(string|null)} [ifStr3] - runner event
- * @param {(*|null)} [arg1] - variable to be added to event handler's scope
- * @param {(*|null)} [arg2] - variable to be added to event handler's scope
- * @return {Function} event handler for the requested runner events
- */
function createRunnerFunction(runStr, ifStr1, ifStr2, ifStr3, arg1, arg2) {
var test = null;
switch (runStr) {
@@ -197,35 +178,23 @@ function createRunReporterFunction(ctor) {
* @return {string[]} Lines of output written to `stdout`
*/
var runReporter = function(stubSelf, runner, options, tee) {
- var origStdoutWrite = process.stdout.write;
- var stdoutWriteStub = sinon.stub(process.stdout, 'write');
var stdout = [];
- var gather = function(chunk, enc, callback) {
- stdout.push(chunk);
+ // Reassign stream in order to make a copy of all reporter output
+ var stdoutWrite = process.stdout.write;
+ process.stdout.write = function(string, enc, callback) {
+ stdout.push(string);
if (tee) {
- origStdoutWrite.call(process.stdout, chunk);
+ stdoutWrite.call(process.stdout, string, enc, callback);
}
};
- // Reassign stream in order to make a copy of all reporter output
- stdoutWriteStub.callsFake(gather);
-
- // Give `stubSelf` access to `ctor` prototype chain
- Object.setPrototypeOf(stubSelf, ctor.prototype);
+ // Invoke reporter
+ ctor.call(stubSelf, runner, options);
- try {
- try {
- // Invoke reporter
- ctor.call(stubSelf, runner, options);
- } finally {
- // Revert stream reassignment here so reporter output
- // can't be corrupted if any test assertions throw
- stdoutWriteStub.restore();
- }
- } catch (err) {
- throw err; // Rethrow
- }
+ // Revert stream reassignment here so reporter output
+ // can't be corrupted if any test assertions throw
+ process.stdout.write = stdoutWrite;
return stdout;
};
diff --git a/test/reporters/json-stream.spec.js b/test/reporters/json-stream.spec.js
index de83f861b2..8c9fcfff35 100644
--- a/test/reporters/json-stream.spec.js
+++ b/test/reporters/json-stream.spec.js
@@ -1,22 +1,15 @@
'use strict';
-var events = require('../../').Runner.constants;
-var helpers = require('./helpers');
var reporters = require('../../').reporters;
-var utils = require('../../lib/utils');
-
var JSONStream = reporters.JSONStream;
-var createMockRunner = helpers.createMockRunner;
-var dQuote = utils.dQuote;
-var makeExpectedTest = helpers.makeExpectedTest;
-var makeRunReporter = helpers.createRunReporterFunction;
-var EVENT_RUN_BEGIN = events.EVENT_RUN_BEGIN;
-var EVENT_RUN_END = events.EVENT_RUN_END;
-var EVENT_TEST_FAIL = events.EVENT_TEST_FAIL;
-var EVENT_TEST_PASS = events.EVENT_TEST_PASS;
+var createMockRunner = require('./helpers').createMockRunner;
+var makeExpectedTest = require('./helpers').makeExpectedTest;
+var makeRunReporter = require('./helpers.js').createRunReporterFunction;
describe('JSON Stream reporter', function() {
+ var runner;
+ var options = {};
var runReporter = makeRunReporter(JSONStream);
var expectedTitle = 'some title';
var expectedFullTitle = 'full title';
@@ -34,126 +27,119 @@ describe('JSON Stream reporter', function() {
message: expectedErrorMessage
};
- describe('event handlers', function() {
- describe("on 'start' event", function() {
- it('should write stringified start with expected total', function() {
- var runner = createMockRunner('start', EVENT_RUN_BEGIN);
- var expectedTotal = 12;
- runner.total = expectedTotal;
- var options = {};
- var stdout = runReporter({}, runner, options);
+ afterEach(function() {
+ runner = undefined;
+ });
- expect(
- stdout[0],
- 'to equal',
- '["start",{"total":' + expectedTotal + '}]\n'
- );
- });
+ describe('on start', function() {
+ it('should write stringified start with expected total', function() {
+ runner = createMockRunner('start', 'start');
+ var expectedTotal = 12;
+ runner.total = expectedTotal;
+ var stdout = runReporter({}, runner, options);
+
+ expect(
+ stdout[0],
+ 'to equal',
+ '["start",{"total":' + expectedTotal + '}]\n'
+ );
+ });
+ });
+
+ describe('on pass', function() {
+ it('should write stringified test data', function() {
+ runner = createMockRunner('pass', 'pass', null, null, expectedTest);
+ var stdout = runReporter({}, runner, options);
+
+ expect(
+ stdout[0],
+ 'to equal',
+ '["pass",{"title":"' +
+ expectedTitle +
+ '","fullTitle":"' +
+ expectedFullTitle +
+ '","duration":' +
+ expectedDuration +
+ ',"currentRetry":' +
+ currentRetry +
+ '}]\n'
+ );
});
+ });
- describe("on 'pass' event", function() {
- it('should write stringified test data', function() {
- var runner = createMockRunner(
- 'pass',
- EVENT_TEST_PASS,
+ describe('on fail', function() {
+ describe('if error stack exists', function() {
+ it('should write stringified test data with error data', function() {
+ expectedError.stack = expectedErrorStack;
+ runner = createMockRunner(
+ 'fail two args',
+ 'fail',
null,
null,
- expectedTest
+ expectedTest,
+ expectedError
);
- var options = {};
+
var stdout = runReporter({}, runner, options);
expect(
stdout[0],
'to equal',
- '["pass",{"title":' +
- dQuote(expectedTitle) +
- ',"fullTitle":' +
- dQuote(expectedFullTitle) +
- ',"duration":' +
+ '["fail",{"title":"' +
+ expectedTitle +
+ '","fullTitle":"' +
+ expectedFullTitle +
+ '","duration":' +
expectedDuration +
',"currentRetry":' +
currentRetry +
- '}]\n'
+ ',"err":"' +
+ expectedErrorMessage +
+ '","stack":"' +
+ expectedErrorStack +
+ '"}]\n'
);
});
});
- describe("on 'fail' event", function() {
- describe('when error stack exists', function() {
- it('should write stringified test data with error data', function() {
- expectedError.stack = expectedErrorStack;
- var runner = createMockRunner(
- 'fail two args',
- EVENT_TEST_FAIL,
- null,
- null,
- expectedTest,
- expectedError
- );
- var options = {};
- var stdout = runReporter({}, runner, options);
-
- expect(
- stdout[0],
- 'to equal',
- '["fail",{"title":' +
- dQuote(expectedTitle) +
- ',"fullTitle":' +
- dQuote(expectedFullTitle) +
- ',"duration":' +
- expectedDuration +
- ',"currentRetry":' +
- currentRetry +
- ',"err":' +
- dQuote(expectedErrorMessage) +
- ',"stack":' +
- dQuote(expectedErrorStack) +
- '}]\n'
- );
- });
- });
+ describe('if error stack does not exist', function() {
+ it('should write stringified test data with error data', function() {
+ expectedError.stack = null;
+ runner = createMockRunner(
+ 'fail two args',
+ 'fail',
+ null,
+ null,
+ expectedTest,
+ expectedError
+ );
- describe('when error stack does not exist', function() {
- it('should write stringified test data with error data', function() {
- expectedError.stack = null;
- var runner = createMockRunner(
- 'fail two args',
- EVENT_TEST_FAIL,
- null,
- null,
- expectedTest,
- expectedError
- );
- var options = {};
- var stdout = runReporter(this, runner, options);
+ var stdout = runReporter(this, runner, options);
- expect(
- stdout[0],
- 'to equal',
- '["fail",{"title":' +
- dQuote(expectedTitle) +
- ',"fullTitle":' +
- dQuote(expectedFullTitle) +
- ',"duration":' +
- expectedDuration +
- ',"currentRetry":' +
- currentRetry +
- ',"err":' +
- dQuote(expectedErrorMessage) +
- ',"stack":null}]\n'
- );
- });
+ expect(
+ stdout[0],
+ 'to equal',
+ '["fail",{"title":"' +
+ expectedTitle +
+ '","fullTitle":"' +
+ expectedFullTitle +
+ '","duration":' +
+ expectedDuration +
+ ',"currentRetry":' +
+ currentRetry +
+ ',"err":"' +
+ expectedErrorMessage +
+ '","stack":null}]\n'
+ );
});
});
+ });
- describe("on 'end' event", function() {
- it('should write summary statistics', function() {
- var runner = createMockRunner('end', EVENT_RUN_END);
- var options = {};
- var stdout = runReporter(this, runner, options);
- expect(stdout[0], 'to match', /end/);
- });
+ describe('on end', function() {
+ it('should write end details', function() {
+ runner = createMockRunner('end', 'end');
+ var stdout = runReporter(this, runner, options);
+ expect(stdout[0], 'to match', /end/);
});
});
});
diff --git a/test/reporters/json.spec.js b/test/reporters/json.spec.js
index f6299dd134..5d7a37c564 100644
--- a/test/reporters/json.spec.js
+++ b/test/reporters/json.spec.js
@@ -7,11 +7,8 @@ var Runner = Mocha.Runner;
var Test = Mocha.Test;
describe('JSON reporter', function() {
- var sandbox;
- var suite;
- var runner;
+ var suite, runner;
var testTitle = 'json test 1';
- var noop = function() {};
beforeEach(function() {
var mocha = new Mocha({
@@ -19,18 +16,8 @@ describe('JSON reporter', function() {
});
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() {
- sandbox = sinon.createSandbox();
- sandbox.stub(process.stdout, 'write').callsFake(noop);
- });
-
- afterEach(function() {
- sandbox.restore();
+ var mochaReporter = new mocha._reporter(runner);
});
it('should have 1 test failure', function(done) {
@@ -42,8 +29,9 @@ describe('JSON reporter', function() {
})
);
+ var stdoutWrite = sinon.stub(process.stdout, 'write');
runner.run(function(failureCount) {
- sandbox.restore();
+ stdoutWrite.restore();
expect(runner, 'to satisfy', {
testResults: {
failures: [
@@ -64,8 +52,9 @@ describe('JSON reporter', function() {
it('should have 1 test pending', function(done) {
suite.addTest(new Test(testTitle));
+ var stdoutWrite = sinon.stub(process.stdout, 'write');
runner.run(function(failureCount) {
- sandbox.restore();
+ stdoutWrite.restore();
expect(runner, 'to satisfy', {
testResults: {
pending: [
@@ -94,8 +83,9 @@ describe('JSON reporter', function() {
})
);
+ var stdoutWrite = sinon.stub(process.stdout, 'write');
runner.run(function(failureCount) {
- sandbox.restore();
+ stdoutWrite.restore();
expect(runner, 'to satisfy', {
testResults: {
failures: [
diff --git a/test/reporters/landing.spec.js b/test/reporters/landing.spec.js
index acb2ee3ef6..dd73d9e5b3 100644
--- a/test/reporters/landing.spec.js
+++ b/test/reporters/landing.spec.js
@@ -1,25 +1,20 @@
'use strict';
-var sinon = require('sinon');
-var events = require('../../').Runner.constants;
-var helpers = require('./helpers');
-var reporters = require('../../').reporters;
-var states = require('../../').Runnable.constants;
-
-var Base = reporters.Base;
+var sandbox = require('sinon').createSandbox();
+var Mocha = require('../..');
+var reporters = Mocha.reporters;
var Landing = reporters.Landing;
-var createMockRunner = helpers.createMockRunner;
-var makeRunReporter = helpers.createRunReporterFunction;
-
-var EVENT_RUN_BEGIN = events.EVENT_RUN_BEGIN;
-var EVENT_RUN_END = events.EVENT_RUN_END;
-var EVENT_TEST_END = events.EVENT_TEST_END;
+var constants = Mocha.Runnable.constants;
+var STATE_FAILED = constants.STATE_FAILED;
+var STATE_PASSED = constants.STATE_PASSED;
+var Base = reporters.Base;
-var STATE_FAILED = states.STATE_FAILED;
-var STATE_PASSED = states.STATE_PASSED;
+var createMockRunner = require('./helpers').createMockRunner;
+var makeRunReporter = require('./helpers.js').createRunReporterFunction;
describe('Landing reporter', function() {
- var sandbox;
+ var runner;
+ var options = {};
var runReporter = makeRunReporter(Landing);
var resetCode = '\u001b[0m';
var expectedArray = [
@@ -34,98 +29,73 @@ describe('Landing reporter', function() {
];
beforeEach(function() {
- sandbox = sinon.createSandbox();
sandbox.stub(Base, 'useColors').value(false);
sandbox.stub(Base.window, 'width').value(1);
});
afterEach(function() {
sandbox.restore();
+ runner = undefined;
});
- describe('event handlers', function() {
- describe("on 'start' event", function() {
- it('should write newlines', function() {
- sandbox.stub(Base.cursor, 'hide');
+ describe('on start', function() {
+ it('should write new lines', function() {
+ sandbox.stub(Base.cursor, 'hide');
- var runner = createMockRunner('start', EVENT_RUN_BEGIN);
- var options = {};
- var stdout = runReporter({}, runner, options);
- sandbox.restore();
+ runner = createMockRunner('start', 'start');
+ var stdout = runReporter({}, runner, options);
- expect(stdout[0], 'to equal', '\n\n\n ');
- });
+ expect(stdout[0], 'to equal', '\n\n\n ');
+ });
- it('should call cursor hide', function() {
- var hideCursorStub = sandbox.stub(Base.cursor, 'hide');
+ it('should call cursor hide', function() {
+ sandbox.stub(Base.cursor, 'hide');
- var runner = createMockRunner('start', EVENT_RUN_BEGIN);
- var options = {};
- runReporter({}, runner, options);
- sandbox.restore();
+ runner = createMockRunner('start', 'start');
+ runReporter({}, runner, options);
- expect(hideCursorStub.called, 'to be true');
- });
+ expect(Base.cursor.hide, 'was called');
});
+ });
- describe("on 'test end' event", function() {
- describe('when test passes', function() {
- it('should write expected landing strip', function() {
- var test = {
- state: STATE_PASSED
- };
- var runner = createMockRunner(
- 'test end',
- EVENT_TEST_END,
- null,
- null,
- test
- );
- var options = {};
- var stdout = runReporter({}, runner, options);
- sandbox.restore();
-
- expect(stdout, 'to equal', expectedArray);
- });
+ describe('on test end', function() {
+ describe('if test has failed', function() {
+ it('should write expected landing strip', function() {
+ var test = {
+ state: STATE_FAILED
+ };
+ runner = createMockRunner('test end', 'test end', null, null, test);
+ runner.total = 12;
+ var stdout = runReporter({}, runner, options);
+
+ expect(stdout, 'to equal', expectedArray);
});
+ });
+ describe('if test has not failed', function() {
+ it('should write expected landing strip', function() {
+ var test = {
+ state: STATE_PASSED
+ };
+ runner = createMockRunner('test end', 'test end', null, null, test);
- describe('when test fails', function() {
- it('should write expected landing strip', function() {
- var test = {
- state: STATE_FAILED
- };
- var runner = createMockRunner(
- 'test end',
- EVENT_TEST_END,
- null,
- null,
- test
- );
- runner.total = 12;
- var options = {};
- var stdout = runReporter({}, runner, options);
- sandbox.restore();
-
- expect(stdout, 'to equal', expectedArray);
- });
+ var stdout = runReporter({}, runner, options);
+
+ expect(stdout, 'to equal', expectedArray);
});
});
+ });
+ describe('on end', function() {
+ it('should call cursor show and epilogue', function() {
+ var reporterStub = {epilogue: function() {}};
+ sandbox.stub(Base.cursor, 'show');
+ sandbox.stub(reporterStub, 'epilogue');
- describe("on 'end' event", function() {
- it('should call cursor show and epilogue', function() {
- var showCursorStub = sandbox.stub(Base.cursor, 'show');
+ runner = createMockRunner('end', 'end');
- var fakeThis = {
- epilogue: sinon.spy()
- };
- var runner = createMockRunner('end', EVENT_RUN_END);
- var options = {};
- runReporter(fakeThis, runner, options);
- sandbox.restore();
+ runReporter(reporterStub, runner, options);
- expect(fakeThis.epilogue.calledOnce, 'to be true');
- expect(showCursorStub.called, 'to be true');
- });
+ expect(reporterStub.epilogue, 'was called');
+ expect(Base.cursor.show, 'was called');
});
});
});
diff --git a/test/reporters/list.spec.js b/test/reporters/list.spec.js
index c10272e953..c9eceb87fe 100644
--- a/test/reporters/list.spec.js
+++ b/test/reporters/list.spec.js
@@ -1,246 +1,144 @@
'use strict';
-var sinon = require('sinon');
-var events = require('../../').Runner.constants;
-var helpers = require('./helpers');
+var sandbox = require('sinon').createSandbox();
var reporters = require('../../').reporters;
-
-var Base = reporters.Base;
var List = reporters.List;
-var createMockRunner = helpers.createMockRunner;
-var makeRunReporter = helpers.createRunReporterFunction;
+var Base = reporters.Base;
-var EVENT_RUN_BEGIN = events.EVENT_RUN_BEGIN;
-var EVENT_RUN_END = events.EVENT_RUN_END;
-var EVENT_TEST_BEGIN = events.EVENT_TEST_BEGIN;
-var EVENT_TEST_FAIL = events.EVENT_TEST_FAIL;
-var EVENT_TEST_PASS = events.EVENT_TEST_PASS;
-var EVENT_TEST_PENDING = events.EVENT_TEST_PENDING;
+var createMockRunner = require('./helpers').createMockRunner;
+var makeRunReporter = require('./helpers.js').createRunReporterFunction;
describe('List reporter', function() {
- var sandbox;
+ var runner;
+ var options = {};
var runReporter = makeRunReporter(List);
var expectedTitle = 'some title';
var expectedDuration = 100;
- var noop = function() {};
var test = {
fullTitle: function() {
return expectedTitle;
},
duration: expectedDuration,
- slow: noop
+ slow: function() {}
};
beforeEach(function() {
- sandbox = sinon.createSandbox();
sandbox.stub(Base, 'useColors').value(false);
});
afterEach(function() {
sandbox.restore();
+ runner = undefined;
});
- describe('event handlers', function() {
- describe("on 'start' and 'test' events", function() {
- it('should write expected newline and title', function() {
- var runner = createMockRunner(
- 'start test',
- EVENT_RUN_BEGIN,
- EVENT_TEST_BEGIN,
- null,
- test
- );
- var options = {};
- var fakeThis = {
- epilogue: noop
- };
- var stdout = runReporter(fakeThis, runner, options);
- sandbox.restore();
-
- var startString = '\n';
- var testString = ' ' + expectedTitle + ': ';
- var expectedArray = [startString, testString];
- expect(stdout, 'to equal', expectedArray);
- });
+ describe('on start and test', function() {
+ it('should write expected new line and title to the console', function() {
+ runner = createMockRunner('start test', 'start', 'test', null, test);
+ var stdout = runReporter({epilogue: function() {}}, runner, options);
+
+ var startString = '\n';
+ var testString = ' ' + expectedTitle + ': ';
+ var expectedArray = [startString, testString];
+ expect(stdout, 'to equal', expectedArray);
});
+ });
+ describe('on pending', function() {
+ it('should write expected title to the console', function() {
+ runner = createMockRunner('pending test', 'pending', null, null, test);
+ var stdout = runReporter({epilogue: function() {}}, runner, options);
- describe("on 'pending' event", function() {
- it('should write expected title', function() {
- var runner = createMockRunner(
- 'pending test',
- EVENT_TEST_PENDING,
- null,
- null,
- test
- );
- var options = {};
- var fakeThis = {
- epilogue: noop
- };
- var stdout = runReporter(fakeThis, runner, options);
- sandbox.restore();
-
- expect(stdout[0], 'to equal', ' - ' + expectedTitle + '\n');
- });
+ expect(stdout[0], 'to equal', ' - ' + expectedTitle + '\n');
});
+ });
+ describe('on pass', function() {
+ it('should call cursor CR', function() {
+ sandbox.stub(Base.cursor, 'CR');
- describe("on 'pass' event", function() {
- var crStub;
-
- beforeEach(function() {
- crStub = sandbox.stub(Base.cursor, 'CR').callsFake(noop);
- });
-
- it('should call cursor CR', function() {
- var runner = createMockRunner(
- 'pass',
- EVENT_TEST_PASS,
- null,
- null,
- test
- );
- var options = {};
- var fakeThis = {
- epilogue: noop
- };
- runReporter(fakeThis, runner, options);
- sandbox.restore();
-
- expect(crStub.called, 'to be true');
- });
-
- it('should write expected symbol, title, and duration', function() {
- var expectedOkSymbol = 'OK';
- sandbox.stub(Base.symbols, 'ok').value(expectedOkSymbol);
-
- var runner = createMockRunner(
- 'pass',
- EVENT_TEST_PASS,
- null,
- null,
- test
- );
- var options = {};
- var fakeThis = {
- epilogue: noop
- };
- var stdout = runReporter(fakeThis, runner, options);
- sandbox.restore();
-
- expect(
- stdout[0],
- 'to be',
- ' ' +
- expectedOkSymbol +
- ' ' +
- expectedTitle +
- ': ' +
- expectedDuration +
- 'ms\n'
- );
- });
+ runner = createMockRunner('pass', 'pass', null, null, test);
+ runReporter({epilogue: function() {}}, runner, options);
+
+ expect(Base.cursor.CR, 'was called');
+ });
+ it('should write expected symbol, title and duration to the console', function() {
+ var expectedOkSymbol = 'OK';
+ sandbox.stub(Base.symbols, 'ok').value(expectedOkSymbol);
+ sandbox.stub(Base.cursor, 'CR');
+
+ runner = createMockRunner('pass', 'pass', null, null, test);
+ var stdout = runReporter({epilogue: function() {}}, runner, options);
+
+ expect(
+ stdout[0],
+ 'to be',
+ ' ' +
+ expectedOkSymbol +
+ ' ' +
+ expectedTitle +
+ ': ' +
+ expectedDuration +
+ 'ms\n'
+ );
});
+ });
+ describe('on fail', function() {
+ it('should call cursor CR', function() {
+ sandbox.stub(Base.cursor, 'CR');
+
+ runner = createMockRunner('fail', 'fail', null, null, test);
+ runReporter({epilogue: function() {}}, runner, options);
- describe("on 'fail' event", function() {
- var crStub;
-
- beforeEach(function() {
- crStub = sandbox.stub(Base.cursor, 'CR').callsFake(noop);
- });
-
- it('should call cursor CR', function() {
- var runner = createMockRunner(
- 'fail',
- EVENT_TEST_FAIL,
- null,
- null,
- test
- );
- var options = {};
- var fakeThis = {
- epilogue: noop
- };
- runReporter(fakeThis, runner, options);
- sandbox.restore();
-
- expect(crStub.called, 'to be true');
- });
-
- it('should write expected error number and title', function() {
- var expectedErrorCount = 1;
- var runner = createMockRunner(
- 'fail',
- EVENT_TEST_FAIL,
- null,
- null,
- test
- );
- var options = {};
- var fakeThis = {
- epilogue: noop
- };
- var stdout = runReporter(fakeThis, runner, options);
- sandbox.restore();
-
- expect(
- stdout[0],
- 'to be',
- ' ' + expectedErrorCount + ') ' + expectedTitle + '\n'
- );
- });
-
- it('should immediately construct fail strings', function() {
- var actual = {a: 'actual'};
- var expected = {a: 'expected'};
- var checked = false;
- var err;
- test = {};
-
- var runner = createMockRunner(
- 'fail',
- EVENT_TEST_FAIL,
- null,
- null,
- test
- );
- runner.on = runner.once = function(event, callback) {
- if (
- !checked &&
- event === 'fail' &&
- callback.toString().includes('stringifyDiffObjs') // target correct fail event callback
- ) {
- err = new Error('fake failure object with actual/expected');
- err.actual = actual;
- err.expected = expected;
- err.showDiff = true;
- callback(test, err);
- checked = true;
- }
- };
- var options = {};
- var fakeThis = {
- epilogue: noop
- };
- runReporter(fakeThis, runner, options);
- sandbox.restore();
-
- expect(typeof err.actual, 'to be', 'string');
- expect(typeof err.expected, 'to be', 'string');
- });
+ expect(Base.cursor.CR, 'was called');
+ });
+ it('should write expected error number and title', function() {
+ sandbox.stub(Base.cursor, 'CR');
+
+ var expectedErrorCount = 1;
+ runner = createMockRunner('fail', 'fail', null, null, test);
+ var stdout = runReporter({epilogue: function() {}}, runner, options);
+
+ expect(
+ stdout[0],
+ 'to be',
+ ' ' + expectedErrorCount + ') ' + expectedTitle + '\n'
+ );
+ });
+ it('should immediately construct fail strings', function() {
+ var actual = {a: 'actual'};
+ var expected = {a: 'expected'};
+ var checked = false;
+ var err;
+ test = {};
+ runner = createMockRunner('fail', 'fail', null, null, test);
+ runner.on = runner.once = function(event, callback) {
+ if (
+ !checked &&
+ event === 'fail' &&
+ callback.toString().includes('stringifyDiffObjs') // target correct fail event callback
+ ) {
+ err = new Error('fake failure object with actual/expected');
+ err.actual = actual;
+ err.expected = expected;
+ err.showDiff = true;
+ callback(test, err);
+ checked = true;
+ }
+ };
+ runReporter({epilogue: function() {}}, runner, options);
+
+ expect(typeof err.actual, 'to be', 'string');
+ expect(typeof err.expected, 'to be', 'string');
});
+ });
+
+ describe('on end', function() {
+ it('should call epilogue', function() {
+ var reporterStub = {epilogue: function() {}};
+ sandbox.stub(reporterStub, 'epilogue');
+
+ runner = createMockRunner('end', 'end');
+ runReporter(reporterStub, runner, options);
- describe("on 'end' event", function() {
- it('should call epilogue', function() {
- var runner = createMockRunner('end', EVENT_RUN_END);
- var options = {};
- var fakeThis = {
- epilogue: sinon.spy()
- };
- runReporter(fakeThis, runner, options);
- sandbox.restore();
-
- expect(fakeThis.epilogue.calledOnce, 'to be true');
- });
+ expect(reporterStub.epilogue, 'was called');
});
});
});
diff --git a/test/reporters/markdown.spec.js b/test/reporters/markdown.spec.js
index e068c58cea..842d7c7643 100644
--- a/test/reporters/markdown.spec.js
+++ b/test/reporters/markdown.spec.js
@@ -1,115 +1,102 @@
'use strict';
-var events = require('../../').Runner.constants;
-var helpers = require('./helpers');
var reporters = require('../../').reporters;
-
var Markdown = reporters.Markdown;
-var createMockRunner = helpers.createMockRunner;
-var makeRunReporter = helpers.createRunReporterFunction;
-var EVENT_RUN_END = events.EVENT_RUN_END;
-var EVENT_SUITE_BEGIN = events.EVENT_SUITE_BEGIN;
-var EVENT_SUITE_END = events.EVENT_SUITE_END;
-var EVENT_TEST_PASS = events.EVENT_TEST_PASS;
+var createMockRunner = require('./helpers').createMockRunner;
+var makeRunReporter = require('./helpers.js').createRunReporterFunction;
describe('Markdown reporter', function() {
+ var runner;
+ var options = {};
var runReporter = makeRunReporter(Markdown);
var expectedTitle = 'expected title';
var expectedFullTitle = 'full title';
var sluggedFullTitle = 'full-title';
- var noop = function() {};
- describe('event handlers', function() {
- describe("on 'suite' event", function() {
- it("should write expected slugged titles on 'end' event", function() {
- var expectedSuite = {
- title: expectedTitle,
- fullTitle: function() {
- return expectedFullTitle;
- },
- suites: [
- {
- title: expectedTitle,
- fullTitle: function() {
- return expectedFullTitle;
- },
- suites: []
- }
- ]
- };
- var runner = createMockRunner(
- 'suite suite end',
- EVENT_SUITE_BEGIN,
- EVENT_SUITE_END,
- EVENT_RUN_END,
- expectedSuite
- );
- runner.suite = expectedSuite;
- var options = {};
- var stdout = runReporter({}, runner, options);
+ afterEach(function() {
+ runner = undefined;
+ });
- var expectedArray = [
- '# TOC\n',
- ' - [' +
- expectedTitle +
- '](#' +
- sluggedFullTitle +
- ')\n - [' +
- expectedTitle +
- '](#' +
- sluggedFullTitle +
- ')\n',
- '\n ' + expectedTitle + '\n'
- ];
+ describe("on 'suite'", function() {
+ it("should write expected slugged titles on 'end' event", function() {
+ var expectedSuite = {
+ title: expectedTitle,
+ fullTitle: function() {
+ return expectedFullTitle;
+ },
+ suites: [
+ {
+ title: expectedTitle,
+ fullTitle: function() {
+ return expectedFullTitle;
+ },
+ suites: []
+ }
+ ]
+ };
+ runner = createMockRunner(
+ 'suite suite end',
+ 'suite',
+ 'suite end',
+ 'end',
+ expectedSuite
+ );
+ runner.suite = expectedSuite;
+ var stdout = runReporter({}, runner, options);
- expect(stdout, 'to equal', expectedArray);
- });
- });
+ var expectedArray = [
+ '# TOC\n',
+ ' - [' +
+ expectedTitle +
+ '](#' +
+ sluggedFullTitle +
+ ')\n - [' +
+ expectedTitle +
+ '](#' +
+ sluggedFullTitle +
+ ')\n',
+ '\n ' + expectedTitle + '\n'
+ ];
- describe("on 'pass' event", function() {
- it("should write test code inside js code block, on 'end' event", function() {
- var expectedSuite = {
- title: expectedTitle,
- fullTitle: function() {
- return expectedFullTitle;
- },
- suites: []
- };
- var expectedDuration = 1000;
- var currentRetry = 1;
- var expectedBody = 'some body';
- var expectedTest = {
- title: expectedTitle,
- fullTitle: function() {
- return expectedFullTitle;
- },
- duration: expectedDuration,
- currentRetry: function() {
- return currentRetry;
- },
- slow: noop,
- body: expectedBody
- };
- var runner = createMockRunner(
- 'pass end',
- EVENT_TEST_PASS,
- EVENT_RUN_END,
- null,
- expectedTest
- );
- runner.suite = expectedSuite;
- var options = {};
- var stdout = runReporter({}, runner, options);
+ expect(stdout, 'to equal', expectedArray);
+ });
+ });
+ describe("on 'pass'", function() {
+ it("should write test code inside js code block, on 'end' event", function() {
+ var expectedSuite = {
+ title: expectedTitle,
+ fullTitle: function() {
+ return expectedFullTitle;
+ },
+ suites: []
+ };
+ var expectedDuration = 1000;
+ var currentRetry = 1;
+ var expectedBody = 'some body';
+ var expectedTest = {
+ title: expectedTitle,
+ fullTitle: function() {
+ return expectedFullTitle;
+ },
+ duration: expectedDuration,
+ currentRetry: function() {
+ return currentRetry;
+ },
+ slow: function() {},
+ body: expectedBody
+ };
+ runner = createMockRunner('pass end', 'pass', 'end', null, expectedTest);
+ runner.suite = expectedSuite;
+ var stdout = runReporter({}, runner, options);
- var expectedArray = [
- '# TOC\n',
- ' - [' + expectedTitle + '](#' + sluggedFullTitle + ')\n',
- expectedTitle + '.\n\n```js\n' + expectedBody + '\n```\n\n'
- ];
+ var expectedArray = [
+ '# TOC\n',
+ ' - [' + expectedTitle + '](#' + sluggedFullTitle + ')\n',
+ expectedTitle + '.\n\n```js\n' + expectedBody + '\n```\n\n'
+ ];
- expect(stdout, 'to equal', expectedArray);
- });
+ expect(stdout, 'to equal', expectedArray);
});
});
});
diff --git a/test/reporters/min.spec.js b/test/reporters/min.spec.js
index 1fe46333cf..f88adf31d7 100644
--- a/test/reporters/min.spec.js
+++ b/test/reporters/min.spec.js
@@ -1,47 +1,45 @@
'use strict';
-var sinon = require('sinon');
-var events = require('../../').Runner.constants;
-var helpers = require('./helpers');
var reporters = require('../../').reporters;
-
var Min = reporters.Min;
-var createMockRunner = helpers.createMockRunner;
-var makeRunReporter = helpers.createRunReporterFunction;
-var EVENT_RUN_BEGIN = events.EVENT_RUN_BEGIN;
-var EVENT_RUN_END = events.EVENT_RUN_END;
+var createMockRunner = require('./helpers').createMockRunner;
+var makeRunReporter = require('./helpers.js').createRunReporterFunction;
describe('Min reporter', function() {
+ var runner;
+ var options = {};
var runReporter = makeRunReporter(Min);
- var noop = function() {};
-
- describe('event handlers', function() {
- describe("on 'start' event", function() {
- it('should clear screen then set cursor position', function() {
- var runner = createMockRunner('start', EVENT_RUN_BEGIN);
- var options = {};
- var fakeThis = {
- epilogue: noop
- };
- var stdout = runReporter(fakeThis, runner, options);
-
- var expectedArray = ['\u001b[2J', '\u001b[1;3H'];
- expect(stdout, 'to equal', expectedArray);
- });
+
+ afterEach(function() {
+ runner = undefined;
+ });
+
+ describe('on start', function() {
+ it('should clear screen then set cursor position', function() {
+ runner = createMockRunner('start', 'start');
+ var stdout = runReporter({epilogue: function() {}}, runner, options);
+
+ var expectedArray = ['\u001b[2J', '\u001b[1;3H'];
+ expect(stdout, 'to equal', expectedArray);
});
+ });
- describe("on 'end' event", function() {
- it('should call epilogue', function() {
- var fakeThis = {
- epilogue: sinon.stub().callsFake(noop)
- };
- var runner = createMockRunner('end', EVENT_RUN_END);
- var options = {};
- runReporter(fakeThis, runner, options);
-
- expect(fakeThis.epilogue.called, 'to be true');
- });
+ describe('on end', function() {
+ it('should call epilogue', function() {
+ var calledEpilogue = false;
+ runner = createMockRunner('end', 'end');
+ runReporter(
+ {
+ epilogue: function() {
+ calledEpilogue = true;
+ }
+ },
+ runner,
+ options
+ );
+
+ expect(calledEpilogue, 'to be', true);
});
});
});
diff --git a/test/reporters/nyan.spec.js b/test/reporters/nyan.spec.js
index 05d2e1bf77..b1ad3a22a3 100644
--- a/test/reporters/nyan.spec.js
+++ b/test/reporters/nyan.spec.js
@@ -1,205 +1,172 @@
'use strict';
-var sinon = require('sinon');
-var events = require('../../').Runner.constants;
-var helpers = require('./helpers');
+var sandbox = require('sinon').createSandbox();
var reporters = require('../../').reporters;
-
-var Base = reporters.Base;
var NyanCat = reporters.Nyan;
-var createMockRunner = helpers.createMockRunner;
-var makeRunReporter = helpers.createRunReporterFunction;
+var Base = reporters.Base;
-var EVENT_RUN_BEGIN = events.EVENT_RUN_BEGIN;
-var EVENT_RUN_END = events.EVENT_RUN_END;
-var EVENT_TEST_FAIL = events.EVENT_TEST_FAIL;
-var EVENT_TEST_PASS = events.EVENT_TEST_PASS;
-var EVENT_TEST_PENDING = events.EVENT_TEST_PENDING;
+var createMockRunner = require('./helpers').createMockRunner;
+var makeRunReporter = require('./helpers.js').createRunReporterFunction;
describe('Nyan reporter', function() {
- var sandbox;
- var noop = function() {};
-
- beforeEach(function() {
- sandbox = sinon.createSandbox();
- });
-
- afterEach(function() {
- sandbox.restore();
- });
-
- describe('event handlers', function() {
+ describe('events', function() {
+ var runner;
+ var options = {};
var runReporter = makeRunReporter(NyanCat);
- describe("on 'start' event", function() {
+ afterEach(function() {
+ sandbox.restore();
+ runner = undefined;
+ });
+
+ describe('on start', function() {
it('should call draw', function() {
- var fakeThis = {
- draw: sinon.stub().callsFake(noop),
- generateColors: noop
+ var reporterStub = {
+ draw: function() {},
+ generateColors: function() {}
};
+ sandbox.stub(reporterStub, 'draw');
- var runner = createMockRunner('start', EVENT_RUN_BEGIN);
- var options = {};
- runReporter(fakeThis, runner, options);
+ runner = createMockRunner('start', 'start');
+ runReporter(reporterStub, runner, options);
- expect(fakeThis.draw.called, 'to be true');
+ expect(reporterStub.draw, 'was called');
});
});
-
- describe("on 'pending' event", function() {
+ describe('on pending', function() {
it('should call draw', function() {
- var fakeThis = {
- draw: sinon.stub().callsFake(noop),
- generateColors: noop
+ var reporterStub = {
+ draw: function() {},
+ generateColors: function() {}
};
- var runner = createMockRunner('pending', EVENT_TEST_PENDING);
- var options = {};
- runReporter(fakeThis, runner, options);
+ sandbox.stub(reporterStub, 'draw');
- expect(fakeThis.draw.called, 'to be true');
+ runner = createMockRunner('pending', 'pending');
+ runReporter(reporterStub, runner, options);
+
+ expect(reporterStub.draw, 'was called');
});
});
-
- describe("on 'pass' event", function() {
+ describe('on pass', function() {
it('should call draw', function() {
+ var reporterStub = {
+ draw: function() {},
+ generateColors: function() {}
+ };
+ sandbox.stub(reporterStub, 'draw');
+
var test = {
duration: '',
- slow: noop
+ slow: function() {}
};
- var fakeThis = {
- draw: sinon.stub().callsFake(noop),
- generateColors: noop
- };
- var runner = createMockRunner(
- 'pass',
- EVENT_TEST_PASS,
- null,
- null,
- test
- );
- var options = {};
- runReporter(fakeThis, runner, options);
+ runner = createMockRunner('pass', 'pass', null, null, test);
+ runReporter(reporterStub, runner, options);
- expect(fakeThis.draw.called, 'to be true');
+ expect(reporterStub.draw, 'was called');
});
});
-
- describe("on 'fail' event", function() {
+ describe('on fail', function() {
it('should call draw', function() {
+ var reporterStub = {
+ draw: function() {},
+ generateColors: function() {}
+ };
+ sandbox.stub(reporterStub, 'draw');
+
var test = {
err: ''
};
- var fakeThis = {
- draw: sinon.stub().callsFake(noop),
- generateColors: noop
- };
- var runner = createMockRunner(
- 'fail',
- EVENT_TEST_FAIL,
- null,
- null,
- test
- );
- var options = {};
- runReporter(fakeThis, runner, options);
+ runner = createMockRunner('fail', 'fail', null, null, test);
+ runReporter(reporterStub, runner, options);
- expect(fakeThis.draw.called, 'to be true');
+ expect(reporterStub.draw, 'was called');
});
});
-
- describe("on 'end' event", function() {
+ describe('on end', function() {
it('should call epilogue', function() {
- var fakeThis = {
- draw: noop,
- epilogue: sinon.stub().callsFake(noop),
- generateColors: noop
+ var reporterStub = {
+ draw: function() {},
+ generateColors: function() {},
+ epilogue: function() {}
};
- var runner = createMockRunner('end', EVENT_RUN_END);
- var options = {};
- runReporter(fakeThis, runner, options);
+ sandbox.stub(reporterStub, 'epilogue');
- expect(fakeThis.epilogue.called, 'to be true');
- });
+ runner = createMockRunner('end', 'end');
+ runReporter(reporterStub, runner, options);
- it('should write numberOfLines amount of newlines', function() {
+ expect(reporterStub.epilogue, 'was called');
+ });
+ it('should write numberOfLines amount of new lines', function() {
var expectedNumberOfLines = 4;
- var fakeThis = {
- draw: noop,
- epilogue: noop,
- generateColors: noop
- };
- var runner = createMockRunner('end', EVENT_RUN_END);
- var options = {};
- var stdout = runReporter(fakeThis, runner, options);
+ runner = createMockRunner('end', 'end');
+ var stdout = runReporter(
+ {
+ draw: function() {},
+ generateColors: function() {},
+ epilogue: function() {}
+ },
+ runner,
+ options
+ );
- var isBlankLine = function(value) {
+ var arrayOfNewlines = stdout.filter(function(value) {
return value === '\n';
- };
+ });
- expect(
- stdout.filter(isBlankLine),
- 'to have length',
- expectedNumberOfLines
- );
+ expect(arrayOfNewlines, 'to have length', expectedNumberOfLines);
});
-
it('should call Base show', function() {
- var showCursorStub = sandbox.stub(Base.cursor, 'show');
- var fakeThis = {
- draw: noop,
- epilogue: noop,
- generateColors: noop
- };
- var runner = createMockRunner('end', EVENT_RUN_END);
- var options = {};
- runReporter(fakeThis, runner, options);
- sandbox.restore();
+ sandbox.stub(Base.cursor, 'show');
+
+ runner = createMockRunner('end', 'end');
+ runReporter(
+ {
+ draw: function() {},
+ generateColors: function() {},
+ epilogue: function() {}
+ },
+ runner,
+ options
+ );
- expect(showCursorStub.called, 'to be true');
+ expect(Base.cursor.show, 'was called');
});
});
});
- describe('#draw', function() {
- var stdoutWriteStub;
+ describe('draw', function() {
var stdout;
+ var stdoutWrite;
beforeEach(function() {
- stdoutWriteStub = sandbox.stub(process.stdout, 'write');
- stdoutWriteStub.callsFake(function(chunk, encoding, cb) {
- stdout.push(chunk);
- });
stdout = [];
+ stdoutWrite = process.stdout.write;
+ process.stdout.write = function(string, enc, callback) {
+ stdout.push(string);
+ };
});
- describe("when 'tick' is false", function() {
+ afterEach(function() {
+ process.stdout.write = stdoutWrite;
+ });
+
+ describe('if tick is false', function() {
it('should draw face with expected spaces, _ and ^', function() {
- var runner = {on: noop, once: noop};
- var options = {};
- var nyanCat = new NyanCat(runner, options);
+ var nyanCat = new NyanCat({on: function() {}, once: function() {}});
nyanCat.stats = {passes: 2, pending: 1, failures: 0};
- var fakeThis = {
+
+ nyanCat.draw.call({
tick: false,
- appendRainbow: noop,
- rainbowify: noop,
- drawScoreboard: noop,
- drawRainbow: noop,
+ appendRainbow: function() {},
+ rainbowify: function() {},
+ drawScoreboard: function() {},
+ drawRainbow: function() {},
drawNyanCat: NyanCat.prototype.drawNyanCat,
scoreboardWidth: 0,
trajectories: [[]],
- face: noop,
- cursorUp: noop
- };
-
- try {
- try {
- nyanCat.draw.call(fakeThis);
- } finally {
- sandbox.restore();
- }
- } catch (err) {
- throw err; // Rethrow
- }
+ face: function() {},
+ cursorUp: function() {}
+ });
var expectedArray = [
'\u001b[0C',
@@ -218,35 +185,23 @@ describe('Nyan reporter', function() {
expect(stdout, 'to equal', expectedArray);
});
});
-
- describe("when 'tick' is true", function() {
+ describe('if tick is true', function() {
it('should draw face with expected spaces, _ and ~', function() {
- var runner = {on: noop, once: noop};
- var options = {};
- var nyanCat = new NyanCat(runner, options);
+ var nyanCat = new NyanCat({on: function() {}, once: function() {}});
nyanCat.stats = {passes: 2, pending: 1, failures: 0};
- var fakeThis = {
+
+ nyanCat.draw.call({
tick: true,
- appendRainbow: noop,
- rainbowify: noop,
- drawScoreboard: noop,
- drawRainbow: noop,
+ appendRainbow: function() {},
+ rainbowify: function() {},
+ drawScoreboard: function() {},
+ drawRainbow: function() {},
drawNyanCat: NyanCat.prototype.drawNyanCat,
scoreboardWidth: 0,
trajectories: [[]],
- face: noop,
- cursorUp: noop
- };
-
- try {
- try {
- nyanCat.draw.call(fakeThis);
- } finally {
- sandbox.restore();
- }
- } catch (err) {
- throw err; // Rethrow
- }
+ face: function() {},
+ cursorUp: function() {}
+ });
var expectedArray = [
'\u001b[0C',
@@ -267,136 +222,102 @@ describe('Nyan reporter', function() {
});
});
- describe('#cursorDown', function() {
- var stdoutWriteStub;
+ describe('cursorDown', function() {
var stdout;
+ var stdoutWrite;
beforeEach(function() {
- stdoutWriteStub = sandbox.stub(process.stdout, 'write');
- stdoutWriteStub.callsFake(function(chunk, encoding, cb) {
- stdout.push(chunk);
- });
stdout = [];
+ stdoutWrite = process.stdout.write;
+ process.stdout.write = function(string) {
+ stdout.push(string);
+ };
+ });
+
+ afterEach(function() {
+ process.stdout.write = stdoutWrite;
});
it('should write cursor down interaction with expected number', function() {
- var runner = {on: noop, once: noop};
- var options = {};
- var nyanCat = new NyanCat(runner, options);
+ var nyanCat = new NyanCat({on: function() {}, once: function() {}});
var expectedNumber = 25;
- try {
- try {
- nyanCat.cursorDown(expectedNumber);
- } finally {
- sandbox.restore();
- }
- } catch (err) {
- throw err; // Rethrow
- }
-
+ nyanCat.cursorDown(expectedNumber);
var expectedArray = ['\u001b[' + expectedNumber + 'B'];
expect(stdout, 'to equal', expectedArray);
});
});
- describe('#cursorUp', function() {
- var stdoutWriteStub;
+ describe('cursorUp', function() {
var stdout;
+ var stdoutWrite;
beforeEach(function() {
- stdoutWriteStub = sandbox.stub(process.stdout, 'write');
- stdoutWriteStub.callsFake(function(chunk, encoding, cb) {
- stdout.push(chunk);
- });
stdout = [];
+ stdoutWrite = process.stdout.write;
+ process.stdout.write = function(string, enc, callback) {
+ stdout.push(string);
+ };
+ });
+
+ afterEach(function() {
+ process.stdout.write = stdoutWrite;
});
it('should write cursor up interaction with expected number', function() {
- var runner = {on: noop, once: noop};
- var options = {};
- var nyanCat = new NyanCat(runner, options);
+ var nyanCat = new NyanCat({on: function() {}, once: function() {}});
var expectedNumber = 25;
- try {
- try {
- nyanCat.cursorUp(expectedNumber);
- } finally {
- sandbox.restore();
- }
- } catch (err) {
- throw err; // Rethrow
- }
-
+ nyanCat.cursorUp(expectedNumber);
var expectedArray = ['\u001b[' + expectedNumber + 'A'];
expect(stdout, 'to equal', expectedArray);
});
});
- describe('#rainbowify', function() {
- var useColorsStub;
-
- beforeEach(function() {
- useColorsStub = sandbox.stub(Base, 'useColors');
- });
-
- afterEach(function() {
- sandbox.restore();
- });
-
- describe("when 'useColors' is false", function() {
+ describe('rainbowify', function() {
+ describe('useColors is false', function() {
beforeEach(function() {
- useColorsStub.value(false);
+ sandbox.stub(Base, 'useColors').value(false);
});
it('should return argument string', function() {
- var runner = {on: noop, once: noop};
- var options = {};
- var nyanCat = new NyanCat(runner, options);
-
- var inputString = 'hello';
- var outputString = nyanCat.rainbowify(inputString);
- sandbox.restore();
+ var nyanCat = new NyanCat({on: function() {}, once: function() {}});
+ var expectedString = 'hello';
+ var outputString = nyanCat.rainbowify(expectedString);
- var expectedString = inputString;
expect(outputString, 'to be', expectedString);
});
});
-
- describe("when 'useColors' is true", function() {
+ describe('useColors is true', function() {
beforeEach(function() {
- useColorsStub.value(true);
+ sandbox.stub(Base, 'useColors').value(true);
});
it('should return rainbowified string from the given string and predefined codes', function() {
- var runner = {on: noop, once: noop};
- var options = {};
- var nyanCat = new NyanCat(runner, options);
-
- var inputString = 'hello';
- var colorCode = 'somecode';
- var fakeThis = {
- rainbowColors: [colorCode],
- colorIndex: 0
- };
- var outputString = nyanCat.rainbowify.call(fakeThis, inputString);
- sandbox.restore();
-
var startCode = '\u001b[38;5;';
var endCode = '\u001b[0m';
- var expectedString =
- startCode + colorCode + 'm' + inputString + endCode;
- expect(outputString, 'to be', expectedString);
+ var nyanCat = new NyanCat({on: function() {}, once: function() {}});
+ var expectedString = 'hello';
+ var colorCode = 'somecode';
+ var expectedRainbowifyString =
+ startCode + colorCode + 'm' + expectedString + endCode;
+ var outputString = nyanCat.rainbowify.call(
+ {
+ rainbowColors: [colorCode],
+ colorIndex: 0
+ },
+ expectedString
+ );
+
+ expect(outputString, 'to be', expectedRainbowifyString);
});
});
});
- describe('#appendRainbow', function() {
- describe("when 'tick' is true", function() {
- it('should set an underscore segment', function() {
- var runner = {on: noop, once: noop};
- var options = {};
- var nyanCat = new NyanCat(runner, options);
+ describe('appendRainbow', function() {
+ describe('if tick is true', function() {
+ it('should set an _ segment', function() {
+ var nyanCat = new NyanCat({on: function() {}, once: function() {}});
var expectedSegment;
var inputArray = [];
var trajectories = [inputArray, inputArray, inputArray, inputArray];
@@ -412,11 +333,8 @@ describe('Nyan reporter', function() {
expect(expectedSegment, 'to be', '_');
});
-
- it('should shift each trajectory item if its length is greater than or equal to its max width', function() {
- var runner = {on: noop, once: noop};
- var options = {};
- var nyanCat = new NyanCat(runner, options);
+ it('should shift each trajectory item, if its length is greater of equal to its max width', function() {
+ var nyanCat = new NyanCat({on: function() {}, once: function() {}});
var rainbowifyResult = 'rainbowify';
var inputArray = ['itemToShify'];
@@ -441,12 +359,9 @@ describe('Nyan reporter', function() {
expect(trajectories, 'to equal', expectedTrajectories);
});
});
-
- describe("when 'tick' is false", function() {
- it('should set a dash segment', function() {
- var runner = {on: noop, once: noop};
- var options = {};
- var nyanCat = new NyanCat(runner, options);
+ describe('if tick is false', function() {
+ it('should set an - segment', function() {
+ var nyanCat = new NyanCat({on: function() {}, once: function() {}});
var expectedSegment;
var inputArray = [];
var trajectories = [inputArray, inputArray, inputArray, inputArray];
@@ -465,45 +380,42 @@ describe('Nyan reporter', function() {
});
});
- describe('#drawScoreboard', function() {
+ describe('drawScoreboard', function() {
+ var stdoutWrite;
var stdout;
+ var cachedColor;
+ var showOutput = false;
beforeEach(function() {
- sandbox.stub(Base, 'color').callsFake(function(type, n) {
- return type + n;
- });
- var stdoutWriteStub = sandbox.stub(process.stdout, 'write');
- stdoutWriteStub.callsFake(function(chunk, encoding, cb) {
- stdout.push(chunk);
- });
stdout = [];
+ stdoutWrite = process.stdout.write;
+ process.stdout.write = function(string, enc, callback) {
+ stdout.push(string);
+ if (showOutput) {
+ stdoutWrite.call(process.stdout, string, enc, callback);
+ }
+ };
+ cachedColor = Base.color;
+ Base.color = function(type, n) {
+ return type + n;
+ };
});
- it('should write scoreboard with color set with each stat', function() {
- var runner = {on: noop, once: noop};
- var options = {};
- var nyanCat = new NyanCat(runner, options);
+ afterEach(function() {
+ process.stdout.write = stdoutWrite;
+ Base.color = cachedColor;
+ });
+ it('should write scoreboard with color set with each stat', function() {
var passes = 2;
var pending = 1;
var failures = 1;
-
- var fakeThis = {
- cursorUp: noop,
+ var nyanCat = new NyanCat({on: function() {}, once: function() {}});
+ nyanCat.drawScoreboard.call({
+ cursorUp: function() {},
stats: {passes: passes, pending: pending, failures: failures},
numberOfLines: 4
- };
-
- try {
- try {
- nyanCat.drawScoreboard.call(fakeThis);
- } finally {
- sandbox.restore();
- }
- } catch (err) {
- throw err; // Rethrow
- }
-
+ });
var expectedArray = [
' ',
'green' + passes,
@@ -520,40 +432,40 @@ describe('Nyan reporter', function() {
});
it('should call cursorUp with given numberOfLines', function() {
+ var expectedCursorArgument = null;
var expectedNumberOfLines = 1000;
- var runner = {on: noop, once: noop};
- var options = {};
- var nyanCat = new NyanCat(runner, options);
- var fakeThis = {
- cursorUp: sinon.spy(),
+ var nyanCat = new NyanCat({on: function() {}, once: function() {}});
+ nyanCat.drawScoreboard.call({
+ cursorUp: function(lines) {
+ expectedCursorArgument = lines;
+ },
stats: {passes: 0, pending: 0, failures: 0},
numberOfLines: expectedNumberOfLines
- };
-
- try {
- try {
- nyanCat.drawScoreboard.call(fakeThis);
- } finally {
- sandbox.restore();
- }
- } catch (err) {
- throw err; // Rethrow
- }
+ });
- expect(fakeThis.cursorUp.calledWith(expectedNumberOfLines), 'to be true');
+ expect(expectedCursorArgument, 'to be', expectedNumberOfLines);
});
});
- describe('#drawRainbow', function() {
+ describe('drawRainbow', function() {
+ var stdoutWrite;
var stdout;
+ var showOutput = false;
beforeEach(function() {
- var stdoutWriteStub = sandbox.stub(process.stdout, 'write');
- stdoutWriteStub.callsFake(function(chunk, encoding, cb) {
- stdout.push(chunk);
- });
stdout = [];
+ stdoutWrite = process.stdout.write;
+ process.stdout.write = function(string, enc, callback) {
+ stdout.push(string);
+ if (showOutput) {
+ stdoutWrite.call(process.stdout, string, enc, callback);
+ }
+ };
+ });
+
+ afterEach(function() {
+ process.stdout.write = stdoutWrite;
});
it('should write width, contents and newline for each trajectory', function() {
@@ -562,25 +474,13 @@ describe('Nyan reporter', function() {
var expectedContents = 'input';
var inputArray = [expectedContents];
var trajectories = [inputArray];
- var runner = {on: noop, once: noop};
- var options = {};
- var nyanCat = new NyanCat(runner, options);
- var fakeThis = {
- cursorUp: noop,
+ var nyanCat = new NyanCat({on: function() {}, once: function() {}});
+ nyanCat.drawRainbow.call({
+ cursorUp: function() {},
trajectories: trajectories,
scoreboardWidth: expectedWidth,
numberOfLines: 1
- };
-
- try {
- try {
- nyanCat.drawRainbow.call(fakeThis);
- } finally {
- sandbox.restore();
- }
- } catch (err) {
- throw err; // Rethrow
- }
+ });
var expectedArray = [
'\u001b[' + expectedWidth + 'C',
@@ -594,66 +494,41 @@ describe('Nyan reporter', function() {
var expectedCursorArgument = null;
var expectedNumberOfLines = 1000;
- var runner = {on: noop, once: noop};
- var options = {};
- var nyanCat = new NyanCat(runner, options);
- var fakeThis = {
+ var nyanCat = new NyanCat({on: function() {}, once: function() {}});
+ nyanCat.drawRainbow.call({
cursorUp: function(lines) {
expectedCursorArgument = lines;
},
trajectories: [['input']],
scoreboardWidth: 1,
numberOfLines: expectedNumberOfLines
- };
-
- try {
- try {
- nyanCat.drawRainbow.call(fakeThis);
- } finally {
- sandbox.restore();
- }
- } catch (err) {
- throw err; // Rethrow
- }
+ });
expect(expectedCursorArgument, 'to be', expectedNumberOfLines);
});
});
-
- describe('#face', function() {
- it('should expect "( x .x)" if any failures', function() {
- var runner = {on: noop, once: noop};
- var options = {};
- var nyanCat = new NyanCat(runner, options);
+ describe('face', function() {
+ it('expected face:(x .x) when "failures" at least one', function() {
+ var nyanCat = new NyanCat({on: function() {}, once: function() {}});
nyanCat.stats = {passes: 2, pending: 1, failures: 1};
-
expect(nyanCat.face(), 'to be', '( x .x)');
});
- it('should expect "( o .o)" if any pending but none failing', function() {
- var runner = {on: noop, once: noop};
- var options = {};
- var nyanCat = new NyanCat(runner, options);
+ it('expected face:(x .x) when "pending" at least one and no failing', function() {
+ var nyanCat = new NyanCat({on: function() {}, once: function() {}});
nyanCat.stats = {passes: 2, pending: 1, failures: 0};
-
expect(nyanCat.face(), 'to be', '( o .o)');
});
- it('should expect "( ^ .^)" if all passing', function() {
- var runner = {on: noop, once: noop};
- var options = {};
- var nyanCat = new NyanCat(runner, options);
+ it('expected face:(^ .^) when "passing" only', function() {
+ var nyanCat = new NyanCat({on: function() {}, once: function() {}});
nyanCat.stats = {passes: 1, pending: 0, failures: 0};
-
expect(nyanCat.face(), 'to be', '( ^ .^)');
});
- it('should expect "( - .-)" otherwise', function(done) {
- var runner = {on: noop, once: noop};
- var options = {};
- var nyanCat = new NyanCat(runner, options);
+ it('expected face:(- .-) when otherwise', function(done) {
+ var nyanCat = new NyanCat({on: function() {}, once: function() {}});
nyanCat.stats = {passes: 0, pending: 0, failures: 0};
-
expect(nyanCat.face(), 'to be', '( - .-)');
done();
});
diff --git a/test/reporters/progress.spec.js b/test/reporters/progress.spec.js
index 0d45abeaf7..cdea9c643e 100644
--- a/test/reporters/progress.spec.js
+++ b/test/reporters/progress.spec.js
@@ -1,117 +1,107 @@
'use strict';
-var sinon = require('sinon');
-var events = require('../../').Runner.constants;
-var helpers = require('./helpers');
+var sandbox = require('sinon').createSandbox();
var reporters = require('../../').reporters;
-
-var Base = reporters.Base;
var Progress = reporters.Progress;
-var createMockRunner = helpers.createMockRunner;
-var makeRunReporter = helpers.createRunReporterFunction;
+var Base = reporters.Base;
-var EVENT_RUN_BEGIN = events.EVENT_RUN_BEGIN;
-var EVENT_RUN_END = events.EVENT_RUN_END;
-var EVENT_TEST_END = events.EVENT_TEST_END;
+var createMockRunner = require('./helpers').createMockRunner;
+var makeRunReporter = require('./helpers.js').createRunReporterFunction;
describe('Progress reporter', function() {
- var sandbox;
+ var stdout;
+ var stdoutWrite;
+ var runner;
var runReporter = makeRunReporter(Progress);
- var noop = function() {};
beforeEach(function() {
- sandbox = sinon.createSandbox();
+ stdout = [];
+ stdoutWrite = process.stdout.write;
+ process.stdout.write = function(string, enc, callback) {
+ stdout.push(string);
+ stdoutWrite.call(process.stdout, string, enc, callback);
+ };
});
afterEach(function() {
sandbox.restore();
+ process.stdout.write = stdoutWrite;
});
- describe('event handlers', function() {
- describe("on 'start' event", function() {
- it('should call cursor hide', function() {
- var hideCursorStub = sandbox.stub(Base.cursor, 'hide');
+ describe('on start', function() {
+ it('should call cursor hide', function() {
+ sandbox.stub(Base.cursor, 'hide');
- var runner = createMockRunner('start', EVENT_RUN_BEGIN);
- var options = {};
- runReporter({}, runner, options);
- sandbox.restore();
+ runner = createMockRunner('start', 'start');
+ runReporter({}, runner, {});
- expect(hideCursorStub.called, 'to be true');
- });
+ expect(Base.cursor.hide, 'was called');
});
+ });
- describe("on 'test end' event", function() {
- describe('when line has changed', function() {
- it('should write expected progress of open and close options', function() {
- var crCursorStub = sandbox.stub(Base.cursor, 'CR').callsFake(noop);
- sandbox.stub(Base, 'useColors').value(false);
- sandbox.stub(Base.window, 'width').value(5);
-
- var expectedTotal = 12;
- var expectedOpen = 'OpEn';
- var expectedClose = 'cLoSe';
- var expectedIncomplete = 'iNcOmPlEtE';
- var expectedOptions = {
- open: expectedOpen,
- complete: 'cOmPlEtE',
- incomplete: expectedIncomplete,
- close: expectedClose
- };
-
- var runner = createMockRunner('test end', EVENT_TEST_END);
- runner.total = expectedTotal;
- var options = {
- reporterOptions: expectedOptions
- };
- var stdout = runReporter({}, runner, options);
- sandbox.restore();
-
- var expectedArray = [
- '\u001b[J',
- ' ' + expectedOpen,
- '',
- expectedIncomplete,
- expectedClose
- ];
-
- expect(crCursorStub.called, 'to be true');
- expect(stdout, 'to equal', expectedArray);
- });
- });
+ describe('on test end', function() {
+ describe('if line has not changed', function() {
+ it('should return and not write anything', function() {
+ sandbox.stub(Base, 'useColors').value(false);
+ sandbox.stub(Base.cursor, 'CR');
+ sandbox.stub(Base.window, 'width').value(-3);
- describe('when line has not changed', function() {
- it('should not write anything', function() {
- sandbox.stub(Base, 'useColors').value(false);
- sandbox.stub(Base.cursor, 'CR').callsFake(noop);
- sandbox.stub(Base.window, 'width').value(-3);
-
- var expectedTotal = 1;
- var runner = createMockRunner('test end', EVENT_TEST_END);
- runner.total = expectedTotal;
- var options = {};
- var stdout = runReporter({}, runner, options);
- sandbox.restore();
-
- expect(stdout, 'to equal', []);
- });
+ var expectedTotal = 1;
+ var expectedOptions = {};
+ runner = createMockRunner('test end', 'test end');
+ runner.total = expectedTotal;
+ var stdout = runReporter({}, runner, expectedOptions);
+
+ expect(stdout, 'to equal', []);
});
});
-
- describe("on 'end' event", function() {
- it('should call cursor show and epilogue', function() {
- var showCursorStub = sandbox.stub(Base.cursor, 'show');
- var fakeThis = {
- epilogue: sinon.spy()
+ describe('if line has changed', function() {
+ it('should write expected progress of open and close options', function() {
+ sandbox.stub(Base, 'useColors').value(false);
+ sandbox.stub(Base.cursor, 'CR');
+ sandbox.stub(Base.window, 'width').value(5);
+
+ var expectedTotal = 12;
+ var expectedOpen = 'OpEn';
+ var expectedClose = 'cLoSe';
+ var expectedIncomplete = 'iNcOmPlEtE';
+ var expectedOptions = {
+ open: expectedOpen,
+ complete: 'cOmPlEtE',
+ incomplete: expectedIncomplete,
+ close: expectedClose
};
- var runner = createMockRunner('end', EVENT_RUN_END);
- var options = {};
- runReporter(fakeThis, runner, options);
- sandbox.restore();
-
- expect(fakeThis.epilogue.calledOnce, 'to be true');
- expect(showCursorStub.called, 'to be true');
+ var options = {
+ reporterOptions: expectedOptions
+ };
+ runner = createMockRunner('test end', 'test end');
+ runner.total = expectedTotal;
+ var stdout = runReporter({}, runner, options);
+
+ var expectedArray = [
+ '\u001b[J',
+ ' ' + expectedOpen,
+ '',
+ expectedIncomplete,
+ expectedClose
+ ];
+ expect(Base.cursor.CR, 'was called');
+ expect(stdout, 'to equal', expectedArray);
});
});
});
+
+ describe('on end', function() {
+ it('should call cursor show and epilogue', function() {
+ var reporterStub = {epilogue: function() {}};
+ sandbox.stub(Base.cursor, 'show');
+ sandbox.stub(reporterStub, 'epilogue');
+
+ runner = createMockRunner('end', 'end');
+ runReporter(reporterStub, runner, {});
+
+ expect(reporterStub.epilogue, 'was called');
+ expect(Base.cursor.show, 'was called');
+ });
+ });
});
diff --git a/test/reporters/spec.spec.js b/test/reporters/spec.spec.js
index 608bc7f512..5f7584e33e 100644
--- a/test/reporters/spec.spec.js
+++ b/test/reporters/spec.spec.js
@@ -1,163 +1,104 @@
'use strict';
-var sinon = require('sinon');
-var events = require('../../').Runner.constants;
-var helpers = require('./helpers');
var reporters = require('../../').reporters;
-
-var Base = reporters.Base;
var Spec = reporters.Spec;
-var createMockRunner = helpers.createMockRunner;
-var makeRunReporter = helpers.createRunReporterFunction;
+var Base = reporters.Base;
-var EVENT_SUITE_BEGIN = events.EVENT_SUITE_BEGIN;
-var EVENT_TEST_FAIL = events.EVENT_TEST_FAIL;
-var EVENT_TEST_PASS = events.EVENT_TEST_PASS;
-var EVENT_TEST_PENDING = events.EVENT_TEST_PENDING;
+var createMockRunner = require('./helpers').createMockRunner;
+var makeRunReporter = require('./helpers.js').createRunReporterFunction;
describe('Spec reporter', function() {
+ var runner;
+ var options = {};
var runReporter = makeRunReporter(Spec);
+ var useColors;
var expectedTitle = 'expectedTitle';
- var noop = function() {};
- var sandbox;
beforeEach(function() {
- sandbox = sinon.createSandbox();
- sandbox.stub(Base, 'useColors').value(false);
+ useColors = Base.useColors;
+ Base.useColors = false;
});
afterEach(function() {
- sandbox.restore();
+ Base.useColors = useColors;
+ runner = undefined;
});
- describe('event handlers', function() {
- describe("on 'suite' event", function() {
- it('should return title', function() {
- var suite = {
- title: expectedTitle
- };
- var runner = createMockRunner(
- 'suite',
- EVENT_SUITE_BEGIN,
- null,
- null,
- suite
- );
- var options = {};
- var stdout = runReporter({epilogue: noop}, runner, options);
- sandbox.restore();
-
- var expectedArray = [expectedTitle + '\n'];
- expect(stdout, 'to equal', expectedArray);
- });
+ describe('on suite', function() {
+ it('should return title', function() {
+ var suite = {
+ title: expectedTitle
+ };
+ runner = createMockRunner('suite', 'suite', null, null, suite);
+ var stdout = runReporter({epilogue: function() {}}, runner, options);
+ var expectedArray = [expectedTitle + '\n'];
+ expect(stdout, 'to equal', expectedArray);
});
-
- describe("on 'pending' event", function() {
- it('should return title', function() {
- var suite = {
- title: expectedTitle
- };
- var runner = createMockRunner(
- 'pending test',
- EVENT_TEST_PENDING,
- null,
- null,
- suite
- );
- var options = {};
- var stdout = runReporter({epilogue: noop}, runner, options);
- sandbox.restore();
-
- var expectedArray = [' - ' + expectedTitle + '\n'];
- expect(stdout, 'to equal', expectedArray);
- });
+ });
+ describe('on pending', function() {
+ it('should return title', function() {
+ var suite = {
+ title: expectedTitle
+ };
+ runner = createMockRunner('pending test', 'pending', null, null, suite);
+ var stdout = runReporter({epilogue: function() {}}, runner, options);
+ var expectedArray = [' - ' + expectedTitle + '\n'];
+ expect(stdout, 'to equal', expectedArray);
});
-
- describe("on 'pass' event", function() {
- describe('when test speed is slow', function() {
- it('should return expected tick, title, and duration', function() {
- var expectedDuration = 2;
- var test = {
- title: expectedTitle,
- duration: expectedDuration,
- slow: function() {
- return 1;
- }
- };
- var runner = createMockRunner(
- 'pass',
- EVENT_TEST_PASS,
- null,
- null,
- test
- );
- var options = {};
- var stdout = runReporter({epilogue: noop}, runner, options);
- sandbox.restore();
-
- var expectedString =
- ' ' +
- Base.symbols.ok +
- ' ' +
- expectedTitle +
- ' (' +
- expectedDuration +
- 'ms)' +
- '\n';
- expect(stdout[0], 'to be', expectedString);
- });
- });
-
- describe('when test speed is fast', function() {
- it('should return expected tick, title without a duration', function() {
- var expectedDuration = 1;
- var test = {
- title: expectedTitle,
- duration: expectedDuration,
- slow: function() {
- return 2;
- }
- };
- var runner = createMockRunner(
- 'pass',
- EVENT_TEST_PASS,
- null,
- null,
- test
- );
- var options = {};
- var stdout = runReporter({epilogue: noop}, runner, options);
- sandbox.restore();
-
- var expectedString =
- ' ' + Base.symbols.ok + ' ' + expectedTitle + '\n';
- expect(stdout[0], 'to be', expectedString);
- });
+ });
+ describe('on pass', function() {
+ describe('if test speed is slow', function() {
+ it('should return expected tick, title and duration', function() {
+ var expectedDuration = 2;
+ var test = {
+ title: expectedTitle,
+ duration: expectedDuration,
+ slow: function() {
+ return 1;
+ }
+ };
+ runner = createMockRunner('pass', 'pass', null, null, test);
+ var stdout = runReporter({epilogue: function() {}}, runner, options);
+ var expectedString =
+ ' ' +
+ Base.symbols.ok +
+ ' ' +
+ expectedTitle +
+ ' (' +
+ expectedDuration +
+ 'ms)' +
+ '\n';
+ expect(stdout[0], 'to be', expectedString);
});
});
-
- describe("on 'fail' event", function() {
- it('should return title and function count', function() {
- var functionCount = 1;
+ describe('if test speed is fast', function() {
+ it('should return expected tick, title and without a duration', function() {
+ var expectedDuration = 1;
var test = {
- title: expectedTitle
+ title: expectedTitle,
+ duration: expectedDuration,
+ slow: function() {
+ return 2;
+ }
};
- var runner = createMockRunner(
- 'fail',
- EVENT_TEST_FAIL,
- null,
- null,
- test
- );
- var options = {};
- var stdout = runReporter({epilogue: noop}, runner, options);
- sandbox.restore();
-
- var expectedArray = [
- ' ' + functionCount + ') ' + expectedTitle + '\n'
- ];
- expect(stdout, 'to equal', expectedArray);
+ runner = createMockRunner('pass', 'pass', null, null, test);
+ var stdout = runReporter({epilogue: function() {}}, runner, options);
+ var expectedString =
+ ' ' + Base.symbols.ok + ' ' + expectedTitle + '\n';
+ expect(stdout[0], 'to be', expectedString);
});
});
});
+ describe('on fail', function() {
+ it('should return title and function count', function() {
+ var functionCount = 1;
+ var test = {
+ title: expectedTitle
+ };
+ runner = createMockRunner('fail', 'fail', null, null, test);
+ var stdout = runReporter({epilogue: function() {}}, runner, options);
+ var expectedArray = [' ' + functionCount + ') ' + expectedTitle + '\n'];
+ expect(stdout, 'to equal', expectedArray);
+ });
+ });
});
diff --git a/test/reporters/tap.spec.js b/test/reporters/tap.spec.js
index f3bfe8d473..c0a5419d37 100644
--- a/test/reporters/tap.spec.js
+++ b/test/reporters/tap.spec.js
@@ -1,295 +1,246 @@
'use strict';
-var events = require('../../').Runner.constants;
-var helpers = require('./helpers');
var reporters = require('../../').reporters;
-
var TAP = reporters.TAP;
-var createMockRunner = helpers.createMockRunner;
-var makeRunReporter = helpers.createRunReporterFunction;
-var EVENT_RUN_BEGIN = events.EVENT_RUN_BEGIN;
-var EVENT_RUN_END = events.EVENT_RUN_END;
-var EVENT_TEST_END = events.EVENT_TEST_END;
-var EVENT_TEST_FAIL = events.EVENT_TEST_FAIL;
-var EVENT_TEST_PASS = events.EVENT_TEST_PASS;
-var EVENT_TEST_PENDING = events.EVENT_TEST_PENDING;
+var createMockRunner = require('./helpers').createMockRunner;
+var makeRunReporter = require('./helpers.js').createRunReporterFunction;
describe('TAP reporter', function() {
+ var runner;
var runReporter = makeRunReporter(TAP);
var expectedTitle = 'some title';
var countAfterTestEnd = 2;
- var noop = function() {};
+ var test;
- function createTest() {
- return {
+ beforeEach(function() {
+ test = {
fullTitle: function() {
return expectedTitle;
},
- slow: noop
+ slow: function() {}
};
- }
+ });
- describe('TAP12 spec', function() {
- var options = {
- reporterOptions: {
- tapVersion: '12'
- }
- };
+ afterEach(function() {
+ runner = undefined;
+ test = undefined;
+ });
- describe('event handlers', function() {
- describe("on 'start' event", function() {
- var expectedSuite = 'some suite';
- var expectedTotal = 10;
- var expectedString;
- var stdout = [];
-
- before(function() {
- var runner = createMockRunner('start', EVENT_RUN_BEGIN);
- runner.suite = expectedSuite;
- runner.grepTotal = function(string) {
- expectedString = string;
- return expectedTotal;
- };
- stdout = runReporter({}, runner, options);
- });
+ describe('TAP12 spec', function() {
+ var options = {};
+
+ describe('on start', function() {
+ var expectedSuite = 'some suite';
+ var expectedTotal = 10;
+ var expectedString;
+ var stdout;
+
+ before(function() {
+ runner = createMockRunner('start', 'start');
+ runner.suite = expectedSuite;
+ runner.grepTotal = function(string) {
+ expectedString = string;
+ return expectedTotal;
+ };
+ stdout = runReporter({}, runner, options);
+ });
- it('should not write a TAP specification version', function() {
- expect(stdout, 'not to contain', 'TAP version');
- });
+ it('should not write the TAP specification version', function() {
+ expect(stdout, 'not to contain', 'TAP version');
+ });
+ it('should write the number of tests that it plans to run', function() {
+ var expectedArray = ['1..' + expectedTotal + '\n'];
+ expect(stdout, 'to equal', expectedArray);
+ expect(expectedString, 'to be', expectedSuite);
+ });
+ });
- it('should write the number of tests that it plans to run', function() {
- var expectedArray = ['1..' + expectedTotal + '\n'];
- expect(stdout, 'to equal', expectedArray);
- expect(expectedString, 'to be', expectedSuite);
- });
+ describe('on pending', function() {
+ it('should write expected message including count and title', function() {
+ runner = createMockRunner(
+ 'start test',
+ 'test end',
+ 'pending',
+ null,
+ test
+ );
+ runner.suite = '';
+ runner.grepTotal = function() {};
+
+ var stdout = runReporter({}, runner, options);
+
+ var expectedMessage =
+ 'ok ' + countAfterTestEnd + ' ' + expectedTitle + ' # SKIP -\n';
+ expect(stdout[0], 'to equal', expectedMessage);
});
+ });
+
+ describe('on pass', function() {
+ it('should write expected message including count and title', function() {
+ runner = createMockRunner('start test', 'test end', 'pass', null, test);
+ runner.suite = '';
+ runner.grepTotal = function() {};
- describe("on 'pending' event", function() {
- var stdout = [];
+ var stdout = runReporter({}, runner, options);
- before(function() {
- var test = createTest();
- var runner = createMockRunner(
- 'start test',
- EVENT_TEST_END,
- EVENT_TEST_PENDING,
+ var expectedMessage =
+ 'ok ' + countAfterTestEnd + ' ' + expectedTitle + '\n';
+ expect(stdout[0], 'to equal', expectedMessage);
+ });
+ });
+
+ describe('on fail', function() {
+ describe('if there is an error message', function() {
+ it('should write expected message and error message', function() {
+ var expectedErrorMessage = 'some error';
+ var error = {
+ message: expectedErrorMessage
+ };
+ runner = createMockRunner(
+ 'test end fail',
+ 'test end',
+ 'fail',
null,
- test
+ test,
+ error
);
+ runner.on = function(event, callback) {
+ if (event === 'test end') {
+ callback();
+ } else if (event === 'fail') {
+ callback(test, error);
+ }
+ };
runner.suite = '';
- runner.grepTotal = noop;
- stdout = runReporter({}, runner, options);
- });
+ runner.grepTotal = function() {};
- it('should write expected message including count and title', function() {
- var expectedMessage =
- 'ok ' + countAfterTestEnd + ' ' + expectedTitle + ' # SKIP -\n';
- expect(stdout[0], 'to equal', expectedMessage);
+ var stdout = runReporter({}, runner, options);
+
+ var expectedArray = [
+ 'not ok ' + countAfterTestEnd + ' ' + expectedTitle + '\n',
+ ' ' + expectedErrorMessage + '\n'
+ ];
+ expect(stdout, 'to equal', expectedArray);
});
});
- describe("on 'pass' event", function() {
- var stdout;
-
- before(function() {
- var test = createTest();
- var runner = createMockRunner(
- 'start test',
- EVENT_TEST_END,
- EVENT_TEST_PASS,
+ describe('if there is an error stack', function() {
+ it('should write expected message and stack', function() {
+ var expectedStack = 'some stack';
+ var error = {
+ stack: expectedStack
+ };
+ runner = createMockRunner(
+ 'test end fail',
+ 'test end',
+ 'fail',
null,
- test
+ test,
+ error
);
runner.suite = '';
- runner.grepTotal = noop;
- stdout = runReporter({}, runner, options);
- });
+ runner.grepTotal = function() {};
- it('should write expected message including count and title', function() {
- var expectedMessage =
- 'ok ' + countAfterTestEnd + ' ' + expectedTitle + '\n';
- expect(stdout[0], 'to equal', expectedMessage);
- });
- });
+ var stdout = runReporter({}, runner, options);
- describe("on 'fail' event", function() {
- var expectedErrorMessage = 'some error';
- var expectedStack = 'some stack';
-
- describe("when 'error' has only message", function() {
- var stdout;
-
- before(function() {
- var test = createTest();
- var error = {
- message: expectedErrorMessage
- };
- var runner = createMockRunner(
- 'test end fail',
- EVENT_TEST_END,
- EVENT_TEST_FAIL,
- null,
- test,
- error
- );
- runner.on = function(event, callback) {
- if (event === EVENT_TEST_END) {
- callback();
- } else if (event === EVENT_TEST_FAIL) {
- callback(test, error);
- }
- };
- runner.suite = '';
- runner.grepTotal = noop;
- stdout = runReporter({}, runner, options);
- });
-
- it('should write expected message and error message', function() {
- var expectedArray = [
- 'not ok ' + countAfterTestEnd + ' ' + expectedTitle + '\n',
- ' ' + expectedErrorMessage + '\n'
- ];
- expect(stdout, 'to equal', expectedArray);
- });
+ var expectedArray = [
+ 'not ok ' + countAfterTestEnd + ' ' + expectedTitle + '\n',
+ ' ' + expectedStack + '\n'
+ ];
+ expect(stdout, 'to equal', expectedArray);
});
+ });
- describe("when 'error' has only stack", function() {
- var stdout;
-
- before(function() {
- var test = createTest();
- var error = {
- stack: expectedStack
- };
- var runner = createMockRunner(
- 'test end fail',
- EVENT_TEST_END,
- EVENT_TEST_FAIL,
- null,
- test,
- error
- );
- runner.suite = '';
- runner.grepTotal = noop;
- stdout = runReporter({}, runner, options);
- });
-
- it('should write expected message and stack', function() {
- var expectedArray = [
- 'not ok ' + countAfterTestEnd + ' ' + expectedTitle + '\n',
- ' ' + expectedStack + '\n'
- ];
- expect(stdout, 'to equal', expectedArray);
- });
- });
+ describe('if there is an error stack and error message', function() {
+ it('should write expected message and stack', function() {
+ var expectedStack = 'some stack';
+ var expectedErrorMessage = 'some error';
+ var error = {
+ stack: expectedStack,
+ message: expectedErrorMessage
+ };
+ runner = createMockRunner(
+ 'test end fail',
+ 'test end',
+ 'fail',
+ null,
+ test,
+ error
+ );
+ runner.on = function(event, callback) {
+ if (event === 'test end') {
+ callback();
+ } else if (event === 'fail') {
+ callback(test, error);
+ }
+ };
+ runner.suite = '';
+ runner.grepTotal = function() {};
- describe("when 'error' has both message and stack", function() {
- var stdout;
-
- before(function() {
- var test = createTest();
- var error = {
- stack: expectedStack,
- message: expectedErrorMessage
- };
- var runner = createMockRunner(
- 'test end fail',
- EVENT_TEST_END,
- EVENT_TEST_FAIL,
- null,
- test,
- error
- );
- runner.on = function(event, callback) {
- if (event === EVENT_TEST_END) {
- callback();
- } else if (event === EVENT_TEST_FAIL) {
- callback(test, error);
- }
- };
- runner.suite = '';
- runner.grepTotal = noop;
- stdout = runReporter({}, runner, options);
- });
-
- it('should write expected message, error message, and stack', function() {
- var expectedArray = [
- 'not ok ' + countAfterTestEnd + ' ' + expectedTitle + '\n',
- ' ' + expectedErrorMessage + '\n',
- ' ' + expectedStack + '\n'
- ];
- expect(stdout, 'to equal', expectedArray);
- });
- });
+ var stdout = runReporter({}, runner, options);
- describe("when 'error' has neither message nor stack", function() {
- var stdout;
-
- before(function() {
- var test = createTest();
- var error = {};
- var runner = createMockRunner(
- 'test end fail',
- EVENT_TEST_END,
- EVENT_TEST_FAIL,
- null,
- test,
- error
- );
- runner.on = runner.once = function(event, callback) {
- if (event === EVENT_TEST_END) {
- callback();
- } else if (event === EVENT_TEST_FAIL) {
- callback(test, error);
- }
- };
- runner.suite = '';
- runner.grepTotal = noop;
- stdout = runReporter({}, runner, options);
- });
-
- it('should write expected message only', function() {
- var expectedArray = [
- 'not ok ' + countAfterTestEnd + ' ' + expectedTitle + '\n'
- ];
- expect(stdout, 'to equal', expectedArray);
- });
+ var expectedArray = [
+ 'not ok ' + countAfterTestEnd + ' ' + expectedTitle + '\n',
+ ' ' + expectedErrorMessage + '\n',
+ ' ' + expectedStack + '\n'
+ ];
+ expect(stdout, 'to equal', expectedArray);
});
});
- describe("on 'end' event", function() {
- var stdout;
-
- before(function() {
- var test = createTest();
- var runner = createMockRunner(
- 'fail end pass',
- EVENT_TEST_FAIL,
- EVENT_RUN_END,
- EVENT_TEST_PASS,
- test
+ describe('if there is no error stack or error message', function() {
+ it('should write expected message only', function() {
+ var error = {};
+ runner = createMockRunner(
+ 'test end fail',
+ 'test end',
+ 'fail',
+ null,
+ test,
+ error
);
+ runner.on = runner.once = function(event, callback) {
+ if (event === 'test end') {
+ callback();
+ } else if (event === 'fail') {
+ callback(test, error);
+ }
+ };
runner.suite = '';
- runner.grepTotal = noop;
- stdout = runReporter({}, runner, options);
- });
+ runner.grepTotal = function() {};
+
+ var stdout = runReporter({}, runner, options);
- it('should write total tests, passes, and failures', function() {
- var numberOfPasses = 1;
- var numberOfFails = 1;
- var totalTests = numberOfPasses + numberOfFails;
var expectedArray = [
- 'ok ' + numberOfPasses + ' ' + expectedTitle + '\n',
- 'not ok ' + numberOfFails + ' ' + expectedTitle + '\n',
- '# tests ' + totalTests + '\n',
- '# pass ' + numberOfPasses + '\n',
- '# fail ' + numberOfFails + '\n'
+ 'not ok ' + countAfterTestEnd + ' ' + expectedTitle + '\n'
];
expect(stdout, 'to equal', expectedArray);
});
});
});
+
+ describe('on end', function() {
+ it('should write total tests, passes and failures', function() {
+ var numberOfPasses = 1;
+ var numberOfFails = 1;
+ runner = createMockRunner('fail end pass', 'fail', 'end', 'pass', test);
+ runner.suite = '';
+ runner.grepTotal = function() {};
+
+ var stdout = runReporter({}, runner, options);
+
+ var totalTests = numberOfPasses + numberOfFails;
+ var expectedArray = [
+ 'ok ' + numberOfPasses + ' ' + expectedTitle + '\n',
+ 'not ok ' + numberOfFails + ' ' + expectedTitle + '\n',
+ '# tests ' + totalTests + '\n',
+ '# pass ' + numberOfPasses + '\n',
+ '# fail ' + numberOfFails + '\n'
+ ];
+ expect(stdout, 'to equal', expectedArray);
+ });
+ });
});
describe('TAP13 spec', function() {
@@ -299,270 +250,229 @@ describe('TAP reporter', function() {
}
};
- describe('event handlers', function() {
- describe("on 'start' event", function() {
- var expectedSuite = 'some suite';
- var expectedTotal = 10;
- var expectedString;
- var stdout;
-
- before(function() {
- var runner = createMockRunner('start', EVENT_RUN_BEGIN);
- runner.suite = expectedSuite;
- runner.grepTotal = function(string) {
- expectedString = string;
- return expectedTotal;
- };
- stdout = runReporter({}, runner, options);
- });
+ describe('on start', function() {
+ var expectedSuite = 'some suite';
+ var expectedTotal = 10;
+ var expectedString;
+ var stdout;
+
+ before(function() {
+ runner = createMockRunner('start', 'start');
+ runner.suite = expectedSuite;
+ runner.grepTotal = function(string) {
+ expectedString = string;
+ return expectedTotal;
+ };
+
+ stdout = runReporter({}, runner, options);
+ });
- it('should write the TAP specification version', function() {
- var tapVersion = options.reporterOptions.tapVersion;
- var expectedFirstLine = 'TAP version ' + tapVersion + '\n';
- expect(stdout[0], 'to equal', expectedFirstLine);
- });
+ it('should write the TAP specification version', function() {
+ var tapVersion = options.reporterOptions.tapVersion;
+ var expectedFirstLine = 'TAP version ' + tapVersion + '\n';
+ expect(stdout[0], 'to equal', expectedFirstLine);
+ });
+ it('should write the number of tests that it plans to run', function() {
+ var expectedSecondLine = '1..' + expectedTotal + '\n';
+ expect(stdout[1], 'to equal', expectedSecondLine);
+ expect(expectedString, 'to be', expectedSuite);
+ });
+ });
- it('should write the number of tests that it plans to run', function() {
- var expectedSecondLine = '1..' + expectedTotal + '\n';
- expect(stdout[1], 'to equal', expectedSecondLine);
- expect(expectedString, 'to be', expectedSuite);
- });
+ describe('on pending', function() {
+ it('should write expected message including count and title', function() {
+ runner = createMockRunner(
+ 'start test',
+ 'test end',
+ 'pending',
+ null,
+ test
+ );
+ runner.suite = '';
+ runner.grepTotal = function() {};
+
+ var stdout = runReporter({}, runner, options);
+
+ var expectedMessage =
+ 'ok ' + countAfterTestEnd + ' ' + expectedTitle + ' # SKIP -\n';
+ expect(stdout[0], 'to equal', expectedMessage);
});
+ });
+
+ describe('on pass', function() {
+ it('should write expected message including count and title', function() {
+ runner = createMockRunner('start test', 'test end', 'pass', null, test);
+ runner.suite = '';
+ runner.grepTotal = function() {};
- describe("on 'pending' event", function() {
- var stdout;
+ var stdout = runReporter({}, runner, options);
- before(function() {
- var test = createTest();
- var runner = createMockRunner(
- 'start test',
- EVENT_TEST_END,
- EVENT_TEST_PENDING,
+ var expectedMessage =
+ 'ok ' + countAfterTestEnd + ' ' + expectedTitle + '\n';
+ expect(stdout[0], 'to equal', expectedMessage);
+ });
+ });
+
+ describe('on fail', function() {
+ describe('if there is an error message', function() {
+ it('should write expected message and error message', function() {
+ var expectedErrorMessage = 'some error';
+ var error = {
+ message: expectedErrorMessage
+ };
+ runner = createMockRunner(
+ 'test end fail',
+ 'test end',
+ 'fail',
null,
- test
+ test,
+ error
);
+ runner.on = function(event, callback) {
+ if (event === 'test end') {
+ callback();
+ } else if (event === 'fail') {
+ callback(test, error);
+ }
+ };
runner.suite = '';
- runner.grepTotal = noop;
- stdout = runReporter({}, runner, options);
- });
+ runner.grepTotal = function() {};
+
+ var stdout = runReporter({}, runner, options);
- it('should write expected message including count and title', function() {
- var expectedMessage =
- 'ok ' + countAfterTestEnd + ' ' + expectedTitle + ' # SKIP -\n';
- expect(stdout[0], 'to equal', expectedMessage);
+ var expectedArray = [
+ 'not ok ' + countAfterTestEnd + ' ' + expectedTitle + '\n',
+ ' ---\n',
+ ' message: |-\n',
+ ' ' + expectedErrorMessage + '\n',
+ ' ...\n'
+ ];
+ expect(stdout, 'to equal', expectedArray);
});
});
- describe("on 'pass' event", function() {
- var stdout;
-
- before(function() {
- var test = createTest();
- var runner = createMockRunner(
- 'start test',
- EVENT_TEST_END,
- EVENT_TEST_PASS,
+ describe('if there is an error stack', function() {
+ it('should write expected message and stack', function() {
+ var expectedStack = 'some stack';
+ var error = {
+ stack: expectedStack
+ };
+ runner = createMockRunner(
+ 'test end fail',
+ 'test end',
+ 'fail',
null,
- test
+ test,
+ error
);
runner.suite = '';
- runner.grepTotal = noop;
- stdout = runReporter({}, runner, options);
- });
+ runner.grepTotal = function() {};
- it('should write expected message including count and title', function() {
- var expectedMessage =
- 'ok ' + countAfterTestEnd + ' ' + expectedTitle + '\n';
- expect(stdout[0], 'to equal', expectedMessage);
- });
- });
+ var stdout = runReporter({}, runner, options);
- describe("on 'fail' event", function() {
- var expectedErrorMessage = 'some error';
- var expectedStack = 'some stack';
-
- describe("when 'error' has only message", function() {
- var stdout;
-
- before(function() {
- var test = createTest();
- var error = {
- message: expectedErrorMessage
- };
- var runner = createMockRunner(
- 'test end fail',
- EVENT_TEST_END,
- EVENT_TEST_FAIL,
- null,
- test,
- error
- );
- runner.on = function(event, callback) {
- if (event === EVENT_TEST_END) {
- callback();
- } else if (event === EVENT_TEST_FAIL) {
- callback(test, error);
- }
- };
- runner.suite = '';
- runner.grepTotal = noop;
- stdout = runReporter({}, runner, options);
- });
-
- it('should write expected message and error message', function() {
- var expectedArray = [
- 'not ok ' + countAfterTestEnd + ' ' + expectedTitle + '\n',
- ' ---\n',
- ' message: |-\n',
- ' ' + expectedErrorMessage + '\n',
- ' ...\n'
- ];
- expect(stdout, 'to equal', expectedArray);
- });
+ var expectedArray = [
+ 'not ok ' + countAfterTestEnd + ' ' + expectedTitle + '\n',
+ ' ---\n',
+ ' stack: |-\n',
+ ' ' + expectedStack + '\n',
+ ' ...\n'
+ ];
+ expect(stdout, 'to equal', expectedArray);
});
+ });
- describe("when 'error' has only stack", function() {
- var stdout;
-
- before(function() {
- var test = createTest();
- var error = {
- stack: expectedStack
- };
- var runner = createMockRunner(
- 'test end fail',
- EVENT_TEST_END,
- EVENT_TEST_FAIL,
- null,
- test,
- error
- );
- runner.suite = '';
- runner.grepTotal = noop;
- stdout = runReporter({}, runner, options);
- });
-
- it('should write expected message and stack', function() {
- var expectedArray = [
- 'not ok ' + countAfterTestEnd + ' ' + expectedTitle + '\n',
- ' ---\n',
- ' stack: |-\n',
- ' ' + expectedStack + '\n',
- ' ...\n'
- ];
- expect(stdout, 'to equal', expectedArray);
- });
- });
+ describe('if there is an error stack and error message', function() {
+ it('should write expected message and stack', function() {
+ var expectedStack = 'some stack';
+ var expectedErrorMessage = 'some error';
+ var error = {
+ stack: expectedStack,
+ message: expectedErrorMessage
+ };
+ runner = createMockRunner(
+ 'test end fail',
+ 'test end',
+ 'fail',
+ null,
+ test,
+ error
+ );
+ runner.on = function(event, callback) {
+ if (event === 'test end') {
+ callback();
+ } else if (event === 'fail') {
+ callback(test, error);
+ }
+ };
+ runner.suite = '';
+ runner.grepTotal = function() {};
- describe("when 'error' has both message and stack", function() {
- var stdout;
-
- before(function() {
- var test = createTest();
- var error = {
- stack: expectedStack,
- message: expectedErrorMessage
- };
- var runner = createMockRunner(
- 'test end fail',
- EVENT_TEST_END,
- EVENT_TEST_FAIL,
- null,
- test,
- error
- );
- runner.on = function(event, callback) {
- if (event === EVENT_TEST_END) {
- callback();
- } else if (event === EVENT_TEST_FAIL) {
- callback(test, error);
- }
- };
- runner.suite = '';
- runner.grepTotal = noop;
- stdout = runReporter({}, runner, options);
- });
-
- it('should write expected message, error message, and stack', function() {
- var expectedArray = [
- 'not ok ' + countAfterTestEnd + ' ' + expectedTitle + '\n',
- ' ---\n',
- ' message: |-\n',
- ' ' + expectedErrorMessage + '\n',
- ' stack: |-\n',
- ' ' + expectedStack + '\n',
- ' ...\n'
- ];
- expect(stdout, 'to equal', expectedArray);
- });
- });
+ var stdout = runReporter({}, runner, options);
- describe("when 'error' has neither message nor stack", function() {
- var stdout;
-
- before(function() {
- var test = createTest();
- var error = {};
- var runner = createMockRunner(
- 'test end fail',
- EVENT_TEST_END,
- EVENT_TEST_FAIL,
- null,
- test,
- error
- );
- runner.on = runner.once = function(event, callback) {
- if (event === EVENT_TEST_END) {
- callback();
- } else if (event === EVENT_TEST_FAIL) {
- callback(test, error);
- }
- };
- runner.suite = '';
- runner.grepTotal = noop;
- stdout = runReporter({}, runner, options);
- });
-
- it('should write expected message only', function() {
- var expectedArray = [
- 'not ok ' + countAfterTestEnd + ' ' + expectedTitle + '\n'
- ];
- expect(stdout, 'to equal', expectedArray);
- });
+ var expectedArray = [
+ 'not ok ' + countAfterTestEnd + ' ' + expectedTitle + '\n',
+ ' ---\n',
+ ' message: |-\n',
+ ' ' + expectedErrorMessage + '\n',
+ ' stack: |-\n',
+ ' ' + expectedStack + '\n',
+ ' ...\n'
+ ];
+ expect(stdout, 'to equal', expectedArray);
});
});
- describe("on 'end' event", function() {
- var stdout;
-
- before(function() {
- var test = createTest();
- var runner = createMockRunner(
- 'fail end pass',
- EVENT_TEST_FAIL,
- EVENT_RUN_END,
- EVENT_TEST_PASS,
- test
+ describe('if there is no error stack or error message', function() {
+ it('should write expected message only', function() {
+ var error = {};
+ runner = createMockRunner(
+ 'test end fail',
+ 'test end',
+ 'fail',
+ null,
+ test,
+ error
);
+ runner.on = runner.once = function(event, callback) {
+ if (event === 'test end') {
+ callback();
+ } else if (event === 'fail') {
+ callback(test, error);
+ }
+ };
runner.suite = '';
- runner.grepTotal = noop;
- stdout = runReporter({}, runner, options);
- });
+ runner.grepTotal = function() {};
+
+ var stdout = runReporter({}, runner, options);
- it('should write total tests, passes, and failures', function() {
- var numberOfPasses = 1;
- var numberOfFails = 1;
- var totalTests = numberOfPasses + numberOfFails;
var expectedArray = [
- 'ok ' + numberOfPasses + ' ' + expectedTitle + '\n',
- 'not ok ' + numberOfFails + ' ' + expectedTitle + '\n',
- '# tests ' + totalTests + '\n',
- '# pass ' + numberOfPasses + '\n',
- '# fail ' + numberOfFails + '\n'
+ 'not ok ' + countAfterTestEnd + ' ' + expectedTitle + '\n'
];
expect(stdout, 'to equal', expectedArray);
});
});
});
+
+ describe('on end', function() {
+ it('should write total tests, passes and failures', function() {
+ var numberOfPasses = 1;
+ var numberOfFails = 1;
+ runner = createMockRunner('fail end pass', 'fail', 'end', 'pass', test);
+ runner.suite = '';
+ runner.grepTotal = function() {};
+
+ var stdout = runReporter({}, runner, options);
+
+ var totalTests = numberOfPasses + numberOfFails;
+ var expectedArray = [
+ 'ok ' + numberOfPasses + ' ' + expectedTitle + '\n',
+ 'not ok ' + numberOfFails + ' ' + expectedTitle + '\n',
+ '# tests ' + totalTests + '\n',
+ '# pass ' + numberOfPasses + '\n',
+ '# fail ' + numberOfFails + '\n'
+ ];
+ expect(stdout, 'to equal', expectedArray);
+ });
+ });
});
});
diff --git a/test/reporters/xunit.spec.js b/test/reporters/xunit.spec.js
index 26fce4a1c4..35555968a1 100644
--- a/test/reporters/xunit.spec.js
+++ b/test/reporters/xunit.spec.js
@@ -1,34 +1,25 @@
'use strict';
-var EventEmitter = require('events').EventEmitter;
var fs = require('fs');
-var os = require('os');
-var path = require('path');
var mkdirp = require('mkdirp');
-var rimraf = require('rimraf');
-var sinon = require('sinon');
+var path = require('path');
+var assert = require('assert');
var createStatsCollector = require('../../lib/stats-collector');
-var events = require('../../').Runner.constants;
+var EventEmitter = require('events').EventEmitter;
var reporters = require('../../').reporters;
-var states = require('../../').Runnable.constants;
-
-var Base = reporters.Base;
+var constants = require('../../lib/runnable').constants;
+var STATE_FAILED = constants.STATE_FAILED;
+var STATE_PASSED = constants.STATE_PASSED;
var XUnit = reporters.XUnit;
-var EVENT_RUN_END = events.EVENT_RUN_END;
-var EVENT_TEST_END = events.EVENT_TEST_END;
-var EVENT_TEST_FAIL = events.EVENT_TEST_FAIL;
-var EVENT_TEST_PASS = events.EVENT_TEST_PASS;
-var EVENT_TEST_PENDING = events.EVENT_TEST_PENDING;
-
-var STATE_FAILED = states.STATE_FAILED;
-var STATE_PASSED = states.STATE_PASSED;
-
describe('XUnit reporter', function() {
- var sandbox;
+ var stdout;
+ var stdoutWrite;
+ // the runner parameter of the reporter
var runner;
- var noop = function() {};
+ var callbackArgument = null;
+ var expectedFailure = 'some-failures';
var expectedLine = 'some-line';
var expectedClassName = 'fullTitle';
var expectedTitle = 'some title';
@@ -36,286 +27,192 @@ describe('XUnit reporter', function() {
var expectedDiff =
'\n + expected - actual\n\n -foo\n +bar\n ';
var expectedStack = 'some-stack';
+ var expectedWrite = null;
beforeEach(function() {
- runner = {on: noop, once: noop};
+ stdout = [];
+ runner = {on: function() {}, once: function() {}};
createStatsCollector(runner);
});
- describe("when 'reporterOptions.output' is provided", function() {
- var expectedOutput = path.join(path.sep, 'path', 'to', 'some-output');
+ describe('if reporter options output is given', function() {
+ var expectedOutput = 'some-output';
var options = {
reporterOptions: {
output: expectedOutput
}
};
-
- describe('when fileStream can be created', function() {
- var mkdirpSync;
- var fsCreateWriteStream;
-
- beforeEach(function() {
- sandbox = sinon.createSandbox();
- mkdirpSync = sandbox.stub(mkdirp, 'sync');
- fsCreateWriteStream = sandbox.stub(fs, 'createWriteStream');
+ describe('but it cant create a write stream', function() {
+ it('should throw expected error', function() {
+ var fsCreateWriteStream = fs.createWriteStream;
+ fs.createWriteStream = false;
+
+ var boundXUnit = XUnit.bind({}, runner, options);
+ expect(boundXUnit, 'to throw', 'file output not supported in browser');
+ fs.createWriteStream = fsCreateWriteStream;
});
+ });
+ describe('and it can create a write stream', function() {
+ it('should locate the output dir, create it, then assign as fileStream', function() {
+ var expectedDirectory;
+ var mkdirpSync = mkdirp.sync;
+ var pathDirname = path.dirname;
+ var fsCreateWriteStream = fs.createWriteStream;
+ mkdirp.sync = function(directory) {
+ expectedDirectory = directory;
+ };
+ path.dirname = function(location) {
+ return location;
+ };
+ fs.createWriteStream = function(streamDetails) {
+ return streamDetails;
+ };
- it('should open given file for writing, recursively creating directories in pathname', function() {
- var fakeThis = {
+ var contextVariables = {
fileStream: null
};
- XUnit.call(fakeThis, runner, options);
+ XUnit.call(contextVariables, runner, options);
- var expectedDirectory = path.dirname(expectedOutput);
- expect(mkdirpSync.calledWith(expectedDirectory), 'to be true');
- expect(fsCreateWriteStream.calledWith(expectedOutput), 'to be true');
- });
+ expect(expectedDirectory, 'to be', expectedOutput);
+ expect(contextVariables.fileStream, 'to be', expectedOutput);
- afterEach(function() {
- sandbox.restore();
+ fs.createWriteStream = fsCreateWriteStream;
+ mkdirp.sync = mkdirpSync;
+ path.dirname = pathDirname;
});
});
+ });
- describe('when fileStream cannot be created', function() {
- describe('when given an invalid pathname', function() {
- var tmpdir;
- var invalidPath;
-
- beforeEach(function createInvalidPath() {
- tmpdir = fs.mkdtempSync(path.join(os.tmpdir(), 'mocha-test-'));
+ describe("on 'pending', 'pass' and 'fail' events", function() {
+ it("should add test to tests called on 'end' event", function() {
+ var pendingTest = {
+ name: 'pending',
+ slow: function() {}
+ };
+ var failTest = {
+ name: 'fail',
+ slow: function() {}
+ };
+ var passTest = {
+ name: 'pass',
+ slow: function() {}
+ };
+ runner.on = runner.once = function(event, callback) {
+ if (event === 'pending') {
+ callback(pendingTest);
+ }
+ if (event === 'pass') {
+ callback(passTest);
+ }
+ if (event === 'fail') {
+ callback(failTest);
+ }
+ if (event === 'end') {
+ callback();
+ }
+ };
- function touch(filename) {
- fs.closeSync(fs.openSync(filename, 'w'));
+ var calledTests = [];
+ XUnit.call(
+ {
+ write: function() {},
+ test: function(test) {
+ calledTests.push(test);
}
+ },
+ runner
+ );
- // Create path where file 'some-file' used as directory
- invalidPath = path.join(
- tmpdir,
- 'some-file',
- path.basename(expectedOutput)
- );
- touch(path.dirname(invalidPath));
- });
-
- it('should throw system error', function() {
- var options = {
- reporterOptions: {
- output: invalidPath
- }
- };
- var boundXUnit = XUnit.bind({}, runner, options);
- expect(
- boundXUnit,
- 'to throw',
- expect.it('to be an', Error).and('to satisfy', {
- syscall: 'mkdir',
- code: 'EEXIST',
- path: path.dirname(invalidPath)
- })
- );
- });
-
- afterEach(function() {
- rimraf.sync(tmpdir);
- });
- });
-
- describe('when run in browser', function() {
- beforeEach(function() {
- sandbox = sinon.createSandbox();
- sandbox.stub(fs, 'createWriteStream').value(false);
- });
-
- it('should throw unsupported error', function() {
- var boundXUnit = XUnit.bind({}, runner, options);
- expect(
- boundXUnit,
- 'to throw',
- 'file output not supported in browser'
- );
- });
-
- afterEach(function() {
- sandbox.restore();
- });
- });
+ var expectedCalledTests = [pendingTest, passTest, failTest];
+ expect(calledTests, 'to equal', expectedCalledTests);
});
});
- describe('event handlers', function() {
- describe("on 'pending', 'pass' and 'fail' events", function() {
- it("should add test to tests called on 'end' event", function() {
- var pendingTest = {
- name: 'pending',
- slow: noop
- };
- var failTest = {
- name: 'fail',
- slow: noop
- };
- var passTest = {
- name: 'pass',
- slow: noop
+ describe('done', function() {
+ describe('if fileStream is truthy', function() {
+ it('should run callback with failure inside streams end', function() {
+ var xunit = new XUnit({on: function() {}, once: function() {}});
+ var callback = function(failures) {
+ callbackArgument = failures;
};
- runner.on = runner.once = function(event, callback) {
- if (event === EVENT_TEST_PENDING) {
- callback(pendingTest);
- } else if (event === EVENT_TEST_PASS) {
- callback(passTest);
- } else if (event === EVENT_TEST_FAIL) {
- callback(failTest);
- } else if (event === EVENT_RUN_END) {
+ var calledEnd = false;
+ var fileStream = {
+ end: function(callback) {
+ calledEnd = true;
callback();
}
};
+ xunit.done.call({fileStream: fileStream}, expectedFailure, callback);
- var calledTests = [];
- var fakeThis = {
- write: noop,
- test: function(test) {
- calledTests.push(test);
- }
+ expect(calledEnd, 'to be', true);
+ expect(callbackArgument, 'to be', expectedFailure);
+ });
+ });
+ describe('if fileStream is falsy', function() {
+ it('should run callback with failure', function() {
+ var xunit = new XUnit({on: function() {}, once: function() {}});
+ var callback = function(failures) {
+ callbackArgument = failures;
};
- XUnit.call(fakeThis, runner);
+ xunit.done.call({fileStream: false}, expectedFailure, callback);
- var expectedCalledTests = [pendingTest, passTest, failTest];
- expect(calledTests, 'to equal', expectedCalledTests);
+ expect(callbackArgument, 'to be', expectedFailure);
});
});
});
- describe('#done', function() {
- var xunit;
- var options = {
- reporterOptions: {}
- };
- var expectedNFailures = 13;
- var callback;
-
- beforeEach(function() {
- sandbox = sinon.createSandbox();
- callback = sandbox.spy();
- });
-
- afterEach(function() {
- callback = null;
- xunit = null;
- sandbox.restore();
- });
-
- describe('when output directed to file', function() {
- var fakeThis;
-
- beforeEach(function() {
- xunit = new XUnit(runner, options);
-
- fakeThis = {
- fileStream: {
- end: sinon.stub().callsFake(function(chunk, encoding, cb) {
- if (typeof arguments[0] === 'function') {
- cb = arguments[0];
- }
- cb();
- }),
- write: function(chunk, encoding, cb) {}
+ describe('write', function() {
+ describe('if fileStream is truthy', function() {
+ it('should call fileStream write with line and new line', function() {
+ var xunit = new XUnit({on: function() {}, once: function() {}});
+ var fileStream = {
+ write: function(write) {
+ expectedWrite = write;
}
};
- });
-
- it("should run completion callback via 'fileStream.end'", function() {
- xunit.done.call(fakeThis, expectedNFailures, callback);
-
- expect(fakeThis.fileStream.end.calledOnce, 'to be true');
- expect(callback.calledOnce, 'to be true');
- expect(callback.calledWith(expectedNFailures), 'to be true');
- });
- });
-
- describe('when output directed to stdout (or console)', function() {
- var fakeThis;
+ xunit.write.call({fileStream: fileStream}, expectedLine);
- beforeEach(function() {
- xunit = new XUnit(runner, options);
- fakeThis = {};
- });
-
- it('should run completion callback', function() {
- xunit.done.call(fakeThis, expectedNFailures, callback);
-
- expect(callback.calledOnce, 'to be true');
- expect(callback.calledWith(expectedNFailures), 'to be true');
+ expect(expectedWrite, 'to be', expectedLine + '\n');
});
});
- });
-
- describe('#write', function() {
- // :TODO: Method should be named 'writeln', not 'write'
- describe('when output directed to file', function() {
- var fileStream = {
- write: sinon.spy()
- };
+ describe('if fileStream is falsy and stdout exists', function() {
+ it('should call write with line and new line', function() {
+ stdoutWrite = process.stdout.write;
+ process.stdout.write = function(string) {
+ stdout.push(string);
+ };
- it("should call 'fileStream.write' with line and newline", function() {
- var xunit = new XUnit(runner);
- var fakeThis = {fileStream: fileStream};
- xunit.write.call(fakeThis, expectedLine);
+ var xunit = new XUnit({on: function() {}, once: function() {}});
+ xunit.write.call({fileStream: false}, expectedLine);
- expect(fileStream.write.calledWith(expectedLine + '\n'), 'to be true');
- });
- });
+ process.stdout.write = stdoutWrite;
- describe('when output directed to stdout', function() {
- it("should call 'process.stdout.write' with line and newline", function() {
- var xunit = new XUnit(runner);
- var fakeThis = {fileStream: false};
- var stdoutWriteStub = sinon.stub(process.stdout, 'write');
- xunit.write.call(fakeThis, expectedLine);
- stdoutWriteStub.restore();
-
- expect(stdoutWriteStub.calledWith(expectedLine + '\n'), 'to be true');
+ expect(stdout[0], 'to be', expectedLine + '\n');
});
});
-
- describe('when output directed to console', function() {
- it("should call 'console.log' with line", function() {
- // :TODO: XUnit needs a trivially testable means to force console.log()
- var realProcess = process;
+ describe('if fileStream is falsy and stdout does not exist', function() {
+ it('should call write with line', function() {
+ stdoutWrite = process;
process = false; // eslint-disable-line no-native-reassign, no-global-assign
+ var cachedConsoleLog = console.log;
+ console.log = function(string) {
+ stdout.push(string);
+ };
- var xunit = new XUnit(runner);
- var fakeThis = {fileStream: false};
- var consoleLogStub = sinon.stub(console, 'log');
- xunit.write.call(fakeThis, expectedLine);
- consoleLogStub.restore();
-
- process = realProcess; // eslint-disable-line no-native-reassign, no-global-assign
+ var xunit = new XUnit({on: function() {}, once: function() {}});
+ xunit.write.call({fileStream: false}, expectedLine);
- expect(consoleLogStub.calledWith(expectedLine), 'to be true');
+ console.log = cachedConsoleLog;
+ process = stdoutWrite; // eslint-disable-line no-native-reassign, no-global-assign
+ expect(stdout[0], 'to be', expectedLine);
});
});
});
- describe('#test', function() {
- var expectedWrite;
- var fakeThis = {
- write: function(str) {
- expectedWrite = str;
- }
- };
-
- beforeEach(function() {
- sandbox = sinon.createSandbox();
- sandbox.stub(Base, 'useColors').value(false);
- });
-
- afterEach(function() {
- sandbox.restore();
- expectedWrite = null;
- });
-
+ describe('test', function() {
describe('on test failure', function() {
it('should write expected tag with error details', function() {
- var xunit = new XUnit(runner);
+ var xunit = new XUnit({on: function() {}, once: function() {}});
var expectedTest = {
state: STATE_FAILED,
title: expectedTitle,
@@ -332,9 +229,14 @@ describe('XUnit reporter', function() {
stack: expectedStack
}
};
-
- xunit.test.call(fakeThis, expectedTest);
- sandbox.restore();
+ xunit.test.call(
+ {
+ write: function(string) {
+ expectedWrite = string;
+ }
+ },
+ expectedTest
+ );
var expectedTag =
'';
+
expect(expectedWrite, 'to be', expectedTag);
});
});
-
describe('on test in any other state', function() {
it('should write expected tag', function() {
- var xunit = new XUnit(runner);
+ var xunit = new XUnit({on: function() {}, once: function() {}});
+
var expectedTest = {
isPending: function() {
return false;
@@ -396,9 +305,14 @@ describe('XUnit reporter', function() {
},
duration: false
};
-
- xunit.test.call(fakeThis, expectedTest);
- sandbox.restore();
+ xunit.test.call(
+ {
+ write: function(string) {
+ expectedWrite = string;
+ }
+ },
+ expectedTest
+ );
var expectedTag =
'';
+
expect(expectedWrite, 'to be', expectedTag);
});
});
-
it('should write expected summary statistics', function() {
- var numTests = 0;
- var numPass = 0;
- var numFail = 0;
+ var count = 0;
var simpleError = {
actual: 'foo',
expected: 'bar',
@@ -421,14 +333,8 @@ describe('XUnit reporter', function() {
stack: expectedStack
};
var generateTest = function(passed) {
- numTests++;
- if (passed) {
- numPass++;
- } else {
- numFail++;
- }
- return {
- title: [expectedTitle, numTests].join(': '),
+ var t = {
+ title: expectedTitle + count,
state: passed ? STATE_PASSED : STATE_FAILED,
isPending: function() {
return false;
@@ -443,36 +349,26 @@ describe('XUnit reporter', function() {
},
duration: 1000
};
+ return t;
};
var runner = new EventEmitter();
createStatsCollector(runner);
var xunit = new XUnit(runner);
expectedWrite = '';
- sandbox.stub(xunit, 'write').callsFake(function(str) {
- expectedWrite += str;
- });
+ xunit.write = function(string) {
+ expectedWrite += string;
+ };
// 3 tests, no failures (i.e. tests that could not run), and 2 errors
- runner.emit(EVENT_TEST_PASS, generateTest(true));
- runner.emit(EVENT_TEST_END);
- runner.emit(EVENT_TEST_FAIL, generateTest(false), simpleError);
- runner.emit(EVENT_TEST_END);
- runner.emit(EVENT_TEST_FAIL, generateTest(false), simpleError);
- runner.emit(EVENT_TEST_END);
- runner.emit(EVENT_RUN_END);
-
- sandbox.restore();
-
- var expectedNumPass = 1;
- var expectedNumFail = 2;
- var expectedNumTests = 3;
-
- expect(expectedNumPass, 'to be', numPass);
- expect(expectedNumFail, 'to be', numFail);
- expect(expectedNumTests, 'to be', numTests);
+ runner.emit('test end');
+ runner.emit('pass', generateTest(true));
+ runner.emit('test end');
+ runner.emit('fail', generateTest(false), simpleError);
+ runner.emit('test end');
+ runner.emit('fail', generateTest(false), simpleError);
+ runner.emit('end');
- // :NOTE: Mocha test "fail" is an XUnit "error"
var expectedTag =
'= 0,
+ 'it should contain the text "Mocha Tests"'
+ );
});
- it('should use default name otherwise', function() {
- var defaultSuiteName = 'Mocha Tests';
+ it('should use the custom suite name as the suite name when provided in the reporter options', function() {
+ // arrange
var options = {
- reporterOptions: {}
+ reporterOptions: {
+ // this time, with a custom suite name
+ suiteName: 'Mocha Is Great!'
+ }
};
var xunit = new XUnit(runner, options);
xunit.fileStream = fileStream;
- // Trigger end event to force XUnit reporter to write its output
- events[EVENT_RUN_END]();
+ // act (trigger the end event to force xunit reporter to write the output)
+ events['end']();
- expect(lines[0], 'to contain', defaultSuiteName);
+ // assert
+ assert(
+ lines[0].indexOf('