diff options
Diffstat (limited to 'node_modules/@jest/core')
90 files changed, 6549 insertions, 0 deletions
diff --git a/node_modules/@jest/core/LICENSE b/node_modules/@jest/core/LICENSE new file mode 100644 index 0000000..b96dcb0 --- /dev/null +++ b/node_modules/@jest/core/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) Facebook, Inc. and its affiliates. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/node_modules/@jest/core/README.md b/node_modules/@jest/core/README.md new file mode 100644 index 0000000..e5852b6 --- /dev/null +++ b/node_modules/@jest/core/README.md @@ -0,0 +1,3 @@ +# @jest/core + +Jest is currently working on providing a programmatic API. This is under development, and usage of this package directly is currently not supported. diff --git a/node_modules/@jest/core/build/FailedTestsCache.d.ts b/node_modules/@jest/core/build/FailedTestsCache.d.ts new file mode 100644 index 0000000..565af37 --- /dev/null +++ b/node_modules/@jest/core/build/FailedTestsCache.d.ts @@ -0,0 +1,12 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +import type { Test, TestResult } from '@jest/test-result'; +export default class FailedTestsCache { + private _enabledTestsMap?; + filterTests(tests: Array<Test>): Array<Test>; + setTestResults(testResults: Array<TestResult>): void; +} diff --git a/node_modules/@jest/core/build/FailedTestsCache.js b/node_modules/@jest/core/build/FailedTestsCache.js new file mode 100644 index 0000000..389e8b8 --- /dev/null +++ b/node_modules/@jest/core/build/FailedTestsCache.js @@ -0,0 +1,59 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; + +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; +} + +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +class FailedTestsCache { + constructor() { + _defineProperty(this, '_enabledTestsMap', void 0); + } + + filterTests(tests) { + const enabledTestsMap = this._enabledTestsMap; + + if (!enabledTestsMap) { + return tests; + } + + return tests.filter(testResult => enabledTestsMap[testResult.path]); + } + + setTestResults(testResults) { + this._enabledTestsMap = (testResults || []) + .filter(testResult => testResult.numFailingTests) + .reduce((suiteMap, testResult) => { + suiteMap[testResult.testFilePath] = testResult.testResults + .filter(test => test.status === 'failed') + .reduce((testMap, test) => { + testMap[test.fullName] = true; + return testMap; + }, {}); + return suiteMap; + }, {}); + this._enabledTestsMap = Object.freeze(this._enabledTestsMap); + } +} + +exports.default = FailedTestsCache; diff --git a/node_modules/@jest/core/build/FailedTestsInteractiveMode.d.ts b/node_modules/@jest/core/build/FailedTestsInteractiveMode.d.ts new file mode 100644 index 0000000..c543c69 --- /dev/null +++ b/node_modules/@jest/core/build/FailedTestsInteractiveMode.d.ts @@ -0,0 +1,31 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +/// <reference types="node" /> +import type { AggregatedResult, AssertionLocation } from '@jest/test-result'; +declare type RunnerUpdateFunction = (failure?: AssertionLocation) => void; +export default class FailedTestsInteractiveMode { + private _pipe; + private _isActive; + private _countPaths; + private _skippedNum; + private _testAssertions; + private _updateTestRunnerConfig?; + constructor(_pipe: NodeJS.WritableStream); + isActive(): boolean; + put(key: string): void; + run(failedTestAssertions: Array<AssertionLocation>, updateConfig: RunnerUpdateFunction): void; + updateWithResults(results: AggregatedResult): void; + private _clearTestSummary; + private _drawUIDone; + private _drawUIDoneWithSkipped; + private _drawUIProgress; + private _drawUIOverlay; + private _run; + private abort; + private restart; +} +export {}; diff --git a/node_modules/@jest/core/build/FailedTestsInteractiveMode.js b/node_modules/@jest/core/build/FailedTestsInteractiveMode.js new file mode 100644 index 0000000..e9e6534 --- /dev/null +++ b/node_modules/@jest/core/build/FailedTestsInteractiveMode.js @@ -0,0 +1,262 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; + +function _ansiEscapes() { + const data = _interopRequireDefault(require('ansi-escapes')); + + _ansiEscapes = function () { + return data; + }; + + return data; +} + +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + + _chalk = function () { + return data; + }; + + return data; +} + +function _jestUtil() { + const data = require('jest-util'); + + _jestUtil = function () { + return data; + }; + + return data; +} + +function _jestWatcher() { + const data = require('jest-watcher'); + + _jestWatcher = function () { + return data; + }; + + return data; +} + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} + +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; +} + +const {ARROW, CLEAR} = _jestUtil().specialChars; + +function describeKey(key, description) { + return `${_chalk().default.dim( + ARROW + 'Press' + )} ${key} ${_chalk().default.dim(description)}`; +} + +const TestProgressLabel = _chalk().default.bold('Interactive Test Progress'); + +class FailedTestsInteractiveMode { + constructor(_pipe) { + _defineProperty(this, '_isActive', false); + + _defineProperty(this, '_countPaths', 0); + + _defineProperty(this, '_skippedNum', 0); + + _defineProperty(this, '_testAssertions', []); + + _defineProperty(this, '_updateTestRunnerConfig', void 0); + + this._pipe = _pipe; + } + + isActive() { + return this._isActive; + } + + put(key) { + switch (key) { + case 's': + if (this._skippedNum === this._testAssertions.length) { + break; + } + + this._skippedNum += 1; // move skipped test to the end + + this._testAssertions.push(this._testAssertions.shift()); + + if (this._testAssertions.length - this._skippedNum > 0) { + this._run(); + } else { + this._drawUIDoneWithSkipped(); + } + + break; + + case 'q': + case _jestWatcher().KEYS.ESCAPE: + this.abort(); + break; + + case 'r': + this.restart(); + break; + + case _jestWatcher().KEYS.ENTER: + if (this._testAssertions.length === 0) { + this.abort(); + } else { + this._run(); + } + + break; + + default: + } + } + + run(failedTestAssertions, updateConfig) { + if (failedTestAssertions.length === 0) return; + this._testAssertions = [...failedTestAssertions]; + this._countPaths = this._testAssertions.length; + this._updateTestRunnerConfig = updateConfig; + this._isActive = true; + + this._run(); + } + + updateWithResults(results) { + if (!results.snapshot.failure && results.numFailedTests > 0) { + return this._drawUIOverlay(); + } + + this._testAssertions.shift(); + + if (this._testAssertions.length === 0) { + return this._drawUIOverlay(); + } // Go to the next test + + return this._run(); + } + + _clearTestSummary() { + this._pipe.write(_ansiEscapes().default.cursorUp(6)); + + this._pipe.write(_ansiEscapes().default.eraseDown); + } + + _drawUIDone() { + this._pipe.write(CLEAR); + + const messages = [ + _chalk().default.bold('Watch Usage'), + describeKey('Enter', 'to return to watch mode.') + ]; + + this._pipe.write(messages.join('\n') + '\n'); + } + + _drawUIDoneWithSkipped() { + this._pipe.write(CLEAR); + + let stats = `${(0, _jestUtil().pluralize)( + 'test', + this._countPaths + )} reviewed`; + + if (this._skippedNum > 0) { + const skippedText = _chalk().default.bold.yellow( + (0, _jestUtil().pluralize)('test', this._skippedNum) + ' skipped' + ); + + stats = `${stats}, ${skippedText}`; + } + + const message = [ + TestProgressLabel, + `${ARROW}${stats}`, + '\n', + _chalk().default.bold('Watch Usage'), + describeKey('r', 'to restart Interactive Mode.'), + describeKey('q', 'to quit Interactive Mode.'), + describeKey('Enter', 'to return to watch mode.') + ]; + + this._pipe.write(`\n${message.join('\n')}`); + } + + _drawUIProgress() { + this._clearTestSummary(); + + const numPass = this._countPaths - this._testAssertions.length; + const numRemaining = this._countPaths - numPass - this._skippedNum; + let stats = `${(0, _jestUtil().pluralize)('test', numRemaining)} remaining`; + + if (this._skippedNum > 0) { + const skippedText = _chalk().default.bold.yellow( + (0, _jestUtil().pluralize)('test', this._skippedNum) + ' skipped' + ); + + stats = `${stats}, ${skippedText}`; + } + + const message = [ + TestProgressLabel, + `${ARROW}${stats}`, + '\n', + _chalk().default.bold('Watch Usage'), + describeKey('s', 'to skip the current test.'), + describeKey('q', 'to quit Interactive Mode.'), + describeKey('Enter', 'to return to watch mode.') + ]; + + this._pipe.write(`\n${message.join('\n')}`); + } + + _drawUIOverlay() { + if (this._testAssertions.length === 0) return this._drawUIDone(); + return this._drawUIProgress(); + } + + _run() { + if (this._updateTestRunnerConfig) { + this._updateTestRunnerConfig(this._testAssertions[0]); + } + } + + abort() { + this._isActive = false; + this._skippedNum = 0; + + if (this._updateTestRunnerConfig) { + this._updateTestRunnerConfig(); + } + } + + restart() { + this._skippedNum = 0; + this._countPaths = this._testAssertions.length; + + this._run(); + } +} + +exports.default = FailedTestsInteractiveMode; diff --git a/node_modules/@jest/core/build/ReporterDispatcher.d.ts b/node_modules/@jest/core/build/ReporterDispatcher.d.ts new file mode 100644 index 0000000..ed34a0e --- /dev/null +++ b/node_modules/@jest/core/build/ReporterDispatcher.d.ts @@ -0,0 +1,22 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +import type { Reporter, ReporterOnStartOptions } from '@jest/reporters'; +import type { AggregatedResult, Test, TestCaseResult, TestResult } from '@jest/test-result'; +import type { Context } from 'jest-runtime'; +export default class ReporterDispatcher { + private _reporters; + constructor(); + register(reporter: Reporter): void; + unregister(ReporterClass: Function): void; + onTestFileResult(test: Test, testResult: TestResult, results: AggregatedResult): Promise<void>; + onTestFileStart(test: Test): Promise<void>; + onRunStart(results: AggregatedResult, options: ReporterOnStartOptions): Promise<void>; + onTestCaseResult(test: Test, testCaseResult: TestCaseResult): Promise<void>; + onRunComplete(contexts: Set<Context>, results: AggregatedResult): Promise<void>; + getErrors(): Array<Error>; + hasErrors(): boolean; +} diff --git a/node_modules/@jest/core/build/ReporterDispatcher.js b/node_modules/@jest/core/build/ReporterDispatcher.js new file mode 100644 index 0000000..efd6af0 --- /dev/null +++ b/node_modules/@jest/core/build/ReporterDispatcher.js @@ -0,0 +1,104 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; + +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; +} + +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ + +/* eslint-disable local/ban-types-eventually */ +class ReporterDispatcher { + constructor() { + _defineProperty(this, '_reporters', void 0); + + this._reporters = []; + } + + register(reporter) { + this._reporters.push(reporter); + } + + unregister(ReporterClass) { + this._reporters = this._reporters.filter( + reporter => !(reporter instanceof ReporterClass) + ); + } + + async onTestFileResult(test, testResult, results) { + for (const reporter of this._reporters) { + if (reporter.onTestFileResult) { + await reporter.onTestFileResult(test, testResult, results); + } else if (reporter.onTestResult) { + await reporter.onTestResult(test, testResult, results); + } + } // Release memory if unused later. + + testResult.coverage = undefined; + testResult.console = undefined; + } + + async onTestFileStart(test) { + for (const reporter of this._reporters) { + if (reporter.onTestFileStart) { + await reporter.onTestFileStart(test); + } else if (reporter.onTestStart) { + await reporter.onTestStart(test); + } + } + } + + async onRunStart(results, options) { + for (const reporter of this._reporters) { + reporter.onRunStart && (await reporter.onRunStart(results, options)); + } + } + + async onTestCaseResult(test, testCaseResult) { + for (const reporter of this._reporters) { + if (reporter.onTestCaseResult) { + await reporter.onTestCaseResult(test, testCaseResult); + } + } + } + + async onRunComplete(contexts, results) { + for (const reporter of this._reporters) { + if (reporter.onRunComplete) { + await reporter.onRunComplete(contexts, results); + } + } + } // Return a list of last errors for every reporter + + getErrors() { + return this._reporters.reduce((list, reporter) => { + const error = reporter.getLastError && reporter.getLastError(); + return error ? list.concat(error) : list; + }, []); + } + + hasErrors() { + return this.getErrors().length !== 0; + } +} + +exports.default = ReporterDispatcher; diff --git a/node_modules/@jest/core/build/SearchSource.d.ts b/node_modules/@jest/core/build/SearchSource.d.ts new file mode 100644 index 0000000..43c8e82 --- /dev/null +++ b/node_modules/@jest/core/build/SearchSource.d.ts @@ -0,0 +1,46 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +import type { Test } from '@jest/test-result'; +import type { Config } from '@jest/types'; +import type { ChangedFiles } from 'jest-changed-files'; +import type { Context } from 'jest-runtime'; +import type { Filter, Stats } from './types'; +export declare type SearchResult = { + noSCM?: boolean; + stats?: Stats; + collectCoverageFrom?: Set<string>; + tests: Array<Test>; + total?: number; +}; +export declare type TestSelectionConfig = { + input?: string; + findRelatedTests?: boolean; + onlyChanged?: boolean; + paths?: Array<Config.Path>; + shouldTreatInputAsPattern?: boolean; + testPathPattern?: string; + watch?: boolean; +}; +export default class SearchSource { + private _context; + private _dependencyResolver; + private _testPathCases; + constructor(context: Context); + private _getOrBuildDependencyResolver; + private _filterTestPathsWithStats; + private _getAllTestPaths; + isTestFilePath(path: Config.Path): boolean; + findMatchingTests(testPathPattern?: string): SearchResult; + findRelatedTests(allPaths: Set<Config.Path>, collectCoverage: boolean): Promise<SearchResult>; + findTestsByPaths(paths: Array<Config.Path>): SearchResult; + findRelatedTestsFromPattern(paths: Array<Config.Path>, collectCoverage: boolean): Promise<SearchResult>; + findTestRelatedToChangedFiles(changedFilesInfo: ChangedFiles, collectCoverage: boolean): Promise<SearchResult>; + private _getTestPaths; + filterPathsWin32(paths: Array<string>): Array<string>; + getTestPaths(globalConfig: Config.GlobalConfig, changedFiles: ChangedFiles | undefined, filter?: Filter): Promise<SearchResult>; + findRelatedSourcesFromTestsInChangedFiles(changedFilesInfo: ChangedFiles): Promise<Array<string>>; +} diff --git a/node_modules/@jest/core/build/SearchSource.js b/node_modules/@jest/core/build/SearchSource.js new file mode 100644 index 0000000..927f59d --- /dev/null +++ b/node_modules/@jest/core/build/SearchSource.js @@ -0,0 +1,490 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; + +function os() { + const data = _interopRequireWildcard(require('os')); + + os = function () { + return data; + }; + + return data; +} + +function path() { + const data = _interopRequireWildcard(require('path')); + + path = function () { + return data; + }; + + return data; +} + +function _micromatch() { + const data = _interopRequireDefault(require('micromatch')); + + _micromatch = function () { + return data; + }; + + return data; +} + +function _jestConfig() { + const data = require('jest-config'); + + _jestConfig = function () { + return data; + }; + + return data; +} + +function _jestRegexUtil() { + const data = require('jest-regex-util'); + + _jestRegexUtil = function () { + return data; + }; + + return data; +} + +function _jestResolveDependencies() { + const data = require('jest-resolve-dependencies'); + + _jestResolveDependencies = function () { + return data; + }; + + return data; +} + +function _jestSnapshot() { + const data = require('jest-snapshot'); + + _jestSnapshot = function () { + return data; + }; + + return data; +} + +function _jestUtil() { + const data = require('jest-util'); + + _jestUtil = function () { + return data; + }; + + return data; +} + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} + +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} + +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} + +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; +} + +const regexToMatcher = testRegex => { + const regexes = testRegex.map(testRegex => new RegExp(testRegex)); + return path => + regexes.some(regex => { + const result = regex.test(path); // prevent stateful regexes from breaking, just in case + + regex.lastIndex = 0; + return result; + }); +}; + +const toTests = (context, tests) => + tests.map(path => ({ + context, + duration: undefined, + path + })); + +const hasSCM = changedFilesInfo => { + const {repos} = changedFilesInfo; // no SCM (git/hg/...) is found in any of the roots. + + const noSCM = Object.values(repos).every(scm => scm.size === 0); + return !noSCM; +}; + +class SearchSource { + constructor(context) { + _defineProperty(this, '_context', void 0); + + _defineProperty(this, '_dependencyResolver', void 0); + + _defineProperty(this, '_testPathCases', []); + + const {config} = context; + this._context = context; + this._dependencyResolver = null; + const rootPattern = new RegExp( + config.roots + .map(dir => (0, _jestRegexUtil().escapePathForRegex)(dir + path().sep)) + .join('|') + ); + + this._testPathCases.push({ + isMatch: path => rootPattern.test(path), + stat: 'roots' + }); + + if (config.testMatch.length) { + this._testPathCases.push({ + isMatch: (0, _jestUtil().globsToMatcher)(config.testMatch), + stat: 'testMatch' + }); + } + + if (config.testPathIgnorePatterns.length) { + const testIgnorePatternsRegex = new RegExp( + config.testPathIgnorePatterns.join('|') + ); + + this._testPathCases.push({ + isMatch: path => !testIgnorePatternsRegex.test(path), + stat: 'testPathIgnorePatterns' + }); + } + + if (config.testRegex.length) { + this._testPathCases.push({ + isMatch: regexToMatcher(config.testRegex), + stat: 'testRegex' + }); + } + } + + async _getOrBuildDependencyResolver() { + if (!this._dependencyResolver) { + this._dependencyResolver = + new (_jestResolveDependencies().DependencyResolver)( + this._context.resolver, + this._context.hasteFS, + await (0, _jestSnapshot().buildSnapshotResolver)(this._context.config) + ); + } + + return this._dependencyResolver; + } + + _filterTestPathsWithStats(allPaths, testPathPattern) { + const data = { + stats: { + roots: 0, + testMatch: 0, + testPathIgnorePatterns: 0, + testRegex: 0 + }, + tests: [], + total: allPaths.length + }; + const testCases = Array.from(this._testPathCases); // clone + + if (testPathPattern) { + const regex = (0, _jestUtil().testPathPatternToRegExp)(testPathPattern); + testCases.push({ + isMatch: path => regex.test(path), + stat: 'testPathPattern' + }); + data.stats.testPathPattern = 0; + } + + data.tests = allPaths.filter(test => { + let filterResult = true; + + for (const {isMatch, stat} of testCases) { + if (isMatch(test.path)) { + data.stats[stat]++; + } else { + filterResult = false; + } + } + + return filterResult; + }); + return data; + } + + _getAllTestPaths(testPathPattern) { + return this._filterTestPathsWithStats( + toTests(this._context, this._context.hasteFS.getAllFiles()), + testPathPattern + ); + } + + isTestFilePath(path) { + return this._testPathCases.every(testCase => testCase.isMatch(path)); + } + + findMatchingTests(testPathPattern) { + return this._getAllTestPaths(testPathPattern); + } + + async findRelatedTests(allPaths, collectCoverage) { + const dependencyResolver = await this._getOrBuildDependencyResolver(); + + if (!collectCoverage) { + return { + tests: toTests( + this._context, + dependencyResolver.resolveInverse( + allPaths, + this.isTestFilePath.bind(this), + { + skipNodeResolution: this._context.config.skipNodeResolution + } + ) + ) + }; + } + + const testModulesMap = dependencyResolver.resolveInverseModuleMap( + allPaths, + this.isTestFilePath.bind(this), + { + skipNodeResolution: this._context.config.skipNodeResolution + } + ); + const allPathsAbsolute = Array.from(allPaths).map(p => path().resolve(p)); + const collectCoverageFrom = new Set(); + testModulesMap.forEach(testModule => { + if (!testModule.dependencies) { + return; + } + + testModule.dependencies.forEach(p => { + if (!allPathsAbsolute.includes(p)) { + return; + } + + const filename = (0, _jestConfig().replaceRootDirInPath)( + this._context.config.rootDir, + p + ); + collectCoverageFrom.add( + path().isAbsolute(filename) + ? path().relative(this._context.config.rootDir, filename) + : filename + ); + }); + }); + return { + collectCoverageFrom, + tests: toTests( + this._context, + testModulesMap.map(testModule => testModule.file) + ) + }; + } + + findTestsByPaths(paths) { + return { + tests: toTests( + this._context, + paths + .map(p => path().resolve(this._context.config.cwd, p)) + .filter(this.isTestFilePath.bind(this)) + ) + }; + } + + async findRelatedTestsFromPattern(paths, collectCoverage) { + if (Array.isArray(paths) && paths.length) { + const resolvedPaths = paths.map(p => + path().resolve(this._context.config.cwd, p) + ); + return this.findRelatedTests(new Set(resolvedPaths), collectCoverage); + } + + return { + tests: [] + }; + } + + async findTestRelatedToChangedFiles(changedFilesInfo, collectCoverage) { + if (!hasSCM(changedFilesInfo)) { + return { + noSCM: true, + tests: [] + }; + } + + const {changedFiles} = changedFilesInfo; + return this.findRelatedTests(changedFiles, collectCoverage); + } + + async _getTestPaths(globalConfig, changedFiles) { + if (globalConfig.onlyChanged) { + if (!changedFiles) { + throw new Error('Changed files must be set when running with -o.'); + } + + return this.findTestRelatedToChangedFiles( + changedFiles, + globalConfig.collectCoverage + ); + } + + let paths = globalConfig.nonFlagArgs; + + if (globalConfig.findRelatedTests && 'win32' === os().platform()) { + paths = this.filterPathsWin32(paths); + } + + if (globalConfig.runTestsByPath && paths && paths.length) { + return this.findTestsByPaths(paths); + } else if (globalConfig.findRelatedTests && paths && paths.length) { + return this.findRelatedTestsFromPattern( + paths, + globalConfig.collectCoverage + ); + } else if (globalConfig.testPathPattern != null) { + return this.findMatchingTests(globalConfig.testPathPattern); + } else { + return { + tests: [] + }; + } + } + + filterPathsWin32(paths) { + const allFiles = this._context.hasteFS.getAllFiles(); + + const options = { + nocase: true, + windows: false + }; + + function normalizePosix(filePath) { + return filePath.replace(/\\/g, '/'); + } + + paths = paths + .map(p => { + // micromatch works with forward slashes: https://github.com/micromatch/micromatch#backslashes + const normalizedPath = normalizePosix( + path().resolve(this._context.config.cwd, p) + ); + const match = (0, _micromatch().default)( + allFiles.map(normalizePosix), + normalizedPath, + options + ); + return match[0]; + }) + .filter(Boolean) + .map(p => path().resolve(p)); + return paths; + } + + async getTestPaths(globalConfig, changedFiles, filter) { + const searchResult = await this._getTestPaths(globalConfig, changedFiles); + const filterPath = globalConfig.filter; + + if (filter) { + const tests = searchResult.tests; + const filterResult = await filter(tests.map(test => test.path)); + + if (!Array.isArray(filterResult.filtered)) { + throw new Error( + `Filter ${filterPath} did not return a valid test list` + ); + } + + const filteredSet = new Set( + filterResult.filtered.map(result => result.test) + ); + return { + ...searchResult, + tests: tests.filter(test => filteredSet.has(test.path)) + }; + } + + return searchResult; + } + + async findRelatedSourcesFromTestsInChangedFiles(changedFilesInfo) { + if (!hasSCM(changedFilesInfo)) { + return []; + } + + const {changedFiles} = changedFilesInfo; + const dependencyResolver = await this._getOrBuildDependencyResolver(); + const relatedSourcesSet = new Set(); + changedFiles.forEach(filePath => { + if (this.isTestFilePath(filePath)) { + const sourcePaths = dependencyResolver.resolve(filePath, { + skipNodeResolution: this._context.config.skipNodeResolution + }); + sourcePaths.forEach(sourcePath => relatedSourcesSet.add(sourcePath)); + } + }); + return Array.from(relatedSourcesSet); + } +} + +exports.default = SearchSource; diff --git a/node_modules/@jest/core/build/SnapshotInteractiveMode.d.ts b/node_modules/@jest/core/build/SnapshotInteractiveMode.d.ts new file mode 100644 index 0000000..1198a50 --- /dev/null +++ b/node_modules/@jest/core/build/SnapshotInteractiveMode.d.ts @@ -0,0 +1,30 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +/// <reference types="node" /> +import type { AggregatedResult, AssertionLocation } from '@jest/test-result'; +export default class SnapshotInteractiveMode { + private _pipe; + private _isActive; + private _updateTestRunnerConfig; + private _testAssertions; + private _countPaths; + private _skippedNum; + constructor(pipe: NodeJS.WritableStream); + isActive(): boolean; + getSkippedNum(): number; + private _clearTestSummary; + private _drawUIProgress; + private _drawUIDoneWithSkipped; + private _drawUIDone; + private _drawUIOverlay; + put(key: string): void; + abort(): void; + restart(): void; + updateWithResults(results: AggregatedResult): void; + private _run; + run(failedSnapshotTestAssertions: Array<AssertionLocation>, onConfigChange: (assertion: AssertionLocation | null, shouldUpdateSnapshot: boolean) => unknown): void; +} diff --git a/node_modules/@jest/core/build/SnapshotInteractiveMode.js b/node_modules/@jest/core/build/SnapshotInteractiveMode.js new file mode 100644 index 0000000..fac34db --- /dev/null +++ b/node_modules/@jest/core/build/SnapshotInteractiveMode.js @@ -0,0 +1,327 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; + +function _ansiEscapes() { + const data = _interopRequireDefault(require('ansi-escapes')); + + _ansiEscapes = function () { + return data; + }; + + return data; +} + +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + + _chalk = function () { + return data; + }; + + return data; +} + +function _jestUtil() { + const data = require('jest-util'); + + _jestUtil = function () { + return data; + }; + + return data; +} + +function _jestWatcher() { + const data = require('jest-watcher'); + + _jestWatcher = function () { + return data; + }; + + return data; +} + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} + +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; +} + +const {ARROW, CLEAR} = _jestUtil().specialChars; + +class SnapshotInteractiveMode { + constructor(pipe) { + _defineProperty(this, '_pipe', void 0); + + _defineProperty(this, '_isActive', void 0); + + _defineProperty(this, '_updateTestRunnerConfig', void 0); + + _defineProperty(this, '_testAssertions', void 0); + + _defineProperty(this, '_countPaths', void 0); + + _defineProperty(this, '_skippedNum', void 0); + + this._pipe = pipe; + this._isActive = false; + this._skippedNum = 0; + } + + isActive() { + return this._isActive; + } + + getSkippedNum() { + return this._skippedNum; + } + + _clearTestSummary() { + this._pipe.write(_ansiEscapes().default.cursorUp(6)); + + this._pipe.write(_ansiEscapes().default.eraseDown); + } + + _drawUIProgress() { + this._clearTestSummary(); + + const numPass = this._countPaths - this._testAssertions.length; + const numRemaining = this._countPaths - numPass - this._skippedNum; + + let stats = _chalk().default.bold.dim( + (0, _jestUtil().pluralize)('snapshot', numRemaining) + ' remaining' + ); + + if (numPass) { + stats += + ', ' + + _chalk().default.bold.green( + (0, _jestUtil().pluralize)('snapshot', numPass) + ' updated' + ); + } + + if (this._skippedNum) { + stats += + ', ' + + _chalk().default.bold.yellow( + (0, _jestUtil().pluralize)('snapshot', this._skippedNum) + ' skipped' + ); + } + + const messages = [ + '\n' + _chalk().default.bold('Interactive Snapshot Progress'), + ARROW + stats, + '\n' + _chalk().default.bold('Watch Usage'), + _chalk().default.dim(ARROW + 'Press ') + + 'u' + + _chalk().default.dim(' to update failing snapshots for this test.'), + _chalk().default.dim(ARROW + 'Press ') + + 's' + + _chalk().default.dim(' to skip the current test.'), + _chalk().default.dim(ARROW + 'Press ') + + 'q' + + _chalk().default.dim(' to quit Interactive Snapshot Mode.'), + _chalk().default.dim(ARROW + 'Press ') + + 'Enter' + + _chalk().default.dim(' to trigger a test run.') + ]; + + this._pipe.write(messages.filter(Boolean).join('\n') + '\n'); + } + + _drawUIDoneWithSkipped() { + this._pipe.write(CLEAR); + + const numPass = this._countPaths - this._testAssertions.length; + + let stats = _chalk().default.bold.dim( + (0, _jestUtil().pluralize)('snapshot', this._countPaths) + ' reviewed' + ); + + if (numPass) { + stats += + ', ' + + _chalk().default.bold.green( + (0, _jestUtil().pluralize)('snapshot', numPass) + ' updated' + ); + } + + if (this._skippedNum) { + stats += + ', ' + + _chalk().default.bold.yellow( + (0, _jestUtil().pluralize)('snapshot', this._skippedNum) + ' skipped' + ); + } + + const messages = [ + '\n' + _chalk().default.bold('Interactive Snapshot Result'), + ARROW + stats, + '\n' + _chalk().default.bold('Watch Usage'), + _chalk().default.dim(ARROW + 'Press ') + + 'r' + + _chalk().default.dim(' to restart Interactive Snapshot Mode.'), + _chalk().default.dim(ARROW + 'Press ') + + 'q' + + _chalk().default.dim(' to quit Interactive Snapshot Mode.') + ]; + + this._pipe.write(messages.filter(Boolean).join('\n') + '\n'); + } + + _drawUIDone() { + this._pipe.write(CLEAR); + + const numPass = this._countPaths - this._testAssertions.length; + + let stats = _chalk().default.bold.dim( + (0, _jestUtil().pluralize)('snapshot', this._countPaths) + ' reviewed' + ); + + if (numPass) { + stats += + ', ' + + _chalk().default.bold.green( + (0, _jestUtil().pluralize)('snapshot', numPass) + ' updated' + ); + } + + const messages = [ + '\n' + _chalk().default.bold('Interactive Snapshot Result'), + ARROW + stats, + '\n' + _chalk().default.bold('Watch Usage'), + _chalk().default.dim(ARROW + 'Press ') + + 'Enter' + + _chalk().default.dim(' to return to watch mode.') + ]; + + this._pipe.write(messages.filter(Boolean).join('\n') + '\n'); + } + + _drawUIOverlay() { + if (this._testAssertions.length === 0) { + return this._drawUIDone(); + } + + if (this._testAssertions.length - this._skippedNum === 0) { + return this._drawUIDoneWithSkipped(); + } + + return this._drawUIProgress(); + } + + put(key) { + switch (key) { + case 's': + if (this._skippedNum === this._testAssertions.length) break; + this._skippedNum += 1; // move skipped test to the end + + this._testAssertions.push(this._testAssertions.shift()); + + if (this._testAssertions.length - this._skippedNum > 0) { + this._run(false); + } else { + this._drawUIDoneWithSkipped(); + } + + break; + + case 'u': + this._run(true); + + break; + + case 'q': + case _jestWatcher().KEYS.ESCAPE: + this.abort(); + break; + + case 'r': + this.restart(); + break; + + case _jestWatcher().KEYS.ENTER: + if (this._testAssertions.length === 0) { + this.abort(); + } else { + this._run(false); + } + + break; + + default: + break; + } + } + + abort() { + this._isActive = false; + this._skippedNum = 0; + + this._updateTestRunnerConfig(null, false); + } + + restart() { + this._skippedNum = 0; + this._countPaths = this._testAssertions.length; + + this._run(false); + } + + updateWithResults(results) { + const hasSnapshotFailure = !!results.snapshot.failure; + + if (hasSnapshotFailure) { + this._drawUIOverlay(); + + return; + } + + this._testAssertions.shift(); + + if (this._testAssertions.length - this._skippedNum === 0) { + this._drawUIOverlay(); + + return; + } // Go to the next test + + this._run(false); + } + + _run(shouldUpdateSnapshot) { + const testAssertion = this._testAssertions[0]; + + this._updateTestRunnerConfig(testAssertion, shouldUpdateSnapshot); + } + + run(failedSnapshotTestAssertions, onConfigChange) { + if (!failedSnapshotTestAssertions.length) { + return; + } + + this._testAssertions = [...failedSnapshotTestAssertions]; + this._countPaths = this._testAssertions.length; + this._updateTestRunnerConfig = onConfigChange; + this._isActive = true; + + this._run(false); + } +} + +exports.default = SnapshotInteractiveMode; diff --git a/node_modules/@jest/core/build/TestNamePatternPrompt.d.ts b/node_modules/@jest/core/build/TestNamePatternPrompt.d.ts new file mode 100644 index 0000000..c3a187c --- /dev/null +++ b/node_modules/@jest/core/build/TestNamePatternPrompt.d.ts @@ -0,0 +1,17 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +/// <reference types="node" /> +import type { TestResult } from '@jest/test-result'; +import { PatternPrompt, Prompt, ScrollOptions } from 'jest-watcher'; +export default class TestNamePatternPrompt extends PatternPrompt { + _cachedTestResults: Array<TestResult>; + constructor(pipe: NodeJS.WritableStream, prompt: Prompt); + _onChange(pattern: string, options: ScrollOptions): void; + _printPrompt(pattern: string): void; + _getMatchedTests(pattern: string): Array<string>; + updateCachedTestResults(testResults?: Array<TestResult>): void; +} diff --git a/node_modules/@jest/core/build/TestNamePatternPrompt.js b/node_modules/@jest/core/build/TestNamePatternPrompt.js new file mode 100644 index 0000000..4d9bb2b --- /dev/null +++ b/node_modules/@jest/core/build/TestNamePatternPrompt.js @@ -0,0 +1,86 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; + +function _jestWatcher() { + const data = require('jest-watcher'); + + _jestWatcher = function () { + return data; + }; + + return data; +} + +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; +} + +// TODO: Make underscored props `private` +class TestNamePatternPrompt extends _jestWatcher().PatternPrompt { + constructor(pipe, prompt) { + super(pipe, prompt); + + _defineProperty(this, '_cachedTestResults', void 0); + + this._entityName = 'tests'; + this._cachedTestResults = []; + } + + _onChange(pattern, options) { + super._onChange(pattern, options); + + this._printPrompt(pattern); + } + + _printPrompt(pattern) { + const pipe = this._pipe; + (0, _jestWatcher().printPatternCaret)(pattern, pipe); + (0, _jestWatcher().printRestoredPatternCaret)( + pattern, + this._currentUsageRows, + pipe + ); + } + + _getMatchedTests(pattern) { + let regex; + + try { + regex = new RegExp(pattern, 'i'); + } catch { + return []; + } + + const matchedTests = []; + + this._cachedTestResults.forEach(({testResults}) => + testResults.forEach(({title}) => { + if (regex.test(title)) { + matchedTests.push(title); + } + }) + ); + + return matchedTests; + } + + updateCachedTestResults(testResults = []) { + this._cachedTestResults = testResults; + } +} + +exports.default = TestNamePatternPrompt; diff --git a/node_modules/@jest/core/build/TestPathPatternPrompt.d.ts b/node_modules/@jest/core/build/TestPathPatternPrompt.d.ts new file mode 100644 index 0000000..589ee48 --- /dev/null +++ b/node_modules/@jest/core/build/TestPathPatternPrompt.d.ts @@ -0,0 +1,24 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +/// <reference types="node" /> +import type { Test } from '@jest/test-result'; +import type { Context } from 'jest-runtime'; +import { PatternPrompt, Prompt, ScrollOptions } from 'jest-watcher'; +import type SearchSource from './SearchSource'; +declare type SearchSources = Array<{ + context: Context; + searchSource: SearchSource; +}>; +export default class TestPathPatternPrompt extends PatternPrompt { + _searchSources?: SearchSources; + constructor(pipe: NodeJS.WritableStream, prompt: Prompt); + _onChange(pattern: string, options: ScrollOptions): void; + _printPrompt(pattern: string): void; + _getMatchedTests(pattern: string): Array<Test>; + updateSearchSources(searchSources: SearchSources): void; +} +export {}; diff --git a/node_modules/@jest/core/build/TestPathPatternPrompt.js b/node_modules/@jest/core/build/TestPathPatternPrompt.js new file mode 100644 index 0000000..fe0a2bf --- /dev/null +++ b/node_modules/@jest/core/build/TestPathPatternPrompt.js @@ -0,0 +1,81 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; + +function _jestWatcher() { + const data = require('jest-watcher'); + + _jestWatcher = function () { + return data; + }; + + return data; +} + +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; +} + +// TODO: Make underscored props `private` +class TestPathPatternPrompt extends _jestWatcher().PatternPrompt { + constructor(pipe, prompt) { + super(pipe, prompt); + + _defineProperty(this, '_searchSources', void 0); + + this._entityName = 'filenames'; + } + + _onChange(pattern, options) { + super._onChange(pattern, options); + + this._printPrompt(pattern); + } + + _printPrompt(pattern) { + const pipe = this._pipe; + (0, _jestWatcher().printPatternCaret)(pattern, pipe); + (0, _jestWatcher().printRestoredPatternCaret)( + pattern, + this._currentUsageRows, + pipe + ); + } + + _getMatchedTests(pattern) { + let regex; + + try { + regex = new RegExp(pattern, 'i'); + } catch {} + + let tests = []; + + if (regex && this._searchSources) { + this._searchSources.forEach(({searchSource}) => { + tests = tests.concat(searchSource.findMatchingTests(pattern).tests); + }); + } + + return tests; + } + + updateSearchSources(searchSources) { + this._searchSources = searchSources; + } +} + +exports.default = TestPathPatternPrompt; diff --git a/node_modules/@jest/core/build/TestScheduler.d.ts b/node_modules/@jest/core/build/TestScheduler.d.ts new file mode 100644 index 0000000..7cf0c18 --- /dev/null +++ b/node_modules/@jest/core/build/TestScheduler.d.ts @@ -0,0 +1,42 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +import { Reporter } from '@jest/reporters'; +import { AggregatedResult, Test } from '@jest/test-result'; +import type { Config } from '@jest/types'; +import type TestWatcher from './TestWatcher'; +export declare type TestSchedulerOptions = { + startRun: (globalConfig: Config.GlobalConfig) => void; +}; +export declare type TestSchedulerContext = { + firstRun: boolean; + previousSuccess: boolean; + changedFiles?: Set<Config.Path>; + sourcesRelatedToTestsInChangedFiles?: Set<Config.Path>; +}; +export declare function createTestScheduler(globalConfig: Config.GlobalConfig, options: TestSchedulerOptions, context: TestSchedulerContext): Promise<TestScheduler>; +declare class TestScheduler { + private readonly _dispatcher; + private readonly _globalConfig; + private readonly _options; + private readonly _context; + constructor(globalConfig: Config.GlobalConfig, options: TestSchedulerOptions, context: TestSchedulerContext); + addReporter(reporter: Reporter): void; + removeReporter(ReporterClass: Function): void; + scheduleTests(tests: Array<Test>, watcher: TestWatcher): Promise<AggregatedResult>; + private _partitionTests; + private _shouldAddDefaultReporters; + _setupReporters(): Promise<void>; + private _setupDefaultReporters; + private _addCustomReporters; + /** + * Get properties of a reporter in an object + * to make dealing with them less painful. + */ + private _getReporterProps; + private _bailIfNeeded; +} +export {}; diff --git a/node_modules/@jest/core/build/TestScheduler.js b/node_modules/@jest/core/build/TestScheduler.js new file mode 100644 index 0000000..fb0d314 --- /dev/null +++ b/node_modules/@jest/core/build/TestScheduler.js @@ -0,0 +1,570 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.createTestScheduler = createTestScheduler; + +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + + _chalk = function () { + return data; + }; + + return data; +} + +function _exit() { + const data = _interopRequireDefault(require('exit')); + + _exit = function () { + return data; + }; + + return data; +} + +function _reporters() { + const data = require('@jest/reporters'); + + _reporters = function () { + return data; + }; + + return data; +} + +function _testResult() { + const data = require('@jest/test-result'); + + _testResult = function () { + return data; + }; + + return data; +} + +function _transform() { + const data = require('@jest/transform'); + + _transform = function () { + return data; + }; + + return data; +} + +function _jestMessageUtil() { + const data = require('jest-message-util'); + + _jestMessageUtil = function () { + return data; + }; + + return data; +} + +function _jestSnapshot() { + const data = _interopRequireDefault(require('jest-snapshot')); + + _jestSnapshot = function () { + return data; + }; + + return data; +} + +function _jestUtil() { + const data = require('jest-util'); + + _jestUtil = function () { + return data; + }; + + return data; +} + +var _ReporterDispatcher = _interopRequireDefault( + require('./ReporterDispatcher') +); + +var _testSchedulerHelper = require('./testSchedulerHelper'); + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} + +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; +} + +async function createTestScheduler(globalConfig, options, context) { + const scheduler = new TestScheduler(globalConfig, options, context); + await scheduler._setupReporters(); + return scheduler; +} + +class TestScheduler { + constructor(globalConfig, options, context) { + _defineProperty(this, '_dispatcher', void 0); + + _defineProperty(this, '_globalConfig', void 0); + + _defineProperty(this, '_options', void 0); + + _defineProperty(this, '_context', void 0); + + this._dispatcher = new _ReporterDispatcher.default(); + this._globalConfig = globalConfig; + this._options = options; + this._context = context; + } + + addReporter(reporter) { + this._dispatcher.register(reporter); + } + + removeReporter(ReporterClass) { + this._dispatcher.unregister(ReporterClass); + } + + async scheduleTests(tests, watcher) { + const onTestFileStart = this._dispatcher.onTestFileStart.bind( + this._dispatcher + ); + + const timings = []; + const contexts = new Set(); + tests.forEach(test => { + contexts.add(test.context); + + if (test.duration) { + timings.push(test.duration); + } + }); + const aggregatedResults = createAggregatedResults(tests.length); + const estimatedTime = Math.ceil( + getEstimatedTime(timings, this._globalConfig.maxWorkers) / 1000 + ); + const runInBand = (0, _testSchedulerHelper.shouldRunInBand)( + tests, + timings, + this._globalConfig + ); + + const onResult = async (test, testResult) => { + if (watcher.isInterrupted()) { + return Promise.resolve(); + } + + if (testResult.testResults.length === 0) { + const message = 'Your test suite must contain at least one test.'; + return onFailure(test, { + message, + stack: new Error(message).stack + }); + } // Throws when the context is leaked after executing a test. + + if (testResult.leaks) { + const message = + _chalk().default.red.bold('EXPERIMENTAL FEATURE!\n') + + 'Your test suite is leaking memory. Please ensure all references are cleaned.\n' + + '\n' + + 'There is a number of things that can leak memory:\n' + + ' - Async operations that have not finished (e.g. fs.readFile).\n' + + ' - Timers not properly mocked (e.g. setInterval, setTimeout).\n' + + ' - Keeping references to the global scope.'; + return onFailure(test, { + message, + stack: new Error(message).stack + }); + } + + (0, _testResult().addResult)(aggregatedResults, testResult); + await this._dispatcher.onTestFileResult( + test, + testResult, + aggregatedResults + ); + return this._bailIfNeeded(contexts, aggregatedResults, watcher); + }; + + const onFailure = async (test, error) => { + if (watcher.isInterrupted()) { + return; + } + + const testResult = (0, _testResult().buildFailureTestResult)( + test.path, + error + ); + testResult.failureMessage = (0, _jestMessageUtil().formatExecError)( + testResult.testExecError, + test.context.config, + this._globalConfig, + test.path + ); + (0, _testResult().addResult)(aggregatedResults, testResult); + await this._dispatcher.onTestFileResult( + test, + testResult, + aggregatedResults + ); + }; + + const updateSnapshotState = async () => { + const contextsWithSnapshotResolvers = await Promise.all( + Array.from(contexts).map(async context => [ + context, + await _jestSnapshot().default.buildSnapshotResolver(context.config) + ]) + ); + contextsWithSnapshotResolvers.forEach(([context, snapshotResolver]) => { + const status = _jestSnapshot().default.cleanup( + context.hasteFS, + this._globalConfig.updateSnapshot, + snapshotResolver, + context.config.testPathIgnorePatterns + ); + + aggregatedResults.snapshot.filesRemoved += status.filesRemoved; + aggregatedResults.snapshot.filesRemovedList = ( + aggregatedResults.snapshot.filesRemovedList || [] + ).concat(status.filesRemovedList); + }); + const updateAll = this._globalConfig.updateSnapshot === 'all'; + aggregatedResults.snapshot.didUpdate = updateAll; + aggregatedResults.snapshot.failure = !!( + !updateAll && + (aggregatedResults.snapshot.unchecked || + aggregatedResults.snapshot.unmatched || + aggregatedResults.snapshot.filesRemoved) + ); + }; + + await this._dispatcher.onRunStart(aggregatedResults, { + estimatedTime, + showStatus: !runInBand + }); + const testRunners = Object.create(null); + const contextsByTestRunner = new WeakMap(); + await Promise.all( + Array.from(contexts).map(async context => { + const {config} = context; + + if (!testRunners[config.runner]) { + var _this$_context, _this$_context2; + + const transformer = await (0, _transform().createScriptTransformer)( + config + ); + const Runner = await transformer.requireAndTranspileModule( + config.runner + ); + const runner = new Runner(this._globalConfig, { + changedFiles: + (_this$_context = this._context) === null || + _this$_context === void 0 + ? void 0 + : _this$_context.changedFiles, + sourcesRelatedToTestsInChangedFiles: + (_this$_context2 = this._context) === null || + _this$_context2 === void 0 + ? void 0 + : _this$_context2.sourcesRelatedToTestsInChangedFiles + }); + testRunners[config.runner] = runner; + contextsByTestRunner.set(runner, context); + } + }) + ); + + const testsByRunner = this._partitionTests(testRunners, tests); + + if (testsByRunner) { + try { + for (const runner of Object.keys(testRunners)) { + const testRunner = testRunners[runner]; + const context = contextsByTestRunner.get(testRunner); + invariant(context); + const tests = testsByRunner[runner]; + const testRunnerOptions = { + serial: runInBand || Boolean(testRunner.isSerial) + }; + /** + * Test runners with event emitters are still not supported + * for third party test runners. + */ + + if (testRunner.__PRIVATE_UNSTABLE_API_supportsEventEmitters__) { + const unsubscribes = [ + testRunner.on('test-file-start', ([test]) => + onTestFileStart(test) + ), + testRunner.on('test-file-success', ([test, testResult]) => + onResult(test, testResult) + ), + testRunner.on('test-file-failure', ([test, error]) => + onFailure(test, error) + ), + testRunner.on( + 'test-case-result', + ([testPath, testCaseResult]) => { + const test = { + context, + path: testPath + }; + + this._dispatcher.onTestCaseResult(test, testCaseResult); + } + ) + ]; + await testRunner.runTests( + tests, + watcher, + undefined, + undefined, + undefined, + testRunnerOptions + ); + unsubscribes.forEach(sub => sub()); + } else { + await testRunner.runTests( + tests, + watcher, + onTestFileStart, + onResult, + onFailure, + testRunnerOptions + ); + } + } + } catch (error) { + if (!watcher.isInterrupted()) { + throw error; + } + } + } + + await updateSnapshotState(); + aggregatedResults.wasInterrupted = watcher.isInterrupted(); + await this._dispatcher.onRunComplete(contexts, aggregatedResults); + const anyTestFailures = !( + aggregatedResults.numFailedTests === 0 && + aggregatedResults.numRuntimeErrorTestSuites === 0 + ); + + const anyReporterErrors = this._dispatcher.hasErrors(); + + aggregatedResults.success = !( + anyTestFailures || + aggregatedResults.snapshot.failure || + anyReporterErrors + ); + return aggregatedResults; + } + + _partitionTests(testRunners, tests) { + if (Object.keys(testRunners).length > 1) { + return tests.reduce((testRuns, test) => { + const runner = test.context.config.runner; + + if (!testRuns[runner]) { + testRuns[runner] = []; + } + + testRuns[runner].push(test); + return testRuns; + }, Object.create(null)); + } else if (tests.length > 0 && tests[0] != null) { + // If there is only one runner, don't partition the tests. + return Object.assign(Object.create(null), { + [tests[0].context.config.runner]: tests + }); + } else { + return null; + } + } + + _shouldAddDefaultReporters(reporters) { + return ( + !reporters || + !!reporters.find( + reporter => this._getReporterProps(reporter).path === 'default' + ) + ); + } + + async _setupReporters() { + const {collectCoverage, notify, reporters} = this._globalConfig; + + const isDefault = this._shouldAddDefaultReporters(reporters); + + if (isDefault) { + this._setupDefaultReporters(collectCoverage); + } + + if (!isDefault && collectCoverage) { + var _this$_context3, _this$_context4; + + this.addReporter( + new (_reporters().CoverageReporter)(this._globalConfig, { + changedFiles: + (_this$_context3 = this._context) === null || + _this$_context3 === void 0 + ? void 0 + : _this$_context3.changedFiles, + sourcesRelatedToTestsInChangedFiles: + (_this$_context4 = this._context) === null || + _this$_context4 === void 0 + ? void 0 + : _this$_context4.sourcesRelatedToTestsInChangedFiles + }) + ); + } + + if (notify) { + this.addReporter( + new (_reporters().NotifyReporter)( + this._globalConfig, + this._options.startRun, + this._context + ) + ); + } + + if (reporters && Array.isArray(reporters)) { + await this._addCustomReporters(reporters); + } + } + + _setupDefaultReporters(collectCoverage) { + this.addReporter( + this._globalConfig.verbose + ? new (_reporters().VerboseReporter)(this._globalConfig) + : new (_reporters().DefaultReporter)(this._globalConfig) + ); + + if (collectCoverage) { + var _this$_context5, _this$_context6; + + this.addReporter( + new (_reporters().CoverageReporter)(this._globalConfig, { + changedFiles: + (_this$_context5 = this._context) === null || + _this$_context5 === void 0 + ? void 0 + : _this$_context5.changedFiles, + sourcesRelatedToTestsInChangedFiles: + (_this$_context6 = this._context) === null || + _this$_context6 === void 0 + ? void 0 + : _this$_context6.sourcesRelatedToTestsInChangedFiles + }) + ); + } + + this.addReporter(new (_reporters().SummaryReporter)(this._globalConfig)); + } + + async _addCustomReporters(reporters) { + for (const reporter of reporters) { + const {options, path} = this._getReporterProps(reporter); + + if (path === 'default') continue; + + try { + const Reporter = await (0, _jestUtil().requireOrImportModule)( + path, + true + ); + this.addReporter(new Reporter(this._globalConfig, options)); + } catch (error) { + error.message = + 'An error occurred while adding the reporter at path "' + + _chalk().default.bold(path) + + '".' + + error.message; + throw error; + } + } + } + /** + * Get properties of a reporter in an object + * to make dealing with them less painful. + */ + + _getReporterProps(reporter) { + if (typeof reporter === 'string') { + return { + options: this._options, + path: reporter + }; + } else if (Array.isArray(reporter)) { + const [path, options] = reporter; + return { + options, + path + }; + } + + throw new Error('Reporter should be either a string or an array'); + } + + async _bailIfNeeded(contexts, aggregatedResults, watcher) { + if ( + this._globalConfig.bail !== 0 && + aggregatedResults.numFailedTests >= this._globalConfig.bail + ) { + if (watcher.isWatchMode()) { + await watcher.setState({ + interrupted: true + }); + return; + } + + try { + await this._dispatcher.onRunComplete(contexts, aggregatedResults); + } finally { + const exitCode = this._globalConfig.testFailureExitCode; + (0, _exit().default)(exitCode); + } + } + } +} + +function invariant(condition, message) { + if (!condition) { + throw new Error(message); + } +} + +const createAggregatedResults = numTotalTestSuites => { + const result = (0, _testResult().makeEmptyAggregatedTestResult)(); + result.numTotalTestSuites = numTotalTestSuites; + result.startTime = Date.now(); + result.success = false; + return result; +}; + +const getEstimatedTime = (timings, workers) => { + if (timings.length === 0) { + return 0; + } + + const max = Math.max(...timings); + return timings.length <= workers + ? max + : Math.max(timings.reduce((sum, time) => sum + time) / workers, max); +}; diff --git a/node_modules/@jest/core/build/TestWatcher.d.ts b/node_modules/@jest/core/build/TestWatcher.d.ts new file mode 100644 index 0000000..baceb5e --- /dev/null +++ b/node_modules/@jest/core/build/TestWatcher.d.ts @@ -0,0 +1,23 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +import emittery = require('emittery'); +declare type State = { + interrupted: boolean; +}; +export default class TestWatcher extends emittery<{ + change: State; +}> { + state: State; + private _isWatchMode; + constructor({ isWatchMode }: { + isWatchMode: boolean; + }); + setState(state: State): Promise<void>; + isInterrupted(): boolean; + isWatchMode(): boolean; +} +export {}; diff --git a/node_modules/@jest/core/build/TestWatcher.js b/node_modules/@jest/core/build/TestWatcher.js new file mode 100644 index 0000000..491279b --- /dev/null +++ b/node_modules/@jest/core/build/TestWatcher.js @@ -0,0 +1,64 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; + +function _emittery() { + const data = _interopRequireDefault(require('emittery')); + + _emittery = function () { + return data; + }; + + return data; +} + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} + +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; +} + +class TestWatcher extends _emittery().default { + constructor({isWatchMode}) { + super(); + + _defineProperty(this, 'state', void 0); + + _defineProperty(this, '_isWatchMode', void 0); + + this.state = { + interrupted: false + }; + this._isWatchMode = isWatchMode; + } + + async setState(state) { + Object.assign(this.state, state); + await this.emit('change', this.state); + } + + isInterrupted() { + return this.state.interrupted; + } + + isWatchMode() { + return this._isWatchMode; + } +} + +exports.default = TestWatcher; diff --git a/node_modules/@jest/core/build/assets/jest_logo.png b/node_modules/@jest/core/build/assets/jest_logo.png Binary files differnew file mode 100644 index 0000000..079356b --- /dev/null +++ b/node_modules/@jest/core/build/assets/jest_logo.png diff --git a/node_modules/@jest/core/build/cli/index.d.ts b/node_modules/@jest/core/build/cli/index.d.ts new file mode 100644 index 0000000..bfa970e --- /dev/null +++ b/node_modules/@jest/core/build/cli/index.d.ts @@ -0,0 +1,12 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +import type { AggregatedResult } from '@jest/test-result'; +import type { Config } from '@jest/types'; +export declare function runCLI(argv: Config.Argv, projects: Array<Config.Path>): Promise<{ + results: AggregatedResult; + globalConfig: Config.GlobalConfig; +}>; diff --git a/node_modules/@jest/core/build/cli/index.js b/node_modules/@jest/core/build/cli/index.js new file mode 100644 index 0000000..2844390 --- /dev/null +++ b/node_modules/@jest/core/build/cli/index.js @@ -0,0 +1,399 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.runCLI = runCLI; + +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + + _chalk = function () { + return data; + }; + + return data; +} + +function _exit() { + const data = _interopRequireDefault(require('exit')); + + _exit = function () { + return data; + }; + + return data; +} + +function _rimraf() { + const data = _interopRequireDefault(require('rimraf')); + + _rimraf = function () { + return data; + }; + + return data; +} + +function _console() { + const data = require('@jest/console'); + + _console = function () { + return data; + }; + + return data; +} + +function _jestConfig() { + const data = require('jest-config'); + + _jestConfig = function () { + return data; + }; + + return data; +} + +function _jestRuntime() { + const data = _interopRequireDefault(require('jest-runtime')); + + _jestRuntime = function () { + return data; + }; + + return data; +} + +function _jestUtil() { + const data = require('jest-util'); + + _jestUtil = function () { + return data; + }; + + return data; +} + +var _TestWatcher = _interopRequireDefault(require('../TestWatcher')); + +var _collectHandles = require('../collectHandles'); + +var _getChangedFilesPromise = _interopRequireDefault( + require('../getChangedFilesPromise') +); + +var _getConfigsOfProjectsToRun = _interopRequireDefault( + require('../getConfigsOfProjectsToRun') +); + +var _getProjectNamesMissingWarning = _interopRequireDefault( + require('../getProjectNamesMissingWarning') +); + +var _getSelectProjectsMessage = _interopRequireDefault( + require('../getSelectProjectsMessage') +); + +var _createContext = _interopRequireDefault(require('../lib/createContext')); + +var _handleDeprecationWarnings = _interopRequireDefault( + require('../lib/handleDeprecationWarnings') +); + +var _logDebugMessages = _interopRequireDefault( + require('../lib/logDebugMessages') +); + +var _pluralize = _interopRequireDefault(require('../pluralize')); + +var _runJest = _interopRequireDefault(require('../runJest')); + +var _watch = _interopRequireDefault(require('../watch')); + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} + +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +const {print: preRunMessagePrint} = _jestUtil().preRunMessage; + +async function runCLI(argv, projects) { + let results; // If we output a JSON object, we can't write anything to stdout, since + // it'll break the JSON structure and it won't be valid. + + const outputStream = + argv.json || argv.useStderr ? process.stderr : process.stdout; + const {globalConfig, configs, hasDeprecationWarnings} = await (0, + _jestConfig().readConfigs)(argv, projects); + + if (argv.debug) { + (0, _logDebugMessages.default)(globalConfig, configs, outputStream); + } + + if (argv.showConfig) { + (0, _logDebugMessages.default)(globalConfig, configs, process.stdout); + (0, _exit().default)(0); + } + + if (argv.clearCache) { + configs.forEach(config => { + _rimraf().default.sync(config.cacheDirectory); + + process.stdout.write(`Cleared ${config.cacheDirectory}\n`); + }); + (0, _exit().default)(0); + } + + let configsOfProjectsToRun = configs; + + if (argv.selectProjects) { + const namesMissingWarning = (0, _getProjectNamesMissingWarning.default)( + configs + ); + + if (namesMissingWarning) { + outputStream.write(namesMissingWarning); + } + + configsOfProjectsToRun = (0, _getConfigsOfProjectsToRun.default)( + argv.selectProjects, + configs + ); + outputStream.write( + (0, _getSelectProjectsMessage.default)(configsOfProjectsToRun) + ); + } + + await _run10000( + globalConfig, + configsOfProjectsToRun, + hasDeprecationWarnings, + outputStream, + r => { + results = r; + } + ); + + if (argv.watch || argv.watchAll) { + // If in watch mode, return the promise that will never resolve. + // If the watch mode is interrupted, watch should handle the process + // shutdown. + return new Promise(() => {}); + } + + if (!results) { + throw new Error( + 'AggregatedResult must be present after test run is complete' + ); + } + + const {openHandles} = results; + + if (openHandles && openHandles.length) { + const formatted = (0, _collectHandles.formatHandleErrors)( + openHandles, + configs[0] + ); + const openHandlesString = (0, _pluralize.default)( + 'open handle', + formatted.length, + 's' + ); + const message = + _chalk().default.red( + `\nJest has detected the following ${openHandlesString} potentially keeping Jest from exiting:\n\n` + ) + formatted.join('\n\n'); + console.error(message); + } + + return { + globalConfig, + results + }; +} + +const buildContextsAndHasteMaps = async ( + configs, + globalConfig, + outputStream +) => { + const hasteMapInstances = Array(configs.length); + const contexts = await Promise.all( + configs.map(async (config, index) => { + (0, _jestUtil().createDirectory)(config.cacheDirectory); + + const hasteMapInstance = _jestRuntime().default.createHasteMap(config, { + console: new (_console().CustomConsole)(outputStream, outputStream), + maxWorkers: Math.max( + 1, + Math.floor(globalConfig.maxWorkers / configs.length) + ), + resetCache: !config.cache, + watch: globalConfig.watch || globalConfig.watchAll, + watchman: globalConfig.watchman + }); + + hasteMapInstances[index] = hasteMapInstance; + return (0, _createContext.default)( + config, + await hasteMapInstance.build() + ); + }) + ); + return { + contexts, + hasteMapInstances + }; +}; + +const _run10000 = async ( + globalConfig, + configs, + hasDeprecationWarnings, + outputStream, + onComplete +) => { + // Queries to hg/git can take a while, so we need to start the process + // as soon as possible, so by the time we need the result it's already there. + const changedFilesPromise = (0, _getChangedFilesPromise.default)( + globalConfig, + configs + ); // Filter may need to do an HTTP call or something similar to setup. + // We will wait on an async response from this before using the filter. + + let filter; + + if (globalConfig.filter && !globalConfig.skipFilter) { + const rawFilter = require(globalConfig.filter); + + let filterSetupPromise; + + if (rawFilter.setup) { + // Wrap filter setup Promise to avoid "uncaught Promise" error. + // If an error is returned, we surface it in the return value. + filterSetupPromise = (async () => { + try { + await rawFilter.setup(); + } catch (err) { + return err; + } + + return undefined; + })(); + } + + filter = async testPaths => { + if (filterSetupPromise) { + // Expect an undefined return value unless there was an error. + const err = await filterSetupPromise; + + if (err) { + throw err; + } + } + + return rawFilter(testPaths); + }; + } + + const {contexts, hasteMapInstances} = await buildContextsAndHasteMaps( + configs, + globalConfig, + outputStream + ); + globalConfig.watch || globalConfig.watchAll + ? await runWatch( + contexts, + configs, + hasDeprecationWarnings, + globalConfig, + outputStream, + hasteMapInstances, + filter + ) + : await runWithoutWatch( + globalConfig, + contexts, + outputStream, + onComplete, + changedFilesPromise, + filter + ); +}; + +const runWatch = async ( + contexts, + _configs, + hasDeprecationWarnings, + globalConfig, + outputStream, + hasteMapInstances, + filter +) => { + if (hasDeprecationWarnings) { + try { + await (0, _handleDeprecationWarnings.default)( + outputStream, + process.stdin + ); + return (0, _watch.default)( + globalConfig, + contexts, + outputStream, + hasteMapInstances, + undefined, + undefined, + filter + ); + } catch { + (0, _exit().default)(0); + } + } + + return (0, _watch.default)( + globalConfig, + contexts, + outputStream, + hasteMapInstances, + undefined, + undefined, + filter + ); +}; + +const runWithoutWatch = async ( + globalConfig, + contexts, + outputStream, + onComplete, + changedFilesPromise, + filter +) => { + const startRun = async () => { + if (!globalConfig.listTests) { + preRunMessagePrint(outputStream); + } + + return (0, _runJest.default)({ + changedFilesPromise, + contexts, + failedTestsCache: undefined, + filter, + globalConfig, + onComplete, + outputStream, + startRun, + testWatcher: new _TestWatcher.default({ + isWatchMode: false + }) + }); + }; + + return startRun(); +}; diff --git a/node_modules/@jest/core/build/collectHandles.d.ts b/node_modules/@jest/core/build/collectHandles.d.ts new file mode 100644 index 0000000..7e72c44 --- /dev/null +++ b/node_modules/@jest/core/build/collectHandles.d.ts @@ -0,0 +1,10 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +import type { Config } from '@jest/types'; +export declare type HandleCollectionResult = () => Promise<Array<Error>>; +export default function collectHandles(): HandleCollectionResult; +export declare function formatHandleErrors(errors: Array<Error>, config: Config.ProjectConfig): Array<string>; diff --git a/node_modules/@jest/core/build/collectHandles.js b/node_modules/@jest/core/build/collectHandles.js new file mode 100644 index 0000000..6b77f1c --- /dev/null +++ b/node_modules/@jest/core/build/collectHandles.js @@ -0,0 +1,269 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = collectHandles; +exports.formatHandleErrors = formatHandleErrors; + +function asyncHooks() { + const data = _interopRequireWildcard(require('async_hooks')); + + asyncHooks = function () { + return data; + }; + + return data; +} + +function _util() { + const data = require('util'); + + _util = function () { + return data; + }; + + return data; +} + +function _stripAnsi() { + const data = _interopRequireDefault(require('strip-ansi')); + + _stripAnsi = function () { + return data; + }; + + return data; +} + +function _jestMessageUtil() { + const data = require('jest-message-util'); + + _jestMessageUtil = function () { + return data; + }; + + return data; +} + +function _jestUtil() { + const data = require('jest-util'); + + _jestUtil = function () { + return data; + }; + + return data; +} + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} + +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} + +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} + +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ + +/* eslint-disable local/ban-types-eventually */ +function stackIsFromUser(stack) { + // Either the test file, or something required by it + if (stack.includes('Runtime.requireModule')) { + return true; + } // jest-jasmine it or describe call + + if (stack.includes('asyncJestTest') || stack.includes('asyncJestLifecycle')) { + return true; + } // An async function call from within circus + + if (stack.includes('callAsyncCircusFn')) { + // jest-circus it or describe call + return ( + stack.includes('_callCircusTest') || stack.includes('_callCircusHook') + ); + } + + return false; +} + +const alwaysActive = () => true; // @ts-expect-error: doesn't exist in v10 typings + +const hasWeakRef = typeof WeakRef === 'function'; +const asyncSleep = (0, _util().promisify)(setTimeout); // Inspired by https://github.com/mafintosh/why-is-node-running/blob/master/index.js +// Extracted as we want to format the result ourselves + +function collectHandles() { + const activeHandles = new Map(); + const hook = asyncHooks().createHook({ + destroy(asyncId) { + activeHandles.delete(asyncId); + }, + + init: function initHook(asyncId, type, triggerAsyncId, resource) { + // Skip resources that should not generally prevent the process from + // exiting, not last a meaningfully long time, or otherwise shouldn't be + // tracked. + if ( + type === 'PROMISE' || + type === 'TIMERWRAP' || + type === 'ELDHISTOGRAM' || + type === 'PerformanceObserver' || + type === 'RANDOMBYTESREQUEST' || + type === 'DNSCHANNEL' || + type === 'ZLIB' + ) { + return; + } + + const error = new (_jestUtil().ErrorWithStack)(type, initHook, 100); + let fromUser = stackIsFromUser(error.stack || ''); // If the async resource was not directly created by user code, but was + // triggered by another async resource from user code, track it and use + // the original triggering resource's stack. + + if (!fromUser) { + const triggeringHandle = activeHandles.get(triggerAsyncId); + + if (triggeringHandle) { + fromUser = true; + error.stack = triggeringHandle.error.stack; + } + } + + if (fromUser) { + let isActive; + + if (type === 'Timeout' || type === 'Immediate') { + // Timer that supports hasRef (Node v11+) + if ('hasRef' in resource) { + if (hasWeakRef) { + // @ts-expect-error: doesn't exist in v10 typings + const ref = new WeakRef(resource); + + isActive = () => { + var _ref$deref$hasRef, _ref$deref; + + return (_ref$deref$hasRef = + (_ref$deref = ref.deref()) === null || _ref$deref === void 0 + ? void 0 + : _ref$deref.hasRef()) !== null && + _ref$deref$hasRef !== void 0 + ? _ref$deref$hasRef + : false; + }; + } else { + // @ts-expect-error: doesn't exist in v10 typings + isActive = resource.hasRef.bind(resource); + } + } else { + // Timer that doesn't support hasRef + isActive = alwaysActive; + } + } else { + // Any other async resource + isActive = alwaysActive; + } + + activeHandles.set(asyncId, { + error, + isActive + }); + } + } + }); + hook.enable(); + return async () => { + // Wait briefly for any async resources that have been queued for + // destruction to actually be destroyed. + // For example, Node.js TCP Servers are not destroyed until *after* their + // `close` callback runs. If someone finishes a test from the `close` + // callback, we will not yet have seen the resource be destroyed here. + await asyncSleep(100); + hook.disable(); // Get errors for every async resource still referenced at this moment + + const result = Array.from(activeHandles.values()) + .filter(({isActive}) => isActive()) + .map(({error}) => error); + activeHandles.clear(); + return result; + }; +} + +function formatHandleErrors(errors, config) { + const stacks = new Set(); + return ( + errors + .map(err => + (0, _jestMessageUtil().formatExecError)( + err, + config, + { + noStackTrace: false + }, + undefined, + true + ) + ) // E.g. timeouts might give multiple traces to the same line of code + // This hairy filtering tries to remove entries with duplicate stack traces + .filter(handle => { + const ansiFree = (0, _stripAnsi().default)(handle); + const match = ansiFree.match(/\s+at(.*)/); + + if (!match || match.length < 2) { + return true; + } + + const stack = ansiFree.substr(ansiFree.indexOf(match[1])).trim(); + + if (stacks.has(stack)) { + return false; + } + + stacks.add(stack); + return true; + }) + ); +} diff --git a/node_modules/@jest/core/build/getChangedFilesPromise.d.ts b/node_modules/@jest/core/build/getChangedFilesPromise.d.ts new file mode 100644 index 0000000..4a42b64 --- /dev/null +++ b/node_modules/@jest/core/build/getChangedFilesPromise.d.ts @@ -0,0 +1,9 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +import type { Config } from '@jest/types'; +import { ChangedFilesPromise } from 'jest-changed-files'; +export default function getChangedFilesPromise(globalConfig: Config.GlobalConfig, configs: Array<Config.ProjectConfig>): ChangedFilesPromise | undefined; diff --git a/node_modules/@jest/core/build/getChangedFilesPromise.js b/node_modules/@jest/core/build/getChangedFilesPromise.js new file mode 100644 index 0000000..c7912af --- /dev/null +++ b/node_modules/@jest/core/build/getChangedFilesPromise.js @@ -0,0 +1,77 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = getChangedFilesPromise; + +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + + _chalk = function () { + return data; + }; + + return data; +} + +function _jestChangedFiles() { + const data = require('jest-changed-files'); + + _jestChangedFiles = function () { + return data; + }; + + return data; +} + +function _jestMessageUtil() { + const data = require('jest-message-util'); + + _jestMessageUtil = function () { + return data; + }; + + return data; +} + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} + +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +function getChangedFilesPromise(globalConfig, configs) { + if (globalConfig.onlyChanged) { + const allRootsForAllProjects = configs.reduce((roots, config) => { + if (config.roots) { + roots.push(...config.roots); + } + + return roots; + }, []); + return (0, _jestChangedFiles().getChangedFilesForRoots)( + allRootsForAllProjects, + { + changedSince: globalConfig.changedSince, + lastCommit: globalConfig.lastCommit, + withAncestor: globalConfig.changedFilesWithAncestor + } + ).catch(e => { + const message = (0, _jestMessageUtil().formatExecError)(e, configs[0], { + noStackTrace: true + }) + .split('\n') + .filter(line => !line.includes('Command failed:')) + .join('\n'); + console.error(_chalk().default.red(`\n\n${message}`)); + process.exit(1); + }); + } + + return undefined; +} diff --git a/node_modules/@jest/core/build/getConfigsOfProjectsToRun.d.ts b/node_modules/@jest/core/build/getConfigsOfProjectsToRun.d.ts new file mode 100644 index 0000000..0a780d4 --- /dev/null +++ b/node_modules/@jest/core/build/getConfigsOfProjectsToRun.d.ts @@ -0,0 +1,8 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +import type { Config } from '@jest/types'; +export default function getConfigsOfProjectsToRun(namesOfProjectsToRun: Array<string>, projectConfigs: Array<Config.ProjectConfig>): Array<Config.ProjectConfig>; diff --git a/node_modules/@jest/core/build/getConfigsOfProjectsToRun.js b/node_modules/@jest/core/build/getConfigsOfProjectsToRun.js new file mode 100644 index 0000000..9326e30 --- /dev/null +++ b/node_modules/@jest/core/build/getConfigsOfProjectsToRun.js @@ -0,0 +1,28 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = getConfigsOfProjectsToRun; + +var _getProjectDisplayName = _interopRequireDefault( + require('./getProjectDisplayName') +); + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} + +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +function getConfigsOfProjectsToRun(namesOfProjectsToRun, projectConfigs) { + const setOfProjectsToRun = new Set(namesOfProjectsToRun); + return projectConfigs.filter(config => { + const name = (0, _getProjectDisplayName.default)(config); + return name && setOfProjectsToRun.has(name); + }); +} diff --git a/node_modules/@jest/core/build/getNoTestFound.d.ts b/node_modules/@jest/core/build/getNoTestFound.d.ts new file mode 100644 index 0000000..4e30581 --- /dev/null +++ b/node_modules/@jest/core/build/getNoTestFound.d.ts @@ -0,0 +1,9 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +import type { Config } from '@jest/types'; +import type { TestRunData } from './types'; +export default function getNoTestFound(testRunData: TestRunData, globalConfig: Config.GlobalConfig): string; diff --git a/node_modules/@jest/core/build/getNoTestFound.js b/node_modules/@jest/core/build/getNoTestFound.js new file mode 100644 index 0000000..bd33d58 --- /dev/null +++ b/node_modules/@jest/core/build/getNoTestFound.js @@ -0,0 +1,63 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = getNoTestFound; + +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + + _chalk = function () { + return data; + }; + + return data; +} + +var _pluralize = _interopRequireDefault(require('./pluralize')); + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} + +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +function getNoTestFound(testRunData, globalConfig) { + const testFiles = testRunData.reduce( + (current, testRun) => current + (testRun.matches.total || 0), + 0 + ); + let dataMessage; + + if (globalConfig.runTestsByPath) { + dataMessage = `Files: ${globalConfig.nonFlagArgs + .map(p => `"${p}"`) + .join(', ')}`; + } else { + dataMessage = `Pattern: ${_chalk().default.yellow( + globalConfig.testPathPattern + )} - 0 matches`; + } + + return ( + _chalk().default.bold('No tests found, exiting with code 1') + + '\n' + + 'Run with `--passWithNoTests` to exit with code 0' + + '\n' + + `In ${_chalk().default.bold(globalConfig.rootDir)}` + + '\n' + + ` ${(0, _pluralize.default)('file', testFiles, 's')} checked across ${(0, + _pluralize.default)( + 'project', + testRunData.length, + 's' + )}. Run with \`--verbose\` for more details.` + + '\n' + + dataMessage + ); +} diff --git a/node_modules/@jest/core/build/getNoTestFoundFailed.d.ts b/node_modules/@jest/core/build/getNoTestFoundFailed.d.ts new file mode 100644 index 0000000..16c5fab --- /dev/null +++ b/node_modules/@jest/core/build/getNoTestFoundFailed.d.ts @@ -0,0 +1,8 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +import type { Config } from '@jest/types'; +export default function getNoTestFoundFailed(globalConfig: Config.GlobalConfig): string; diff --git a/node_modules/@jest/core/build/getNoTestFoundFailed.js b/node_modules/@jest/core/build/getNoTestFoundFailed.js new file mode 100644 index 0000000..a7d404c --- /dev/null +++ b/node_modules/@jest/core/build/getNoTestFoundFailed.js @@ -0,0 +1,51 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = getNoTestFoundFailed; + +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + + _chalk = function () { + return data; + }; + + return data; +} + +function _jestUtil() { + const data = require('jest-util'); + + _jestUtil = function () { + return data; + }; + + return data; +} + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} + +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +function getNoTestFoundFailed(globalConfig) { + let msg = _chalk().default.bold('No failed test found.'); + + if (_jestUtil().isInteractive) { + msg += _chalk().default.dim( + '\n' + + (globalConfig.watch + ? 'Press `f` to quit "only failed tests" mode.' + : 'Run Jest without `--onlyFailures` or with `--all` to run all tests.') + ); + } + + return msg; +} diff --git a/node_modules/@jest/core/build/getNoTestFoundPassWithNoTests.d.ts b/node_modules/@jest/core/build/getNoTestFoundPassWithNoTests.d.ts new file mode 100644 index 0000000..a594ba4 --- /dev/null +++ b/node_modules/@jest/core/build/getNoTestFoundPassWithNoTests.d.ts @@ -0,0 +1,7 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +export default function getNoTestFoundPassWithNoTests(): string; diff --git a/node_modules/@jest/core/build/getNoTestFoundPassWithNoTests.js b/node_modules/@jest/core/build/getNoTestFoundPassWithNoTests.js new file mode 100644 index 0000000..eb279c3 --- /dev/null +++ b/node_modules/@jest/core/build/getNoTestFoundPassWithNoTests.js @@ -0,0 +1,30 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = getNoTestFoundPassWithNoTests; + +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + + _chalk = function () { + return data; + }; + + return data; +} + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} + +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +function getNoTestFoundPassWithNoTests() { + return _chalk().default.bold('No tests found, exiting with code 0'); +} diff --git a/node_modules/@jest/core/build/getNoTestFoundRelatedToChangedFiles.d.ts b/node_modules/@jest/core/build/getNoTestFoundRelatedToChangedFiles.d.ts new file mode 100644 index 0000000..53cdefc --- /dev/null +++ b/node_modules/@jest/core/build/getNoTestFoundRelatedToChangedFiles.d.ts @@ -0,0 +1,8 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +import type { Config } from '@jest/types'; +export default function getNoTestFoundRelatedToChangedFiles(globalConfig: Config.GlobalConfig): string; diff --git a/node_modules/@jest/core/build/getNoTestFoundRelatedToChangedFiles.js b/node_modules/@jest/core/build/getNoTestFoundRelatedToChangedFiles.js new file mode 100644 index 0000000..9571d18 --- /dev/null +++ b/node_modules/@jest/core/build/getNoTestFoundRelatedToChangedFiles.js @@ -0,0 +1,57 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = getNoTestFoundRelatedToChangedFiles; + +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + + _chalk = function () { + return data; + }; + + return data; +} + +function _jestUtil() { + const data = require('jest-util'); + + _jestUtil = function () { + return data; + }; + + return data; +} + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} + +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +function getNoTestFoundRelatedToChangedFiles(globalConfig) { + const ref = globalConfig.changedSince + ? `"${globalConfig.changedSince}"` + : 'last commit'; + + let msg = _chalk().default.bold( + `No tests found related to files changed since ${ref}.` + ); + + if (_jestUtil().isInteractive) { + msg += _chalk().default.dim( + '\n' + + (globalConfig.watch + ? 'Press `a` to run all tests, or run Jest with `--watchAll`.' + : 'Run Jest without `-o` or with `--all` to run all tests.') + ); + } + + return msg; +} diff --git a/node_modules/@jest/core/build/getNoTestFoundVerbose.d.ts b/node_modules/@jest/core/build/getNoTestFoundVerbose.d.ts new file mode 100644 index 0000000..a84572a --- /dev/null +++ b/node_modules/@jest/core/build/getNoTestFoundVerbose.d.ts @@ -0,0 +1,9 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +import type { Config } from '@jest/types'; +import type { TestRunData } from './types'; +export default function getNoTestFoundVerbose(testRunData: TestRunData, globalConfig: Config.GlobalConfig): string; diff --git a/node_modules/@jest/core/build/getNoTestFoundVerbose.js b/node_modules/@jest/core/build/getNoTestFoundVerbose.js new file mode 100644 index 0000000..8f1359c --- /dev/null +++ b/node_modules/@jest/core/build/getNoTestFoundVerbose.js @@ -0,0 +1,95 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = getNoTestFoundVerbose; + +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + + _chalk = function () { + return data; + }; + + return data; +} + +var _pluralize = _interopRequireDefault(require('./pluralize')); + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} + +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +function getNoTestFoundVerbose(testRunData, globalConfig) { + const individualResults = testRunData.map(testRun => { + const stats = testRun.matches.stats || {}; + const config = testRun.context.config; + const statsMessage = Object.keys(stats) + .map(key => { + if (key === 'roots' && config.roots.length === 1) { + return null; + } + + const value = config[key]; + + if (value) { + const valueAsString = Array.isArray(value) + ? value.join(', ') + : String(value); + const matches = (0, _pluralize.default)( + 'match', + stats[key] || 0, + 'es' + ); + return ` ${key}: ${_chalk().default.yellow( + valueAsString + )} - ${matches}`; + } + + return null; + }) + .filter(line => line) + .join('\n'); + return testRun.matches.total + ? `In ${_chalk().default.bold(config.rootDir)}\n` + + ` ${(0, _pluralize.default)( + 'file', + testRun.matches.total || 0, + 's' + )} checked.\n` + + statsMessage + : `No files found in ${config.rootDir}.\n` + + "Make sure Jest's configuration does not exclude this directory." + + '\nTo set up Jest, make sure a package.json file exists.\n' + + 'Jest Documentation: ' + + 'https://jestjs.io/docs/configuration'; + }); + let dataMessage; + + if (globalConfig.runTestsByPath) { + dataMessage = `Files: ${globalConfig.nonFlagArgs + .map(p => `"${p}"`) + .join(', ')}`; + } else { + dataMessage = `Pattern: ${_chalk().default.yellow( + globalConfig.testPathPattern + )} - 0 matches`; + } + + return ( + _chalk().default.bold('No tests found, exiting with code 1') + + '\n' + + 'Run with `--passWithNoTests` to exit with code 0' + + '\n' + + individualResults.join('\n') + + '\n' + + dataMessage + ); +} diff --git a/node_modules/@jest/core/build/getNoTestsFoundMessage.d.ts b/node_modules/@jest/core/build/getNoTestsFoundMessage.d.ts new file mode 100644 index 0000000..910467e --- /dev/null +++ b/node_modules/@jest/core/build/getNoTestsFoundMessage.d.ts @@ -0,0 +1,9 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +import type { Config } from '@jest/types'; +import type { TestRunData } from './types'; +export default function getNoTestsFoundMessage(testRunData: TestRunData, globalConfig: Config.GlobalConfig): string; diff --git a/node_modules/@jest/core/build/getNoTestsFoundMessage.js b/node_modules/@jest/core/build/getNoTestsFoundMessage.js new file mode 100644 index 0000000..293d092 --- /dev/null +++ b/node_modules/@jest/core/build/getNoTestsFoundMessage.js @@ -0,0 +1,52 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = getNoTestsFoundMessage; + +var _getNoTestFound = _interopRequireDefault(require('./getNoTestFound')); + +var _getNoTestFoundFailed = _interopRequireDefault( + require('./getNoTestFoundFailed') +); + +var _getNoTestFoundPassWithNoTests = _interopRequireDefault( + require('./getNoTestFoundPassWithNoTests') +); + +var _getNoTestFoundRelatedToChangedFiles = _interopRequireDefault( + require('./getNoTestFoundRelatedToChangedFiles') +); + +var _getNoTestFoundVerbose = _interopRequireDefault( + require('./getNoTestFoundVerbose') +); + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} + +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +function getNoTestsFoundMessage(testRunData, globalConfig) { + if (globalConfig.onlyFailures) { + return (0, _getNoTestFoundFailed.default)(globalConfig); + } + + if (globalConfig.onlyChanged) { + return (0, _getNoTestFoundRelatedToChangedFiles.default)(globalConfig); + } + + if (globalConfig.passWithNoTests) { + return (0, _getNoTestFoundPassWithNoTests.default)(); + } + + return testRunData.length === 1 || globalConfig.verbose + ? (0, _getNoTestFoundVerbose.default)(testRunData, globalConfig) + : (0, _getNoTestFound.default)(testRunData, globalConfig); +} diff --git a/node_modules/@jest/core/build/getProjectDisplayName.d.ts b/node_modules/@jest/core/build/getProjectDisplayName.d.ts new file mode 100644 index 0000000..192e9fe --- /dev/null +++ b/node_modules/@jest/core/build/getProjectDisplayName.d.ts @@ -0,0 +1,8 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +import type { Config } from '@jest/types'; +export default function getProjectDisplayName(projectConfig: Config.ProjectConfig): string | undefined; diff --git a/node_modules/@jest/core/build/getProjectDisplayName.js b/node_modules/@jest/core/build/getProjectDisplayName.js new file mode 100644 index 0000000..70b7c9e --- /dev/null +++ b/node_modules/@jest/core/build/getProjectDisplayName.js @@ -0,0 +1,23 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = getProjectDisplayName; + +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +function getProjectDisplayName(projectConfig) { + var _projectConfig$displa; + + return ( + ((_projectConfig$displa = projectConfig.displayName) === null || + _projectConfig$displa === void 0 + ? void 0 + : _projectConfig$displa.name) || undefined + ); +} diff --git a/node_modules/@jest/core/build/getProjectNamesMissingWarning.d.ts b/node_modules/@jest/core/build/getProjectNamesMissingWarning.d.ts new file mode 100644 index 0000000..b2e17cf --- /dev/null +++ b/node_modules/@jest/core/build/getProjectNamesMissingWarning.d.ts @@ -0,0 +1,8 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +import type { Config } from '@jest/types'; +export default function getProjectNamesMissingWarning(projectConfigs: Array<Config.ProjectConfig>): string | undefined; diff --git a/node_modules/@jest/core/build/getProjectNamesMissingWarning.js b/node_modules/@jest/core/build/getProjectNamesMissingWarning.js new file mode 100644 index 0000000..32ac1e1 --- /dev/null +++ b/node_modules/@jest/core/build/getProjectNamesMissingWarning.js @@ -0,0 +1,49 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = getProjectNamesMissingWarning; + +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + + _chalk = function () { + return data; + }; + + return data; +} + +var _getProjectDisplayName = _interopRequireDefault( + require('./getProjectDisplayName') +); + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} + +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +function getProjectNamesMissingWarning(projectConfigs) { + const numberOfProjectsWithoutAName = projectConfigs.filter( + config => !(0, _getProjectDisplayName.default)(config) + ).length; + + if (numberOfProjectsWithoutAName === 0) { + return undefined; + } + + return _chalk().default.yellow( + `You provided values for --selectProjects but ${ + numberOfProjectsWithoutAName === 1 + ? 'a project does not have a name' + : `${numberOfProjectsWithoutAName} projects do not have a name` + }.\n` + + 'Set displayName in the config of all projects in order to disable this warning.\n' + ); +} diff --git a/node_modules/@jest/core/build/getSelectProjectsMessage.d.ts b/node_modules/@jest/core/build/getSelectProjectsMessage.d.ts new file mode 100644 index 0000000..21a4cd2 --- /dev/null +++ b/node_modules/@jest/core/build/getSelectProjectsMessage.d.ts @@ -0,0 +1,8 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +import type { Config } from '@jest/types'; +export default function getSelectProjectsMessage(projectConfigs: Array<Config.ProjectConfig>): string; diff --git a/node_modules/@jest/core/build/getSelectProjectsMessage.js b/node_modules/@jest/core/build/getSelectProjectsMessage.js new file mode 100644 index 0000000..5607f69 --- /dev/null +++ b/node_modules/@jest/core/build/getSelectProjectsMessage.js @@ -0,0 +1,65 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = getSelectProjectsMessage; + +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + + _chalk = function () { + return data; + }; + + return data; +} + +var _getProjectDisplayName = _interopRequireDefault( + require('./getProjectDisplayName') +); + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} + +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +function getSelectProjectsMessage(projectConfigs) { + if (projectConfigs.length === 0) { + return getNoSelectionWarning(); + } + + return getProjectsRunningMessage(projectConfigs); +} + +function getNoSelectionWarning() { + return _chalk().default.yellow( + 'You provided values for --selectProjects but no projects were found matching the selection.\n' + ); +} + +function getProjectsRunningMessage(projectConfigs) { + if (projectConfigs.length === 1) { + const name = (0, _getProjectDisplayName.default)(projectConfigs[0]); + return `Running one project: ${_chalk().default.bold(name)}\n`; + } + + const projectsList = projectConfigs + .map(getProjectNameListElement) + .sort() + .join('\n'); + return `Running ${projectConfigs.length} projects:\n${projectsList}\n`; +} + +function getProjectNameListElement(projectConfig) { + const name = (0, _getProjectDisplayName.default)(projectConfig); + const elementContent = name + ? _chalk().default.bold(name) + : '<unnamed project>'; + return `- ${elementContent}`; +} diff --git a/node_modules/@jest/core/build/jest.d.ts b/node_modules/@jest/core/build/jest.d.ts new file mode 100644 index 0000000..58b0335 --- /dev/null +++ b/node_modules/@jest/core/build/jest.d.ts @@ -0,0 +1,11 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +export { default as SearchSource } from './SearchSource'; +export { createTestScheduler } from './TestScheduler'; +export { default as TestWatcher } from './TestWatcher'; +export { runCLI } from './cli'; +export { default as getVersion } from './version'; diff --git a/node_modules/@jest/core/build/jest.js b/node_modules/@jest/core/build/jest.js new file mode 100644 index 0000000..d320303 --- /dev/null +++ b/node_modules/@jest/core/build/jest.js @@ -0,0 +1,49 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +Object.defineProperty(exports, 'SearchSource', { + enumerable: true, + get: function () { + return _SearchSource.default; + } +}); +Object.defineProperty(exports, 'TestWatcher', { + enumerable: true, + get: function () { + return _TestWatcher.default; + } +}); +Object.defineProperty(exports, 'createTestScheduler', { + enumerable: true, + get: function () { + return _TestScheduler.createTestScheduler; + } +}); +Object.defineProperty(exports, 'getVersion', { + enumerable: true, + get: function () { + return _version.default; + } +}); +Object.defineProperty(exports, 'runCLI', { + enumerable: true, + get: function () { + return _cli.runCLI; + } +}); + +var _SearchSource = _interopRequireDefault(require('./SearchSource')); + +var _TestScheduler = require('./TestScheduler'); + +var _TestWatcher = _interopRequireDefault(require('./TestWatcher')); + +var _cli = require('./cli'); + +var _version = _interopRequireDefault(require('./version')); + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} diff --git a/node_modules/@jest/core/build/lib/activeFiltersMessage.d.ts b/node_modules/@jest/core/build/lib/activeFiltersMessage.d.ts new file mode 100644 index 0000000..15f595a --- /dev/null +++ b/node_modules/@jest/core/build/lib/activeFiltersMessage.d.ts @@ -0,0 +1,9 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +import type { Config } from '@jest/types'; +declare const activeFilters: (globalConfig: Config.GlobalConfig, delimiter?: string) => string; +export default activeFilters; diff --git a/node_modules/@jest/core/build/lib/activeFiltersMessage.js b/node_modules/@jest/core/build/lib/activeFiltersMessage.js new file mode 100644 index 0000000..ff63332 --- /dev/null +++ b/node_modules/@jest/core/build/lib/activeFiltersMessage.js @@ -0,0 +1,54 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; + +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + + _chalk = function () { + return data; + }; + + return data; +} + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} + +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +const activeFilters = (globalConfig, delimiter = '\n') => { + const {testNamePattern, testPathPattern} = globalConfig; + + if (testNamePattern || testPathPattern) { + const filters = [ + testPathPattern + ? _chalk().default.dim('filename ') + + _chalk().default.yellow('/' + testPathPattern + '/') + : null, + testNamePattern + ? _chalk().default.dim('test name ') + + _chalk().default.yellow('/' + testNamePattern + '/') + : null + ] + .filter(f => f) + .join(', '); + const messages = [ + '\n' + _chalk().default.bold('Active Filters: ') + filters + ]; + return messages.filter(message => !!message).join(delimiter); + } + + return ''; +}; + +var _default = activeFilters; +exports.default = _default; diff --git a/node_modules/@jest/core/build/lib/createContext.d.ts b/node_modules/@jest/core/build/lib/createContext.d.ts new file mode 100644 index 0000000..c98a3ef --- /dev/null +++ b/node_modules/@jest/core/build/lib/createContext.d.ts @@ -0,0 +1,10 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +import type { Config } from '@jest/types'; +import type { HasteMapObject } from 'jest-haste-map'; +import { Context } from 'jest-runtime'; +export default function createContext(config: Config.ProjectConfig, { hasteFS, moduleMap }: HasteMapObject): Context; diff --git a/node_modules/@jest/core/build/lib/createContext.js b/node_modules/@jest/core/build/lib/createContext.js new file mode 100644 index 0000000..b360e9c --- /dev/null +++ b/node_modules/@jest/core/build/lib/createContext.js @@ -0,0 +1,35 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = createContext; + +function _jestRuntime() { + const data = _interopRequireDefault(require('jest-runtime')); + + _jestRuntime = function () { + return data; + }; + + return data; +} + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} + +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +function createContext(config, {hasteFS, moduleMap}) { + return { + config, + hasteFS, + moduleMap, + resolver: _jestRuntime().default.createResolver(config, moduleMap) + }; +} diff --git a/node_modules/@jest/core/build/lib/handleDeprecationWarnings.d.ts b/node_modules/@jest/core/build/lib/handleDeprecationWarnings.d.ts new file mode 100644 index 0000000..8d2151e --- /dev/null +++ b/node_modules/@jest/core/build/lib/handleDeprecationWarnings.d.ts @@ -0,0 +1,8 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +/// <reference types="node" /> +export default function handleDeprecationWarnings(pipe: NodeJS.WriteStream, stdin?: NodeJS.ReadStream): Promise<void>; diff --git a/node_modules/@jest/core/build/lib/handleDeprecationWarnings.js b/node_modules/@jest/core/build/lib/handleDeprecationWarnings.js new file mode 100644 index 0000000..f0a15d6 --- /dev/null +++ b/node_modules/@jest/core/build/lib/handleDeprecationWarnings.js @@ -0,0 +1,72 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = handleDeprecationWarnings; + +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + + _chalk = function () { + return data; + }; + + return data; +} + +function _jestWatcher() { + const data = require('jest-watcher'); + + _jestWatcher = function () { + return data; + }; + + return data; +} + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} + +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +function handleDeprecationWarnings(pipe, stdin = process.stdin) { + return new Promise((resolve, reject) => { + if (typeof stdin.setRawMode === 'function') { + const messages = [ + _chalk().default.red('There are deprecation warnings.\n'), + _chalk().default.dim(' \u203A Press ') + + 'Enter' + + _chalk().default.dim(' to continue.'), + _chalk().default.dim(' \u203A Press ') + + 'Esc' + + _chalk().default.dim(' to exit.') + ]; + pipe.write(messages.join('\n')); + stdin.setRawMode(true); + stdin.resume(); + stdin.setEncoding('utf8'); // this is a string since we set encoding above + + stdin.on('data', key => { + if (key === _jestWatcher().KEYS.ENTER) { + resolve(); + } else if ( + [ + _jestWatcher().KEYS.ESCAPE, + _jestWatcher().KEYS.CONTROL_C, + _jestWatcher().KEYS.CONTROL_D + ].indexOf(key) !== -1 + ) { + reject(); + } + }); + } else { + resolve(); + } + }); +} diff --git a/node_modules/@jest/core/build/lib/isValidPath.d.ts b/node_modules/@jest/core/build/lib/isValidPath.d.ts new file mode 100644 index 0000000..d81880a --- /dev/null +++ b/node_modules/@jest/core/build/lib/isValidPath.d.ts @@ -0,0 +1,8 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +import type { Config } from '@jest/types'; +export default function isValidPath(globalConfig: Config.GlobalConfig, filePath: Config.Path): boolean; diff --git a/node_modules/@jest/core/build/lib/isValidPath.js b/node_modules/@jest/core/build/lib/isValidPath.js new file mode 100644 index 0000000..10971d3 --- /dev/null +++ b/node_modules/@jest/core/build/lib/isValidPath.js @@ -0,0 +1,29 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = isValidPath; + +function _jestSnapshot() { + const data = require('jest-snapshot'); + + _jestSnapshot = function () { + return data; + }; + + return data; +} + +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +function isValidPath(globalConfig, filePath) { + return ( + !filePath.includes(globalConfig.coverageDirectory) && + !(0, _jestSnapshot().isSnapshotPath)(filePath) + ); +} diff --git a/node_modules/@jest/core/build/lib/logDebugMessages.d.ts b/node_modules/@jest/core/build/lib/logDebugMessages.d.ts new file mode 100644 index 0000000..b312cd9 --- /dev/null +++ b/node_modules/@jest/core/build/lib/logDebugMessages.d.ts @@ -0,0 +1,9 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +/// <reference types="node" /> +import type { Config } from '@jest/types'; +export default function logDebugMessages(globalConfig: Config.GlobalConfig, configs: Array<Config.ProjectConfig> | Config.ProjectConfig, outputStream: NodeJS.WriteStream): void; diff --git a/node_modules/@jest/core/build/lib/logDebugMessages.js b/node_modules/@jest/core/build/lib/logDebugMessages.js new file mode 100644 index 0000000..9c1f2f5 --- /dev/null +++ b/node_modules/@jest/core/build/lib/logDebugMessages.js @@ -0,0 +1,23 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = logDebugMessages; + +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +const VERSION = require('../../package.json').version; // if the output here changes, update `getConfig` in e2e/runJest.ts + +function logDebugMessages(globalConfig, configs, outputStream) { + const output = { + configs, + globalConfig, + version: VERSION + }; + outputStream.write(JSON.stringify(output, null, ' ') + '\n'); +} diff --git a/node_modules/@jest/core/build/lib/updateGlobalConfig.d.ts b/node_modules/@jest/core/build/lib/updateGlobalConfig.d.ts new file mode 100644 index 0000000..8282936 --- /dev/null +++ b/node_modules/@jest/core/build/lib/updateGlobalConfig.d.ts @@ -0,0 +1,11 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +import type { Config } from '@jest/types'; +import type { AllowedConfigOptions } from 'jest-watcher'; +declare type ExtraConfigOptions = Partial<Pick<Config.GlobalConfig, 'noSCM' | 'passWithNoTests'>>; +export default function updateGlobalConfig(globalConfig: Config.GlobalConfig, options?: AllowedConfigOptions & ExtraConfigOptions): Config.GlobalConfig; +export {}; diff --git a/node_modules/@jest/core/build/lib/updateGlobalConfig.js b/node_modules/@jest/core/build/lib/updateGlobalConfig.js new file mode 100644 index 0000000..5c49586 --- /dev/null +++ b/node_modules/@jest/core/build/lib/updateGlobalConfig.js @@ -0,0 +1,121 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = updateGlobalConfig; + +function _jestRegexUtil() { + const data = require('jest-regex-util'); + + _jestRegexUtil = function () { + return data; + }; + + return data; +} + +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +function updateGlobalConfig(globalConfig, options = {}) { + const newConfig = {...globalConfig}; + + if (options.mode === 'watch') { + newConfig.watch = true; + newConfig.watchAll = false; + } else if (options.mode === 'watchAll') { + newConfig.watch = false; + newConfig.watchAll = true; + } + + if (options.testNamePattern !== undefined) { + newConfig.testNamePattern = options.testNamePattern || ''; + } + + if (options.testPathPattern !== undefined) { + newConfig.testPathPattern = + (0, _jestRegexUtil().replacePathSepForRegex)(options.testPathPattern) || + ''; + } + + newConfig.onlyChanged = + !newConfig.watchAll && + !newConfig.testNamePattern && + !newConfig.testPathPattern; + + if (typeof options.bail === 'boolean') { + newConfig.bail = options.bail ? 1 : 0; + } else if (options.bail !== undefined) { + newConfig.bail = options.bail; + } + + if (options.changedSince !== undefined) { + newConfig.changedSince = options.changedSince; + } + + if (options.collectCoverage !== undefined) { + newConfig.collectCoverage = options.collectCoverage || false; + } + + if (options.collectCoverageFrom !== undefined) { + newConfig.collectCoverageFrom = options.collectCoverageFrom; + } + + if (options.collectCoverageOnlyFrom !== undefined) { + newConfig.collectCoverageOnlyFrom = options.collectCoverageOnlyFrom; + } + + if (options.coverageDirectory !== undefined) { + newConfig.coverageDirectory = options.coverageDirectory; + } + + if (options.coverageReporters !== undefined) { + newConfig.coverageReporters = options.coverageReporters; + } + + if (options.findRelatedTests !== undefined) { + newConfig.findRelatedTests = options.findRelatedTests; + } + + if (options.nonFlagArgs !== undefined) { + newConfig.nonFlagArgs = options.nonFlagArgs; + } + + if (options.noSCM) { + newConfig.noSCM = true; + } + + if (options.notify !== undefined) { + newConfig.notify = options.notify || false; + } + + if (options.notifyMode !== undefined) { + newConfig.notifyMode = options.notifyMode; + } + + if (options.onlyFailures !== undefined) { + newConfig.onlyFailures = options.onlyFailures || false; + } + + if (options.passWithNoTests !== undefined) { + newConfig.passWithNoTests = true; + } + + if (options.reporters !== undefined) { + newConfig.reporters = options.reporters; + } + + if (options.updateSnapshot !== undefined) { + newConfig.updateSnapshot = options.updateSnapshot; + } + + if (options.verbose !== undefined) { + newConfig.verbose = options.verbose || false; + } + + return Object.freeze(newConfig); +} diff --git a/node_modules/@jest/core/build/lib/watchPluginsHelpers.d.ts b/node_modules/@jest/core/build/lib/watchPluginsHelpers.d.ts new file mode 100644 index 0000000..99e8d7f --- /dev/null +++ b/node_modules/@jest/core/build/lib/watchPluginsHelpers.d.ts @@ -0,0 +1,10 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +import type { Config } from '@jest/types'; +import type { UsageData, WatchPlugin } from 'jest-watcher'; +export declare const filterInteractivePlugins: (watchPlugins: Array<WatchPlugin>, globalConfig: Config.GlobalConfig) => Array<WatchPlugin>; +export declare const getSortedUsageRows: (watchPlugins: Array<WatchPlugin>, globalConfig: Config.GlobalConfig) => Array<UsageData>; diff --git a/node_modules/@jest/core/build/lib/watchPluginsHelpers.js b/node_modules/@jest/core/build/lib/watchPluginsHelpers.js new file mode 100644 index 0000000..9f595ce --- /dev/null +++ b/node_modules/@jest/core/build/lib/watchPluginsHelpers.js @@ -0,0 +1,62 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.getSortedUsageRows = exports.filterInteractivePlugins = void 0; + +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +const filterInteractivePlugins = (watchPlugins, globalConfig) => { + const usageInfos = watchPlugins.map( + p => p.getUsageInfo && p.getUsageInfo(globalConfig) + ); + return watchPlugins.filter((_plugin, i) => { + const usageInfo = usageInfos[i]; + + if (usageInfo) { + const {key} = usageInfo; + return !usageInfos.slice(i + 1).some(u => !!u && key === u.key); + } + + return false; + }); +}; + +exports.filterInteractivePlugins = filterInteractivePlugins; + +function notEmpty(value) { + return value != null; +} + +const getSortedUsageRows = (watchPlugins, globalConfig) => + filterInteractivePlugins(watchPlugins, globalConfig) + .sort((a, b) => { + if (a.isInternal && b.isInternal) { + // internal plugins in the order we specify them + return 0; + } + + if (a.isInternal !== b.isInternal) { + // external plugins afterwards + return a.isInternal ? -1 : 1; + } + + const usageInfoA = a.getUsageInfo && a.getUsageInfo(globalConfig); + const usageInfoB = b.getUsageInfo && b.getUsageInfo(globalConfig); + + if (usageInfoA && usageInfoB) { + // external plugins in alphabetical order + return usageInfoA.key.localeCompare(usageInfoB.key); + } + + return 0; + }) + .map(p => p.getUsageInfo && p.getUsageInfo(globalConfig)) + .filter(notEmpty); + +exports.getSortedUsageRows = getSortedUsageRows; diff --git a/node_modules/@jest/core/build/plugins/FailedTestsInteractive.d.ts b/node_modules/@jest/core/build/plugins/FailedTestsInteractive.d.ts new file mode 100644 index 0000000..d696181 --- /dev/null +++ b/node_modules/@jest/core/build/plugins/FailedTestsInteractive.d.ts @@ -0,0 +1,17 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +import type { Config } from '@jest/types'; +import { BaseWatchPlugin, JestHookSubscriber, UpdateConfigCallback, UsageData } from 'jest-watcher'; +export default class FailedTestsInteractivePlugin extends BaseWatchPlugin { + private _failedTestAssertions?; + private readonly _manager; + apply(hooks: JestHookSubscriber): void; + getUsageInfo(): UsageData | null; + onKey(key: string): void; + run(_: Config.GlobalConfig, updateConfigAndRun: UpdateConfigCallback): Promise<void>; + private getFailedTestAssertions; +} diff --git a/node_modules/@jest/core/build/plugins/FailedTestsInteractive.js b/node_modules/@jest/core/build/plugins/FailedTestsInteractive.js new file mode 100644 index 0000000..a830abe --- /dev/null +++ b/node_modules/@jest/core/build/plugins/FailedTestsInteractive.js @@ -0,0 +1,135 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; + +function _jestWatcher() { + const data = require('jest-watcher'); + + _jestWatcher = function () { + return data; + }; + + return data; +} + +var _FailedTestsInteractiveMode = _interopRequireDefault( + require('../FailedTestsInteractiveMode') +); + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} + +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; +} + +class FailedTestsInteractivePlugin extends _jestWatcher().BaseWatchPlugin { + constructor(...args) { + super(...args); + + _defineProperty(this, '_failedTestAssertions', void 0); + + _defineProperty( + this, + '_manager', + new _FailedTestsInteractiveMode.default(this._stdout) + ); + } + + apply(hooks) { + hooks.onTestRunComplete(results => { + this._failedTestAssertions = this.getFailedTestAssertions(results); + if (this._manager.isActive()) this._manager.updateWithResults(results); + }); + } + + getUsageInfo() { + var _this$_failedTestAsse; + + if ( + (_this$_failedTestAsse = this._failedTestAssertions) !== null && + _this$_failedTestAsse !== void 0 && + _this$_failedTestAsse.length + ) { + return { + key: 'i', + prompt: 'run failing tests interactively' + }; + } + + return null; + } + + onKey(key) { + if (this._manager.isActive()) { + this._manager.put(key); + } + } + + run(_, updateConfigAndRun) { + return new Promise(resolve => { + if ( + !this._failedTestAssertions || + this._failedTestAssertions.length === 0 + ) { + resolve(); + return; + } + + this._manager.run(this._failedTestAssertions, failure => { + updateConfigAndRun({ + mode: 'watch', + testNamePattern: failure ? `^${failure.fullName}$` : '', + testPathPattern: + (failure === null || failure === void 0 ? void 0 : failure.path) || + '' + }); + + if (!this._manager.isActive()) { + resolve(); + } + }); + }); + } + + getFailedTestAssertions(results) { + const failedTestPaths = []; + + if ( + // skip if no failed tests + results.numFailedTests === 0 || // skip if missing test results + !results.testResults || // skip if unmatched snapshots are present + results.snapshot.unmatched + ) { + return failedTestPaths; + } + + results.testResults.forEach(testResult => { + testResult.testResults.forEach(result => { + if (result.status === 'failed') { + failedTestPaths.push({ + fullName: result.fullName, + path: testResult.testFilePath + }); + } + }); + }); + return failedTestPaths; + } +} + +exports.default = FailedTestsInteractivePlugin; diff --git a/node_modules/@jest/core/build/plugins/Quit.d.ts b/node_modules/@jest/core/build/plugins/Quit.d.ts new file mode 100644 index 0000000..e865612 --- /dev/null +++ b/node_modules/@jest/core/build/plugins/Quit.d.ts @@ -0,0 +1,18 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +/// <reference types="node" /> +import { BaseWatchPlugin, UsageData } from 'jest-watcher'; +declare class QuitPlugin extends BaseWatchPlugin { + isInternal: true; + constructor(options: { + stdin: NodeJS.ReadStream; + stdout: NodeJS.WriteStream; + }); + run(): Promise<void>; + getUsageInfo(): UsageData; +} +export default QuitPlugin; diff --git a/node_modules/@jest/core/build/plugins/Quit.js b/node_modules/@jest/core/build/plugins/Quit.js new file mode 100644 index 0000000..e643a2b --- /dev/null +++ b/node_modules/@jest/core/build/plugins/Quit.js @@ -0,0 +1,60 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; + +function _jestWatcher() { + const data = require('jest-watcher'); + + _jestWatcher = function () { + return data; + }; + + return data; +} + +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; +} + +class QuitPlugin extends _jestWatcher().BaseWatchPlugin { + constructor(options) { + super(options); + + _defineProperty(this, 'isInternal', void 0); + + this.isInternal = true; + } + + async run() { + if (typeof this._stdin.setRawMode === 'function') { + this._stdin.setRawMode(false); + } + + this._stdout.write('\n'); + + process.exit(0); + } + + getUsageInfo() { + return { + key: 'q', + prompt: 'quit watch mode' + }; + } +} + +var _default = QuitPlugin; +exports.default = _default; diff --git a/node_modules/@jest/core/build/plugins/TestNamePattern.d.ts b/node_modules/@jest/core/build/plugins/TestNamePattern.d.ts new file mode 100644 index 0000000..dc0409a --- /dev/null +++ b/node_modules/@jest/core/build/plugins/TestNamePattern.d.ts @@ -0,0 +1,21 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +/// <reference types="node" /> +import type { Config } from '@jest/types'; +import { BaseWatchPlugin, Prompt, UpdateConfigCallback, UsageData } from 'jest-watcher'; +declare class TestNamePatternPlugin extends BaseWatchPlugin { + _prompt: Prompt; + isInternal: true; + constructor(options: { + stdin: NodeJS.ReadStream; + stdout: NodeJS.WriteStream; + }); + getUsageInfo(): UsageData; + onKey(key: string): void; + run(globalConfig: Config.GlobalConfig, updateConfigAndRun: UpdateConfigCallback): Promise<void>; +} +export default TestNamePatternPlugin; diff --git a/node_modules/@jest/core/build/plugins/TestNamePattern.js b/node_modules/@jest/core/build/plugins/TestNamePattern.js new file mode 100644 index 0000000..ac60851 --- /dev/null +++ b/node_modules/@jest/core/build/plugins/TestNamePattern.js @@ -0,0 +1,91 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; + +function _jestWatcher() { + const data = require('jest-watcher'); + + _jestWatcher = function () { + return data; + }; + + return data; +} + +var _TestNamePatternPrompt = _interopRequireDefault( + require('../TestNamePatternPrompt') +); + +var _activeFiltersMessage = _interopRequireDefault( + require('../lib/activeFiltersMessage') +); + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} + +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; +} + +class TestNamePatternPlugin extends _jestWatcher().BaseWatchPlugin { + constructor(options) { + super(options); + + _defineProperty(this, '_prompt', void 0); + + _defineProperty(this, 'isInternal', void 0); + + this._prompt = new (_jestWatcher().Prompt)(); + this.isInternal = true; + } + + getUsageInfo() { + return { + key: 't', + prompt: 'filter by a test name regex pattern' + }; + } + + onKey(key) { + this._prompt.put(key); + } + + run(globalConfig, updateConfigAndRun) { + return new Promise((res, rej) => { + const testNamePatternPrompt = new _TestNamePatternPrompt.default( + this._stdout, + this._prompt + ); + testNamePatternPrompt.run( + value => { + updateConfigAndRun({ + mode: 'watch', + testNamePattern: value + }); + res(); + }, + rej, + { + header: (0, _activeFiltersMessage.default)(globalConfig) + } + ); + }); + } +} + +var _default = TestNamePatternPlugin; +exports.default = _default; diff --git a/node_modules/@jest/core/build/plugins/TestPathPattern.d.ts b/node_modules/@jest/core/build/plugins/TestPathPattern.d.ts new file mode 100644 index 0000000..9eefab9 --- /dev/null +++ b/node_modules/@jest/core/build/plugins/TestPathPattern.d.ts @@ -0,0 +1,21 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +/// <reference types="node" /> +import type { Config } from '@jest/types'; +import { BaseWatchPlugin, UpdateConfigCallback, UsageData } from 'jest-watcher'; +declare class TestPathPatternPlugin extends BaseWatchPlugin { + private _prompt; + isInternal: true; + constructor(options: { + stdin: NodeJS.ReadStream; + stdout: NodeJS.WriteStream; + }); + getUsageInfo(): UsageData; + onKey(key: string): void; + run(globalConfig: Config.GlobalConfig, updateConfigAndRun: UpdateConfigCallback): Promise<void>; +} +export default TestPathPatternPlugin; diff --git a/node_modules/@jest/core/build/plugins/TestPathPattern.js b/node_modules/@jest/core/build/plugins/TestPathPattern.js new file mode 100644 index 0000000..5c5c4b7 --- /dev/null +++ b/node_modules/@jest/core/build/plugins/TestPathPattern.js @@ -0,0 +1,91 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; + +function _jestWatcher() { + const data = require('jest-watcher'); + + _jestWatcher = function () { + return data; + }; + + return data; +} + +var _TestPathPatternPrompt = _interopRequireDefault( + require('../TestPathPatternPrompt') +); + +var _activeFiltersMessage = _interopRequireDefault( + require('../lib/activeFiltersMessage') +); + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} + +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; +} + +class TestPathPatternPlugin extends _jestWatcher().BaseWatchPlugin { + constructor(options) { + super(options); + + _defineProperty(this, '_prompt', void 0); + + _defineProperty(this, 'isInternal', void 0); + + this._prompt = new (_jestWatcher().Prompt)(); + this.isInternal = true; + } + + getUsageInfo() { + return { + key: 'p', + prompt: 'filter by a filename regex pattern' + }; + } + + onKey(key) { + this._prompt.put(key); + } + + run(globalConfig, updateConfigAndRun) { + return new Promise((res, rej) => { + const testPathPatternPrompt = new _TestPathPatternPrompt.default( + this._stdout, + this._prompt + ); + testPathPatternPrompt.run( + value => { + updateConfigAndRun({ + mode: 'watch', + testPathPattern: value + }); + res(); + }, + rej, + { + header: (0, _activeFiltersMessage.default)(globalConfig) + } + ); + }); + } +} + +var _default = TestPathPatternPlugin; +exports.default = _default; diff --git a/node_modules/@jest/core/build/plugins/UpdateSnapshots.d.ts b/node_modules/@jest/core/build/plugins/UpdateSnapshots.d.ts new file mode 100644 index 0000000..3eff4c2 --- /dev/null +++ b/node_modules/@jest/core/build/plugins/UpdateSnapshots.d.ts @@ -0,0 +1,21 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +/// <reference types="node" /> +import type { Config } from '@jest/types'; +import { BaseWatchPlugin, JestHookSubscriber, UpdateConfigCallback, UsageData } from 'jest-watcher'; +declare class UpdateSnapshotsPlugin extends BaseWatchPlugin { + private _hasSnapshotFailure; + isInternal: true; + constructor(options: { + stdin: NodeJS.ReadStream; + stdout: NodeJS.WriteStream; + }); + run(_globalConfig: Config.GlobalConfig, updateConfigAndRun: UpdateConfigCallback): Promise<boolean>; + apply(hooks: JestHookSubscriber): void; + getUsageInfo(): UsageData | null; +} +export default UpdateSnapshotsPlugin; diff --git a/node_modules/@jest/core/build/plugins/UpdateSnapshots.js b/node_modules/@jest/core/build/plugins/UpdateSnapshots.js new file mode 100644 index 0000000..c2a9de7 --- /dev/null +++ b/node_modules/@jest/core/build/plugins/UpdateSnapshots.js @@ -0,0 +1,70 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; + +function _jestWatcher() { + const data = require('jest-watcher'); + + _jestWatcher = function () { + return data; + }; + + return data; +} + +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; +} + +class UpdateSnapshotsPlugin extends _jestWatcher().BaseWatchPlugin { + constructor(options) { + super(options); + + _defineProperty(this, '_hasSnapshotFailure', void 0); + + _defineProperty(this, 'isInternal', void 0); + + this.isInternal = true; + this._hasSnapshotFailure = false; + } + + run(_globalConfig, updateConfigAndRun) { + updateConfigAndRun({ + updateSnapshot: 'all' + }); + return Promise.resolve(false); + } + + apply(hooks) { + hooks.onTestRunComplete(results => { + this._hasSnapshotFailure = results.snapshot.failure; + }); + } + + getUsageInfo() { + if (this._hasSnapshotFailure) { + return { + key: 'u', + prompt: 'update failing snapshots' + }; + } + + return null; + } +} + +var _default = UpdateSnapshotsPlugin; +exports.default = _default; diff --git a/node_modules/@jest/core/build/plugins/UpdateSnapshotsInteractive.d.ts b/node_modules/@jest/core/build/plugins/UpdateSnapshotsInteractive.d.ts new file mode 100644 index 0000000..c6a60e6 --- /dev/null +++ b/node_modules/@jest/core/build/plugins/UpdateSnapshotsInteractive.d.ts @@ -0,0 +1,20 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +import type { AggregatedResult, AssertionLocation } from '@jest/test-result'; +import type { Config } from '@jest/types'; +import { BaseWatchPlugin, JestHookSubscriber, UsageData } from 'jest-watcher'; +declare class UpdateSnapshotInteractivePlugin extends BaseWatchPlugin { + private _snapshotInteractiveMode; + private _failedSnapshotTestAssertions; + isInternal: true; + getFailedSnapshotTestAssertions(testResults: AggregatedResult): Array<AssertionLocation>; + apply(hooks: JestHookSubscriber): void; + onKey(key: string): void; + run(_globalConfig: Config.GlobalConfig, updateConfigAndRun: Function): Promise<void>; + getUsageInfo(): UsageData | null; +} +export default UpdateSnapshotInteractivePlugin; diff --git a/node_modules/@jest/core/build/plugins/UpdateSnapshotsInteractive.js b/node_modules/@jest/core/build/plugins/UpdateSnapshotsInteractive.js new file mode 100644 index 0000000..5346bc3 --- /dev/null +++ b/node_modules/@jest/core/build/plugins/UpdateSnapshotsInteractive.js @@ -0,0 +1,138 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; + +function _jestWatcher() { + const data = require('jest-watcher'); + + _jestWatcher = function () { + return data; + }; + + return data; +} + +var _SnapshotInteractiveMode = _interopRequireDefault( + require('../SnapshotInteractiveMode') +); + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} + +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; +} + +class UpdateSnapshotInteractivePlugin extends _jestWatcher().BaseWatchPlugin { + constructor(...args) { + super(...args); + + _defineProperty( + this, + '_snapshotInteractiveMode', + new _SnapshotInteractiveMode.default(this._stdout) + ); + + _defineProperty(this, '_failedSnapshotTestAssertions', []); + + _defineProperty(this, 'isInternal', true); + } + + getFailedSnapshotTestAssertions(testResults) { + const failedTestPaths = []; + + if (testResults.numFailedTests === 0 || !testResults.testResults) { + return failedTestPaths; + } + + testResults.testResults.forEach(testResult => { + if (testResult.snapshot && testResult.snapshot.unmatched) { + testResult.testResults.forEach(result => { + if (result.status === 'failed') { + failedTestPaths.push({ + fullName: result.fullName, + path: testResult.testFilePath + }); + } + }); + } + }); + return failedTestPaths; + } + + apply(hooks) { + hooks.onTestRunComplete(results => { + this._failedSnapshotTestAssertions = + this.getFailedSnapshotTestAssertions(results); + + if (this._snapshotInteractiveMode.isActive()) { + this._snapshotInteractiveMode.updateWithResults(results); + } + }); + } + + onKey(key) { + if (this._snapshotInteractiveMode.isActive()) { + this._snapshotInteractiveMode.put(key); + } + } + + run(_globalConfig, updateConfigAndRun) { + if (this._failedSnapshotTestAssertions.length) { + return new Promise(res => { + this._snapshotInteractiveMode.run( + this._failedSnapshotTestAssertions, + (assertion, shouldUpdateSnapshot) => { + updateConfigAndRun({ + mode: 'watch', + testNamePattern: assertion ? `^${assertion.fullName}$` : '', + testPathPattern: assertion ? assertion.path : '', + updateSnapshot: shouldUpdateSnapshot ? 'all' : 'none' + }); + + if (!this._snapshotInteractiveMode.isActive()) { + res(); + } + } + ); + }); + } else { + return Promise.resolve(); + } + } + + getUsageInfo() { + var _this$_failedSnapshot; + + if ( + ((_this$_failedSnapshot = this._failedSnapshotTestAssertions) === null || + _this$_failedSnapshot === void 0 + ? void 0 + : _this$_failedSnapshot.length) > 0 + ) { + return { + key: 'i', + prompt: 'update failing snapshots interactively' + }; + } + + return null; + } +} + +var _default = UpdateSnapshotInteractivePlugin; +exports.default = _default; diff --git a/node_modules/@jest/core/build/pluralize.d.ts b/node_modules/@jest/core/build/pluralize.d.ts new file mode 100644 index 0000000..a4e01ce --- /dev/null +++ b/node_modules/@jest/core/build/pluralize.d.ts @@ -0,0 +1,7 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +export default function pluralize(word: string, count: number, ending: string): string; diff --git a/node_modules/@jest/core/build/pluralize.js b/node_modules/@jest/core/build/pluralize.js new file mode 100644 index 0000000..08695e5 --- /dev/null +++ b/node_modules/@jest/core/build/pluralize.js @@ -0,0 +1,16 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = pluralize; + +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +function pluralize(word, count, ending) { + return `${count} ${word}${count === 1 ? '' : ending}`; +} diff --git a/node_modules/@jest/core/build/runGlobalHook.d.ts b/node_modules/@jest/core/build/runGlobalHook.d.ts new file mode 100644 index 0000000..726baf0 --- /dev/null +++ b/node_modules/@jest/core/build/runGlobalHook.d.ts @@ -0,0 +1,13 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +import type { Test } from '@jest/test-result'; +import type { Config } from '@jest/types'; +export default function runGlobalHook({ allTests, globalConfig, moduleName, }: { + allTests: Array<Test>; + globalConfig: Config.GlobalConfig; + moduleName: 'globalSetup' | 'globalTeardown'; +}): Promise<void>; diff --git a/node_modules/@jest/core/build/runGlobalHook.js b/node_modules/@jest/core/build/runGlobalHook.js new file mode 100644 index 0000000..c4ebdbd --- /dev/null +++ b/node_modules/@jest/core/build/runGlobalHook.js @@ -0,0 +1,143 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = runGlobalHook; + +function util() { + const data = _interopRequireWildcard(require('util')); + + util = function () { + return data; + }; + + return data; +} + +function _transform() { + const data = require('@jest/transform'); + + _transform = function () { + return data; + }; + + return data; +} + +function _prettyFormat() { + const data = _interopRequireDefault(require('pretty-format')); + + _prettyFormat = function () { + return data; + }; + + return data; +} + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} + +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} + +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} + +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +async function runGlobalHook({allTests, globalConfig, moduleName}) { + const globalModulePaths = new Set( + allTests.map(test => test.context.config[moduleName]) + ); + + if (globalConfig[moduleName]) { + globalModulePaths.add(globalConfig[moduleName]); + } + + if (globalModulePaths.size > 0) { + for (const modulePath of globalModulePaths) { + if (!modulePath) { + continue; + } + + const correctConfig = allTests.find( + t => t.context.config[moduleName] === modulePath + ); + const projectConfig = correctConfig + ? correctConfig.context.config // Fallback to first config + : allTests[0].context.config; + const transformer = await (0, _transform().createScriptTransformer)( + projectConfig + ); + + try { + await transformer.requireAndTranspileModule( + modulePath, + async globalModule => { + if (typeof globalModule !== 'function') { + throw new TypeError( + `${moduleName} file must export a function at ${modulePath}` + ); + } + + await globalModule(globalConfig); + } + ); + } catch (error) { + if (util().types.isNativeError(error)) { + error.message = `Jest: Got error running ${moduleName} - ${modulePath}, reason: ${error.message}`; + throw error; + } + + throw new Error( + `Jest: Got error running ${moduleName} - ${modulePath}, reason: ${(0, + _prettyFormat().default)(error, { + maxDepth: 3 + })}` + ); + } + } + } +} diff --git a/node_modules/@jest/core/build/runJest.d.ts b/node_modules/@jest/core/build/runJest.d.ts new file mode 100644 index 0000000..9a8240b --- /dev/null +++ b/node_modules/@jest/core/build/runJest.d.ts @@ -0,0 +1,27 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +/// <reference types="node" /> +import { AggregatedResult } from '@jest/test-result'; +import type { Config } from '@jest/types'; +import type { ChangedFilesPromise } from 'jest-changed-files'; +import type { Context } from 'jest-runtime'; +import { JestHookEmitter } from 'jest-watcher'; +import type FailedTestsCache from './FailedTestsCache'; +import type TestWatcher from './TestWatcher'; +import type { Filter } from './types'; +export default function runJest({ contexts, globalConfig, outputStream, testWatcher, jestHooks, startRun, changedFilesPromise, onComplete, failedTestsCache, filter, }: { + globalConfig: Config.GlobalConfig; + contexts: Array<Context>; + outputStream: NodeJS.WriteStream; + testWatcher: TestWatcher; + jestHooks?: JestHookEmitter; + startRun: (globalConfig: Config.GlobalConfig) => void; + changedFilesPromise?: ChangedFilesPromise; + onComplete: (testResults: AggregatedResult) => void; + failedTestsCache?: FailedTestsCache; + filter?: Filter; +}): Promise<void>; diff --git a/node_modules/@jest/core/build/runJest.js b/node_modules/@jest/core/build/runJest.js new file mode 100644 index 0000000..24b40ac --- /dev/null +++ b/node_modules/@jest/core/build/runJest.js @@ -0,0 +1,423 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = runJest; + +function path() { + const data = _interopRequireWildcard(require('path')); + + path = function () { + return data; + }; + + return data; +} + +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + + _chalk = function () { + return data; + }; + + return data; +} + +function _exit() { + const data = _interopRequireDefault(require('exit')); + + _exit = function () { + return data; + }; + + return data; +} + +function fs() { + const data = _interopRequireWildcard(require('graceful-fs')); + + fs = function () { + return data; + }; + + return data; +} + +function _console() { + const data = require('@jest/console'); + + _console = function () { + return data; + }; + + return data; +} + +function _testResult() { + const data = require('@jest/test-result'); + + _testResult = function () { + return data; + }; + + return data; +} + +function _jestResolve() { + const data = _interopRequireDefault(require('jest-resolve')); + + _jestResolve = function () { + return data; + }; + + return data; +} + +function _jestUtil() { + const data = require('jest-util'); + + _jestUtil = function () { + return data; + }; + + return data; +} + +function _jestWatcher() { + const data = require('jest-watcher'); + + _jestWatcher = function () { + return data; + }; + + return data; +} + +var _SearchSource = _interopRequireDefault(require('./SearchSource')); + +var _TestScheduler = require('./TestScheduler'); + +var _collectHandles = _interopRequireDefault(require('./collectHandles')); + +var _getNoTestsFoundMessage = _interopRequireDefault( + require('./getNoTestsFoundMessage') +); + +var _runGlobalHook = _interopRequireDefault(require('./runGlobalHook')); + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} + +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} + +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} + +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +const getTestPaths = async ( + globalConfig, + source, + outputStream, + changedFiles, + jestHooks, + filter +) => { + const data = await source.getTestPaths(globalConfig, changedFiles, filter); + + if (!data.tests.length && globalConfig.onlyChanged && data.noSCM) { + new (_console().CustomConsole)(outputStream, outputStream).log( + 'Jest can only find uncommitted changed files in a git or hg ' + + 'repository. If you make your project a git or hg ' + + 'repository (`git init` or `hg init`), Jest will be able ' + + 'to only run tests related to files changed since the last ' + + 'commit.' + ); + } + + const shouldTestArray = await Promise.all( + data.tests.map(test => + jestHooks.shouldRunTestSuite({ + config: test.context.config, + duration: test.duration, + testPath: test.path + }) + ) + ); + const filteredTests = data.tests.filter((_test, i) => shouldTestArray[i]); + return {...data, allTests: filteredTests.length, tests: filteredTests}; +}; + +const processResults = async (runResults, options) => { + const { + outputFile, + json: isJSON, + onComplete, + outputStream, + testResultsProcessor, + collectHandles + } = options; + + if (collectHandles) { + runResults.openHandles = await collectHandles(); + } else { + runResults.openHandles = []; + } + + if (testResultsProcessor) { + const processor = await (0, _jestUtil().requireOrImportModule)( + testResultsProcessor + ); + runResults = processor(runResults); + } + + if (isJSON) { + if (outputFile) { + const cwd = (0, _jestUtil().tryRealpath)(process.cwd()); + const filePath = path().resolve(cwd, outputFile); + fs().writeFileSync( + filePath, + JSON.stringify((0, _testResult().formatTestResults)(runResults)) + ); + outputStream.write( + `Test results written to: ${path().relative(cwd, filePath)}\n` + ); + } else { + process.stdout.write( + JSON.stringify((0, _testResult().formatTestResults)(runResults)) + ); + } + } + + onComplete === null || onComplete === void 0 + ? void 0 + : onComplete(runResults); +}; + +const testSchedulerContext = { + firstRun: true, + previousSuccess: true +}; + +async function runJest({ + contexts, + globalConfig, + outputStream, + testWatcher, + jestHooks = new (_jestWatcher().JestHook)().getEmitter(), + startRun, + changedFilesPromise, + onComplete, + failedTestsCache, + filter +}) { + // Clear cache for required modules - there might be different resolutions + // from Jest's config loading to running the tests + _jestResolve().default.clearDefaultResolverCache(); + + const Sequencer = await (0, _jestUtil().requireOrImportModule)( + globalConfig.testSequencer + ); + const sequencer = new Sequencer(); + let allTests = []; + + if (changedFilesPromise && globalConfig.watch) { + const {repos} = await changedFilesPromise; + const noSCM = Object.keys(repos).every(scm => repos[scm].size === 0); + + if (noSCM) { + process.stderr.write( + '\n' + + _chalk().default.bold('--watch') + + ' is not supported without git/hg, please use --watchAll ' + + '\n' + ); + (0, _exit().default)(1); + } + } + + const searchSources = contexts.map( + context => new _SearchSource.default(context) + ); + const testRunData = await Promise.all( + contexts.map(async (context, index) => { + const searchSource = searchSources[index]; + const matches = await getTestPaths( + globalConfig, + searchSource, + outputStream, + changedFilesPromise && (await changedFilesPromise), + jestHooks, + filter + ); + allTests = allTests.concat(matches.tests); + return { + context, + matches + }; + }) + ); + allTests = await sequencer.sort(allTests); + + if (globalConfig.listTests) { + const testsPaths = Array.from(new Set(allTests.map(test => test.path))); + /* eslint-disable no-console */ + + if (globalConfig.json) { + console.log(JSON.stringify(testsPaths)); + } else { + console.log(testsPaths.join('\n')); + } + /* eslint-enable */ + + onComplete && + onComplete((0, _testResult().makeEmptyAggregatedTestResult)()); + return; + } + + if (globalConfig.onlyFailures) { + if (failedTestsCache) { + allTests = failedTestsCache.filterTests(allTests); + } else { + allTests = await sequencer.allFailedTests(allTests); + } + } + + const hasTests = allTests.length > 0; + + if (!hasTests) { + const noTestsFoundMessage = (0, _getNoTestsFoundMessage.default)( + testRunData, + globalConfig + ); + + if ( + globalConfig.passWithNoTests || + globalConfig.findRelatedTests || + globalConfig.lastCommit || + globalConfig.onlyChanged + ) { + new (_console().CustomConsole)(outputStream, outputStream).log( + noTestsFoundMessage + ); + } else { + new (_console().CustomConsole)(outputStream, outputStream).error( + noTestsFoundMessage + ); + (0, _exit().default)(1); + } + } else if ( + allTests.length === 1 && + globalConfig.silent !== true && + globalConfig.verbose !== false + ) { + const newConfig = {...globalConfig, verbose: true}; + globalConfig = Object.freeze(newConfig); + } + + let collectHandles; + + if (globalConfig.detectOpenHandles) { + collectHandles = (0, _collectHandles.default)(); + } + + if (hasTests) { + await (0, _runGlobalHook.default)({ + allTests, + globalConfig, + moduleName: 'globalSetup' + }); + } + + if (changedFilesPromise) { + const changedFilesInfo = await changedFilesPromise; + + if (changedFilesInfo.changedFiles) { + testSchedulerContext.changedFiles = changedFilesInfo.changedFiles; + const sourcesRelatedToTestsInChangedFilesArray = ( + await Promise.all( + contexts.map(async (_, index) => { + const searchSource = searchSources[index]; + return searchSource.findRelatedSourcesFromTestsInChangedFiles( + changedFilesInfo + ); + }) + ) + ).reduce((total, paths) => total.concat(paths), []); + testSchedulerContext.sourcesRelatedToTestsInChangedFiles = new Set( + sourcesRelatedToTestsInChangedFilesArray + ); + } + } + + const scheduler = await (0, _TestScheduler.createTestScheduler)( + globalConfig, + { + startRun + }, + testSchedulerContext + ); + const results = await scheduler.scheduleTests(allTests, testWatcher); + await sequencer.cacheResults(allTests, results); + + if (hasTests) { + await (0, _runGlobalHook.default)({ + allTests, + globalConfig, + moduleName: 'globalTeardown' + }); + } + + await processResults(results, { + collectHandles, + json: globalConfig.json, + onComplete, + outputFile: globalConfig.outputFile, + outputStream, + testResultsProcessor: globalConfig.testResultsProcessor + }); +} diff --git a/node_modules/@jest/core/build/testSchedulerHelper.d.ts b/node_modules/@jest/core/build/testSchedulerHelper.d.ts new file mode 100644 index 0000000..d49d44f --- /dev/null +++ b/node_modules/@jest/core/build/testSchedulerHelper.d.ts @@ -0,0 +1,9 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +import type { Test } from '@jest/test-result'; +import type { Config } from '@jest/types'; +export declare function shouldRunInBand(tests: Array<Test>, timings: Array<number>, { detectOpenHandles, maxWorkers, watch, watchAll }: Config.GlobalConfig): boolean; diff --git a/node_modules/@jest/core/build/testSchedulerHelper.js b/node_modules/@jest/core/build/testSchedulerHelper.js new file mode 100644 index 0000000..78cf48c --- /dev/null +++ b/node_modules/@jest/core/build/testSchedulerHelper.js @@ -0,0 +1,51 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.shouldRunInBand = shouldRunInBand; + +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +const SLOW_TEST_TIME = 1000; + +function shouldRunInBand( + tests, + timings, + {detectOpenHandles, maxWorkers, watch, watchAll} +) { + // detectOpenHandles makes no sense without runInBand, because it cannot detect leaks in workers + if (detectOpenHandles) { + return true; + } + /* + * Run in band if we only have one test or one worker available, unless we + * are using the watch mode, in which case the TTY has to be responsive and + * we cannot schedule anything in the main thread. Same logic applies to + * watchAll. + * Also, if we are confident from previous runs that the tests will finish + * quickly we also run in band to reduce the overhead of spawning workers. + * Finally, the user can provide the runInBand argument in the CLI to + * force running in band. + * https://github.com/facebook/jest/blob/700e0dadb85f5dc8ff5dac6c7e98956690049734/packages/jest-config/src/getMaxWorkers.js#L14-L17 + */ + + const isWatchMode = watch || watchAll; + const areFastTests = timings.every(timing => timing < SLOW_TEST_TIME); + const oneWorkerOrLess = maxWorkers <= 1; + const oneTestOrLess = tests.length <= 1; + + if (isWatchMode) { + return oneWorkerOrLess || (oneTestOrLess && areFastTests); + } + + return ( + oneWorkerOrLess || + oneTestOrLess || + (tests.length <= 20 && timings.length > 0 && areFastTests) + ); +} diff --git a/node_modules/@jest/core/build/types.d.ts b/node_modules/@jest/core/build/types.d.ts new file mode 100644 index 0000000..877941c --- /dev/null +++ b/node_modules/@jest/core/build/types.d.ts @@ -0,0 +1,39 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +import type { Test } from '@jest/test-result'; +import type { Config } from '@jest/types'; +import type { Context } from 'jest-runtime'; +export declare type Stats = { + roots: number; + testMatch: number; + testPathIgnorePatterns: number; + testRegex: number; + testPathPattern?: number; +}; +export declare type TestRunData = Array<{ + context: Context; + matches: { + allTests: number; + tests: Array<Test>; + total?: number; + stats?: Stats; + }; +}>; +export declare type TestPathCases = Array<{ + stat: keyof Stats; + isMatch: (path: Config.Path) => boolean; +}>; +export declare type TestPathCasesWithPathPattern = TestPathCases & { + testPathPattern: (path: Config.Path) => boolean; +}; +export declare type FilterResult = { + test: string; + message: string; +}; +export declare type Filter = (testPaths: Array<string>) => Promise<{ + filtered: Array<FilterResult>; +}>; diff --git a/node_modules/@jest/core/build/types.js b/node_modules/@jest/core/build/types.js new file mode 100644 index 0000000..ad9a93a --- /dev/null +++ b/node_modules/@jest/core/build/types.js @@ -0,0 +1 @@ +'use strict'; diff --git a/node_modules/@jest/core/build/version.d.ts b/node_modules/@jest/core/build/version.d.ts new file mode 100644 index 0000000..8646731 --- /dev/null +++ b/node_modules/@jest/core/build/version.d.ts @@ -0,0 +1,7 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +export default function getVersion(): string; diff --git a/node_modules/@jest/core/build/version.js b/node_modules/@jest/core/build/version.js new file mode 100644 index 0000000..1bcd800 --- /dev/null +++ b/node_modules/@jest/core/build/version.js @@ -0,0 +1,19 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = getVersion; + +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +// Cannot be `import` as it's not under TS root dir +const {version: VERSION} = require('../package.json'); + +function getVersion() { + return VERSION; +} diff --git a/node_modules/@jest/core/build/watch.d.ts b/node_modules/@jest/core/build/watch.d.ts new file mode 100644 index 0000000..d8df910 --- /dev/null +++ b/node_modules/@jest/core/build/watch.d.ts @@ -0,0 +1,13 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +/// <reference types="node" /> +import type { Config } from '@jest/types'; +import type { default as HasteMap } from 'jest-haste-map'; +import type { Context } from 'jest-runtime'; +import { JestHook } from 'jest-watcher'; +import type { Filter } from './types'; +export default function watch(initialGlobalConfig: Config.GlobalConfig, contexts: Array<Context>, outputStream: NodeJS.WriteStream, hasteMapInstances: Array<HasteMap>, stdin?: NodeJS.ReadStream, hooks?: JestHook, filter?: Filter): Promise<void>; diff --git a/node_modules/@jest/core/build/watch.js b/node_modules/@jest/core/build/watch.js new file mode 100644 index 0000000..cffb811 --- /dev/null +++ b/node_modules/@jest/core/build/watch.js @@ -0,0 +1,769 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = watch; + +function path() { + const data = _interopRequireWildcard(require('path')); + + path = function () { + return data; + }; + + return data; +} + +function _ansiEscapes() { + const data = _interopRequireDefault(require('ansi-escapes')); + + _ansiEscapes = function () { + return data; + }; + + return data; +} + +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + + _chalk = function () { + return data; + }; + + return data; +} + +function _exit() { + const data = _interopRequireDefault(require('exit')); + + _exit = function () { + return data; + }; + + return data; +} + +function _slash() { + const data = _interopRequireDefault(require('slash')); + + _slash = function () { + return data; + }; + + return data; +} + +function _jestMessageUtil() { + const data = require('jest-message-util'); + + _jestMessageUtil = function () { + return data; + }; + + return data; +} + +function _jestUtil() { + const data = require('jest-util'); + + _jestUtil = function () { + return data; + }; + + return data; +} + +function _jestValidate() { + const data = require('jest-validate'); + + _jestValidate = function () { + return data; + }; + + return data; +} + +function _jestWatcher() { + const data = require('jest-watcher'); + + _jestWatcher = function () { + return data; + }; + + return data; +} + +var _FailedTestsCache = _interopRequireDefault(require('./FailedTestsCache')); + +var _SearchSource = _interopRequireDefault(require('./SearchSource')); + +var _TestWatcher = _interopRequireDefault(require('./TestWatcher')); + +var _getChangedFilesPromise = _interopRequireDefault( + require('./getChangedFilesPromise') +); + +var _activeFiltersMessage = _interopRequireDefault( + require('./lib/activeFiltersMessage') +); + +var _createContext = _interopRequireDefault(require('./lib/createContext')); + +var _isValidPath = _interopRequireDefault(require('./lib/isValidPath')); + +var _updateGlobalConfig = _interopRequireDefault( + require('./lib/updateGlobalConfig') +); + +var _watchPluginsHelpers = require('./lib/watchPluginsHelpers'); + +var _FailedTestsInteractive = _interopRequireDefault( + require('./plugins/FailedTestsInteractive') +); + +var _Quit = _interopRequireDefault(require('./plugins/Quit')); + +var _TestNamePattern = _interopRequireDefault( + require('./plugins/TestNamePattern') +); + +var _TestPathPattern = _interopRequireDefault( + require('./plugins/TestPathPattern') +); + +var _UpdateSnapshots = _interopRequireDefault( + require('./plugins/UpdateSnapshots') +); + +var _UpdateSnapshotsInteractive = _interopRequireDefault( + require('./plugins/UpdateSnapshotsInteractive') +); + +var _runJest = _interopRequireDefault(require('./runJest')); + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} + +function _getRequireWildcardCache(nodeInterop) { + if (typeof WeakMap !== 'function') return null; + var cacheBabelInterop = new WeakMap(); + var cacheNodeInterop = new WeakMap(); + return (_getRequireWildcardCache = function (nodeInterop) { + return nodeInterop ? cacheNodeInterop : cacheBabelInterop; + })(nodeInterop); +} + +function _interopRequireWildcard(obj, nodeInterop) { + if (!nodeInterop && obj && obj.__esModule) { + return obj; + } + if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) { + return {default: obj}; + } + var cache = _getRequireWildcardCache(nodeInterop); + if (cache && cache.has(obj)) { + return cache.get(obj); + } + var newObj = {}; + var hasPropertyDescriptor = + Object.defineProperty && Object.getOwnPropertyDescriptor; + for (var key in obj) { + if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor + ? Object.getOwnPropertyDescriptor(obj, key) + : null; + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + newObj.default = obj; + if (cache) { + cache.set(obj, newObj); + } + return newObj; +} + +/** + * Copyright (c) Facebook, Inc. and its affiliates. 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. + */ +const {print: preRunMessagePrint} = _jestUtil().preRunMessage; + +let hasExitListener = false; +const INTERNAL_PLUGINS = [ + _FailedTestsInteractive.default, + _TestPathPattern.default, + _TestNamePattern.default, + _UpdateSnapshots.default, + _UpdateSnapshotsInteractive.default, + _Quit.default +]; +const RESERVED_KEY_PLUGINS = new Map([ + [ + _UpdateSnapshots.default, + { + forbiddenOverwriteMessage: 'updating snapshots', + key: 'u' + } + ], + [ + _UpdateSnapshotsInteractive.default, + { + forbiddenOverwriteMessage: 'updating snapshots interactively', + key: 'i' + } + ], + [ + _Quit.default, + { + forbiddenOverwriteMessage: 'quitting watch mode' + } + ] +]); + +async function watch( + initialGlobalConfig, + contexts, + outputStream, + hasteMapInstances, + stdin = process.stdin, + hooks = new (_jestWatcher().JestHook)(), + filter +) { + // `globalConfig` will be constantly updated and reassigned as a result of + // watch mode interactions. + let globalConfig = initialGlobalConfig; + let activePlugin; + globalConfig = (0, _updateGlobalConfig.default)(globalConfig, { + mode: globalConfig.watch ? 'watch' : 'watchAll', + passWithNoTests: true + }); + + const updateConfigAndRun = ({ + bail, + changedSince, + collectCoverage, + collectCoverageFrom, + collectCoverageOnlyFrom, + coverageDirectory, + coverageReporters, + findRelatedTests, + mode, + nonFlagArgs, + notify, + notifyMode, + onlyFailures, + reporters, + testNamePattern, + testPathPattern, + updateSnapshot, + verbose + } = {}) => { + const previousUpdateSnapshot = globalConfig.updateSnapshot; + globalConfig = (0, _updateGlobalConfig.default)(globalConfig, { + bail, + changedSince, + collectCoverage, + collectCoverageFrom, + collectCoverageOnlyFrom, + coverageDirectory, + coverageReporters, + findRelatedTests, + mode, + nonFlagArgs, + notify, + notifyMode, + onlyFailures, + reporters, + testNamePattern, + testPathPattern, + updateSnapshot, + verbose + }); + startRun(globalConfig); + globalConfig = (0, _updateGlobalConfig.default)(globalConfig, { + // updateSnapshot is not sticky after a run. + updateSnapshot: + previousUpdateSnapshot === 'all' ? 'none' : previousUpdateSnapshot + }); + }; + + const watchPlugins = INTERNAL_PLUGINS.map( + InternalPlugin => + new InternalPlugin({ + stdin, + stdout: outputStream + }) + ); + watchPlugins.forEach(plugin => { + const hookSubscriber = hooks.getSubscriber(); + + if (plugin.apply) { + plugin.apply(hookSubscriber); + } + }); + + if (globalConfig.watchPlugins != null) { + const watchPluginKeys = new Map(); + + for (const plugin of watchPlugins) { + const reservedInfo = RESERVED_KEY_PLUGINS.get(plugin.constructor) || {}; + const key = reservedInfo.key || getPluginKey(plugin, globalConfig); + + if (!key) { + continue; + } + + const {forbiddenOverwriteMessage} = reservedInfo; + watchPluginKeys.set(key, { + forbiddenOverwriteMessage, + overwritable: forbiddenOverwriteMessage == null, + plugin + }); + } + + for (const pluginWithConfig of globalConfig.watchPlugins) { + let plugin; + + try { + const ThirdPartyPlugin = await (0, _jestUtil().requireOrImportModule)( + pluginWithConfig.path + ); + plugin = new ThirdPartyPlugin({ + config: pluginWithConfig.config, + stdin, + stdout: outputStream + }); + } catch (error) { + const errorWithContext = new Error( + `Failed to initialize watch plugin "${_chalk().default.bold( + (0, _slash().default)( + path().relative(process.cwd(), pluginWithConfig.path) + ) + )}":\n\n${(0, _jestMessageUtil().formatExecError)( + error, + contexts[0].config, + { + noStackTrace: false + } + )}` + ); + delete errorWithContext.stack; + return Promise.reject(errorWithContext); + } + + checkForConflicts(watchPluginKeys, plugin, globalConfig); + const hookSubscriber = hooks.getSubscriber(); + + if (plugin.apply) { + plugin.apply(hookSubscriber); + } + + watchPlugins.push(plugin); + } + } + + const failedTestsCache = new _FailedTestsCache.default(); + let searchSources = contexts.map(context => ({ + context, + searchSource: new _SearchSource.default(context) + })); + let isRunning = false; + let testWatcher; + let shouldDisplayWatchUsage = true; + let isWatchUsageDisplayed = false; + + const emitFileChange = () => { + if (hooks.isUsed('onFileChange')) { + const projects = searchSources.map(({context, searchSource}) => ({ + config: context.config, + testPaths: searchSource.findMatchingTests('').tests.map(t => t.path) + })); + hooks.getEmitter().onFileChange({ + projects + }); + } + }; + + emitFileChange(); + hasteMapInstances.forEach((hasteMapInstance, index) => { + hasteMapInstance.on('change', ({eventsQueue, hasteFS, moduleMap}) => { + const validPaths = eventsQueue.filter(({filePath}) => + (0, _isValidPath.default)(globalConfig, filePath) + ); + + if (validPaths.length) { + const context = (contexts[index] = (0, _createContext.default)( + contexts[index].config, + { + hasteFS, + moduleMap + } + )); + activePlugin = null; + searchSources = searchSources.slice(); + searchSources[index] = { + context, + searchSource: new _SearchSource.default(context) + }; + emitFileChange(); + startRun(globalConfig); + } + }); + }); + + if (!hasExitListener) { + hasExitListener = true; + process.on('exit', () => { + if (activePlugin) { + outputStream.write(_ansiEscapes().default.cursorDown()); + outputStream.write(_ansiEscapes().default.eraseDown); + } + }); + } + + const startRun = globalConfig => { + if (isRunning) { + return Promise.resolve(null); + } + + testWatcher = new _TestWatcher.default({ + isWatchMode: true + }); + _jestUtil().isInteractive && + outputStream.write(_jestUtil().specialChars.CLEAR); + preRunMessagePrint(outputStream); + isRunning = true; + const configs = contexts.map(context => context.config); + const changedFilesPromise = (0, _getChangedFilesPromise.default)( + globalConfig, + configs + ); + return (0, _runJest.default)({ + changedFilesPromise, + contexts, + failedTestsCache, + filter, + globalConfig, + jestHooks: hooks.getEmitter(), + onComplete: results => { + isRunning = false; + hooks.getEmitter().onTestRunComplete(results); // Create a new testWatcher instance so that re-runs won't be blocked. + // The old instance that was passed to Jest will still be interrupted + // and prevent test runs from the previous run. + + testWatcher = new _TestWatcher.default({ + isWatchMode: true + }); // Do not show any Watch Usage related stuff when running in a + // non-interactive environment + + if (_jestUtil().isInteractive) { + if (shouldDisplayWatchUsage) { + outputStream.write(usage(globalConfig, watchPlugins)); + shouldDisplayWatchUsage = false; // hide Watch Usage after first run + + isWatchUsageDisplayed = true; + } else { + outputStream.write(showToggleUsagePrompt()); + shouldDisplayWatchUsage = false; + isWatchUsageDisplayed = false; + } + } else { + outputStream.write('\n'); + } + + failedTestsCache.setTestResults(results.testResults); + }, + outputStream, + startRun, + testWatcher + }).catch( + ( + error // Errors thrown inside `runJest`, e.g. by resolvers, are caught here for + ) => + // continuous watch mode execution. We need to reprint them to the + // terminal and give just a little bit of extra space so they fit below + // `preRunMessagePrint` message nicely. + console.error( + '\n\n' + + (0, _jestMessageUtil().formatExecError)(error, contexts[0].config, { + noStackTrace: false + }) + ) + ); + }; + + const onKeypress = key => { + if ( + key === _jestWatcher().KEYS.CONTROL_C || + key === _jestWatcher().KEYS.CONTROL_D + ) { + if (typeof stdin.setRawMode === 'function') { + stdin.setRawMode(false); + } + + outputStream.write('\n'); + (0, _exit().default)(0); + return; + } + + if (activePlugin != null && activePlugin.onKey) { + // if a plugin is activate, Jest should let it handle keystrokes, so ignore + // them here + activePlugin.onKey(key); + return; + } // Abort test run + + const pluginKeys = (0, _watchPluginsHelpers.getSortedUsageRows)( + watchPlugins, + globalConfig + ).map(usage => Number(usage.key).toString(16)); + + if ( + isRunning && + testWatcher && + ['q', _jestWatcher().KEYS.ENTER, 'a', 'o', 'f'] + .concat(pluginKeys) + .includes(key) + ) { + testWatcher.setState({ + interrupted: true + }); + return; + } + + const matchingWatchPlugin = (0, + _watchPluginsHelpers.filterInteractivePlugins)( + watchPlugins, + globalConfig + ).find(plugin => getPluginKey(plugin, globalConfig) === key); + + if (matchingWatchPlugin != null) { + if (isRunning) { + testWatcher.setState({ + interrupted: true + }); + return; + } // "activate" the plugin, which has jest ignore keystrokes so the plugin + // can handle them + + activePlugin = matchingWatchPlugin; + + if (activePlugin.run) { + activePlugin.run(globalConfig, updateConfigAndRun).then( + shouldRerun => { + activePlugin = null; + + if (shouldRerun) { + updateConfigAndRun(); + } + }, + () => { + activePlugin = null; + onCancelPatternPrompt(); + } + ); + } else { + activePlugin = null; + } + } + + switch (key) { + case _jestWatcher().KEYS.ENTER: + startRun(globalConfig); + break; + + case 'a': + globalConfig = (0, _updateGlobalConfig.default)(globalConfig, { + mode: 'watchAll', + testNamePattern: '', + testPathPattern: '' + }); + startRun(globalConfig); + break; + + case 'c': + updateConfigAndRun({ + mode: 'watch', + testNamePattern: '', + testPathPattern: '' + }); + break; + + case 'f': + globalConfig = (0, _updateGlobalConfig.default)(globalConfig, { + onlyFailures: !globalConfig.onlyFailures + }); + startRun(globalConfig); + break; + + case 'o': + globalConfig = (0, _updateGlobalConfig.default)(globalConfig, { + mode: 'watch', + testNamePattern: '', + testPathPattern: '' + }); + startRun(globalConfig); + break; + + case '?': + break; + + case 'w': + if (!shouldDisplayWatchUsage && !isWatchUsageDisplayed) { + outputStream.write(_ansiEscapes().default.cursorUp()); + outputStream.write(_ansiEscapes().default.eraseDown); + outputStream.write(usage(globalConfig, watchPlugins)); + isWatchUsageDisplayed = true; + shouldDisplayWatchUsage = false; + } + + break; + } + }; + + const onCancelPatternPrompt = () => { + outputStream.write(_ansiEscapes().default.cursorHide); + outputStream.write(_jestUtil().specialChars.CLEAR); + outputStream.write(usage(globalConfig, watchPlugins)); + outputStream.write(_ansiEscapes().default.cursorShow); + }; + + if (typeof stdin.setRawMode === 'function') { + stdin.setRawMode(true); + stdin.resume(); + stdin.setEncoding('utf8'); + stdin.on('data', onKeypress); + } + + startRun(globalConfig); + return Promise.resolve(); +} + +const checkForConflicts = (watchPluginKeys, plugin, globalConfig) => { + const key = getPluginKey(plugin, globalConfig); + + if (!key) { + return; + } + + const conflictor = watchPluginKeys.get(key); + + if (!conflictor || conflictor.overwritable) { + watchPluginKeys.set(key, { + overwritable: false, + plugin + }); + return; + } + + let error; + + if (conflictor.forbiddenOverwriteMessage) { + error = ` + Watch plugin ${_chalk().default.bold.red( + getPluginIdentifier(plugin) + )} attempted to register key ${_chalk().default.bold.red(`<${key}>`)}, + that is reserved internally for ${_chalk().default.bold.red( + conflictor.forbiddenOverwriteMessage + )}. + Please change the configuration key for this plugin.`.trim(); + } else { + const plugins = [conflictor.plugin, plugin] + .map(p => _chalk().default.bold.red(getPluginIdentifier(p))) + .join(' and '); + error = ` + Watch plugins ${plugins} both attempted to register key ${_chalk().default.bold.red( + `<${key}>` + )}. + Please change the key configuration for one of the conflicting plugins to avoid overlap.`.trim(); + } + + throw new (_jestValidate().ValidationError)( + 'Watch plugin configuration error', + error + ); +}; + +const getPluginIdentifier = ( + plugin // This breaks as `displayName` is not defined as a static, but since +) => + // WatchPlugin is an interface, and it is my understanding interface + // static fields are not definable anymore, no idea how to circumvent + // this :-( + // @ts-expect-error: leave `displayName` be. + plugin.constructor.displayName || plugin.constructor.name; + +const getPluginKey = (plugin, globalConfig) => { + if (typeof plugin.getUsageInfo === 'function') { + return ( + plugin.getUsageInfo(globalConfig) || { + key: null + } + ).key; + } + + return null; +}; + +const usage = (globalConfig, watchPlugins, delimiter = '\n') => { + const messages = [ + (0, _activeFiltersMessage.default)(globalConfig), + globalConfig.testPathPattern || globalConfig.testNamePattern + ? _chalk().default.dim(' \u203A Press ') + + 'c' + + _chalk().default.dim(' to clear filters.') + : null, + '\n' + _chalk().default.bold('Watch Usage'), + globalConfig.watch + ? _chalk().default.dim(' \u203A Press ') + + 'a' + + _chalk().default.dim(' to run all tests.') + : null, + globalConfig.onlyFailures + ? _chalk().default.dim(' \u203A Press ') + + 'f' + + _chalk().default.dim(' to quit "only failed tests" mode.') + : _chalk().default.dim(' \u203A Press ') + + 'f' + + _chalk().default.dim(' to run only failed tests.'), + (globalConfig.watchAll || + globalConfig.testPathPattern || + globalConfig.testNamePattern) && + !globalConfig.noSCM + ? _chalk().default.dim(' \u203A Press ') + + 'o' + + _chalk().default.dim(' to only run tests related to changed files.') + : null, + ...(0, _watchPluginsHelpers.getSortedUsageRows)( + watchPlugins, + globalConfig + ).map( + plugin => + _chalk().default.dim(' \u203A Press') + + ' ' + + plugin.key + + ' ' + + _chalk().default.dim(`to ${plugin.prompt}.`) + ), + _chalk().default.dim(' \u203A Press ') + + 'Enter' + + _chalk().default.dim(' to trigger a test run.') + ]; + return messages.filter(message => !!message).join(delimiter) + '\n'; +}; + +const showToggleUsagePrompt = () => + '\n' + + _chalk().default.bold('Watch Usage: ') + + _chalk().default.dim('Press ') + + 'w' + + _chalk().default.dim(' to show more.'); diff --git a/node_modules/@jest/core/package.json b/node_modules/@jest/core/package.json new file mode 100644 index 0000000..a160167 --- /dev/null +++ b/node_modules/@jest/core/package.json @@ -0,0 +1,103 @@ +{ + "name": "@jest/core", + "description": "Delightful JavaScript Testing.", + "version": "27.5.1", + "main": "./build/jest.js", + "types": "./build/jest.d.ts", + "exports": { + ".": { + "types": "./build/jest.d.ts", + "default": "./build/jest.js" + }, + "./package.json": "./package.json" + }, + "dependencies": { + "@jest/console": "^27.5.1", + "@jest/reporters": "^27.5.1", + "@jest/test-result": "^27.5.1", + "@jest/transform": "^27.5.1", + "@jest/types": "^27.5.1", + "@types/node": "*", + "ansi-escapes": "^4.2.1", + "chalk": "^4.0.0", + "emittery": "^0.8.1", + "exit": "^0.1.2", + "graceful-fs": "^4.2.9", + "jest-changed-files": "^27.5.1", + "jest-config": "^27.5.1", + "jest-haste-map": "^27.5.1", + "jest-message-util": "^27.5.1", + "jest-regex-util": "^27.5.1", + "jest-resolve": "^27.5.1", + "jest-resolve-dependencies": "^27.5.1", + "jest-runner": "^27.5.1", + "jest-runtime": "^27.5.1", + "jest-snapshot": "^27.5.1", + "jest-util": "^27.5.1", + "jest-validate": "^27.5.1", + "jest-watcher": "^27.5.1", + "micromatch": "^4.0.4", + "rimraf": "^3.0.0", + "slash": "^3.0.0", + "strip-ansi": "^6.0.0" + }, + "devDependencies": { + "@jest/test-sequencer": "^27.5.1", + "@jest/test-utils": "^27.5.1", + "@types/exit": "^0.1.30", + "@types/graceful-fs": "^4.1.2", + "@types/micromatch": "^4.0.1", + "@types/rimraf": "^3.0.0" + }, + "peerDependencies": { + "node-notifier": "^8.0.1 || ^9.0.0 || ^10.0.0" + }, + "peerDependenciesMeta": { + "node-notifier": { + "optional": true + } + }, + "engines": { + "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0" + }, + "repository": { + "type": "git", + "url": "https://github.com/facebook/jest", + "directory": "packages/jest-core" + }, + "bugs": { + "url": "https://github.com/facebook/jest/issues" + }, + "homepage": "https://jestjs.io/", + "license": "MIT", + "keywords": [ + "ava", + "babel", + "coverage", + "easy", + "expect", + "facebook", + "immersive", + "instant", + "jasmine", + "jest", + "jsdom", + "mocha", + "mocking", + "painless", + "qunit", + "runner", + "sandboxed", + "snapshot", + "tap", + "tape", + "test", + "testing", + "typescript", + "watch" + ], + "publishConfig": { + "access": "public" + }, + "gitHead": "67c1aa20c5fec31366d733e901fee2b981cb1850" +} |
