Updating NPM dependencies

node_modules/jest-runner/build/index.js

@@ -1,9 +1,29 @@
 'use strict';
 
+function _chalk() {
+  const data = _interopRequireDefault(require('chalk'));
+
+  _chalk = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _emittery() {
+  const data = _interopRequireDefault(require('emittery'));
+
+  _emittery = function () {
+    return data;
+  };
+
+  return data;
+}
+
 function _exit() {
   const data = _interopRequireDefault(require('exit'));
 
-  _exit = function _exit() {
+  _exit = function () {
     return data;
   };
 
@@ -13,7 +33,17 @@ function _exit() {
 function _throat() {
   const data = _interopRequireDefault(require('throat'));
 
-  _throat = function _throat() {
+  _throat = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _jestUtil() {
+  const data = require('jest-util');
+
+  _jestUtil = function () {
     return data;
   };
 
@@ -23,7 +53,7 @@ function _throat() {
 function _jestWorker() {
   const data = _interopRequireDefault(require('jest-worker'));
 
-  _jestWorker = function _jestWorker() {
+  _jestWorker = function () {
     return data;
   };
 
@@ -32,62 +62,10 @@ function _jestWorker() {
 
 var _runTest = _interopRequireDefault(require('./runTest'));
 
-var _testWorker = require('./testWorker');
-
 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 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);
-    });
-  };
-}
-
 function _defineProperty(obj, key, value) {
   if (key in obj) {
     Object.defineProperty(obj, key, {
@@ -104,187 +82,230 @@ function _defineProperty(obj, key, value) {
 
 const TEST_WORKER_PATH = require.resolve('./testWorker');
 
-/* eslint-disable-next-line no-redeclare */
 class TestRunner {
   constructor(globalConfig, context) {
     _defineProperty(this, '_globalConfig', void 0);
 
     _defineProperty(this, '_context', void 0);
 
+    _defineProperty(this, 'eventEmitter', new (_emittery().default.Typed)());
+
+    _defineProperty(
+      this,
+      '__PRIVATE_UNSTABLE_API_supportsEventEmitters__',
+      true
+    );
+
+    _defineProperty(this, 'isSerial', void 0);
+
+    _defineProperty(this, 'on', this.eventEmitter.on.bind(this.eventEmitter));
+
     this._globalConfig = globalConfig;
     this._context = context || {};
   }
 
-  runTests(tests, watcher, onStart, onResult, onFailure, options) {
-    var _this = this;
-
-    return _asyncToGenerator(function*() {
-      return yield options.serial
-        ? _this._createInBandTestRun(
-            tests,
-            watcher,
-            onStart,
-            onResult,
-            onFailure
-          )
-        : _this._createParallelTestRun(
-            tests,
-            watcher,
-            onStart,
-            onResult,
-            onFailure
-          );
-    })();
+  async runTests(tests, watcher, onStart, onResult, onFailure, options) {
+    return await (options.serial
+      ? this._createInBandTestRun(tests, watcher, onStart, onResult, onFailure)
+      : this._createParallelTestRun(
+          tests,
+          watcher,
+          onStart,
+          onResult,
+          onFailure
+        ));
   }
 
-  _createInBandTestRun(tests, watcher, onStart, onResult, onFailure) {
-    var _this2 = this;
+  async _createInBandTestRun(tests, watcher, onStart, onResult, onFailure) {
+    process.env.JEST_WORKER_ID = '1';
+    const mutex = (0, _throat().default)(1);
+    return tests.reduce(
+      (promise, test) =>
+        mutex(() =>
+          promise
+            .then(async () => {
+              if (watcher.isInterrupted()) {
+                throw new CancelRun();
+              }
 
-    return _asyncToGenerator(function*() {
-      process.env.JEST_WORKER_ID = '1';
-      const mutex = (0, _throat().default)(1);
-      return tests.reduce(
-        (promise, test) =>
-          mutex(() =>
-            promise
-              .then(
-                /*#__PURE__*/
-                _asyncToGenerator(function*() {
-                  if (watcher.isInterrupted()) {
-                    throw new CancelRun();
-                  }
+              let sendMessageToJest; // Remove `if(onStart)` in Jest 27
 
-                  yield onStart(test);
-                  return (0,
-                  _runTest.default)(test.path, _this2._globalConfig, test.context.config, test.context.resolver, _this2._context);
-                })
-              )
-              .then(result => onResult(test, result))
-              .catch(err => onFailure(test, err))
-          ),
-        Promise.resolve()
-      );
-    })();
+              if (onStart) {
+                await onStart(test);
+                return (0, _runTest.default)(
+                  test.path,
+                  this._globalConfig,
+                  test.context.config,
+                  test.context.resolver,
+                  this._context,
+                  undefined
+                );
+              } else {
+                // `deepCyclicCopy` used here to avoid mem-leak
+                sendMessageToJest = (eventName, args) =>
+                  this.eventEmitter.emit(
+                    eventName,
+                    (0, _jestUtil().deepCyclicCopy)(args, {
+                      keepPrototype: false
+                    })
+                  );
+
+                await this.eventEmitter.emit('test-file-start', [test]);
+                return (0, _runTest.default)(
+                  test.path,
+                  this._globalConfig,
+                  test.context.config,
+                  test.context.resolver,
+                  this._context,
+                  sendMessageToJest
+                );
+              }
+            })
+            .then(result => {
+              if (onResult) {
+                return onResult(test, result);
+              } else {
+                return this.eventEmitter.emit('test-file-success', [
+                  test,
+                  result
+                ]);
+              }
+            })
+            .catch(err => {
+              if (onFailure) {
+                return onFailure(test, err);
+              } else {
+                return this.eventEmitter.emit('test-file-failure', [test, err]);
+              }
+            })
+        ),
+      Promise.resolve()
+    );
   }
 
-  _createParallelTestRun(tests, watcher, onStart, onResult, onFailure) {
-    var _this3 = this;
+  async _createParallelTestRun(tests, watcher, onStart, onResult, onFailure) {
+    const resolvers = new Map();
 
-    return _asyncToGenerator(function*() {
-      const resolvers = new Map();
-      var _iteratorNormalCompletion = true;
-      var _didIteratorError = false;
-      var _iteratorError = undefined;
+    for (const test of tests) {
+      if (!resolvers.has(test.context.config.name)) {
+        resolvers.set(test.context.config.name, {
+          config: test.context.config,
+          serializableModuleMap: test.context.moduleMap.toJSON()
+        });
+      }
+    }
 
-      try {
-        for (
-          var _iterator = tests[Symbol.iterator](), _step;
-          !(_iteratorNormalCompletion = (_step = _iterator.next()).done);
-          _iteratorNormalCompletion = true
-        ) {
-          const test = _step.value;
-
-          if (!resolvers.has(test.context.config.name)) {
-            resolvers.set(test.context.config.name, {
-              config: test.context.config,
-              serializableModuleMap: test.context.moduleMap.toJSON()
-            });
-          }
+    const worker = new (_jestWorker().default)(TEST_WORKER_PATH, {
+      exposedMethods: ['worker'],
+      forkOptions: {
+        stdio: 'pipe'
+      },
+      maxRetries: 3,
+      numWorkers: this._globalConfig.maxWorkers,
+      setupArgs: [
+        {
+          serializableResolvers: Array.from(resolvers.values())
         }
-      } catch (err) {
-        _didIteratorError = true;
-        _iteratorError = err;
-      } finally {
-        try {
-          if (!_iteratorNormalCompletion && _iterator.return != null) {
-            _iterator.return();
-          }
-        } finally {
-          if (_didIteratorError) {
-            throw _iteratorError;
-          }
+      ]
+    });
+    if (worker.getStdout()) worker.getStdout().pipe(process.stdout);
+    if (worker.getStderr()) worker.getStderr().pipe(process.stderr);
+    const mutex = (0, _throat().default)(this._globalConfig.maxWorkers); // Send test suites to workers continuously instead of all at once to track
+    // the start time of individual tests.
+
+    const runTestInWorker = test =>
+      mutex(async () => {
+        if (watcher.isInterrupted()) {
+          return Promise.reject();
+        } // Remove `if(onStart)` in Jest 27
+
+        if (onStart) {
+          await onStart(test);
+        } else {
+          await this.eventEmitter.emit('test-file-start', [test]);
         }
+
+        const promise = worker.worker({
+          config: test.context.config,
+          context: {
+            ...this._context,
+            changedFiles:
+              this._context.changedFiles &&
+              Array.from(this._context.changedFiles),
+            sourcesRelatedToTestsInChangedFiles:
+              this._context.sourcesRelatedToTestsInChangedFiles &&
+              Array.from(this._context.sourcesRelatedToTestsInChangedFiles)
+          },
+          globalConfig: this._globalConfig,
+          path: test.path
+        });
+
+        if (promise.UNSTABLE_onCustomMessage) {
+          // TODO: Get appropriate type for `onCustomMessage`
+          promise.UNSTABLE_onCustomMessage(([event, payload]) => {
+            this.eventEmitter.emit(event, payload);
+          });
+        }
+
+        return promise;
+      });
+
+    const onError = async (err, test) => {
+      // Remove `if(onFailure)` in Jest 27
+      if (onFailure) {
+        await onFailure(test, err);
+      } else {
+        await this.eventEmitter.emit('test-file-failure', [test, err]);
       }
 
-      const worker = new (_jestWorker()).default(TEST_WORKER_PATH, {
-        exposedMethods: ['worker'],
-        forkOptions: {
-          stdio: 'pipe'
-        },
-        maxRetries: 3,
-        numWorkers: _this3._globalConfig.maxWorkers,
-        setupArgs: [
-          {
-            serializableResolvers: Array.from(resolvers.values())
-          }
-        ]
-      });
-      if (worker.getStdout()) worker.getStdout().pipe(process.stdout);
-      if (worker.getStderr()) worker.getStderr().pipe(process.stderr);
-      const mutex = (0, _throat().default)(_this3._globalConfig.maxWorkers); // Send test suites to workers continuously instead of all at once to track
-      // the start time of individual tests.
-
-      const runTestInWorker = test =>
-        mutex(
-          /*#__PURE__*/
-          _asyncToGenerator(function*() {
-            if (watcher.isInterrupted()) {
-              return Promise.reject();
-            }
-
-            yield onStart(test);
-            return worker.worker({
-              config: test.context.config,
-              context: _objectSpread({}, _this3._context, {
-                changedFiles:
-                  _this3._context.changedFiles &&
-                  Array.from(_this3._context.changedFiles)
-              }),
-              globalConfig: _this3._globalConfig,
-              path: test.path
-            });
-          })
+      if (err.type === 'ProcessTerminatedError') {
+        console.error(
+          'A worker process has quit unexpectedly! ' +
+            'Most likely this is an initialization error.'
         );
+        (0, _exit().default)(1);
+      }
+    };
 
-      const onError =
-        /*#__PURE__*/
-        (function() {
-          var _ref3 = _asyncToGenerator(function*(err, test) {
-            yield onFailure(test, err);
-
-            if (err.type === 'ProcessTerminatedError') {
-              console.error(
-                'A worker process has quit unexpectedly! ' +
-                  'Most likely this is an initialization error.'
-              );
-              (0, _exit().default)(1);
-            }
-          });
-
-          return function onError(_x, _x2) {
-            return _ref3.apply(this, arguments);
-          };
-        })();
-
-      const onInterrupt = new Promise((_, reject) => {
-        watcher.on('change', state => {
-          if (state.interrupted) {
-            reject(new CancelRun());
-          }
-        });
+    const onInterrupt = new Promise((_, reject) => {
+      watcher.on('change', state => {
+        if (state.interrupted) {
+          reject(new CancelRun());
+        }
       });
-      const runAllTests = Promise.all(
-        tests.map(test =>
-          runTestInWorker(test)
-            .then(testResult => onResult(test, testResult))
-            .catch(error => onError(error, test))
-        )
-      );
+    });
+    const runAllTests = Promise.all(
+      tests.map(test =>
+        runTestInWorker(test)
+          .then(result => {
+            if (onResult) {
+              return onResult(test, result);
+            } else {
+              return this.eventEmitter.emit('test-file-success', [
+                test,
+                result
+              ]);
+            }
+          })
+          .catch(error => onError(error, test))
+      )
+    );
 
-      const cleanup = () => worker.end();
+    const cleanup = async () => {
+      const {forceExited} = await worker.end();
 
-      return Promise.race([runAllTests, onInterrupt]).then(cleanup, cleanup);
-    })();
+      if (forceExited) {
+        console.error(
+          _chalk().default.yellow(
+            'A worker process has failed to exit gracefully and has been force exited. ' +
+              'This is likely caused by tests leaking due to improper teardown. ' +
+              'Try running with --detectOpenHandles to find leaks.'
+          )
+        );
+      }
+    };
+
+    return Promise.race([runAllTests, onInterrupt]).then(cleanup, cleanup);
   }
 }