From 5d309ff52cd399a6b71968a6b9a70c8ac0b98981 Mon Sep 17 00:00:00 2001 From: Joel Kronqvist Date: Sat, 5 Mar 2022 19:02:27 +0200 Subject: Added node_modules for the updating to work properly. --- .../legacy-code-todo-rewrite/jestAdapter.d.ts | 12 + .../build/legacy-code-todo-rewrite/jestAdapter.js | 123 +++++++++ .../legacy-code-todo-rewrite/jestAdapterInit.d.ts | 36 +++ .../legacy-code-todo-rewrite/jestAdapterInit.js | 299 +++++++++++++++++++++ .../build/legacy-code-todo-rewrite/jestExpect.d.ts | 10 + .../build/legacy-code-todo-rewrite/jestExpect.js | 37 +++ 6 files changed, 517 insertions(+) create mode 100644 node_modules/jest-circus/build/legacy-code-todo-rewrite/jestAdapter.d.ts create mode 100644 node_modules/jest-circus/build/legacy-code-todo-rewrite/jestAdapter.js create mode 100644 node_modules/jest-circus/build/legacy-code-todo-rewrite/jestAdapterInit.d.ts create mode 100644 node_modules/jest-circus/build/legacy-code-todo-rewrite/jestAdapterInit.js create mode 100644 node_modules/jest-circus/build/legacy-code-todo-rewrite/jestExpect.d.ts create mode 100644 node_modules/jest-circus/build/legacy-code-todo-rewrite/jestExpect.js (limited to 'node_modules/jest-circus/build/legacy-code-todo-rewrite') diff --git a/node_modules/jest-circus/build/legacy-code-todo-rewrite/jestAdapter.d.ts b/node_modules/jest-circus/build/legacy-code-todo-rewrite/jestAdapter.d.ts new file mode 100644 index 0000000..7aa430a --- /dev/null +++ b/node_modules/jest-circus/build/legacy-code-todo-rewrite/jestAdapter.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 { JestEnvironment } from '@jest/environment'; +import type { TestFileEvent, TestResult } from '@jest/test-result'; +import type { Config } from '@jest/types'; +import type Runtime from 'jest-runtime'; +declare const jestAdapter: (globalConfig: Config.GlobalConfig, config: Config.ProjectConfig, environment: JestEnvironment, runtime: Runtime, testPath: string, sendMessageToJest?: TestFileEvent<"test-file-start" | "test-file-success" | "test-file-failure" | "test-case-result"> | undefined) => Promise; +export = jestAdapter; diff --git a/node_modules/jest-circus/build/legacy-code-todo-rewrite/jestAdapter.js b/node_modules/jest-circus/build/legacy-code-todo-rewrite/jestAdapter.js new file mode 100644 index 0000000..1c36d4e --- /dev/null +++ b/node_modules/jest-circus/build/legacy-code-todo-rewrite/jestAdapter.js @@ -0,0 +1,123 @@ +'use strict'; + +var _jestUtil = require('jest-util'); + +/** + * 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 FRAMEWORK_INITIALIZER = require.resolve('./jestAdapterInit'); + +const jestAdapter = async ( + globalConfig, + config, + environment, + runtime, + testPath, + sendMessageToJest +) => { + const {initialize, runAndTransformResultsToJestFormat} = + runtime.requireInternalModule(FRAMEWORK_INITIALIZER); + const {globals, snapshotState} = await initialize({ + config, + environment, + globalConfig, + localRequire: runtime.requireModule.bind(runtime), + parentProcess: process, + sendMessageToJest, + setGlobalsForRuntime: runtime.setGlobalsForRuntime.bind(runtime), + testPath + }); + + if (config.timers === 'fake' || config.timers === 'modern') { + // during setup, this cannot be null (and it's fine to explode if it is) + environment.fakeTimersModern.useFakeTimers(); + } else if (config.timers === 'legacy') { + environment.fakeTimers.useFakeTimers(); + } + + globals.beforeEach(() => { + if (config.resetModules) { + runtime.resetModules(); + } + + if (config.clearMocks) { + runtime.clearAllMocks(); + } + + if (config.resetMocks) { + runtime.resetAllMocks(); + + if (config.timers === 'legacy') { + // during setup, this cannot be null (and it's fine to explode if it is) + environment.fakeTimers.useFakeTimers(); + } + } + + if (config.restoreMocks) { + runtime.restoreAllMocks(); + } + }); + + for (const path of config.setupFilesAfterEnv) { + const esm = runtime.unstable_shouldLoadAsEsm(path); + + if (esm) { + await runtime.unstable_importModule(path); + } else { + runtime.requireModule(path); + } + } + + const esm = runtime.unstable_shouldLoadAsEsm(testPath); + + if (esm) { + await runtime.unstable_importModule(testPath); + } else { + runtime.requireModule(testPath); + } + + const results = await runAndTransformResultsToJestFormat({ + config, + globalConfig, + testPath + }); + + _addSnapshotData(results, snapshotState); // We need to copy the results object to ensure we don't leaks the prototypes + // from the VM. Jasmine creates the result objects in the parent process, we + // should consider doing that for circus as well. + + return (0, _jestUtil.deepCyclicCopy)(results, { + keepPrototype: false + }); +}; + +const _addSnapshotData = (results, snapshotState) => { + results.testResults.forEach(({fullName, status}) => { + if (status === 'pending' || status === 'failed') { + // if test is skipped or failed, we don't want to mark + // its snapshots as obsolete. + snapshotState.markSnapshotsAsCheckedForTest(fullName); + } + }); + const uncheckedCount = snapshotState.getUncheckedCount(); + const uncheckedKeys = snapshotState.getUncheckedKeys(); + + if (uncheckedCount) { + snapshotState.removeUncheckedKeys(); + } + + const status = snapshotState.save(); + results.snapshot.fileDeleted = status.deleted; + results.snapshot.added = snapshotState.added; + results.snapshot.matched = snapshotState.matched; + results.snapshot.unmatched = snapshotState.unmatched; + results.snapshot.updated = snapshotState.updated; + results.snapshot.unchecked = !status.deleted ? uncheckedCount : 0; // Copy the array to prevent memory leaks + + results.snapshot.uncheckedKeys = Array.from(uncheckedKeys); +}; + +module.exports = jestAdapter; diff --git a/node_modules/jest-circus/build/legacy-code-todo-rewrite/jestAdapterInit.d.ts b/node_modules/jest-circus/build/legacy-code-todo-rewrite/jestAdapterInit.d.ts new file mode 100644 index 0000000..b09ec31 --- /dev/null +++ b/node_modules/jest-circus/build/legacy-code-todo-rewrite/jestAdapterInit.d.ts @@ -0,0 +1,36 @@ +/** + * 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 { JestEnvironment } from '@jest/environment'; +import { TestFileEvent, TestResult } from '@jest/test-result'; +import type { Config, Global } from '@jest/types'; +import { SnapshotStateType } from 'jest-snapshot'; +import globals from '..'; +import { Expect } from './jestExpect'; +declare type Process = NodeJS.Process; +interface JestGlobals extends Global.TestFrameworkGlobals { + expect: Expect; +} +export declare const initialize: ({ config, environment, globalConfig, localRequire, parentProcess, sendMessageToJest, setGlobalsForRuntime, testPath, }: { + config: Config.ProjectConfig; + environment: JestEnvironment; + globalConfig: Config.GlobalConfig; + localRequire: (path: Config.Path) => T; + testPath: Config.Path; + parentProcess: Process; + sendMessageToJest?: TestFileEvent<"test-file-start" | "test-file-success" | "test-file-failure" | "test-case-result"> | undefined; + setGlobalsForRuntime: (globals: JestGlobals) => void; +}) => Promise<{ + globals: Global.TestFrameworkGlobals; + snapshotState: SnapshotStateType; +}>; +export declare const runAndTransformResultsToJestFormat: ({ config, globalConfig, testPath, }: { + config: Config.ProjectConfig; + globalConfig: Config.GlobalConfig; + testPath: string; +}) => Promise; +export {}; diff --git a/node_modules/jest-circus/build/legacy-code-todo-rewrite/jestAdapterInit.js b/node_modules/jest-circus/build/legacy-code-todo-rewrite/jestAdapterInit.js new file mode 100644 index 0000000..7059ad2 --- /dev/null +++ b/node_modules/jest-circus/build/legacy-code-todo-rewrite/jestAdapterInit.js @@ -0,0 +1,299 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.runAndTransformResultsToJestFormat = exports.initialize = void 0; + +var _throat = _interopRequireDefault(require('throat')); + +var _testResult = require('@jest/test-result'); + +var _expect = require('expect'); + +var _jestEach = require('jest-each'); + +var _jestMessageUtil = require('jest-message-util'); + +var _jestSnapshot = require('jest-snapshot'); + +var _ = _interopRequireDefault(require('..')); + +var _run = _interopRequireDefault(require('../run')); + +var _state = require('../state'); + +var _testCaseReportHandler = _interopRequireDefault( + require('../testCaseReportHandler') +); + +var _utils = require('../utils'); + +var _jestExpect = _interopRequireDefault(require('./jestExpect')); + +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 initialize = async ({ + config, + environment, + globalConfig, + localRequire, + parentProcess, + sendMessageToJest, + setGlobalsForRuntime, + testPath +}) => { + if (globalConfig.testTimeout) { + (0, _state.getState)().testTimeout = globalConfig.testTimeout; + } + + const mutex = (0, _throat.default)(globalConfig.maxConcurrency); // @ts-expect-error + + const globalsObject = { + ..._.default, + fdescribe: _.default.describe.only, + fit: _.default.it.only, + xdescribe: _.default.describe.skip, + xit: _.default.it.skip, + xtest: _.default.it.skip + }; + + globalsObject.test.concurrent = (test => { + const concurrent = (testName, testFn, timeout) => { + // For concurrent tests we first run the function that returns promise, and then register a + // normal test that will be waiting on the returned promise (when we start the test, the promise + // will already be in the process of execution). + // Unfortunately at this stage there's no way to know if there are any `.only` tests in the suite + // that will result in this test to be skipped, so we'll be executing the promise function anyway, + // even if it ends up being skipped. + const promise = mutex(() => testFn()); // Avoid triggering the uncaught promise rejection handler in case the test errors before + // being awaited on. + + promise.catch(() => {}); + globalsObject.test(testName, () => promise, timeout); + }; + + const only = (testName, testFn, timeout) => { + const promise = mutex(() => testFn()); // eslint-disable-next-line jest/no-focused-tests + + test.only(testName, () => promise, timeout); + }; + + concurrent.only = only; + concurrent.skip = test.skip; + concurrent.each = (0, _jestEach.bind)(test, false); + concurrent.skip.each = (0, _jestEach.bind)(test.skip, false); + only.each = (0, _jestEach.bind)(test.only, false); + return concurrent; + })(globalsObject.test); + + (0, _state.addEventHandler)(eventHandler); + + if (environment.handleTestEvent) { + (0, _state.addEventHandler)(environment.handleTestEvent.bind(environment)); + } + + const runtimeGlobals = { + ...globalsObject, + expect: (0, _jestExpect.default)(globalConfig) + }; + setGlobalsForRuntime(runtimeGlobals); + + if (config.injectGlobals) { + Object.assign(environment.global, runtimeGlobals); + } + + await (0, _state.dispatch)({ + name: 'setup', + parentProcess, + runtimeGlobals, + testNamePattern: globalConfig.testNamePattern + }); + + if (config.testLocationInResults) { + await (0, _state.dispatch)({ + name: 'include_test_location_in_result' + }); + } // Jest tests snapshotSerializers in order preceding built-in serializers. + // Therefore, add in reverse because the last added is the first tested. + + config.snapshotSerializers + .concat() + .reverse() + .forEach(path => (0, _jestSnapshot.addSerializer)(localRequire(path))); + const {expand, updateSnapshot} = globalConfig; + const snapshotResolver = await (0, _jestSnapshot.buildSnapshotResolver)( + config, + localRequire + ); + const snapshotPath = snapshotResolver.resolveSnapshotPath(testPath); + const snapshotState = new _jestSnapshot.SnapshotState(snapshotPath, { + expand, + prettierPath: config.prettierPath, + snapshotFormat: config.snapshotFormat, + updateSnapshot + }); // @ts-expect-error: snapshotState is a jest extension of `expect` + + (0, _expect.setState)({ + snapshotState, + testPath + }); + (0, _state.addEventHandler)(handleSnapshotStateAfterRetry(snapshotState)); + + if (sendMessageToJest) { + (0, _state.addEventHandler)( + (0, _testCaseReportHandler.default)(testPath, sendMessageToJest) + ); + } // Return it back to the outer scope (test runner outside the VM). + + return { + globals: globalsObject, + snapshotState + }; +}; + +exports.initialize = initialize; + +const runAndTransformResultsToJestFormat = async ({ + config, + globalConfig, + testPath +}) => { + const runResult = await (0, _run.default)(); + let numFailingTests = 0; + let numPassingTests = 0; + let numPendingTests = 0; + let numTodoTests = 0; + const assertionResults = runResult.testResults.map(testResult => { + let status; + + if (testResult.status === 'skip') { + status = 'pending'; + numPendingTests += 1; + } else if (testResult.status === 'todo') { + status = 'todo'; + numTodoTests += 1; + } else if (testResult.errors.length) { + status = 'failed'; + numFailingTests += 1; + } else { + status = 'passed'; + numPassingTests += 1; + } + + const ancestorTitles = testResult.testPath.filter( + name => name !== _state.ROOT_DESCRIBE_BLOCK_NAME + ); + const title = ancestorTitles.pop(); + return { + ancestorTitles, + duration: testResult.duration, + failureDetails: testResult.errorsDetailed, + failureMessages: testResult.errors, + fullName: title + ? ancestorTitles.concat(title).join(' ') + : ancestorTitles.join(' '), + invocations: testResult.invocations, + location: testResult.location, + numPassingAsserts: 0, + status, + title: testResult.testPath[testResult.testPath.length - 1] + }; + }); + let failureMessage = (0, _jestMessageUtil.formatResultsErrors)( + assertionResults, + config, + globalConfig, + testPath + ); + let testExecError; + + if (runResult.unhandledErrors.length) { + testExecError = { + message: '', + stack: runResult.unhandledErrors.join('\n') + }; + failureMessage = + (failureMessage || '') + + '\n\n' + + runResult.unhandledErrors + .map(err => + (0, _jestMessageUtil.formatExecError)(err, config, globalConfig) + ) + .join('\n'); + } + + await (0, _state.dispatch)({ + name: 'teardown' + }); + return { + ...(0, _testResult.createEmptyTestResult)(), + console: undefined, + displayName: config.displayName, + failureMessage, + numFailingTests, + numPassingTests, + numPendingTests, + numTodoTests, + testExecError, + testFilePath: testPath, + testResults: assertionResults + }; +}; + +exports.runAndTransformResultsToJestFormat = runAndTransformResultsToJestFormat; + +const handleSnapshotStateAfterRetry = snapshotState => event => { + switch (event.name) { + case 'test_retry': { + // Clear any snapshot data that occurred in previous test run + snapshotState.clear(); + } + } +}; + +const eventHandler = async event => { + switch (event.name) { + case 'test_start': { + (0, _expect.setState)({ + currentTestName: (0, _utils.getTestID)(event.test) + }); + break; + } + + case 'test_done': { + _addSuppressedErrors(event.test); + + _addExpectedAssertionErrors(event.test); + + break; + } + } +}; + +const _addExpectedAssertionErrors = test => { + const failures = (0, _expect.extractExpectedAssertionsErrors)(); + const errors = failures.map(failure => failure.error); + test.errors = test.errors.concat(errors); +}; // Get suppressed errors from ``jest-matchers`` that weren't throw during +// test execution and add them to the test result, potentially failing +// a passing test. + +const _addSuppressedErrors = test => { + const {suppressedErrors} = (0, _expect.getState)(); + (0, _expect.setState)({ + suppressedErrors: [] + }); + + if (suppressedErrors.length) { + test.errors = test.errors.concat(suppressedErrors); + } +}; diff --git a/node_modules/jest-circus/build/legacy-code-todo-rewrite/jestExpect.d.ts b/node_modules/jest-circus/build/legacy-code-todo-rewrite/jestExpect.d.ts new file mode 100644 index 0000000..8902dc0 --- /dev/null +++ b/node_modules/jest-circus/build/legacy-code-todo-rewrite/jestExpect.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 expect = require('expect'); +export declare type Expect = typeof expect; +export default function jestExpect(config: Pick): Expect; diff --git a/node_modules/jest-circus/build/legacy-code-todo-rewrite/jestExpect.js b/node_modules/jest-circus/build/legacy-code-todo-rewrite/jestExpect.js new file mode 100644 index 0000000..d361766 --- /dev/null +++ b/node_modules/jest-circus/build/legacy-code-todo-rewrite/jestExpect.js @@ -0,0 +1,37 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = jestExpect; + +var _expect = _interopRequireDefault(require('expect')); + +var _jestSnapshot = require('jest-snapshot'); + +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 jestExpect(config) { + _expect.default.setState({ + expand: config.expand + }); + + _expect.default.extend({ + toMatchInlineSnapshot: _jestSnapshot.toMatchInlineSnapshot, + toMatchSnapshot: _jestSnapshot.toMatchSnapshot, + toThrowErrorMatchingInlineSnapshot: + _jestSnapshot.toThrowErrorMatchingInlineSnapshot, + toThrowErrorMatchingSnapshot: _jestSnapshot.toThrowErrorMatchingSnapshot + }); + + _expect.default.addSnapshotSerializer = _jestSnapshot.addSerializer; + return _expect.default; +} -- cgit v1.2.3