433 lines
11 KiB
JavaScript
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;
|