RK-archives/ruoyi-ui/node_modules/jest-runner/build/runTest.js

'use strict';

Object.defineProperty(exports, '__esModule', {
  value: true
});
exports.default = runTest;

function _console() {
  const data = require('@jest/console');

  _console = function _console() {
    return data;
  };

  return data;
}

function _gracefulFs() {
  const data = _interopRequireDefault(require('graceful-fs'));

  _gracefulFs = function _gracefulFs() {
    return data;
  };

  return data;
}

function _jestUtil() {
  const data = require('jest-util');

  _jestUtil = function _jestUtil() {
    return data;
  };

  return data;
}

function _jestLeakDetector() {
  const data = _interopRequireDefault(require('jest-leak-detector'));

  _jestLeakDetector = function _jestLeakDetector() {
    return data;
  };

  return data;
}

function _jestConfig() {
  const data = require('jest-config');

  _jestConfig = function _jestConfig() {
    return data;
  };

  return data;
}

function docblock() {
  const data = _interopRequireWildcard(require('jest-docblock'));

  docblock = function docblock() {
    return data;
  };

  return data;
}

function _jestMessageUtil() {
  const data = require('jest-message-util');

  _jestMessageUtil = function _jestMessageUtil() {
    return data;
  };

  return data;
}

function _sourceMapSupport() {
  const data = _interopRequireDefault(require('source-map-support'));

  _sourceMapSupport = function _sourceMapSupport() {
    return data;
  };

  return data;
}

function _chalk() {
  const data = _interopRequireDefault(require('chalk'));

  _chalk = function _chalk() {
    return data;
  };

  return data;
}

function _interopRequireWildcard(obj) {
  if (obj && obj.__esModule) {
    return obj;
  } else {
    var newObj = {};
    if (obj != null) {
      for (var key in obj) {
        if (Object.prototype.hasOwnProperty.call(obj, key)) {
          var desc =
            Object.defineProperty && Object.getOwnPropertyDescriptor
              ? Object.getOwnPropertyDescriptor(obj, key)
              : {};
          if (desc.get || desc.set) {
            Object.defineProperty(newObj, key, desc);
          } else {
            newObj[key] = obj[key];
          }
        }
      }
    }
    newObj.default = obj;
    return newObj;
  }
}

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 _defineProperty(obj, key, value) {
  if (key in obj) {
    Object.defineProperty(obj, key, {
      value: value,
      enumerable: true,
      configurable: true,
      writable: true
    });
  } else {
    obj[key] = value;
  }
  return obj;
}

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 freezeConsole(testConsole, config) {
  // @ts-ignore: `_log` is `private` - we should figure out some proper API here
  testConsole._log = function fakeConsolePush(_type, message) {
    const error = new (_jestUtil()).ErrorWithStack(
      `${_chalk().default.red(
        `${_chalk().default.bold(
          'Cannot log after tests are done.'
        )} Did you forget to wait for something async in your test?`
      )}\nAttempted to log "${message}".`,
      fakeConsolePush
    );
    const formattedError = (0, _jestMessageUtil().formatExecError)(
      error,
      config,
      {
        noStackTrace: false
      },
      undefined,
      true
    );
    process.stderr.write('\n' + formattedError + '\n'); // TODO: set exit code in Jest 25
    // process.exitCode = 1;
  };
} // Keeping the core of "runTest" as a separate function (as "runTestInternal")
// is key to be able to detect memory leaks. Since all variables are local to
// the function, when "runTestInternal" finishes its execution, they can all be
// freed, UNLESS something else is leaking them (and that's why we can detect
// the leak!).
//
// If we had all the code in a single function, we should manually nullify all
// references to verify if there is a leak, which is not maintainable and error
// prone. That's why "runTestInternal" CANNOT be inlined inside "runTest".

function runTestInternal(_x, _x2, _x3, _x4, _x5) {
  return _runTestInternal.apply(this, arguments);
}

