823 lines
28 KiB
JavaScript
823 lines
28 KiB
JavaScript
|
'use strict';var _slicedToArray = function () {function sliceIterator(arr, i) {var _arr = [];var _n = true;var _d = false;var _e = undefined;try {for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {_arr.push(_s.value);if (i && _arr.length === i) break;}} catch (err) {_d = true;_e = err;} finally {try {if (!_n && _i["return"]) _i["return"]();} finally {if (_d) throw _e;}}return _arr;}return function (arr, i) {if (Array.isArray(arr)) {return arr;} else if (Symbol.iterator in Object(arr)) {return sliceIterator(arr, i);} else {throw new TypeError("Invalid attempt to destructure non-iterable instance");}};}(); /**
|
||
|
|
* Copyright (c) 2014-present, Facebook, Inc. All rights reserved.
|
||
|
|
*
|
||
|
|
* This source code is licensed under the MIT license found in the
|
||
|
|
* LICENSE file in the root directory of this source tree.
|
||
|
|
*
|
||
|
|
*
|
||
|
|
*/var _path;
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
function _load_path() {return _path = _interopRequireDefault(require('path'));}var _jestHasteMap;
|
||
|
|
function _load_jestHasteMap() {return _jestHasteMap = _interopRequireDefault(require('jest-haste-map'));}var _jestResolve;
|
||
|
|
function _load_jestResolve() {return _jestResolve = _interopRequireDefault(require('jest-resolve'));}var _jestUtil;
|
||
|
|
function _load_jestUtil() {return _jestUtil = require('jest-util');}var _jestRegexUtil;
|
||
|
|
function _load_jestRegexUtil() {return _jestRegexUtil = require('jest-regex-util');}var _gracefulFs;
|
||
|
|
function _load_gracefulFs() {return _gracefulFs = _interopRequireDefault(require('graceful-fs'));}var _stripBom;
|
||
|
|
function _load_stripBom() {return _stripBom = _interopRequireDefault(require('strip-bom'));}var _script_transformer;
|
||
|
|
function _load_script_transformer() {return _script_transformer = _interopRequireDefault(require('./script_transformer'));}var _should_instrument;
|
||
|
|
function _load_should_instrument() {return _should_instrument = _interopRequireDefault(require('./should_instrument'));}var _cli;
|
||
|
|
function _load_cli() {return _cli = require('./cli');}var _args;
|
||
|
|
function _load_args() {return _args = require('./cli/args');}function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { default: obj };}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
const NODE_MODULES = (_path || _load_path()).default.sep + 'node_modules' + (_path || _load_path()).default.sep;
|
||
|
|
const SNAPSHOT_EXTENSION = 'snap';
|
||
|
|
|
||
|
|
const getModuleNameMapper = config => {
|
||
|
|
if (
|
||
|
|
Array.isArray(config.moduleNameMapper) &&
|
||
|
|
config.moduleNameMapper.length)
|
||
|
|
{
|
||
|
|
return config.moduleNameMapper.map((_ref) => {var _ref2 = _slicedToArray(_ref, 2);let regex = _ref2[0],moduleName = _ref2[1];
|
||
|
|
return { moduleName, regex: new RegExp(regex) };
|
||
|
|
});
|
||
|
|
}
|
||
|
|
return null;
|
||
|
|
};
|
||
|
|
|
||
|
|
const unmockRegExpCache = new WeakMap();
|
||
|
|
|
||
|
|
class Runtime {
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
constructor(
|
||
|
|
config,
|
||
|
|
environment,
|
||
|
|
resolver,
|
||
|
|
cacheFS,
|
||
|
|
coverageOptions)
|
||
|
|
{
|
||
|
|
this._cacheFS = cacheFS || Object.create(null);
|
||
|
|
this._config = config;
|
||
|
|
this._coverageOptions = coverageOptions || {
|
||
|
|
collectCoverage: false,
|
||
|
|
collectCoverageFrom: [],
|
||
|
|
collectCoverageOnlyFrom: null,
|
||
|
|
mapCoverage: false };
|
||
|
|
|
||
|
|
this._currentlyExecutingModulePath = '';
|
||
|
|
this._environment = environment;
|
||
|
|
this._explicitShouldMock = Object.create(null);
|
||
|
|
this._internalModuleRegistry = Object.create(null);
|
||
|
|
this._isCurrentlyExecutingManualMock = null;
|
||
|
|
this._mockFactories = Object.create(null);
|
||
|
|
this._mockRegistry = Object.create(null);
|
||
|
|
this._moduleMocker = this._environment.moduleMocker;
|
||
|
|
this._moduleRegistry = Object.create(null);
|
||
|
|
this._resolver = resolver;
|
||
|
|
this._scriptTransformer = new (_script_transformer || _load_script_transformer()).default(config);
|
||
|
|
this._shouldAutoMock = config.automock;
|
||
|
|
this._sourceMapRegistry = Object.create(null);
|
||
|
|
this._virtualMocks = Object.create(null);
|
||
|
|
|
||
|
|
this._mockMetaDataCache = Object.create(null);
|
||
|
|
this._shouldMockModuleCache = Object.create(null);
|
||
|
|
this._shouldUnmockTransitiveDependenciesCache = Object.create(null);
|
||
|
|
this._transitiveShouldMock = Object.create(null);
|
||
|
|
|
||
|
|
this._unmockList = unmockRegExpCache.get(config);
|
||
|
|
if (!this._unmockList && config.unmockedModulePathPatterns) {
|
||
|
|
this._unmockList = new RegExp(
|
||
|
|
config.unmockedModulePathPatterns.join('|'));
|
||
|
|
|
||
|
|
unmockRegExpCache.set(config, this._unmockList);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (config.automock) {
|
||
|
|
config.setupFiles.forEach(filePath => {
|
||
|
|
if (filePath && filePath.includes(NODE_MODULES)) {
|
||
|
|
const moduleID = this._resolver.getModuleID(
|
||
|
|
this._virtualMocks,
|
||
|
|
filePath);
|
||
|
|
|
||
|
|
this._transitiveShouldMock[moduleID] = false;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
this.resetModules();
|
||
|
|
|
||
|
|
if (config.setupFiles.length) {
|
||
|
|
for (let i = 0; i < config.setupFiles.length; i++) {
|
||
|
|
this.requireModule(config.setupFiles[i]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static shouldInstrument(
|
||
|
|
filename,
|
||
|
|
options,
|
||
|
|
config)
|
||
|
|
{
|
||
|
|
return (0, (_should_instrument || _load_should_instrument()).default)(
|
||
|
|
filename,
|
||
|
|
{
|
||
|
|
collectCoverage: options.collectCoverage,
|
||
|
|
collectCoverageFrom: options.collectCoverageFrom,
|
||
|
|
collectCoverageOnlyFrom: options.collectCoverageOnlyFrom,
|
||
|
|
mapCoverage: options.mapCoverage },
|
||
|
|
|
||
|
|
config);
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
static createContext(
|
||
|
|
config,
|
||
|
|
options)
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
{
|
||
|
|
(0, (_jestUtil || _load_jestUtil()).createDirectory)(config.cacheDirectory);
|
||
|
|
const instance = Runtime.createHasteMap(config, {
|
||
|
|
console: options.console,
|
||
|
|
maxWorkers: options.maxWorkers,
|
||
|
|
resetCache: !config.cache,
|
||
|
|
watch: options.watch,
|
||
|
|
watchman: options.watchman });
|
||
|
|
|
||
|
|
return instance.build().then(
|
||
|
|
hasteMap => ({
|
||
|
|
config,
|
||
|
|
hasteFS: hasteMap.hasteFS,
|
||
|
|
moduleMap: hasteMap.moduleMap,
|
||
|
|
resolver: Runtime.createResolver(config, hasteMap.moduleMap) }),
|
||
|
|
|
||
|
|
error => {
|
||
|
|
throw error;
|
||
|
|
});
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
static createHasteMap(
|
||
|
|
config,
|
||
|
|
options)
|
||
|
|
{
|
||
|
|
const ignorePattern = new RegExp(
|
||
|
|
[config.cacheDirectory].concat(config.modulePathIgnorePatterns).join('|'));
|
||
|
|
|
||
|
|
|
||
|
|
return new (_jestHasteMap || _load_jestHasteMap()).default({
|
||
|
|
cacheDirectory: config.cacheDirectory,
|
||
|
|
console: options && options.console,
|
||
|
|
extensions: [SNAPSHOT_EXTENSION].concat(config.moduleFileExtensions),
|
||
|
|
hasteImplModulePath: config.haste.hasteImplModulePath,
|
||
|
|
ignorePattern,
|
||
|
|
maxWorkers: options && options.maxWorkers || 1,
|
||
|
|
mocksPattern: (0, (_jestRegexUtil || _load_jestRegexUtil()).escapePathForRegex)((_path || _load_path()).default.sep + '__mocks__' + (_path || _load_path()).default.sep),
|
||
|
|
name: config.name,
|
||
|
|
platforms: config.haste.platforms || ['ios', 'android'],
|
||
|
|
providesModuleNodeModules: config.haste.providesModuleNodeModules,
|
||
|
|
resetCache: options && options.resetCache,
|
||
|
|
retainAllFiles: false,
|
||
|
|
roots: config.roots,
|
||
|
|
useWatchman: options && options.watchman,
|
||
|
|
watch: options && options.watch });
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
static createResolver(config, moduleMap) {
|
||
|
|
return new (_jestResolve || _load_jestResolve()).default(moduleMap, {
|
||
|
|
browser: config.browser,
|
||
|
|
defaultPlatform: config.haste.defaultPlatform,
|
||
|
|
extensions: config.moduleFileExtensions.map(extension => '.' + extension),
|
||
|
|
hasCoreModules: true,
|
||
|
|
moduleDirectories: config.moduleDirectories,
|
||
|
|
moduleNameMapper: getModuleNameMapper(config),
|
||
|
|
modulePaths: config.modulePaths,
|
||
|
|
platforms: config.haste.platforms,
|
||
|
|
resolver: config.resolver,
|
||
|
|
rootDir: config.rootDir });
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
static runCLI(args, info) {
|
||
|
|
return (0, (_cli || _load_cli()).run)(args, info);
|
||
|
|
}
|
||
|
|
|
||
|
|
static getCLIOptions() {
|
||
|
|
return (_args || _load_args()).options;
|
||
|
|
}
|
||
|
|
|
||
|
|
requireModule(
|
||
|
|
from,
|
||
|
|
moduleName,
|
||
|
|
options)
|
||
|
|
{
|
||
|
|
const moduleID = this._resolver.getModuleID(
|
||
|
|
this._virtualMocks,
|
||
|
|
from,
|
||
|
|
moduleName);
|
||
|
|
|
||
|
|
let modulePath;
|
||
|
|
|
||
|
|
const moduleRegistry =
|
||
|
|
!options || !options.isInternalModule ?
|
||
|
|
this._moduleRegistry :
|
||
|
|
this._internalModuleRegistry;
|
||
|
|
|
||
|
|
// Some old tests rely on this mocking behavior. Ideally we'll change this
|
||
|
|
// to be more explicit.
|
||
|
|
const moduleResource = moduleName && this._resolver.getModule(moduleName);
|
||
|
|
const manualMock =
|
||
|
|
moduleName && this._resolver.getMockModule(from, moduleName);
|
||
|
|
if (
|
||
|
|
(!options || !options.isInternalModule) &&
|
||
|
|
!moduleResource &&
|
||
|
|
manualMock &&
|
||
|
|
manualMock !== this._isCurrentlyExecutingManualMock &&
|
||
|
|
this._explicitShouldMock[moduleID] !== false)
|
||
|
|
{
|
||
|
|
modulePath = manualMock;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (moduleName && this._resolver.isCoreModule(moduleName)) {
|
||
|
|
return this._requireCoreModule(moduleName);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!modulePath) {
|
||
|
|
modulePath = this._resolveModule(from, moduleName);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!moduleRegistry[modulePath]) {
|
||
|
|
// We must register the pre-allocated module object first so that any
|
||
|
|
// circular dependencies that may arise while evaluating the module can
|
||
|
|
|
||
|
|
const localModule = {
|
||
|
|
children: [],
|
||
|
|
exports: {},
|
||
|
|
filename: modulePath,
|
||
|
|
id: modulePath,
|
||
|
|
loaded: false };
|
||
|
|
|
||
|
|
moduleRegistry[modulePath] = localModule;
|
||
|
|
if ((_path || _load_path()).default.extname(modulePath) === '.json') {
|
||
|
|
localModule.exports = this._environment.global.JSON.parse(
|
||
|
|
(0, (_stripBom || _load_stripBom()).default)((_gracefulFs || _load_gracefulFs()).default.readFileSync(modulePath, 'utf8')));
|
||
|
|
|
||
|
|
} else if ((_path || _load_path()).default.extname(modulePath) === '.node') {
|
||
|
|
// $FlowFixMe
|
||
|
|
localModule.exports = require(modulePath);
|
||
|
|
} else {
|
||
|
|
this._execModule(localModule, options, moduleRegistry, from);
|
||
|
|
}
|
||
|
|
|
||
|
|
localModule.loaded = true;
|
||
|
|
}
|
||
|
|
return moduleRegistry[modulePath].exports;
|
||
|
|
}
|
||
|
|
|
||
|
|
requireInternalModule(from, to) {
|
||
|
|
return this.requireModule(from, to, { isInternalModule: true });
|
||
|
|
}
|
||
|
|
|
||
|
|
requireMock(from, moduleName) {
|
||
|
|
const moduleID = this._resolver.getModuleID(
|
||
|
|
this._virtualMocks,
|
||
|
|
from,
|
||
|
|
moduleName);
|
||
|
|
|
||
|
|
|
||
|
|
if (this._mockRegistry[moduleID]) {
|
||
|
|
return this._mockRegistry[moduleID];
|
||
|
|
}
|
||
|
|
|
||
|
|
if (moduleID in this._mockFactories) {
|
||
|
|
return this._mockRegistry[moduleID] = this._mockFactories[moduleID]();
|
||
|
|
}
|
||
|
|
|
||
|
|
let manualMock = this._resolver.getMockModule(from, moduleName);
|
||
|
|
let modulePath;
|
||
|
|
if (manualMock) {
|
||
|
|
modulePath = this._resolveModule(from, manualMock);
|
||
|
|
} else {
|
||
|
|
modulePath = this._resolveModule(from, moduleName);
|
||
|
|
}
|
||
|
|
// If the actual module file has a __mocks__ dir sitting immediately next
|
||
|
|
// to it, look to see if there is a manual mock for this file.
|
||
|
|
//
|
||
|
|
// subDir1/my_module.js
|
||
|
|
// subDir1/__mocks__/my_module.js
|
||
|
|
// subDir2/my_module.js
|
||
|
|
// subDir2/__mocks__/my_module.js
|
||
|
|
//
|
||
|
|
// Where some other module does a relative require into each of the
|
||
|
|
// respective subDir{1,2} directories and expects a manual mock
|
||
|
|
// corresponding to that particular my_module.js file.
|
||
|
|
const moduleDir = (_path || _load_path()).default.dirname(modulePath);
|
||
|
|
const moduleFileName = (_path || _load_path()).default.basename(modulePath);
|
||
|
|
const potentialManualMock = (_path || _load_path()).default.join(
|
||
|
|
moduleDir,
|
||
|
|
'__mocks__',
|
||
|
|
moduleFileName);
|
||
|
|
|
||
|
|
if ((_gracefulFs || _load_gracefulFs()).default.existsSync(potentialManualMock)) {
|
||
|
|
manualMock = true;
|
||
|
|
modulePath = potentialManualMock;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (manualMock) {
|
||
|
|
const localModule = {
|
||
|
|
children: [],
|
||
|
|
exports: {},
|
||
|
|
filename: modulePath,
|
||
|
|
id: modulePath,
|
||
|
|
loaded: false };
|
||
|
|
|
||
|
|
this._execModule(localModule, undefined, this._mockRegistry, from);
|
||
|
|
this._mockRegistry[moduleID] = localModule.exports;
|
||
|
|
localModule.loaded = true;
|
||
|
|
} else {
|
||
|
|
// Look for a real module to generate an automock from
|
||
|
|
this._mockRegistry[moduleID] = this._generateMock(from, moduleName);
|
||
|
|
}
|
||
|
|
|
||
|
|
return this._mockRegistry[moduleID];
|
||
|
|
}
|
||
|
|
|
||
|
|
requireModuleOrMock(from, moduleName) {
|
||
|
|
if (this._shouldMock(from, moduleName)) {
|
||
|
|
return this.requireMock(from, moduleName);
|
||
|
|
} else {
|
||
|
|
return this.requireModule(from, moduleName);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
resetModules() {
|
||
|
|
this._mockRegistry = Object.create(null);
|
||
|
|
this._moduleRegistry = Object.create(null);
|
||
|
|
|
||
|
|
if (this._environment && this._environment.global) {
|
||
|
|
const envGlobal = this._environment.global;
|
||
|
|
Object.keys(envGlobal).forEach(key => {
|
||
|
|
const globalMock = envGlobal[key];
|
||
|
|
if (
|
||
|
|
typeof globalMock === 'object' && globalMock !== null ||
|
||
|
|
typeof globalMock === 'function')
|
||
|
|
{
|
||
|
|
globalMock._isMockFunction && globalMock.mockClear();
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
if (envGlobal.mockClearTimers) {
|
||
|
|
envGlobal.mockClearTimers();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
getAllCoverageInfoCopy() {
|
||
|
|
return (0, (_jestUtil || _load_jestUtil()).deepCyclicCopy)(this._environment.global.__coverage__);
|
||
|
|
}
|
||
|
|
|
||
|
|
getSourceMapInfo() {
|
||
|
|
return Object.keys(this._sourceMapRegistry).reduce((result, sourcePath) => {
|
||
|
|
if ((_gracefulFs || _load_gracefulFs()).default.existsSync(this._sourceMapRegistry[sourcePath])) {
|
||
|
|
result[sourcePath] = this._sourceMapRegistry[sourcePath];
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
}, {});
|
||
|
|
}
|
||
|
|
|
||
|
|
setMock(
|
||
|
|
from,
|
||
|
|
moduleName,
|
||
|
|
mockFactory,
|
||
|
|
options)
|
||
|
|
{
|
||
|
|
if (options && options.virtual) {
|
||
|
|
const mockPath = this._resolver.getModulePath(from, moduleName);
|
||
|
|
this._virtualMocks[mockPath] = true;
|
||
|
|
}
|
||
|
|
const moduleID = this._resolver.getModuleID(
|
||
|
|
this._virtualMocks,
|
||
|
|
from,
|
||
|
|
moduleName);
|
||
|
|
|
||
|
|
this._explicitShouldMock[moduleID] = true;
|
||
|
|
this._mockFactories[moduleID] = mockFactory;
|
||
|
|
}
|
||
|
|
|
||
|
|
restoreAllMocks() {
|
||
|
|
this._moduleMocker.restoreAllMocks();
|
||
|
|
}
|
||
|
|
|
||
|
|
resetAllMocks() {
|
||
|
|
this._moduleMocker.resetAllMocks();
|
||
|
|
}
|
||
|
|
|
||
|
|
clearAllMocks() {
|
||
|
|
this._moduleMocker.clearAllMocks();
|
||
|
|
}
|
||
|
|
|
||
|
|
_resolveModule(from, to) {
|
||
|
|
return to ? this._resolver.resolveModule(from, to) : from;
|
||
|
|
}
|
||
|
|
|
||
|
|
_execModule(
|
||
|
|
localModule,
|
||
|
|
options,
|
||
|
|
moduleRegistry,
|
||
|
|
from)
|
||
|
|
{
|
||
|
|
// If the environment was disposed, prevent this module from being executed.
|
||
|
|
if (!this._environment.global) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
const isInternalModule = !!(options && options.isInternalModule);
|
||
|
|
const filename = localModule.filename;
|
||
|
|
const lastExecutingModulePath = this._currentlyExecutingModulePath;
|
||
|
|
this._currentlyExecutingModulePath = filename;
|
||
|
|
const origCurrExecutingManualMock = this._isCurrentlyExecutingManualMock;
|
||
|
|
this._isCurrentlyExecutingManualMock = filename;
|
||
|
|
|
||
|
|
const dirname = (_path || _load_path()).default.dirname(filename);
|
||
|
|
localModule.children = [];
|
||
|
|
|
||
|
|
Object.defineProperty(
|
||
|
|
localModule,
|
||
|
|
'parent',
|
||
|
|
// https://github.com/facebook/flow/issues/285#issuecomment-270810619
|
||
|
|
{
|
||
|
|
enumerable: true,
|
||
|
|
get() {
|
||
|
|
return moduleRegistry[from] || null;
|
||
|
|
} });
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
localModule.paths = this._resolver.getModulePaths(dirname);
|
||
|
|
Object.defineProperty(localModule, 'require', {
|
||
|
|
value: this._createRequireImplementation(filename, options) });
|
||
|
|
|
||
|
|
|
||
|
|
const transformedFile = this._scriptTransformer.transform(
|
||
|
|
filename,
|
||
|
|
{
|
||
|
|
collectCoverage: this._coverageOptions.collectCoverage,
|
||
|
|
collectCoverageFrom: this._coverageOptions.collectCoverageFrom,
|
||
|
|
collectCoverageOnlyFrom: this._coverageOptions.collectCoverageOnlyFrom,
|
||
|
|
isInternalModule,
|
||
|
|
mapCoverage: this._coverageOptions.mapCoverage },
|
||
|
|
|
||
|
|
this._cacheFS[filename]);
|
||
|
|
|
||
|
|
|
||
|
|
if (transformedFile.sourceMapPath) {
|
||
|
|
this._sourceMapRegistry[filename] = transformedFile.sourceMapPath;
|
||
|
|
}
|
||
|
|
|
||
|
|
const wrapper = this._environment.runScript(transformedFile.script)[
|
||
|
|
(_script_transformer || _load_script_transformer()).default.EVAL_RESULT_VARIABLE];
|
||
|
|
|
||
|
|
wrapper.call(
|
||
|
|
localModule.exports, // module context
|
||
|
|
localModule, // module object
|
||
|
|
localModule.exports, // module exports
|
||
|
|
localModule.require, // require implementation
|
||
|
|
dirname, // __dirname
|
||
|
|
filename, // __filename
|
||
|
|
this._environment.global, // global object
|
||
|
|
this._createJestObjectFor(
|
||
|
|
filename,
|
||
|
|
// $FlowFixMe
|
||
|
|
localModule.require)
|
||
|
|
// jest object
|
||
|
|
);
|
||
|
|
|
||
|
|
this._isCurrentlyExecutingManualMock = origCurrExecutingManualMock;
|
||
|
|
this._currentlyExecutingModulePath = lastExecutingModulePath;
|
||
|
|
}
|
||
|
|
|
||
|
|
_requireCoreModule(moduleName) {
|
||
|
|
if (moduleName === 'process') {
|
||
|
|
return this._environment.global.process;
|
||
|
|
}
|
||
|
|
|
||
|
|
// $FlowFixMe
|
||
|
|
return require(moduleName);
|
||
|
|
}
|
||
|
|
|
||
|
|
_generateMock(from, moduleName) {
|
||
|
|
const modulePath = this._resolveModule(from, moduleName);
|
||
|
|
|
||
|
|
if (!(modulePath in this._mockMetaDataCache)) {
|
||
|
|
// This allows us to handle circular dependencies while generating an
|
||
|
|
// automock
|
||
|
|
this._mockMetaDataCache[modulePath] = this._moduleMocker.getMetadata(
|
||
|
|
{});
|
||
|
|
|
||
|
|
|
||
|
|
// In order to avoid it being possible for automocking to potentially
|
||
|
|
// cause side-effects within the module environment, we need to execute
|
||
|
|
// the module in isolation. This could cause issues if the module being
|
||
|
|
// mocked has calls into side-effectful APIs on another module.
|
||
|
|
const origMockRegistry = this._mockRegistry;
|
||
|
|
const origModuleRegistry = this._moduleRegistry;
|
||
|
|
this._mockRegistry = Object.create(null);
|
||
|
|
this._moduleRegistry = Object.create(null);
|
||
|
|
|
||
|
|
const moduleExports = this.requireModule(from, moduleName);
|
||
|
|
|
||
|
|
// Restore the "real" module/mock registries
|
||
|
|
this._mockRegistry = origMockRegistry;
|
||
|
|
this._moduleRegistry = origModuleRegistry;
|
||
|
|
|
||
|
|
const mockMetadata = this._moduleMocker.getMetadata(moduleExports);
|
||
|
|
if (mockMetadata == null) {
|
||
|
|
throw new Error(
|
||
|
|
`Failed to get mock metadata: ${modulePath}\n\n` +
|
||
|
|
`See: http://facebook.github.io/jest/docs/manual-mocks.html#content`);
|
||
|
|
|
||
|
|
}
|
||
|
|
this._mockMetaDataCache[modulePath] = mockMetadata;
|
||
|
|
}
|
||
|
|
return this._moduleMocker.generateFromMetadata(
|
||
|
|
this._mockMetaDataCache[modulePath]);
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
_shouldMock(from, moduleName) {
|
||
|
|
const mockPath = this._resolver.getModulePath(from, moduleName);
|
||
|
|
if (mockPath in this._virtualMocks) {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
const explicitShouldMock = this._explicitShouldMock;
|
||
|
|
const moduleID = this._resolver.getModuleID(
|
||
|
|
this._virtualMocks,
|
||
|
|
from,
|
||
|
|
moduleName);
|
||
|
|
|
||
|
|
const key = from + (_path || _load_path()).default.delimiter + moduleID;
|
||
|
|
|
||
|
|
if (moduleID in explicitShouldMock) {
|
||
|
|
return explicitShouldMock[moduleID];
|
||
|
|
}
|
||
|
|
|
||
|
|
if (
|
||
|
|
!this._shouldAutoMock ||
|
||
|
|
this._resolver.isCoreModule(moduleName) ||
|
||
|
|
this._shouldUnmockTransitiveDependenciesCache[key])
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (moduleID in this._shouldMockModuleCache) {
|
||
|
|
return this._shouldMockModuleCache[moduleID];
|
||
|
|
}
|
||
|
|
|
||
|
|
let modulePath;
|
||
|
|
try {
|
||
|
|
modulePath = this._resolveModule(from, moduleName);
|
||
|
|
} catch (e) {
|
||
|
|
const manualMock = this._resolver.getMockModule(from, moduleName);
|
||
|
|
if (manualMock) {
|
||
|
|
this._shouldMockModuleCache[moduleID] = true;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
throw e;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (this._unmockList && this._unmockList.test(modulePath)) {
|
||
|
|
this._shouldMockModuleCache[moduleID] = false;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// transitive unmocking for package managers that store flat packages (npm3)
|
||
|
|
const currentModuleID = this._resolver.getModuleID(
|
||
|
|
this._virtualMocks,
|
||
|
|
from);
|
||
|
|
|
||
|
|
if (
|
||
|
|
this._transitiveShouldMock[currentModuleID] === false ||
|
||
|
|
from.includes(NODE_MODULES) &&
|
||
|
|
modulePath.includes(NODE_MODULES) && (
|
||
|
|
this._unmockList && this._unmockList.test(from) ||
|
||
|
|
explicitShouldMock[currentModuleID] === false))
|
||
|
|
{
|
||
|
|
this._transitiveShouldMock[moduleID] = false;
|
||
|
|
this._shouldUnmockTransitiveDependenciesCache[key] = true;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
return this._shouldMockModuleCache[moduleID] = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
_createRequireImplementation(
|
||
|
|
from,
|
||
|
|
options)
|
||
|
|
{
|
||
|
|
const moduleRequire =
|
||
|
|
options && options.isInternalModule ?
|
||
|
|
moduleName => this.requireInternalModule(from, moduleName) :
|
||
|
|
this.requireModuleOrMock.bind(this, from);
|
||
|
|
moduleRequire.cache = Object.create(null);
|
||
|
|
moduleRequire.extensions = Object.create(null);
|
||
|
|
moduleRequire.requireActual = this.requireModule.bind(this, from);
|
||
|
|
moduleRequire.requireMock = this.requireMock.bind(this, from);
|
||
|
|
moduleRequire.resolve = moduleName => this._resolveModule(from, moduleName);
|
||
|
|
return moduleRequire;
|
||
|
|
}
|
||
|
|
|
||
|
|
_createJestObjectFor(from, localRequire) {
|
||
|
|
const disableAutomock = () => {
|
||
|
|
this._shouldAutoMock = false;
|
||
|
|
return jestObject;
|
||
|
|
};
|
||
|
|
const enableAutomock = () => {
|
||
|
|
this._shouldAutoMock = true;
|
||
|
|
return jestObject;
|
||
|
|
};
|
||
|
|
const unmock = moduleName => {
|
||
|
|
const moduleID = this._resolver.getModuleID(
|
||
|
|
this._virtualMocks,
|
||
|
|
from,
|
||
|
|
moduleName);
|
||
|
|
|
||
|
|
this._explicitShouldMock[moduleID] = false;
|
||
|
|
return jestObject;
|
||
|
|
};
|
||
|
|
const deepUnmock = moduleName => {
|
||
|
|
const moduleID = this._resolver.getModuleID(
|
||
|
|
this._virtualMocks,
|
||
|
|
from,
|
||
|
|
moduleName);
|
||
|
|
|
||
|
|
this._explicitShouldMock[moduleID] = false;
|
||
|
|
this._transitiveShouldMock[moduleID] = false;
|
||
|
|
return jestObject;
|
||
|
|
};
|
||
|
|
const mock = (
|
||
|
|
moduleName,
|
||
|
|
mockFactory,
|
||
|
|
options) =>
|
||
|
|
{
|
||
|
|
if (mockFactory !== undefined) {
|
||
|
|
return setMockFactory(moduleName, mockFactory, options);
|
||
|
|
}
|
||
|
|
|
||
|
|
const moduleID = this._resolver.getModuleID(
|
||
|
|
this._virtualMocks,
|
||
|
|
from,
|
||
|
|
moduleName);
|
||
|
|
|
||
|
|
this._explicitShouldMock[moduleID] = true;
|
||
|
|
return jestObject;
|
||
|
|
};
|
||
|
|
const setMockFactory = (moduleName, mockFactory, options) => {
|
||
|
|
this.setMock(from, moduleName, mockFactory, options);
|
||
|
|
return jestObject;
|
||
|
|
};
|
||
|
|
const clearAllMocks = () => {
|
||
|
|
this.clearAllMocks();
|
||
|
|
return jestObject;
|
||
|
|
};
|
||
|
|
const resetAllMocks = () => {
|
||
|
|
this.resetAllMocks();
|
||
|
|
return jestObject;
|
||
|
|
};
|
||
|
|
const restoreAllMocks = () => {
|
||
|
|
this.restoreAllMocks();
|
||
|
|
return jestObject;
|
||
|
|
};
|
||
|
|
const useFakeTimers = () => {
|
||
|
|
this._environment.fakeTimers.useFakeTimers();
|
||
|
|
return jestObject;
|
||
|
|
};
|
||
|
|
const useRealTimers = () => {
|
||
|
|
this._environment.fakeTimers.useRealTimers();
|
||
|
|
return jestObject;
|
||
|
|
};
|
||
|
|
const resetModules = () => {
|
||
|
|
this.resetModules();
|
||
|
|
return jestObject;
|
||
|
|
};
|
||
|
|
const fn = this._moduleMocker.fn.bind(this._moduleMocker);
|
||
|
|
const spyOn = this._moduleMocker.spyOn.bind(this._moduleMocker);
|
||
|
|
|
||
|
|
const setTimeout = timeout => {
|
||
|
|
this._environment.global.jasmine ?
|
||
|
|
this._environment.global.jasmine.DEFAULT_TIMEOUT_INTERVAL = timeout :
|
||
|
|
this._environment.global[
|
||
|
|
Symbol.for('TEST_TIMEOUT_SYMBOL')] =
|
||
|
|
timeout;
|
||
|
|
return jestObject;
|
||
|
|
};
|
||
|
|
|
||
|
|
const jestObject = {
|
||
|
|
addMatchers: matchers =>
|
||
|
|
this._environment.global.jasmine.addMatchers(matchers),
|
||
|
|
advanceTimersByTime: msToRun =>
|
||
|
|
this._environment.fakeTimers.advanceTimersByTime(msToRun),
|
||
|
|
autoMockOff: disableAutomock,
|
||
|
|
autoMockOn: enableAutomock,
|
||
|
|
clearAllMocks,
|
||
|
|
clearAllTimers: () => this._environment.fakeTimers.clearAllTimers(),
|
||
|
|
deepUnmock,
|
||
|
|
disableAutomock,
|
||
|
|
doMock: mock,
|
||
|
|
dontMock: unmock,
|
||
|
|
enableAutomock,
|
||
|
|
fn,
|
||
|
|
genMockFn: fn,
|
||
|
|
genMockFromModule: moduleName =>
|
||
|
|
this._generateMock(from, moduleName),
|
||
|
|
genMockFunction: fn,
|
||
|
|
isMockFunction: this._moduleMocker.isMockFunction,
|
||
|
|
mock,
|
||
|
|
requireActual: localRequire.requireActual,
|
||
|
|
requireMock: localRequire.requireMock,
|
||
|
|
resetAllMocks,
|
||
|
|
resetModuleRegistry: resetModules,
|
||
|
|
resetModules,
|
||
|
|
restoreAllMocks,
|
||
|
|
runAllImmediates: () => this._environment.fakeTimers.runAllImmediates(),
|
||
|
|
runAllTicks: () => this._environment.fakeTimers.runAllTicks(),
|
||
|
|
runAllTimers: () => this._environment.fakeTimers.runAllTimers(),
|
||
|
|
runOnlyPendingTimers: () =>
|
||
|
|
this._environment.fakeTimers.runOnlyPendingTimers(),
|
||
|
|
runTimersToTime: msToRun =>
|
||
|
|
this._environment.fakeTimers.advanceTimersByTime(msToRun),
|
||
|
|
setMock: (moduleName, mock) =>
|
||
|
|
setMockFactory(moduleName, () => mock),
|
||
|
|
setTimeout,
|
||
|
|
spyOn,
|
||
|
|
unmock,
|
||
|
|
useFakeTimers,
|
||
|
|
useRealTimers };
|
||
|
|
|
||
|
|
return jestObject;
|
||
|
|
}}
|
||
|
|
|
||
|
|
|
||
|
|
Runtime.ScriptTransformer = (_script_transformer || _load_script_transformer()).default;
|
||
|
|
module.exports = Runtime;
|