572 lines
16 KiB
JavaScript
572 lines
16 KiB
JavaScript
|
'use strict';
|
||
|
|
|
||
|
|
Object.defineProperty(exports, '__esModule', {
|
||
|
|
value: true
|
||
|
|
});
|
||
|
|
exports.default = void 0;
|
||
|
|
|
||
|
|
function _path() {
|
||
|
|
const data = _interopRequireDefault(require('path'));
|
||
|
|
|
||
|
|
_path = function _path() {
|
||
|
|
return data;
|
||
|
|
};
|
||
|
|
|
||
|
|
return data;
|
||
|
|
}
|
||
|
|
|
||
|
|
function _jestUtil() {
|
||
|
|
const data = require('jest-util');
|
||
|
|
|
||
|
|
_jestUtil = function _jestUtil() {
|
||
|
|
return data;
|
||
|
|
};
|
||
|
|
|
||
|
|
return data;
|
||
|
|
}
|
||
|
|
|
||
|
|
function _istanbulLibReport() {
|
||
|
|
const data = _interopRequireDefault(require('istanbul-lib-report'));
|
||
|
|
|
||
|
|
_istanbulLibReport = function _istanbulLibReport() {
|
||
|
|
return data;
|
||
|
|
};
|
||
|
|
|
||
|
|
return data;
|
||
|
|
}
|
||
|
|
|
||
|
|
function _istanbulReports() {
|
||
|
|
const data = _interopRequireDefault(require('istanbul-reports'));
|
||
|
|
|
||
|
|
_istanbulReports = function _istanbulReports() {
|
||
|
|
return data;
|
||
|
|
};
|
||
|
|
|
||
|
|
return data;
|
||
|
|
}
|
||
|
|
|
||
|
|
function _chalk() {
|
||
|
|
const data = _interopRequireDefault(require('chalk'));
|
||
|
|
|
||
|
|
_chalk = function _chalk() {
|
||
|
|
return data;
|
||
|
|
};
|
||
|
|
|
||
|
|
return data;
|
||
|
|
}
|
||
|
|
|
||
|
|
function _istanbulLibCoverage() {
|
||
|
|
const data = _interopRequireDefault(require('istanbul-lib-coverage'));
|
||
|
|
|
||
|
|
_istanbulLibCoverage = function _istanbulLibCoverage() {
|
||
|
|
return data;
|
||
|
|
};
|
||
|
|
|
||
|
|
return data;
|
||
|
|
}
|
||
|
|
|
||
|
|
function _istanbulLibSourceMaps() {
|
||
|
|
const data = _interopRequireDefault(require('istanbul-lib-source-maps'));
|
||
|
|
|
||
|
|
_istanbulLibSourceMaps = function _istanbulLibSourceMaps() {
|
||
|
|
return data;
|
||
|
|
};
|
||
|
|
|
||
|
|
return data;
|
||
|
|
}
|
||
|
|
|
||
|
|
function _jestWorker() {
|
||
|
|
const data = _interopRequireDefault(require('jest-worker'));
|
||
|
|
|
||
|
|
_jestWorker = function _jestWorker() {
|
||
|
|
return data;
|
||
|
|
};
|
||
|
|
|
||
|
|
return data;
|
||
|
|
}
|
||
|
|
|
||
|
|
function _glob() {
|
||
|
|
const data = _interopRequireDefault(require('glob'));
|
||
|
|
|
||
|
|
_glob = function _glob() {
|
||
|
|
return data;
|
||
|
|
};
|
||
|
|
|
||
|
|
return data;
|
||
|
|
}
|
||
|
|
|
||
|
|
var _base_reporter = _interopRequireDefault(require('./base_reporter'));
|
||
|
|
|
||
|
|
function _interopRequireDefault(obj) {
|
||
|
|
return obj && obj.__esModule ? obj : {default: obj};
|
||
|
|
}
|
||
|
|
|
||
|
|
function _objectSpread(target) {
|
||
|
|
for (var i = 1; i < arguments.length; i++) {
|
||
|
|
var source = arguments[i] != null ? arguments[i] : {};
|
||
|
|
var ownKeys = Object.keys(source);
|
||
|
|
if (typeof Object.getOwnPropertySymbols === 'function') {
|
||
|
|
ownKeys = ownKeys.concat(
|
||
|
|
Object.getOwnPropertySymbols(source).filter(function(sym) {
|
||
|
|
return Object.getOwnPropertyDescriptor(source, sym).enumerable;
|
||
|
|
})
|
||
|
|
);
|
||
|
|
}
|
||
|
|
ownKeys.forEach(function(key) {
|
||
|
|
_defineProperty(target, key, source[key]);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
return target;
|
||
|
|
}
|
||
|
|
|
||
|
|
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
|
||
|
|
try {
|
||
|
|
var info = gen[key](arg);
|
||
|
|
var value = info.value;
|
||
|
|
} catch (error) {
|
||
|
|
reject(error);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (info.done) {
|
||
|
|
resolve(value);
|
||
|
|
} else {
|
||
|
|
Promise.resolve(value).then(_next, _throw);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function _asyncToGenerator(fn) {
|
||
|
|
return function() {
|
||
|
|
var self = this,
|
||
|
|
args = arguments;
|
||
|
|
return new Promise(function(resolve, reject) {
|
||
|
|
var gen = fn.apply(self, args);
|
||
|
|
function _next(value) {
|
||
|
|
asyncGeneratorStep(gen, resolve, reject, _next, _throw, 'next', value);
|
||
|
|
}
|
||
|
|
function _throw(err) {
|
||
|
|
asyncGeneratorStep(gen, resolve, reject, _next, _throw, 'throw', err);
|
||
|
|
}
|
||
|
|
_next(undefined);
|
||
|
|
});
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
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 FAIL_COLOR = _chalk().default.bold.red;
|
||
|
|
|
||
|
|
const RUNNING_TEST_COLOR = _chalk().default.bold.dim;
|
||
|
|
|
||
|
|
class CoverageReporter extends _base_reporter.default {
|
||
|
|
constructor(globalConfig, options) {
|
||
|
|
super();
|
||
|
|
|
||
|
|
_defineProperty(this, '_coverageMap', void 0);
|
||
|
|
|
||
|
|
_defineProperty(this, '_globalConfig', void 0);
|
||
|
|
|
||
|
|
_defineProperty(this, '_sourceMapStore', void 0);
|
||
|
|
|
||
|
|
_defineProperty(this, '_options', void 0);
|
||
|
|
|
||
|
|
this._coverageMap = _istanbulLibCoverage().default.createCoverageMap({});
|
||
|
|
this._globalConfig = globalConfig;
|
||
|
|
this._sourceMapStore = _istanbulLibSourceMaps().default.createSourceMapStore();
|
||
|
|
this._options = options || {};
|
||
|
|
}
|
||
|
|
|
||
|
|
onTestResult(_test, testResult, _aggregatedResults) {
|
||
|
|
if (testResult.coverage) {
|
||
|
|
this._coverageMap.merge(testResult.coverage);
|
||
|
|
}
|
||
|
|
|
||
|
|
const sourceMaps = testResult.sourceMaps;
|
||
|
|
|
||
|
|
if (sourceMaps) {
|
||
|
|
Object.keys(sourceMaps).forEach(sourcePath => {
|
||
|
|
let inputSourceMap;
|
||
|
|
|
||
|
|
try {
|
||
|
|
const coverage = this._coverageMap.fileCoverageFor(sourcePath);
|
||
|
|
|
||
|
|
inputSourceMap = coverage.toJSON().inputSourceMap;
|
||
|
|
} finally {
|
||
|
|
if (inputSourceMap) {
|
||
|
|
this._sourceMapStore.registerMap(sourcePath, inputSourceMap);
|
||
|
|
} else {
|
||
|
|
this._sourceMapStore.registerURL(
|
||
|
|
sourcePath,
|
||
|
|
sourceMaps[sourcePath]
|
||
|
|
);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
onRunComplete(contexts, aggregatedResults) {
|
||
|
|
var _this = this;
|
||
|
|
|
||
|
|
return _asyncToGenerator(function*() {
|
||
|
|
yield _this._addUntestedFiles(_this._globalConfig, contexts);
|
||
|
|
|
||
|
|
const _this$_sourceMapStore = _this._sourceMapStore.transformCoverage(
|
||
|
|
_this._coverageMap
|
||
|
|
),
|
||
|
|
map = _this$_sourceMapStore.map,
|
||
|
|
sourceFinder = _this$_sourceMapStore.sourceFinder;
|
||
|
|
|
||
|
|
try {
|
||
|
|
const reportContext = _istanbulLibReport().default.createContext({
|
||
|
|
dir: _this._globalConfig.coverageDirectory,
|
||
|
|
sourceFinder
|
||
|
|
});
|
||
|
|
|
||
|
|
const coverageReporters = _this._globalConfig.coverageReporters || [];
|
||
|
|
|
||
|
|
if (!_this._globalConfig.useStderr && coverageReporters.length < 1) {
|
||
|
|
coverageReporters.push('text-summary');
|
||
|
|
}
|
||
|
|
|
||
|
|
const tree = _istanbulLibReport().default.summarizers.pkg(map);
|
||
|
|
|
||
|
|
coverageReporters.forEach(reporter => {
|
||
|
|
tree.visit(
|
||
|
|
_istanbulReports().default.create(reporter, {}),
|
||
|
|
reportContext
|
||
|
|
);
|
||
|
|
});
|
||
|
|
aggregatedResults.coverageMap = map;
|
||
|
|
} catch (e) {
|
||
|
|
console.error(
|
||
|
|
_chalk().default.red(`
|
||
|
|
Failed to write coverage reports:
|
||
|
|
ERROR: ${e.toString()}
|
||
|
|
STACK: ${e.stack}
|
||
|
|
`)
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
_this._checkThreshold(_this._globalConfig, map);
|
||
|
|
})();
|
||
|
|
}
|
||
|
|
|
||
|
|
_addUntestedFiles(globalConfig, contexts) {
|
||
|
|
var _this2 = this;
|
||
|
|
|
||
|
|
return _asyncToGenerator(function*() {
|
||
|
|
const files = [];
|
||
|
|
contexts.forEach(context => {
|
||
|
|
const config = context.config;
|
||
|
|
|
||
|
|
if (
|
||
|
|
globalConfig.collectCoverageFrom &&
|
||
|
|
globalConfig.collectCoverageFrom.length
|
||
|
|
) {
|
||
|
|
context.hasteFS
|
||
|
|
.matchFilesWithGlob(
|
||
|
|
globalConfig.collectCoverageFrom,
|
||
|
|
config.rootDir
|
||
|
|
)
|
||
|
|
.forEach(filePath =>
|
||
|
|
files.push({
|
||
|
|
config,
|
||
|
|
path: filePath
|
||
|
|
})
|
||
|
|
);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
if (!files.length) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (_jestUtil().isInteractive) {
|
||
|
|
process.stderr.write(
|
||
|
|
RUNNING_TEST_COLOR('Running coverage on untested files...')
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
let worker;
|
||
|
|
|
||
|
|
if (_this2._globalConfig.maxWorkers <= 1) {
|
||
|
|
worker = require('./coverage_worker');
|
||
|
|
} else {
|
||
|
|
worker = new (_jestWorker()).default(
|
||
|
|
require.resolve('./coverage_worker'),
|
||
|
|
{
|
||
|
|
exposedMethods: ['worker'],
|
||
|
|
maxRetries: 2,
|
||
|
|
numWorkers: _this2._globalConfig.maxWorkers
|
||
|
|
}
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
const instrumentation = files.map(
|
||
|
|
/*#__PURE__*/
|
||
|
|
(function() {
|
||
|
|
var _ref = _asyncToGenerator(function*(fileObj) {
|
||
|
|
const filename = fileObj.path;
|
||
|
|
const config = fileObj.config;
|
||
|
|
|
||
|
|
if (!_this2._coverageMap.data[filename] && 'worker' in worker) {
|
||
|
|
try {
|
||
|
|
const result = yield worker.worker({
|
||
|
|
config,
|
||
|
|
globalConfig,
|
||
|
|
options: _objectSpread({}, _this2._options, {
|
||
|
|
changedFiles:
|
||
|
|
_this2._options.changedFiles &&
|
||
|
|
Array.from(_this2._options.changedFiles)
|
||
|
|
}),
|
||
|
|
path: filename
|
||
|
|
});
|
||
|
|
|
||
|
|
if (result) {
|
||
|
|
_this2._coverageMap.addFileCoverage(result.coverage);
|
||
|
|
|
||
|
|
if (result.sourceMapPath) {
|
||
|
|
_this2._sourceMapStore.registerURL(
|
||
|
|
filename,
|
||
|
|
result.sourceMapPath
|
||
|
|
);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} catch (error) {
|
||
|
|
console.error(
|
||
|
|
_chalk().default.red(
|
||
|
|
[
|
||
|
|
`Failed to collect coverage from ${filename}`,
|
||
|
|
`ERROR: ${error.message}`,
|
||
|
|
`STACK: ${error.stack}`
|
||
|
|
].join('\n')
|
||
|
|
)
|
||
|
|
);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
return function(_x) {
|
||
|
|
return _ref.apply(this, arguments);
|
||
|
|
};
|
||
|
|
})()
|
||
|
|
);
|
||
|
|
|
||
|
|
try {
|
||
|
|
yield Promise.all(instrumentation);
|
||
|
|
} catch (err) {
|
||
|
|
// Do nothing; errors were reported earlier to the console.
|
||
|
|
}
|
||
|
|
|
||
|
|
if (_jestUtil().isInteractive) {
|
||
|
|
(0, _jestUtil().clearLine)(process.stderr);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (worker && 'end' in worker && typeof worker.end === 'function') {
|
||
|
|
worker.end();
|
||
|
|
}
|
||
|
|
})();
|
||
|
|
}
|
||
|
|
|
||
|
|
_checkThreshold(globalConfig, map) {
|
||
|
|
if (globalConfig.coverageThreshold) {
|
||
|
|
function check(name, thresholds, actuals) {
|
||
|
|
return ['statements', 'branches', 'lines', 'functions'].reduce(
|
||
|
|
(errors, key) => {
|
||
|
|
const actual = actuals[key].pct;
|
||
|
|
const actualUncovered = actuals[key].total - actuals[key].covered;
|
||
|
|
const threshold = thresholds[key];
|
||
|
|
|
||
|
|
if (threshold != null) {
|
||
|
|
if (threshold < 0) {
|
||
|
|
if (threshold * -1 < actualUncovered) {
|
||
|
|
errors.push(
|
||
|
|
`Jest: Uncovered count for ${key} (${actualUncovered})` +
|
||
|
|
`exceeds ${name} threshold (${-1 * threshold})`
|
||
|
|
);
|
||
|
|
}
|
||
|
|
} else if (actual < threshold) {
|
||
|
|
errors.push(
|
||
|
|
`Jest: "${name}" coverage threshold for ${key} (${threshold}%) not met: ${actual}%`
|
||
|
|
);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return errors;
|
||
|
|
},
|
||
|
|
[]
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
const THRESHOLD_GROUP_TYPES = {
|
||
|
|
GLOB: 'glob',
|
||
|
|
GLOBAL: 'global',
|
||
|
|
PATH: 'path'
|
||
|
|
};
|
||
|
|
const coveredFiles = map.files();
|
||
|
|
const thresholdGroups = Object.keys(globalConfig.coverageThreshold);
|
||
|
|
const groupTypeByThresholdGroup = {};
|
||
|
|
const filesByGlob = {};
|
||
|
|
const coveredFilesSortedIntoThresholdGroup = coveredFiles.reduce(
|
||
|
|
(files, file) => {
|
||
|
|
const pathOrGlobMatches = thresholdGroups.reduce(
|
||
|
|
(agg, thresholdGroup) => {
|
||
|
|
const absoluteThresholdGroup = _path().default.resolve(
|
||
|
|
thresholdGroup
|
||
|
|
); // The threshold group might be a path:
|
||
|
|
|
||
|
|
if (file.indexOf(absoluteThresholdGroup) === 0) {
|
||
|
|
groupTypeByThresholdGroup[thresholdGroup] =
|
||
|
|
THRESHOLD_GROUP_TYPES.PATH;
|
||
|
|
return agg.concat([[file, thresholdGroup]]);
|
||
|
|
} // If the threshold group is not a path it might be a glob:
|
||
|
|
// Note: glob.sync is slow. By memoizing the files matching each glob
|
||
|
|
// (rather than recalculating it for each covered file) we save a tonne
|
||
|
|
// of execution time.
|
||
|
|
|
||
|
|
if (filesByGlob[absoluteThresholdGroup] === undefined) {
|
||
|
|
filesByGlob[absoluteThresholdGroup] = _glob()
|
||
|
|
.default.sync(absoluteThresholdGroup)
|
||
|
|
.map(filePath => _path().default.resolve(filePath));
|
||
|
|
}
|
||
|
|
|
||
|
|
if (filesByGlob[absoluteThresholdGroup].indexOf(file) > -1) {
|
||
|
|
groupTypeByThresholdGroup[thresholdGroup] =
|
||
|
|
THRESHOLD_GROUP_TYPES.GLOB;
|
||
|
|
return agg.concat([[file, thresholdGroup]]);
|
||
|
|
}
|
||
|
|
|
||
|
|
return agg;
|
||
|
|
},
|
||
|
|
[]
|
||
|
|
);
|
||
|
|
|
||
|
|
if (pathOrGlobMatches.length > 0) {
|
||
|
|
return files.concat(pathOrGlobMatches);
|
||
|
|
} // Neither a glob or a path? Toss it in global if there's a global threshold:
|
||
|
|
|
||
|
|
if (thresholdGroups.indexOf(THRESHOLD_GROUP_TYPES.GLOBAL) > -1) {
|
||
|
|
groupTypeByThresholdGroup[THRESHOLD_GROUP_TYPES.GLOBAL] =
|
||
|
|
THRESHOLD_GROUP_TYPES.GLOBAL;
|
||
|
|
return files.concat([[file, THRESHOLD_GROUP_TYPES.GLOBAL]]);
|
||
|
|
} // A covered file that doesn't have a threshold:
|
||
|
|
|
||
|
|
return files.concat([[file, undefined]]);
|
||
|
|
},
|
||
|
|
[]
|
||
|
|
);
|
||
|
|
|
||
|
|
const getFilesInThresholdGroup = thresholdGroup =>
|
||
|
|
coveredFilesSortedIntoThresholdGroup
|
||
|
|
.filter(fileAndGroup => fileAndGroup[1] === thresholdGroup)
|
||
|
|
.map(fileAndGroup => fileAndGroup[0]);
|
||
|
|
|
||
|
|
function combineCoverage(filePaths) {
|
||
|
|
return filePaths
|
||
|
|
.map(filePath => map.fileCoverageFor(filePath))
|
||
|
|
.reduce((combinedCoverage, nextFileCoverage) => {
|
||
|
|
if (combinedCoverage === undefined || combinedCoverage === null) {
|
||
|
|
return nextFileCoverage.toSummary();
|
||
|
|
}
|
||
|
|
|
||
|
|
return combinedCoverage.merge(nextFileCoverage.toSummary());
|
||
|
|
}, undefined);
|
||
|
|
}
|
||
|
|
|
||
|
|
let errors = [];
|
||
|
|
thresholdGroups.forEach(thresholdGroup => {
|
||
|
|
switch (groupTypeByThresholdGroup[thresholdGroup]) {
|
||
|
|
case THRESHOLD_GROUP_TYPES.GLOBAL: {
|
||
|
|
const coverage = combineCoverage(
|
||
|
|
getFilesInThresholdGroup(THRESHOLD_GROUP_TYPES.GLOBAL)
|
||
|
|
);
|
||
|
|
|
||
|
|
if (coverage) {
|
||
|
|
errors = errors.concat(
|
||
|
|
check(
|
||
|
|
thresholdGroup,
|
||
|
|
globalConfig.coverageThreshold[thresholdGroup],
|
||
|
|
coverage
|
||
|
|
)
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
case THRESHOLD_GROUP_TYPES.PATH: {
|
||
|
|
const coverage = combineCoverage(
|
||
|
|
getFilesInThresholdGroup(thresholdGroup)
|
||
|
|
);
|
||
|
|
|
||
|
|
if (coverage) {
|
||
|
|
errors = errors.concat(
|
||
|
|
check(
|
||
|
|
thresholdGroup,
|
||
|
|
globalConfig.coverageThreshold[thresholdGroup],
|
||
|
|
coverage
|
||
|
|
)
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
case THRESHOLD_GROUP_TYPES.GLOB:
|
||
|
|
getFilesInThresholdGroup(thresholdGroup).forEach(
|
||
|
|
fileMatchingGlob => {
|
||
|
|
errors = errors.concat(
|
||
|
|
check(
|
||
|
|
fileMatchingGlob,
|
||
|
|
globalConfig.coverageThreshold[thresholdGroup],
|
||
|
|
map.fileCoverageFor(fileMatchingGlob).toSummary()
|
||
|
|
)
|
||
|
|
);
|
||
|
|
}
|
||
|
|
);
|
||
|
|
break;
|
||
|
|
|
||
|
|
default:
|
||
|
|
// If the file specified by path is not found, error is returned.
|
||
|
|
if (thresholdGroup !== THRESHOLD_GROUP_TYPES.GLOBAL) {
|
||
|
|
errors = errors.concat(
|
||
|
|
`Jest: Coverage data for ${thresholdGroup} was not found.`
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Sometimes all files in the coverage data are matched by
|
||
|
|
// PATH and GLOB threshold groups in which case, don't error when
|
||
|
|
// the global threshold group doesn't match any files.
|
||
|
|
}
|
||
|
|
});
|
||
|
|
errors = errors.filter(
|
||
|
|
err => err !== undefined && err !== null && err.length > 0
|
||
|
|
);
|
||
|
|
|
||
|
|
if (errors.length > 0) {
|
||
|
|
this.log(`${FAIL_COLOR(errors.join('\n'))}`);
|
||
|
|
|
||
|
|
this._setError(new Error(errors.join('\n')));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} // Only exposed for the internal runner. Should not be used
|
||
|
|
|
||
|
|
getCoverageMap() {
|
||
|
|
return this._coverageMap;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
exports.default = CoverageReporter;
|