function _runTestInternal() {
  _runTestInternal = _asyncToGenerator(function*(
    path,
    globalConfig,
    config,
    resolver,
    context
  ) {
    const testSource = _gracefulFs().default.readFileSync(path, 'utf8');

    const docblockPragmas = docblock().parse(docblock().extract(testSource));
    const customEnvironment = docblockPragmas['jest-environment'];
    let testEnvironment = config.testEnvironment;

    if (customEnvironment) {
      if (Array.isArray(customEnvironment)) {
        throw new Error(
          `You can only define a single test environment through docblocks, got "${customEnvironment.join(
            ', '
          )}"`
        );
      }

      testEnvironment = (0, _jestConfig().getTestEnvironment)(
        _objectSpread({}, config, {
          testEnvironment: customEnvironment
        })
      );
    }

    const TestEnvironment = (0, _jestUtil().interopRequireDefault)(
      require(testEnvironment)
    ).default;
    const testFramework =
      process.env.JEST_CIRCUS === '1'
        ? require('jest-circus/runner') // eslint-disable-line import/no-extraneous-dependencies
        : require(config.testRunner);
    const Runtime = config.moduleLoader
      ? require(config.moduleLoader)
      : require('jest-runtime');
    let runtime = undefined;
    const consoleOut = globalConfig.useStderr ? process.stderr : process.stdout;

    const consoleFormatter = (type, message) =>
      (0, _console().getConsoleOutput)(
        config.cwd,
        !!globalConfig.verbose, // 4 = the console call is buried 4 stack frames deep
        _console().BufferedConsole.write(
          [],
          type,
          message,
          4,
          runtime && runtime.getSourceMaps()
        )
      );

    let testConsole;

    if (globalConfig.silent) {
      testConsole = new (_console()).NullConsole(
        consoleOut,
        consoleOut,
        consoleFormatter
      );
    } else if (globalConfig.verbose) {
      testConsole = new (_console()).CustomConsole(
        consoleOut,
        consoleOut,
        consoleFormatter
      );
    } else {
      testConsole = new (_console()).BufferedConsole(
        () => runtime && runtime.getSourceMaps()
      );
    }

    const environment = new TestEnvironment(config, {
      console: testConsole,
      docblockPragmas,
      testPath: path
    });
    const leakDetector = config.detectLeaks
      ? new (_jestLeakDetector()).default(environment)
      : null;
    const cacheFS = {
      [path]: testSource
    };
    (0, _jestUtil().setGlobal)(environment.global, 'console', testConsole);
    runtime = new Runtime(config, environment, resolver, cacheFS, {
      changedFiles: context && context.changedFiles,
      collectCoverage: globalConfig.collectCoverage,
      collectCoverageFrom: globalConfig.collectCoverageFrom,
      collectCoverageOnlyFrom: globalConfig.collectCoverageOnlyFrom
    });
    const start = Date.now();
    const sourcemapOptions = {
      environment: 'node',
      handleUncaughtExceptions: false,
      retrieveSourceMap: source => {
        const sourceMaps = runtime && runtime.getSourceMaps();
        const sourceMapSource = sourceMaps && sourceMaps[source];

        if (sourceMapSource) {
          try {
            return {
              map: JSON.parse(
                _gracefulFs().default.readFileSync(sourceMapSource, 'utf8')
              ),
              url: source
            };
          } catch (e) {}
        }

        return null;
      }
    }; // For tests

    runtime
      .requireInternalModule(
        require.resolve('source-map-support'),
        'source-map-support'
      )
      .install(sourcemapOptions); // For runtime errors

    _sourceMapSupport().default.install(sourcemapOptions);

    if (
      environment.global &&
      environment.global.process &&
      environment.global.process.exit
    ) {
      const realExit = environment.global.process.exit;

      environment.global.process.exit = function exit(...args) {
        const error = new (_jestUtil()).ErrorWithStack(
          `process.exit called with "${args.join(', ')}"`,
          exit
        );
        const formattedError = (0, _jestMessageUtil().formatExecError)(
          error,
          config,
          {
            noStackTrace: false
          },
          undefined,
          true
        );
        process.stderr.write(formattedError);
        return realExit(...args);
      };
    }

    try {
      yield environment.setup();
      let result;

      try {
        result = yield testFramework(
          globalConfig,
          config,
          environment,
          runtime,
          path
        );
      } catch (err) {
        // Access stack before uninstalling sourcemaps
        err.stack;
        throw err;
      }

      freezeConsole(testConsole, config);
      const testCount =
        result.numPassingTests +
        result.numFailingTests +
        result.numPendingTests +
        result.numTodoTests;
      result.perfStats = {
        end: Date.now(),
        start
      };
      result.testFilePath = path;
      result.console = testConsole.getBuffer();
      result.skipped = testCount === result.numPendingTests;
      result.displayName = config.displayName;
      const coverage = runtime.getAllCoverageInfoCopy();

      if (coverage) {
        const coverageKeys = Object.keys(coverage);

        if (coverageKeys.length) {
          result.coverage = coverage;
          result.sourceMaps = runtime.getSourceMapInfo(new Set(coverageKeys));
        }
      }

      if (globalConfig.logHeapUsage) {
        if (global.gc) {
          global.gc();
        }

        result.memoryUsage = process.memoryUsage().heapUsed;
      } // Delay the resolution to allow log messages to be output.

      return new Promise(resolve => {
        setImmediate(() =>
          resolve({
            leakDetector,
            result
          })
        );
      });
    } finally {
      yield environment.teardown();

      _sourceMapSupport().default.resetRetrieveHandlers();
    }
  });
  return _runTestInternal.apply(this, arguments);
}

function runTest(_x6, _x7, _x8, _x9, _x10) {
  return _runTest.apply(this, arguments);
}

function _runTest() {
  _runTest = _asyncToGenerator(function*(
    path,
    globalConfig,
    config,
    resolver,
    context
  ) {
    const _ref = yield runTestInternal(
        path,
        globalConfig,
        config,
        resolver,
        context
      ),
      leakDetector = _ref.leakDetector,
      result = _ref.result;

    if (leakDetector) {
      // We wanna allow a tiny but time to pass to allow last-minute cleanup
      yield new Promise(resolve => setTimeout(resolve, 100)); // Resolve leak detector, outside the "runTestInternal" closure.

      result.leaks = leakDetector.isLeaking();
    } else {
      result.leaks = false;
    }

    return result;
  });
  return _runTest.apply(this, arguments);
}