setup-php/node_modules/@jest/core/build/runJest.js
Shivam Mathur 8f9786b73f init
2019-09-06 05:17:43 +05:30

447 lines
11 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 _chalk() {
const data = _interopRequireDefault(require('chalk'));
_chalk = function _chalk() {
return data;
};
return data;
}
function _realpathNative() {
const data = require('realpath-native');
_realpathNative = function _realpathNative() {
return data;
};
return data;
}
function _console() {
const data = require('@jest/console');
_console = function _console() {
return data;
};
return data;
}
function _jestUtil() {
const data = require('jest-util');
_jestUtil = function _jestUtil() {
return data;
};
return data;
}
function _exit() {
const data = _interopRequireDefault(require('exit'));
_exit = function _exit() {
return data;
};
return data;
}
function _gracefulFs() {
const data = _interopRequireDefault(require('graceful-fs'));
_gracefulFs = function _gracefulFs() {
return data;
};
return data;
}
function _jestWatcher() {
const data = require('jest-watcher');
_jestWatcher = function _jestWatcher() {
return data;
};
return data;
}
function _testResult() {
const data = require('@jest/test-result');
_testResult = function _testResult() {
return data;
};
return data;
}
var _getNoTestsFoundMessage = _interopRequireDefault(
require('./getNoTestsFoundMessage')
);
var _runGlobalHook = _interopRequireDefault(require('./runGlobalHook'));
var _SearchSource = _interopRequireDefault(require('./SearchSource'));
var _TestScheduler = _interopRequireDefault(require('./TestScheduler'));
var _collectHandles = _interopRequireDefault(require('./collectHandles'));
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 _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;
}
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);
});
};
}
const getTestPaths =
/*#__PURE__*/
(function() {
var _ref = _asyncToGenerator(function*(
globalConfig,
context,
outputStream,
changedFiles,
jestHooks,
filter
) {
const source = new _SearchSource.default(context);
const data = yield source.getTestPaths(
globalConfig,
changedFiles,
filter
);
if (!data.tests.length && globalConfig.onlyChanged && data.noSCM) {
new (_console()).CustomConsole(outputStream, outputStream).log(
'Jest can only find uncommitted changed files in a git or hg ' +
'repository. If you make your project a git or hg ' +
'repository (`git init` or `hg init`), Jest will be able ' +
'to only run tests related to files changed since the last ' +
'commit.'
);
}
const shouldTestArray = yield Promise.all(
data.tests.map(test =>
jestHooks.shouldRunTestSuite({
config: test.context.config,
duration: test.duration,
testPath: test.path
})
)
);
const filteredTests = data.tests.filter((_test, i) => shouldTestArray[i]);
return _objectSpread({}, data, {
allTests: filteredTests.length,
tests: filteredTests
});
});
return function getTestPaths(_x, _x2, _x3, _x4, _x5, _x6) {
return _ref.apply(this, arguments);
};
})();
const processResults = (runResults, options) => {
const outputFile = options.outputFile,
isJSON = options.json,
onComplete = options.onComplete,
outputStream = options.outputStream,
testResultsProcessor = options.testResultsProcessor,
collectHandles = options.collectHandles;
if (collectHandles) {
runResults.openHandles = collectHandles();
} else {
runResults.openHandles = [];
}
if (testResultsProcessor) {
runResults = require(testResultsProcessor)(runResults);
}
if (isJSON) {
if (outputFile) {
const cwd = (0, _realpathNative().sync)(process.cwd());
const filePath = _path().default.resolve(cwd, outputFile);
_gracefulFs().default.writeFileSync(
filePath,
JSON.stringify((0, _jestUtil().formatTestResults)(runResults))
);
outputStream.write(
`Test results written to: ${_path().default.relative(cwd, filePath)}\n`
);
} else {
process.stdout.write(
JSON.stringify((0, _jestUtil().formatTestResults)(runResults))
);
}
}
return onComplete && onComplete(runResults);
};
const testSchedulerContext = {
firstRun: true,
previousSuccess: true
};
var _default =
/*#__PURE__*/
(function() {
var _runJest = _asyncToGenerator(function*({
contexts,
globalConfig,
outputStream,
testWatcher,
jestHooks = new (_jestWatcher()).JestHook().getEmitter(),
startRun,
changedFilesPromise,
onComplete,
failedTestsCache,
filter
}) {
const Sequencer = (0, _jestUtil().interopRequireDefault)(
require(globalConfig.testSequencer)
).default;
const sequencer = new Sequencer();
let allTests = [];
if (changedFilesPromise && globalConfig.watch) {
const _ref2 = yield changedFilesPromise,
repos = _ref2.repos;
const noSCM = Object.keys(repos).every(scm => repos[scm].size === 0);
if (noSCM) {
process.stderr.write(
'\n' +
_chalk().default.bold('--watch') +
' is not supported without git/hg, please use --watchAll ' +
'\n'
);
(0, _exit().default)(1);
}
}
const testRunData = yield Promise.all(
contexts.map(
/*#__PURE__*/
(function() {
var _ref3 = _asyncToGenerator(function*(context) {
const matches = yield getTestPaths(
globalConfig,
context,
outputStream,
changedFilesPromise && (yield changedFilesPromise),
jestHooks,
filter
);
allTests = allTests.concat(matches.tests);
return {
context,
matches
};
});
return function(_x8) {
return _ref3.apply(this, arguments);
};
})()
)
);
allTests = yield sequencer.sort(allTests);
if (globalConfig.listTests) {
const testsPaths = Array.from(new Set(allTests.map(test => test.path)));
if (globalConfig.json) {
console.log(JSON.stringify(testsPaths));
} else {
console.log(testsPaths.join('\n'));
}
onComplete &&
onComplete((0, _testResult().makeEmptyAggregatedTestResult)());
return null;
}
if (globalConfig.onlyFailures && failedTestsCache) {
allTests = failedTestsCache.filterTests(allTests);
globalConfig = failedTestsCache.updateConfig(globalConfig);
}
const hasTests = allTests.length > 0;
if (!hasTests) {
const noTestsFoundMessage = (0, _getNoTestsFoundMessage.default)(
testRunData,
globalConfig
);
if (
globalConfig.passWithNoTests ||
globalConfig.findRelatedTests ||
globalConfig.lastCommit ||
globalConfig.onlyChanged
) {
new (_console()).CustomConsole(outputStream, outputStream).log(
noTestsFoundMessage
);
} else {
new (_console()).CustomConsole(outputStream, outputStream).error(
noTestsFoundMessage
);
(0, _exit().default)(1);
}
} else if (
allTests.length === 1 &&
globalConfig.silent !== true &&
globalConfig.verbose !== false
) {
const newConfig = _objectSpread({}, globalConfig, {
verbose: true
});
globalConfig = Object.freeze(newConfig);
}
let collectHandles;
if (globalConfig.detectOpenHandles) {
collectHandles = (0, _collectHandles.default)();
}
if (hasTests) {
yield (0, _runGlobalHook.default)({
allTests,
globalConfig,
moduleName: 'globalSetup'
});
}
if (changedFilesPromise) {
testSchedulerContext.changedFiles = (yield changedFilesPromise).changedFiles;
}
const results = yield new _TestScheduler.default(
globalConfig,
{
startRun
},
testSchedulerContext
).scheduleTests(allTests, testWatcher);
sequencer.cacheResults(allTests, results);
if (hasTests) {
yield (0, _runGlobalHook.default)({
allTests,
globalConfig,
moduleName: 'globalTeardown'
});
}
return processResults(results, {
collectHandles,
json: globalConfig.json,
onComplete,
outputFile: globalConfig.outputFile,
outputStream,
testResultsProcessor: globalConfig.testResultsProcessor
});
});
function runJest(_x7) {
return _runJest.apply(this, arguments);
}
return runJest;
})();
exports.default = _default;