.

node_modules/jest-circus/build/run.js

@@ -0,0 +1,432 @@
+'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;