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

'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;