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
281
unified-ai-platform/node_modules/jest-circus/build/eventHandler.js
generated
vendored
Normal file
281
unified-ai-platform/node_modules/jest-circus/build/eventHandler.js
generated
vendored
Normal file
@@ -0,0 +1,281 @@
|
||||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', {
|
||||
value: true
|
||||
});
|
||||
exports.default = void 0;
|
||||
var _jestUtil = require('jest-util');
|
||||
var _globalErrorHandlers = require('./globalErrorHandlers');
|
||||
var _types = require('./types');
|
||||
var _utils = require('./utils');
|
||||
var Symbol = globalThis['jest-symbol-do-not-touch'] || globalThis.Symbol;
|
||||
var Symbol = globalThis['jest-symbol-do-not-touch'] || globalThis.Symbol;
|
||||
var jestNow = globalThis[Symbol.for('jest-native-now')] || globalThis.Date.now;
|
||||
/**
|
||||
* 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.
|
||||
*/
|
||||
const eventHandler = (event, state) => {
|
||||
switch (event.name) {
|
||||
case 'include_test_location_in_result': {
|
||||
state.includeTestLocationInResult = true;
|
||||
break;
|
||||
}
|
||||
case 'hook_start': {
|
||||
event.hook.seenDone = false;
|
||||
break;
|
||||
}
|
||||
case 'start_describe_definition': {
|
||||
const {blockName, mode} = event;
|
||||
const {currentDescribeBlock, currentlyRunningTest} = state;
|
||||
if (currentlyRunningTest) {
|
||||
currentlyRunningTest.errors.push(
|
||||
new Error(
|
||||
`Cannot nest a describe inside a test. Describe block "${blockName}" cannot run because it is nested within "${currentlyRunningTest.name}".`
|
||||
)
|
||||
);
|
||||
break;
|
||||
}
|
||||
const describeBlock = (0, _utils.makeDescribe)(
|
||||
blockName,
|
||||
currentDescribeBlock,
|
||||
mode
|
||||
);
|
||||
currentDescribeBlock.children.push(describeBlock);
|
||||
state.currentDescribeBlock = describeBlock;
|
||||
break;
|
||||
}
|
||||
case 'finish_describe_definition': {
|
||||
const {currentDescribeBlock} = state;
|
||||
(0, _jestUtil.invariant)(
|
||||
currentDescribeBlock,
|
||||
'currentDescribeBlock must be there'
|
||||
);
|
||||
if (!(0, _utils.describeBlockHasTests)(currentDescribeBlock)) {
|
||||
currentDescribeBlock.hooks.forEach(hook => {
|
||||
hook.asyncError.message = `Invalid: ${hook.type}() may not be used in a describe block containing no tests.`;
|
||||
state.unhandledErrors.push(hook.asyncError);
|
||||
});
|
||||
}
|
||||
|
||||
// pass mode of currentDescribeBlock to tests
|
||||
// but do not when there is already a single test with "only" mode
|
||||
const shouldPassMode = !(
|
||||
currentDescribeBlock.mode === 'only' &&
|
||||
currentDescribeBlock.children.some(
|
||||
child => child.type === 'test' && child.mode === 'only'
|
||||
)
|
||||
);
|
||||
if (shouldPassMode) {
|
||||
currentDescribeBlock.children.forEach(child => {
|
||||
if (child.type === 'test' && !child.mode) {
|
||||
child.mode = currentDescribeBlock.mode;
|
||||
}
|
||||
});
|
||||
}
|
||||
if (
|
||||
!state.hasFocusedTests &&
|
||||
currentDescribeBlock.mode !== 'skip' &&
|
||||
currentDescribeBlock.children.some(
|
||||
child => child.type === 'test' && child.mode === 'only'
|
||||
)
|
||||
) {
|
||||
state.hasFocusedTests = true;
|
||||
}
|
||||
if (currentDescribeBlock.parent) {
|
||||
state.currentDescribeBlock = currentDescribeBlock.parent;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 'add_hook': {
|
||||
const {currentDescribeBlock, currentlyRunningTest, hasStarted} = state;
|
||||
const {asyncError, fn, hookType: type, timeout} = event;
|
||||
if (currentlyRunningTest) {
|
||||
currentlyRunningTest.errors.push(
|
||||
new Error(
|
||||
`Hooks cannot be defined inside tests. Hook of type "${type}" is nested within "${currentlyRunningTest.name}".`
|
||||
)
|
||||
);
|
||||
break;
|
||||
} else if (hasStarted) {
|
||||
state.unhandledErrors.push(
|
||||
new Error(
|
||||
'Cannot add a hook after tests have started running. Hooks must be defined synchronously.'
|
||||
)
|
||||
);
|
||||
break;
|
||||
}
|
||||
const parent = currentDescribeBlock;
|
||||
currentDescribeBlock.hooks.push({
|
||||
asyncError,
|
||||
fn,
|
||||
parent,
|
||||
seenDone: false,
|
||||
timeout,
|
||||
type
|
||||
});
|
||||
break;
|
||||
}
|
||||
case 'add_test': {
|
||||
const {currentDescribeBlock, currentlyRunningTest, hasStarted} = state;
|
||||
const {
|
||||
asyncError,
|
||||
fn,
|
||||
mode,
|
||||
testName: name,
|
||||
timeout,
|
||||
concurrent,
|
||||
failing
|
||||
} = event;
|
||||
if (currentlyRunningTest) {
|
||||
currentlyRunningTest.errors.push(
|
||||
new Error(
|
||||
`Tests cannot be nested. Test "${name}" cannot run because it is nested within "${currentlyRunningTest.name}".`
|
||||
)
|
||||
);
|
||||
break;
|
||||
} else if (hasStarted) {
|
||||
state.unhandledErrors.push(
|
||||
new Error(
|
||||
'Cannot add a test after tests have started running. Tests must be defined synchronously.'
|
||||
)
|
||||
);
|
||||
break;
|
||||
}
|
||||
const test = (0, _utils.makeTest)(
|
||||
fn,
|
||||
mode,
|
||||
concurrent,
|
||||
name,
|
||||
currentDescribeBlock,
|
||||
timeout,
|
||||
asyncError,
|
||||
failing
|
||||
);
|
||||
if (currentDescribeBlock.mode !== 'skip' && test.mode === 'only') {
|
||||
state.hasFocusedTests = true;
|
||||
}
|
||||
currentDescribeBlock.children.push(test);
|
||||
currentDescribeBlock.tests.push(test);
|
||||
break;
|
||||
}
|
||||
case 'hook_failure': {
|
||||
const {test, describeBlock, error, hook} = event;
|
||||
const {asyncError, type} = hook;
|
||||
if (type === 'beforeAll') {
|
||||
(0, _jestUtil.invariant)(
|
||||
describeBlock,
|
||||
'always present for `*All` hooks'
|
||||
);
|
||||
(0, _utils.addErrorToEachTestUnderDescribe)(
|
||||
describeBlock,
|
||||
error,
|
||||
asyncError
|
||||
);
|
||||
} else if (type === 'afterAll') {
|
||||
// Attaching `afterAll` errors to each test makes execution flow
|
||||
// too complicated, so we'll consider them to be global.
|
||||
state.unhandledErrors.push([error, asyncError]);
|
||||
} else {
|
||||
(0, _jestUtil.invariant)(test, 'always present for `*Each` hooks');
|
||||
test.errors.push([error, asyncError]);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 'test_skip': {
|
||||
event.test.status = 'skip';
|
||||
break;
|
||||
}
|
||||
case 'test_todo': {
|
||||
event.test.status = 'todo';
|
||||
break;
|
||||
}
|
||||
case 'test_done': {
|
||||
event.test.duration = (0, _utils.getTestDuration)(event.test);
|
||||
event.test.status = 'done';
|
||||
state.currentlyRunningTest = null;
|
||||
break;
|
||||
}
|
||||
case 'test_start': {
|
||||
state.currentlyRunningTest = event.test;
|
||||
event.test.startedAt = jestNow();
|
||||
event.test.invocations += 1;
|
||||
break;
|
||||
}
|
||||
case 'test_fn_start': {
|
||||
event.test.seenDone = false;
|
||||
break;
|
||||
}
|
||||
case 'test_fn_failure': {
|
||||
const {
|
||||
error,
|
||||
test: {asyncError}
|
||||
} = event;
|
||||
event.test.errors.push([error, asyncError]);
|
||||
break;
|
||||
}
|
||||
case 'test_retry': {
|
||||
const logErrorsBeforeRetry =
|
||||
// eslint-disable-next-line no-restricted-globals
|
||||
global[_types.LOG_ERRORS_BEFORE_RETRY] || false;
|
||||
if (logErrorsBeforeRetry) {
|
||||
event.test.retryReasons.push(...event.test.errors);
|
||||
}
|
||||
event.test.errors = [];
|
||||
break;
|
||||
}
|
||||
case 'run_start': {
|
||||
state.hasStarted = true;
|
||||
/* eslint-disable no-restricted-globals */
|
||||
global[_types.TEST_TIMEOUT_SYMBOL] &&
|
||||
(state.testTimeout = global[_types.TEST_TIMEOUT_SYMBOL]);
|
||||
/* eslint-enable */
|
||||
break;
|
||||
}
|
||||
case 'run_finish': {
|
||||
break;
|
||||
}
|
||||
case 'setup': {
|
||||
// Uncaught exception handlers should be defined on the parent process
|
||||
// object. If defined on the VM's process object they just no op and let
|
||||
// the parent process crash. It might make sense to return a `dispatch`
|
||||
// function to the parent process and register handlers there instead, but
|
||||
// i'm not sure if this is works. For now i just replicated whatever
|
||||
// jasmine was doing -- dabramov
|
||||
state.parentProcess = event.parentProcess;
|
||||
(0, _jestUtil.invariant)(state.parentProcess);
|
||||
state.originalGlobalErrorHandlers = (0,
|
||||
_globalErrorHandlers.injectGlobalErrorHandlers)(state.parentProcess);
|
||||
if (event.testNamePattern) {
|
||||
state.testNamePattern = new RegExp(event.testNamePattern, 'i');
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 'teardown': {
|
||||
(0, _jestUtil.invariant)(state.originalGlobalErrorHandlers);
|
||||
(0, _jestUtil.invariant)(state.parentProcess);
|
||||
(0, _globalErrorHandlers.restoreGlobalErrorHandlers)(
|
||||
state.parentProcess,
|
||||
state.originalGlobalErrorHandlers
|
||||
);
|
||||
break;
|
||||
}
|
||||
case 'error': {
|
||||
// It's very likely for long-running async tests to throw errors. In this
|
||||
// case we want to catch them and fail the current test. At the same time
|
||||
// there's a possibility that one test sets a long timeout, that will
|
||||
// eventually throw after this test finishes but during some other test
|
||||
// execution, which will result in one test's error failing another test.
|
||||
// In any way, it should be possible to track where the error was thrown
|
||||
// from.
|
||||
state.currentlyRunningTest
|
||||
? state.currentlyRunningTest.errors.push(event.error)
|
||||
: state.unhandledErrors.push(event.error);
|
||||
break;
|
||||
}
|
||||
}
|
||||
};
|
||||
var _default = eventHandler;
|
||||
exports.default = _default;
|
||||
186
unified-ai-platform/node_modules/jest-circus/build/formatNodeAssertErrors.js
generated
vendored
Normal file
186
unified-ai-platform/node_modules/jest-circus/build/formatNodeAssertErrors.js
generated
vendored
Normal file
@@ -0,0 +1,186 @@
|
||||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', {
|
||||
value: true
|
||||
});
|
||||
exports.default = void 0;
|
||||
var _assert = require('assert');
|
||||
var _chalk = _interopRequireDefault(require('chalk'));
|
||||
var _jestMatcherUtils = require('jest-matcher-utils');
|
||||
var _prettyFormat = require('pretty-format');
|
||||
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.
|
||||
*/
|
||||
|
||||
const assertOperatorsMap = {
|
||||
'!=': 'notEqual',
|
||||
'!==': 'notStrictEqual',
|
||||
'==': 'equal',
|
||||
'===': 'strictEqual'
|
||||
};
|
||||
const humanReadableOperators = {
|
||||
deepEqual: 'to deeply equal',
|
||||
deepStrictEqual: 'to deeply and strictly equal',
|
||||
equal: 'to be equal',
|
||||
notDeepEqual: 'not to deeply equal',
|
||||
notDeepStrictEqual: 'not to deeply and strictly equal',
|
||||
notEqual: 'to not be equal',
|
||||
notStrictEqual: 'not be strictly equal',
|
||||
strictEqual: 'to strictly be equal'
|
||||
};
|
||||
const formatNodeAssertErrors = (event, state) => {
|
||||
if (event.name === 'test_done') {
|
||||
event.test.errors = event.test.errors.map(errors => {
|
||||
let error;
|
||||
if (Array.isArray(errors)) {
|
||||
const [originalError, asyncError] = errors;
|
||||
if (originalError == null) {
|
||||
error = asyncError;
|
||||
} else if (!originalError.stack) {
|
||||
error = asyncError;
|
||||
error.message = originalError.message
|
||||
? originalError.message
|
||||
: `thrown: ${(0, _prettyFormat.format)(originalError, {
|
||||
maxDepth: 3
|
||||
})}`;
|
||||
} else {
|
||||
error = originalError;
|
||||
}
|
||||
} else {
|
||||
error = errors;
|
||||
}
|
||||
return isAssertionError(error)
|
||||
? {
|
||||
message: assertionErrorMessage(error, {
|
||||
expand: state.expand
|
||||
})
|
||||
}
|
||||
: errors;
|
||||
});
|
||||
}
|
||||
};
|
||||
const getOperatorName = (operator, stack) => {
|
||||
if (typeof operator === 'string') {
|
||||
return assertOperatorsMap[operator] || operator;
|
||||
}
|
||||
if (stack.match('.doesNotThrow')) {
|
||||
return 'doesNotThrow';
|
||||
}
|
||||
if (stack.match('.throws')) {
|
||||
return 'throws';
|
||||
}
|
||||
return '';
|
||||
};
|
||||
const operatorMessage = operator => {
|
||||
const niceOperatorName = getOperatorName(operator, '');
|
||||
const humanReadableOperator = humanReadableOperators[niceOperatorName];
|
||||
return typeof operator === 'string'
|
||||
? `${humanReadableOperator || niceOperatorName} to:\n`
|
||||
: '';
|
||||
};
|
||||
const assertThrowingMatcherHint = operatorName =>
|
||||
operatorName
|
||||
? _chalk.default.dim('assert') +
|
||||
_chalk.default.dim(`.${operatorName}(`) +
|
||||
_chalk.default.red('function') +
|
||||
_chalk.default.dim(')')
|
||||
: '';
|
||||
const assertMatcherHint = (operator, operatorName, expected) => {
|
||||
let message = '';
|
||||
if (operator === '==' && expected === true) {
|
||||
message =
|
||||
_chalk.default.dim('assert') +
|
||||
_chalk.default.dim('(') +
|
||||
_chalk.default.red('received') +
|
||||
_chalk.default.dim(')');
|
||||
} else if (operatorName) {
|
||||
message =
|
||||
_chalk.default.dim('assert') +
|
||||
_chalk.default.dim(`.${operatorName}(`) +
|
||||
_chalk.default.red('received') +
|
||||
_chalk.default.dim(', ') +
|
||||
_chalk.default.green('expected') +
|
||||
_chalk.default.dim(')');
|
||||
}
|
||||
return message;
|
||||
};
|
||||
function assertionErrorMessage(error, options) {
|
||||
const {expected, actual, generatedMessage, message, operator, stack} = error;
|
||||
const diffString = (0, _jestMatcherUtils.diff)(expected, actual, options);
|
||||
const hasCustomMessage = !generatedMessage;
|
||||
const operatorName = getOperatorName(operator, stack);
|
||||
const trimmedStack = stack
|
||||
.replace(message, '')
|
||||
.replace(/AssertionError(.*)/g, '');
|
||||
if (operatorName === 'doesNotThrow') {
|
||||
return (
|
||||
// eslint-disable-next-line prefer-template
|
||||
buildHintString(assertThrowingMatcherHint(operatorName)) +
|
||||
_chalk.default.reset('Expected the function not to throw an error.\n') +
|
||||
_chalk.default.reset('Instead, it threw:\n') +
|
||||
` ${(0, _jestMatcherUtils.printReceived)(actual)}` +
|
||||
_chalk.default.reset(
|
||||
hasCustomMessage ? `\n\nMessage:\n ${message}` : ''
|
||||
) +
|
||||
trimmedStack
|
||||
);
|
||||
}
|
||||
if (operatorName === 'throws') {
|
||||
if (error.generatedMessage) {
|
||||
return (
|
||||
buildHintString(assertThrowingMatcherHint(operatorName)) +
|
||||
_chalk.default.reset(error.message) +
|
||||
_chalk.default.reset(
|
||||
hasCustomMessage ? `\n\nMessage:\n ${message}` : ''
|
||||
) +
|
||||
trimmedStack
|
||||
);
|
||||
}
|
||||
return (
|
||||
buildHintString(assertThrowingMatcherHint(operatorName)) +
|
||||
_chalk.default.reset('Expected the function to throw an error.\n') +
|
||||
_chalk.default.reset("But it didn't throw anything.") +
|
||||
_chalk.default.reset(
|
||||
hasCustomMessage ? `\n\nMessage:\n ${message}` : ''
|
||||
) +
|
||||
trimmedStack
|
||||
);
|
||||
}
|
||||
if (operatorName === 'fail') {
|
||||
return (
|
||||
buildHintString(assertMatcherHint(operator, operatorName, expected)) +
|
||||
_chalk.default.reset(hasCustomMessage ? `Message:\n ${message}` : '') +
|
||||
trimmedStack
|
||||
);
|
||||
}
|
||||
return (
|
||||
// eslint-disable-next-line prefer-template
|
||||
buildHintString(assertMatcherHint(operator, operatorName, expected)) +
|
||||
_chalk.default.reset(`Expected value ${operatorMessage(operator)}`) +
|
||||
` ${(0, _jestMatcherUtils.printExpected)(expected)}\n` +
|
||||
_chalk.default.reset('Received:\n') +
|
||||
` ${(0, _jestMatcherUtils.printReceived)(actual)}` +
|
||||
_chalk.default.reset(hasCustomMessage ? `\n\nMessage:\n ${message}` : '') +
|
||||
(diffString ? `\n\nDifference:\n\n${diffString}` : '') +
|
||||
trimmedStack
|
||||
);
|
||||
}
|
||||
function isAssertionError(error) {
|
||||
return (
|
||||
error &&
|
||||
(error instanceof _assert.AssertionError ||
|
||||
error.name === _assert.AssertionError.name ||
|
||||
error.code === 'ERR_ASSERTION')
|
||||
);
|
||||
}
|
||||
function buildHintString(hint) {
|
||||
return hint ? `${hint}\n\n` : '';
|
||||
}
|
||||
var _default = formatNodeAssertErrors;
|
||||
exports.default = _default;
|
||||
0
unified-ai-platform/node_modules/jest-circus/build/globalErrorHandlers.js
generated
vendored
Normal file
0
unified-ai-platform/node_modules/jest-circus/build/globalErrorHandlers.js
generated
vendored
Normal file
Reference in New Issue
Block a user