setup-python/node_modules/jest-circus/build/run.js

433 lines
11 KiB
JavaScript

'use strict';
Object.defineProperty(exports, '__esModule', {
value: true
});
exports.default = void 0;
var _types = require('./types');
var _state = require('./state');
var _utils = require('./utils');
var Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
var Promise = global[Symbol.for('jest-native-promise')] || global.Promise;
var Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
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 run =
/*#__PURE__*/
(function() {
var _ref = _asyncToGenerator(function*() {
const _getState = (0, _state.getState)(),
rootDescribeBlock = _getState.rootDescribeBlock;
(0, _state.dispatch)({
name: 'run_start'
});
yield _runTestsForDescribeBlock(rootDescribeBlock);
(0, _state.dispatch)({
name: 'run_finish'
});
return (0,
_utils.makeRunResult)((0, _state.getState)().rootDescribeBlock, (0, _state.getState)().unhandledErrors);
});
return function run() {
return _ref.apply(this, arguments);
};
})();
const _runTestsForDescribeBlock =
/*#__PURE__*/
(function() {
var _ref2 = _asyncToGenerator(function*(describeBlock) {
(0, _state.dispatch)({
describeBlock,
name: 'run_describe_start'
});
const _getAllHooksForDescri = (0, _utils.getAllHooksForDescribe)(
describeBlock
),
beforeAll = _getAllHooksForDescri.beforeAll,
afterAll = _getAllHooksForDescri.afterAll;
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (
var _iterator = beforeAll[Symbol.iterator](), _step;
!(_iteratorNormalCompletion = (_step = _iterator.next()).done);
_iteratorNormalCompletion = true
) {
const hook = _step.value;
yield _callCircusHook({
describeBlock,
hook
});
} // Tests that fail and are retried we run after other tests
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return != null) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
const retryTimes = parseInt(global[_types.RETRY_TIMES], 10) || 0;
const deferredRetryTests = [];
var _iteratorNormalCompletion2 = true;
var _didIteratorError2 = false;
var _iteratorError2 = undefined;
try {
for (
var _iterator2 = describeBlock.tests[Symbol.iterator](), _step2;
!(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done);
_iteratorNormalCompletion2 = true
) {
const test = _step2.value;
const hasErrorsBeforeTestRun = test.errors.length > 0;
yield _runTest(test);
if (
hasErrorsBeforeTestRun === false &&
retryTimes > 0 &&
test.errors.length > 0
) {
deferredRetryTests.push(test);
}
} // Re-run failed tests n-times if configured
} catch (err) {
_didIteratorError2 = true;
_iteratorError2 = err;
} finally {
try {
if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
_iterator2.return();
}
} finally {
if (_didIteratorError2) {
throw _iteratorError2;
}
}
}
for (var _i = 0; _i < deferredRetryTests.length; _i++) {
const test = deferredRetryTests[_i];
let numRetriesAvailable = retryTimes;
while (numRetriesAvailable > 0 && test.errors.length > 0) {
// Clear errors so retries occur
(0, _state.dispatch)({
name: 'test_retry',
test
});
yield _runTest(test);
numRetriesAvailable--;
}
}
var _iteratorNormalCompletion3 = true;
var _didIteratorError3 = false;
var _iteratorError3 = undefined;
try {
for (
var _iterator3 = describeBlock.children[Symbol.iterator](), _step3;
!(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done);
_iteratorNormalCompletion3 = true
) {
const child = _step3.value;
yield _runTestsForDescribeBlock(child);
}
} catch (err) {
_didIteratorError3 = true;
_iteratorError3 = err;
} finally {
try {
if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
_iterator3.return();
}
} finally {
if (_didIteratorError3) {
throw _iteratorError3;
}
}
}
var _iteratorNormalCompletion4 = true;
var _didIteratorError4 = false;
var _iteratorError4 = undefined;
try {
for (
var _iterator4 = afterAll[Symbol.iterator](), _step4;
!(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done);
_iteratorNormalCompletion4 = true
) {
const hook = _step4.value;
yield _callCircusHook({
describeBlock,
hook
});
}
} catch (err) {
_didIteratorError4 = true;
_iteratorError4 = err;
} finally {
try {
if (!_iteratorNormalCompletion4 && _iterator4.return != null) {
_iterator4.return();
}
} finally {
if (_didIteratorError4) {
throw _iteratorError4;
}
}
}
(0, _state.dispatch)({
describeBlock,
name: 'run_describe_finish'
});
});
return function _runTestsForDescribeBlock(_x) {
return _ref2.apply(this, arguments);
};
})();
const _runTest =
/*#__PURE__*/
(function() {
var _ref3 = _asyncToGenerator(function*(test) {
(0, _state.dispatch)({
name: 'test_start',
test
});
const testContext = Object.create(null);
const _getState2 = (0, _state.getState)(),
hasFocusedTests = _getState2.hasFocusedTests,
testNamePattern = _getState2.testNamePattern;
const isSkipped =
test.mode === 'skip' ||
(hasFocusedTests && test.mode !== 'only') ||
(testNamePattern && !testNamePattern.test((0, _utils.getTestID)(test)));
if (isSkipped) {
(0, _state.dispatch)({
name: 'test_skip',
test
});
return;
}
if (test.mode === 'todo') {
(0, _state.dispatch)({
name: 'test_todo',
test
});
return;
}
const _getEachHooksForTest = (0, _utils.getEachHooksForTest)(test),
afterEach = _getEachHooksForTest.afterEach,
beforeEach = _getEachHooksForTest.beforeEach;
var _iteratorNormalCompletion5 = true;
var _didIteratorError5 = false;
var _iteratorError5 = undefined;
try {
for (
var _iterator5 = beforeEach[Symbol.iterator](), _step5;
!(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done);
_iteratorNormalCompletion5 = true
) {
const hook = _step5.value;
if (test.errors.length) {
// If any of the before hooks failed already, we don't run any
// hooks after that.
break;
}
yield _callCircusHook({
hook,
test,
testContext
});
}
} catch (err) {
_didIteratorError5 = true;
_iteratorError5 = err;
} finally {
try {
if (!_iteratorNormalCompletion5 && _iterator5.return != null) {
_iterator5.return();
}
} finally {
if (_didIteratorError5) {
throw _iteratorError5;
}
}
}
yield _callCircusTest(test, testContext);
var _iteratorNormalCompletion6 = true;
var _didIteratorError6 = false;
var _iteratorError6 = undefined;
try {
for (
var _iterator6 = afterEach[Symbol.iterator](), _step6;
!(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done);
_iteratorNormalCompletion6 = true
) {
const hook = _step6.value;
yield _callCircusHook({
hook,
test,
testContext
});
} // `afterAll` hooks should not affect test status (pass or fail), because if
// we had a global `afterAll` hook it would block all existing tests until
// this hook is executed. So we dispatch `test_done` right away.
} catch (err) {
_didIteratorError6 = true;
_iteratorError6 = err;
} finally {
try {
if (!_iteratorNormalCompletion6 && _iterator6.return != null) {
_iterator6.return();
}
} finally {
if (_didIteratorError6) {
throw _iteratorError6;
}
}
}
(0, _state.dispatch)({
name: 'test_done',
test
});
});
return function _runTest(_x2) {
return _ref3.apply(this, arguments);
};
})();
const _callCircusHook = ({hook, test, describeBlock, testContext}) => {
(0, _state.dispatch)({
hook,
name: 'hook_start'
});
const timeout = hook.timeout || (0, _state.getState)().testTimeout;
return (0, _utils.callAsyncCircusFn)(hook.fn, testContext, {
isHook: true,
timeout
})
.then(() =>
(0, _state.dispatch)({
describeBlock,
hook,
name: 'hook_success',
test
})
)
.catch(error =>
(0, _state.dispatch)({
describeBlock,
error,
hook,
name: 'hook_failure',
test
})
);
};
const _callCircusTest = (test, testContext) => {
(0, _state.dispatch)({
name: 'test_fn_start',
test
});
const timeout = test.timeout || (0, _state.getState)().testTimeout;
(0, _utils.invariant)(
test.fn,
`Tests with no 'fn' should have 'mode' set to 'skipped'`
);
if (test.errors.length) {
// We don't run the test if there's already an error in before hooks.
return Promise.resolve();
}
return (0, _utils.callAsyncCircusFn)(test.fn, testContext, {
isHook: false,
timeout
})
.then(() =>
(0, _state.dispatch)({
name: 'test_fn_success',
test
})
)
.catch(error =>
(0, _state.dispatch)({
error,
name: 'test_fn_failure',
test
})
);
};
var _default = run;
exports.default = _default;