setup-python/node_modules/@jest/reporters/build/Status.js

249 lines
5.2 KiB
JavaScript
Raw Normal View History

2019-06-27 08:12:00 +07:00
'use strict';
Object.defineProperty(exports, '__esModule', {
value: true
});
exports.default = void 0;
function _chalk() {
const data = _interopRequireDefault(require('chalk'));
_chalk = function _chalk() {
return data;
};
return data;
}
function _stringLength() {
const data = _interopRequireDefault(require('string-length'));
_stringLength = function _stringLength() {
return data;
};
return data;
}
var _utils = require('./utils');
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 RUNNING_TEXT = ' RUNS ';
const RUNNING = _chalk().default.reset.inverse.yellow.bold(RUNNING_TEXT) + ' ';
/**
* This class is a perf optimization for sorting the list of currently
* running tests. It tries to keep tests in the same positions without
* shifting the whole list.
*/
class CurrentTestList {
constructor() {
_defineProperty(this, '_array', void 0);
this._array = [];
}
add(testPath, config) {
const index = this._array.indexOf(null);
const record = {
config,
testPath
};
if (index !== -1) {
this._array[index] = record;
} else {
this._array.push(record);
}
}
delete(testPath) {
const record = this._array.find(
record => record !== null && record.testPath === testPath
);
this._array[this._array.indexOf(record || null)] = null;
}
get() {
return this._array;
}
}
/**
* A class that generates the CLI status of currently running tests
* and also provides an ANSI escape sequence to remove status lines
* from the terminal.
*/
class Status {
constructor() {
_defineProperty(this, '_cache', void 0);
_defineProperty(this, '_callback', void 0);
_defineProperty(this, '_currentTests', void 0);
_defineProperty(this, '_done', void 0);
_defineProperty(this, '_emitScheduled', void 0);
_defineProperty(this, '_estimatedTime', void 0);
_defineProperty(this, '_interval', void 0);
_defineProperty(this, '_aggregatedResults', void 0);
_defineProperty(this, '_showStatus', void 0);
this._cache = null;
this._currentTests = new CurrentTestList();
this._done = false;
this._emitScheduled = false;
this._estimatedTime = 0;
this._showStatus = false;
}
onChange(callback) {
this._callback = callback;
}
runStarted(aggregatedResults, options) {
this._estimatedTime = (options && options.estimatedTime) || 0;
this._showStatus = options && options.showStatus;
this._interval = setInterval(() => this._tick(), 1000);
this._aggregatedResults = aggregatedResults;
this._debouncedEmit();
}
runFinished() {
this._done = true;
if (this._interval) clearInterval(this._interval);
this._emit();
}
testStarted(testPath, config) {
this._currentTests.add(testPath, config);
if (!this._showStatus) {
this._emit();
} else {
this._debouncedEmit();
}
}
testFinished(_config, testResult, aggregatedResults) {
const testFilePath = testResult.testFilePath;
this._aggregatedResults = aggregatedResults;
this._currentTests.delete(testFilePath);
this._debouncedEmit();
}
get() {
if (this._cache) {
return this._cache;
}
if (this._done) {
return {
clear: '',
content: ''
};
}
const width = process.stdout.columns;
let content = '\n';
this._currentTests.get().forEach(record => {
if (record) {
const config = record.config,
testPath = record.testPath;
const projectDisplayName = config.displayName
? (0, _utils.printDisplayName)(config) + ' '
: '';
const prefix = RUNNING + projectDisplayName;
content +=
(0, _utils.wrapAnsiString)(
prefix +
(0, _utils.trimAndFormatPath)(
(0, _stringLength().default)(prefix),
config,
testPath,
width
),
width
) + '\n';
}
});
if (this._showStatus && this._aggregatedResults) {
content +=
'\n' +
(0, _utils.getSummary)(this._aggregatedResults, {
estimatedTime: this._estimatedTime,
roundTime: true,
width
});
}
let height = 0;
for (let i = 0; i < content.length; i++) {
if (content[i] === '\n') {
height++;
}
}
const clear = '\r\x1B[K\r\x1B[1A'.repeat(height);
return (this._cache = {
clear,
content
});
}
_emit() {
this._cache = null;
if (this._callback) this._callback();
}
_debouncedEmit() {
if (!this._emitScheduled) {
// Perf optimization to avoid two separate renders When
// one test finishes and another test starts executing.
this._emitScheduled = true;
setTimeout(() => {
this._emit();
this._emitScheduled = false;
}, 100);
}
}
_tick() {
this._debouncedEmit();
}
}
exports.default = Status;