mirror of
https://github.com/x1xhlol/system-prompts-and-models-of-ai-tools.git
synced 2026-02-04 14:00:49 +00:00
nhj
more
This commit is contained in:
dopeuni444
21
unified-ai-platform/node_modules/jest-runner/LICENSE
generated
vendored
Normal file
21
unified-ai-platform/node_modules/jest-runner/LICENSE
generated
vendored
Normal file
@@ -0,0 +1,21 @@
|
||||
MIT License
|
||||
|
||||
Copyright (c) Meta Platforms, Inc. and 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.
|
||||
219
unified-ai-platform/node_modules/jest-runner/build/index.js
generated
vendored
Normal file
219
unified-ai-platform/node_modules/jest-runner/build/index.js
generated
vendored
Normal file
@@ -0,0 +1,219 @@
|
||||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', {
|
||||
value: true
|
||||
});
|
||||
Object.defineProperty(exports, 'CallbackTestRunner', {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _types.CallbackTestRunner;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, 'EmittingTestRunner', {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _types.EmittingTestRunner;
|
||||
}
|
||||
});
|
||||
exports.default = void 0;
|
||||
function _chalk() {
|
||||
const data = _interopRequireDefault(require('chalk'));
|
||||
_chalk = function () {
|
||||
return data;
|
||||
};
|
||||
return data;
|
||||
}
|
||||
function _emittery() {
|
||||
const data = _interopRequireDefault(require('emittery'));
|
||||
_emittery = function () {
|
||||
return data;
|
||||
};
|
||||
return data;
|
||||
}
|
||||
function _pLimit() {
|
||||
const data = _interopRequireDefault(require('p-limit'));
|
||||
_pLimit = function () {
|
||||
return data;
|
||||
};
|
||||
return data;
|
||||
}
|
||||
function _jestUtil() {
|
||||
const data = require('jest-util');
|
||||
_jestUtil = function () {
|
||||
return data;
|
||||
};
|
||||
return data;
|
||||
}
|
||||
function _jestWorker() {
|
||||
const data = require('jest-worker');
|
||||
_jestWorker = function () {
|
||||
return data;
|
||||
};
|
||||
return data;
|
||||
}
|
||||
var _runTest = _interopRequireDefault(require('./runTest'));
|
||||
var _types = require('./types');
|
||||
function _interopRequireDefault(obj) {
|
||||
return obj && obj.__esModule ? obj : {default: obj};
|
||||
}
|
||||
/**
|
||||
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
|
||||
class TestRunner extends _types.EmittingTestRunner {
|
||||
#eventEmitter = new (_emittery().default)();
|
||||
async runTests(tests, watcher, options) {
|
||||
return options.serial
|
||||
? this.#createInBandTestRun(tests, watcher)
|
||||
: this.#createParallelTestRun(tests, watcher);
|
||||
}
|
||||
async #createInBandTestRun(tests, watcher) {
|
||||
process.env.JEST_WORKER_ID = '1';
|
||||
const mutex = (0, _pLimit().default)(1);
|
||||
return tests.reduce(
|
||||
(promise, test) =>
|
||||
mutex(() =>
|
||||
promise
|
||||
.then(async () => {
|
||||
if (watcher.isInterrupted()) {
|
||||
throw new CancelRun();
|
||||
}
|
||||
|
||||
// `deepCyclicCopy` used here to avoid mem-leak
|
||||
const sendMessageToJest = (eventName, args) =>
|
||||
this.#eventEmitter.emit(
|
||||
eventName,
|
||||
(0, _jestUtil().deepCyclicCopy)(args, {
|
||||
keepPrototype: false
|
||||
})
|
||||
);
|
||||
await this.#eventEmitter.emit('test-file-start', [test]);
|
||||
return (0, _runTest.default)(
|
||||
test.path,
|
||||
this._globalConfig,
|
||||
test.context.config,
|
||||
test.context.resolver,
|
||||
this._context,
|
||||
sendMessageToJest
|
||||
);
|
||||
})
|
||||
.then(
|
||||
result =>
|
||||
this.#eventEmitter.emit('test-file-success', [test, result]),
|
||||
error =>
|
||||
this.#eventEmitter.emit('test-file-failure', [test, error])
|
||||
)
|
||||
),
|
||||
Promise.resolve()
|
||||
);
|
||||
}
|
||||
async #createParallelTestRun(tests, watcher) {
|
||||
const resolvers = new Map();
|
||||
for (const test of tests) {
|
||||
if (!resolvers.has(test.context.config.id)) {
|
||||
resolvers.set(test.context.config.id, {
|
||||
config: test.context.config,
|
||||
serializableModuleMap: test.context.moduleMap.toJSON()
|
||||
});
|
||||
}
|
||||
}
|
||||
const worker = new (_jestWorker().Worker)(require.resolve('./testWorker'), {
|
||||
enableWorkerThreads: this._globalConfig.workerThreads,
|
||||
exposedMethods: ['worker'],
|
||||
forkOptions: {
|
||||
serialization: 'json',
|
||||
stdio: 'pipe'
|
||||
},
|
||||
// The workerIdleMemoryLimit should've been converted to a number during
|
||||
// the normalization phase.
|
||||
idleMemoryLimit:
|
||||
typeof this._globalConfig.workerIdleMemoryLimit === 'number'
|
||||
? this._globalConfig.workerIdleMemoryLimit
|
||||
: undefined,
|
||||
maxRetries: 3,
|
||||
numWorkers: this._globalConfig.maxWorkers,
|
||||
setupArgs: [
|
||||
{
|
||||
serializableResolvers: Array.from(resolvers.values())
|
||||
}
|
||||
]
|
||||
});
|
||||
if (worker.getStdout()) worker.getStdout().pipe(process.stdout);
|
||||
if (worker.getStderr()) worker.getStderr().pipe(process.stderr);
|
||||
const mutex = (0, _pLimit().default)(this._globalConfig.maxWorkers);
|
||||
|
||||
// Send test suites to workers continuously instead of all at once to track
|
||||
// the start time of individual tests.
|
||||
const runTestInWorker = test =>
|
||||
mutex(async () => {
|
||||
if (watcher.isInterrupted()) {
|
||||
return Promise.reject();
|
||||
}
|
||||
await this.#eventEmitter.emit('test-file-start', [test]);
|
||||
const promise = worker.worker({
|
||||
config: test.context.config,
|
||||
context: {
|
||||
...this._context,
|
||||
changedFiles:
|
||||
this._context.changedFiles &&
|
||||
Array.from(this._context.changedFiles),
|
||||
sourcesRelatedToTestsInChangedFiles:
|
||||
this._context.sourcesRelatedToTestsInChangedFiles &&
|
||||
Array.from(this._context.sourcesRelatedToTestsInChangedFiles)
|
||||
},
|
||||
globalConfig: this._globalConfig,
|
||||
path: test.path
|
||||
});
|
||||
if (promise.UNSTABLE_onCustomMessage) {
|
||||
// TODO: Get appropriate type for `onCustomMessage`
|
||||
promise.UNSTABLE_onCustomMessage(([event, payload]) =>
|
||||
this.#eventEmitter.emit(event, payload)
|
||||
);
|
||||
}
|
||||
return promise;
|
||||
});
|
||||
const onInterrupt = new Promise((_, reject) => {
|
||||
watcher.on('change', state => {
|
||||
if (state.interrupted) {
|
||||
reject(new CancelRun());
|
||||
}
|
||||
});
|
||||
});
|
||||
const runAllTests = Promise.all(
|
||||
tests.map(test =>
|
||||
runTestInWorker(test).then(
|
||||
result =>
|
||||
this.#eventEmitter.emit('test-file-success', [test, result]),
|
||||
error => this.#eventEmitter.emit('test-file-failure', [test, error])
|
||||
)
|
||||
)
|
||||
);
|
||||
const cleanup = async () => {
|
||||
const {forceExited} = await worker.end();
|
||||
if (forceExited) {
|
||||
console.error(
|
||||
_chalk().default.yellow(
|
||||
'A worker process has failed to exit gracefully and has been force exited. ' +
|
||||
'This is likely caused by tests leaking due to improper teardown. ' +
|
||||
'Try running with --detectOpenHandles to find leaks. ' +
|
||||
'Active timers can also cause this, ensure that .unref() was called on them.'
|
||||
)
|
||||
);
|
||||
}
|
||||
};
|
||||
return Promise.race([runAllTests, onInterrupt]).then(cleanup, cleanup);
|
||||
}
|
||||
on(eventName, listener) {
|
||||
return this.#eventEmitter.on(eventName, listener);
|
||||
}
|
||||
}
|
||||
exports.default = TestRunner;
|
||||
class CancelRun extends Error {
|
||||
constructor(message) {
|
||||
super(message);
|
||||
this.name = 'CancelRun';
|
||||
}
|
||||
}
|
||||
462
unified-ai-platform/node_modules/jest-runner/build/runTest.js
generated
vendored
Normal file
462
unified-ai-platform/node_modules/jest-runner/build/runTest.js
generated
vendored
Normal file
@@ -0,0 +1,462 @@
|
||||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', {
|
||||
value: true
|
||||
});
|
||||
exports.default = runTest;
|
||||
function _chalk() {
|
||||
const data = _interopRequireDefault(require('chalk'));
|
||||
_chalk = function () {
|
||||
return data;
|
||||
};
|
||||
return data;
|
||||
}
|
||||
function fs() {
|
||||
const data = _interopRequireWildcard(require('graceful-fs'));
|
||||
fs = function () {
|
||||
return data;
|
||||
};
|
||||
return data;
|
||||
}
|
||||
function _sourceMapSupport() {
|
||||
const data = _interopRequireDefault(require('source-map-support'));
|
||||
_sourceMapSupport = function () {
|
||||
return data;
|
||||
};
|
||||
return data;
|
||||
}
|
||||
function _console() {
|
||||
const data = require('@jest/console');
|
||||
_console = function () {
|
||||
return data;
|
||||
};
|
||||
return data;
|
||||
}
|
||||
function _transform() {
|
||||
const data = require('@jest/transform');
|
||||
_transform = function () {
|
||||
return data;
|
||||
};
|
||||
return data;
|
||||
}
|
||||
function docblock() {
|
||||
const data = _interopRequireWildcard(require('jest-docblock'));
|
||||
docblock = function () {
|
||||
return data;
|
||||
};
|
||||
return data;
|
||||
}
|
||||
function _jestLeakDetector() {
|
||||
const data = _interopRequireDefault(require('jest-leak-detector'));
|
||||
_jestLeakDetector = function () {
|
||||
return data;
|
||||
};
|
||||
return data;
|
||||
}
|
||||
function _jestMessageUtil() {
|
||||
const data = require('jest-message-util');
|
||||
_jestMessageUtil = function () {
|
||||
return data;
|
||||
};
|
||||
return data;
|
||||
}
|
||||
function _jestResolve() {
|
||||
const data = require('jest-resolve');
|
||||
_jestResolve = function () {
|
||||
return data;
|
||||
};
|
||||
return data;
|
||||
}
|
||||
function _jestUtil() {
|
||||
const data = require('jest-util');
|
||||
_jestUtil = function () {
|
||||
return data;
|
||||
};
|
||||
return data;
|
||||
}
|
||||
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 _interopRequireDefault(obj) {
|
||||
return obj && obj.__esModule ? obj : {default: obj};
|
||||
}
|
||||
/**
|
||||
* Copyright (c) Meta Platforms, Inc. and affiliates.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*
|
||||
*/
|
||||
|
||||
function freezeConsole(testConsole, config) {
|
||||
// @ts-expect-error: `_log` is `private` - we should figure out some proper API here
|
||||
testConsole._log = function fakeConsolePush(_type, message) {
|
||||
const error = new (_jestUtil().ErrorWithStack)(
|
||||
`${_chalk().default.red(
|
||||
`${_chalk().default.bold(
|
||||
'Cannot log after tests are done.'
|
||||
)} Did you forget to wait for something async in your test?`
|
||||
)}\nAttempted to log "${message}".`,
|
||||
fakeConsolePush
|
||||
);
|
||||
const formattedError = (0, _jestMessageUtil().formatExecError)(
|
||||
error,
|
||||
config,
|
||||
{
|
||||
noStackTrace: false
|
||||
},
|
||||
undefined,
|
||||
true
|
||||
);
|
||||
process.stderr.write(`\n${formattedError}\n`);
|
||||
process.exitCode = 1;
|
||||
};
|
||||
}
|
||||
|
||||
// Keeping the core of "runTest" as a separate function (as "runTestInternal")
|
||||
// is key to be able to detect memory leaks. Since all variables are local to
|
||||
// the function, when "runTestInternal" finishes its execution, they can all be
|
||||
// freed, UNLESS something else is leaking them (and that's why we can detect
|
||||
// the leak!).
|
||||
//
|
||||
// If we had all the code in a single function, we should manually nullify all
|
||||
// references to verify if there is a leak, which is not maintainable and error
|
||||
// prone. That's why "runTestInternal" CANNOT be inlined inside "runTest".
|
||||
async function runTestInternal(
|
||||
path,
|
||||
globalConfig,
|
||||
projectConfig,
|
||||
resolver,
|
||||
context,
|
||||
sendMessageToJest
|
||||
) {
|
||||
const testSource = fs().readFileSync(path, 'utf8');
|
||||
const docblockPragmas = docblock().parse(docblock().extract(testSource));
|
||||
const customEnvironment = docblockPragmas['jest-environment'];
|
||||
let testEnvironment = projectConfig.testEnvironment;
|
||||
if (customEnvironment) {
|
||||
if (Array.isArray(customEnvironment)) {
|
||||
throw new Error(
|
||||
`You can only define a single test environment through docblocks, got "${customEnvironment.join(
|
||||
', '
|
||||
)}"`
|
||||
);
|
||||
}
|
||||
testEnvironment = (0, _jestResolve().resolveTestEnvironment)({
|
||||
...projectConfig,
|
||||
requireResolveFunction: require.resolve,
|
||||
testEnvironment: customEnvironment
|
||||
});
|
||||
}
|
||||
const cacheFS = new Map([[path, testSource]]);
|
||||
const transformer = await (0, _transform().createScriptTransformer)(
|
||||
projectConfig,
|
||||
cacheFS
|
||||
);
|
||||
const TestEnvironment = await transformer.requireAndTranspileModule(
|
||||
testEnvironment
|
||||
);
|
||||
const testFramework = await transformer.requireAndTranspileModule(
|
||||
process.env.JEST_JASMINE === '1'
|
||||
? require.resolve('jest-jasmine2')
|
||||
: projectConfig.testRunner
|
||||
);
|
||||
const Runtime = (0, _jestUtil().interopRequireDefault)(
|
||||
projectConfig.runtime
|
||||
? require(projectConfig.runtime)
|
||||
: require('jest-runtime')
|
||||
).default;
|
||||
const consoleOut = globalConfig.useStderr ? process.stderr : process.stdout;
|
||||
const consoleFormatter = (type, message) =>
|
||||
(0, _console().getConsoleOutput)(
|
||||
// 4 = the console call is buried 4 stack frames deep
|
||||
_console().BufferedConsole.write([], type, message, 4),
|
||||
projectConfig,
|
||||
globalConfig
|
||||
);
|
||||
let testConsole;
|
||||
if (globalConfig.silent) {
|
||||
testConsole = new (_console().NullConsole)(
|
||||
consoleOut,
|
||||
consoleOut,
|
||||
consoleFormatter
|
||||
);
|
||||
} else if (globalConfig.verbose) {
|
||||
testConsole = new (_console().CustomConsole)(
|
||||
consoleOut,
|
||||
consoleOut,
|
||||
consoleFormatter
|
||||
);
|
||||
} else {
|
||||
testConsole = new (_console().BufferedConsole)();
|
||||
}
|
||||
let extraTestEnvironmentOptions;
|
||||
const docblockEnvironmentOptions =
|
||||
docblockPragmas['jest-environment-options'];
|
||||
if (typeof docblockEnvironmentOptions === 'string') {
|
||||
extraTestEnvironmentOptions = JSON.parse(docblockEnvironmentOptions);
|
||||
}
|
||||
const environment = new TestEnvironment(
|
||||
{
|
||||
globalConfig,
|
||||
projectConfig: extraTestEnvironmentOptions
|
||||
? {
|
||||
...projectConfig,
|
||||
testEnvironmentOptions: {
|
||||
...projectConfig.testEnvironmentOptions,
|
||||
...extraTestEnvironmentOptions
|
||||
}
|
||||
}
|
||||
: projectConfig
|
||||
},
|
||||
{
|
||||
console: testConsole,
|
||||
docblockPragmas,
|
||||
testPath: path
|
||||
}
|
||||
);
|
||||
if (typeof environment.getVmContext !== 'function') {
|
||||
console.error(
|
||||
`Test environment found at "${testEnvironment}" does not export a "getVmContext" method, which is mandatory from Jest 27. This method is a replacement for "runScript".`
|
||||
);
|
||||
process.exit(1);
|
||||
}
|
||||
const leakDetector = projectConfig.detectLeaks
|
||||
? new (_jestLeakDetector().default)(environment)
|
||||
: null;
|
||||
(0, _jestUtil().setGlobal)(environment.global, 'console', testConsole);
|
||||
const runtime = new Runtime(
|
||||
projectConfig,
|
||||
environment,
|
||||
resolver,
|
||||
transformer,
|
||||
cacheFS,
|
||||
{
|
||||
changedFiles: context.changedFiles,
|
||||
collectCoverage: globalConfig.collectCoverage,
|
||||
collectCoverageFrom: globalConfig.collectCoverageFrom,
|
||||
coverageProvider: globalConfig.coverageProvider,
|
||||
sourcesRelatedToTestsInChangedFiles:
|
||||
context.sourcesRelatedToTestsInChangedFiles
|
||||
},
|
||||
path,
|
||||
globalConfig
|
||||
);
|
||||
let isTornDown = false;
|
||||
const tearDownEnv = async () => {
|
||||
if (!isTornDown) {
|
||||
runtime.teardown();
|
||||
await environment.teardown();
|
||||
isTornDown = true;
|
||||
}
|
||||
};
|
||||
const start = Date.now();
|
||||
for (const path of projectConfig.setupFiles) {
|
||||
const esm = runtime.unstable_shouldLoadAsEsm(path);
|
||||
if (esm) {
|
||||
await runtime.unstable_importModule(path);
|
||||
} else {
|
||||
const setupFile = runtime.requireModule(path);
|
||||
if (typeof setupFile === 'function') {
|
||||
await setupFile();
|
||||
}
|
||||
}
|
||||
}
|
||||
const sourcemapOptions = {
|
||||
environment: 'node',
|
||||
handleUncaughtExceptions: false,
|
||||
retrieveSourceMap: source => {
|
||||
const sourceMapSource = runtime.getSourceMaps()?.get(source);
|
||||
if (sourceMapSource) {
|
||||
try {
|
||||
return {
|
||||
map: JSON.parse(fs().readFileSync(sourceMapSource, 'utf8')),
|
||||
url: source
|
||||
};
|
||||
} catch {}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
};
|
||||
|
||||
// For tests
|
||||
runtime
|
||||
.requireInternalModule(require.resolve('source-map-support'))
|
||||
.install(sourcemapOptions);
|
||||
|
||||
// For runtime errors
|
||||
_sourceMapSupport().default.install(sourcemapOptions);
|
||||
if (
|
||||
environment.global &&
|
||||
environment.global.process &&
|
||||
environment.global.process.exit
|
||||
) {
|
||||
const realExit = environment.global.process.exit;
|
||||
environment.global.process.exit = function exit(...args) {
|
||||
const error = new (_jestUtil().ErrorWithStack)(
|
||||
`process.exit called with "${args.join(', ')}"`,
|
||||
exit
|
||||
);
|
||||
const formattedError = (0, _jestMessageUtil().formatExecError)(
|
||||
error,
|
||||
projectConfig,
|
||||
{
|
||||
noStackTrace: false
|
||||
},
|
||||
undefined,
|
||||
true
|
||||
);
|
||||
process.stderr.write(formattedError);
|
||||
return realExit(...args);
|
||||
};
|
||||
}
|
||||
|
||||
// if we don't have `getVmContext` on the env skip coverage
|
||||
const collectV8Coverage =
|
||||
globalConfig.collectCoverage &&
|
||||
globalConfig.coverageProvider === 'v8' &&
|
||||
typeof environment.getVmContext === 'function';
|
||||
|
||||
// Node's error-message stack size is limited at 10, but it's pretty useful
|
||||
// to see more than that when a test fails.
|
||||
Error.stackTraceLimit = 100;
|
||||
try {
|
||||
await environment.setup();
|
||||
let result;
|
||||
try {
|
||||
if (collectV8Coverage) {
|
||||
await runtime.collectV8Coverage();
|
||||
}
|
||||
result = await testFramework(
|
||||
globalConfig,
|
||||
projectConfig,
|
||||
environment,
|
||||
runtime,
|
||||
path,
|
||||
sendMessageToJest
|
||||
);
|
||||
} catch (err) {
|
||||
// Access stack before uninstalling sourcemaps
|
||||
err.stack;
|
||||
throw err;
|
||||
} finally {
|
||||
if (collectV8Coverage) {
|
||||
await runtime.stopCollectingV8Coverage();
|
||||
}
|
||||
}
|
||||
freezeConsole(testConsole, projectConfig);
|
||||
const testCount =
|
||||
result.numPassingTests +
|
||||
result.numFailingTests +
|
||||
result.numPendingTests +
|
||||
result.numTodoTests;
|
||||
const end = Date.now();
|
||||
const testRuntime = end - start;
|
||||
result.perfStats = {
|
||||
end,
|
||||
runtime: testRuntime,
|
||||
slow: testRuntime / 1000 > projectConfig.slowTestThreshold,
|
||||
start
|
||||
};
|
||||
result.testFilePath = path;
|
||||
result.console = testConsole.getBuffer();
|
||||
result.skipped = testCount === result.numPendingTests;
|
||||
result.displayName = projectConfig.displayName;
|
||||
const coverage = runtime.getAllCoverageInfoCopy();
|
||||
if (coverage) {
|
||||
const coverageKeys = Object.keys(coverage);
|
||||
if (coverageKeys.length) {
|
||||
result.coverage = coverage;
|
||||
}
|
||||
}
|
||||
if (collectV8Coverage) {
|
||||
const v8Coverage = runtime.getAllV8CoverageInfoCopy();
|
||||
if (v8Coverage && v8Coverage.length > 0) {
|
||||
result.v8Coverage = v8Coverage;
|
||||
}
|
||||
}
|
||||
if (globalConfig.logHeapUsage) {
|
||||
// @ts-expect-error - doesn't exist on globalThis
|
||||
globalThis.gc?.();
|
||||
result.memoryUsage = process.memoryUsage().heapUsed;
|
||||
}
|
||||
await tearDownEnv();
|
||||
|
||||
// Delay the resolution to allow log messages to be output.
|
||||
return await new Promise(resolve => {
|
||||
setImmediate(() =>
|
||||
resolve({
|
||||
leakDetector,
|
||||
result
|
||||
})
|
||||
);
|
||||
});
|
||||
} finally {
|
||||
await tearDownEnv();
|
||||
_sourceMapSupport().default.resetRetrieveHandlers();
|
||||
}
|
||||
}
|
||||
async function runTest(
|
||||
path,
|
||||
globalConfig,
|
||||
config,
|
||||
resolver,
|
||||
context,
|
||||
sendMessageToJest
|
||||
) {
|
||||
const {leakDetector, result} = await runTestInternal(
|
||||
path,
|
||||
globalConfig,
|
||||
config,
|
||||
resolver,
|
||||
context,
|
||||
sendMessageToJest
|
||||
);
|
||||
if (leakDetector) {
|
||||
// We wanna allow a tiny but time to pass to allow last-minute cleanup
|
||||
await new Promise(resolve => setTimeout(resolve, 100));
|
||||
|
||||
// Resolve leak detector, outside the "runTestInternal" closure.
|
||||
result.leaks = await leakDetector.isLeaking();
|
||||
} else {
|
||||
result.leaks = false;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
Reference in New Issue
Block a user