diff options
Diffstat (limited to 'node_modules/@jest/reporters/build/DefaultReporter.js')
| -rw-r--r-- | node_modules/@jest/reporters/build/DefaultReporter.js | 254 |
1 files changed, 254 insertions, 0 deletions
diff --git a/node_modules/@jest/reporters/build/DefaultReporter.js b/node_modules/@jest/reporters/build/DefaultReporter.js new file mode 100644 index 0000000..6349e68 --- /dev/null +++ b/node_modules/@jest/reporters/build/DefaultReporter.js @@ -0,0 +1,254 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; + +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + + _chalk = function () { + return data; + }; + + return data; +} + +function _console() { + const data = require('@jest/console'); + + _console = function () { + return data; + }; + + return data; +} + +function _jestUtil() { + const data = require('jest-util'); + + _jestUtil = function () { + return data; + }; + + return data; +} + +var _BaseReporter = _interopRequireDefault(require('./BaseReporter')); + +var _Status = _interopRequireDefault(require('./Status')); + +var _getResultHeader = _interopRequireDefault(require('./getResultHeader')); + +var _getSnapshotStatus = _interopRequireDefault(require('./getSnapshotStatus')); + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} + +function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + return obj; +} + +const TITLE_BULLET = _chalk().default.bold('\u25cf '); + +class DefaultReporter extends _BaseReporter.default { + // ANSI clear sequence for the last printed status + constructor(globalConfig) { + super(); + + _defineProperty(this, '_clear', void 0); + + _defineProperty(this, '_err', void 0); + + _defineProperty(this, '_globalConfig', void 0); + + _defineProperty(this, '_out', void 0); + + _defineProperty(this, '_status', void 0); + + _defineProperty(this, '_bufferedOutput', void 0); + + this._globalConfig = globalConfig; + this._clear = ''; + this._out = process.stdout.write.bind(process.stdout); + this._err = process.stderr.write.bind(process.stderr); + this._status = new _Status.default(); + this._bufferedOutput = new Set(); + + this.__wrapStdio(process.stdout); + + this.__wrapStdio(process.stderr); + + this._status.onChange(() => { + this.__clearStatus(); + + this.__printStatus(); + }); + } + + __wrapStdio(stream) { + const write = stream.write.bind(stream); + let buffer = []; + let timeout = null; + + const flushBufferedOutput = () => { + const string = buffer.join(''); + buffer = []; // This is to avoid conflicts between random output and status text + + this.__clearStatus(); + + if (string) { + write(string); + } + + this.__printStatus(); + + this._bufferedOutput.delete(flushBufferedOutput); + }; + + this._bufferedOutput.add(flushBufferedOutput); + + const debouncedFlush = () => { + // If the process blows up no errors would be printed. + // There should be a smart way to buffer stderr, but for now + // we just won't buffer it. + if (stream === process.stderr) { + flushBufferedOutput(); + } else { + if (!timeout) { + timeout = setTimeout(() => { + flushBufferedOutput(); + timeout = null; + }, 100); + } + } + }; + + stream.write = chunk => { + buffer.push(chunk); + debouncedFlush(); + return true; + }; + } // Don't wait for the debounced call and flush all output immediately. + + forceFlushBufferedOutput() { + for (const flushBufferedOutput of this._bufferedOutput) { + flushBufferedOutput(); + } + } + + __clearStatus() { + if (_jestUtil().isInteractive) { + if (this._globalConfig.useStderr) { + this._err(this._clear); + } else { + this._out(this._clear); + } + } + } + + __printStatus() { + const {content, clear} = this._status.get(); + + this._clear = clear; + + if (_jestUtil().isInteractive) { + if (this._globalConfig.useStderr) { + this._err(content); + } else { + this._out(content); + } + } + } + + onRunStart(aggregatedResults, options) { + this._status.runStarted(aggregatedResults, options); + } + + onTestStart(test) { + this._status.testStarted(test.path, test.context.config); + } + + onTestCaseResult(test, testCaseResult) { + this._status.addTestCaseResult(test, testCaseResult); + } + + onRunComplete() { + this.forceFlushBufferedOutput(); + + this._status.runFinished(); + + process.stdout.write = this._out; + process.stderr.write = this._err; + (0, _jestUtil().clearLine)(process.stderr); + } + + onTestResult(test, testResult, aggregatedResults) { + this.testFinished(test.context.config, testResult, aggregatedResults); + + if (!testResult.skipped) { + this.printTestFileHeader( + testResult.testFilePath, + test.context.config, + testResult + ); + this.printTestFileFailureMessage( + testResult.testFilePath, + test.context.config, + testResult + ); + } + + this.forceFlushBufferedOutput(); + } + + testFinished(config, testResult, aggregatedResults) { + this._status.testFinished(config, testResult, aggregatedResults); + } + + printTestFileHeader(_testPath, config, result) { + this.log((0, _getResultHeader.default)(result, this._globalConfig, config)); + + if (result.console) { + this.log( + ' ' + + TITLE_BULLET + + 'Console\n\n' + + (0, _console().getConsoleOutput)( + result.console, + config, + this._globalConfig + ) + ); + } + } + + printTestFileFailureMessage(_testPath, _config, result) { + if (result.failureMessage) { + this.log(result.failureMessage); + } + + const didUpdate = this._globalConfig.updateSnapshot === 'all'; + const snapshotStatuses = (0, _getSnapshotStatus.default)( + result.snapshot, + didUpdate + ); + snapshotStatuses.forEach(this.log); + } +} + +exports.default = DefaultReporter; + +_defineProperty(DefaultReporter, 'filename', __filename); |