@jest/environment

  • Version 27.0.3
  • Published
  • 11.9 kB
  • 4 dependencies
  • MIT license

Install

npm i @jest/environment
yarn add @jest/environment
pnpm add @jest/environment

Overview

Overview not available.

Index

Classes

class JestEnvironment

class JestEnvironment {}

    constructor

    constructor(config: any, context?: EnvironmentContext);

      property fakeTimers

      fakeTimers: any;

        property fakeTimersModern

        fakeTimersModern: any;

          property global

          global: any;

            property handleTestEvent

            handleTestEvent?: any;

              property moduleMocker

              moduleMocker: any;

                method getVmContext

                getVmContext: () => Context | null;

                  method setup

                  setup: () => Promise<void>;

                    method teardown

                    teardown: () => Promise<void>;

                      Interfaces

                      interface Jest

                      interface Jest {}

                        property fn

                        fn: typeof JestMockFn;
                        • Creates a mock function. Optionally takes a mock implementation.

                        property requireActual

                        requireActual: (moduleName: string) => unknown;
                        • Returns the actual module instead of a mock, bypassing all checks on whether the module should receive a mock implementation or not.

                          Example 1

                          ``` jest.mock('../myModule', () => { // Require the original module to not be mocked... const originalModule = jest.requireActual(moduleName); return { __esModule: true, // Use it when dealing with esModules ...originalModule, getRandom: jest.fn().mockReturnValue(10), }; });

                          const getRandom = require('../myModule').getRandom;

                          getRandom(); // Always returns 10 ```

                        property requireMock

                        requireMock: (moduleName: string) => unknown;
                        • Returns a mock module instead of the actual module, bypassing all checks on whether the module should be required normally or not.

                        property spyOn

                        spyOn: typeof JestMockSpyOn;
                        • Creates a mock function similar to jest.fn but also tracks calls to object[methodName].

                          Note: By default, jest.spyOn also calls the spied method. This is different behavior from most other test libraries.

                        method advanceTimersByTime

                        advanceTimersByTime: (msToRun: number) => void;
                        • Advances all timers by msToRun milliseconds. All pending "macro-tasks" that have been queued via setTimeout() or setInterval(), and would be executed within this timeframe will be executed.

                        method advanceTimersToNextTimer

                        advanceTimersToNextTimer: (steps?: number) => void;
                        • Advances all timers by the needed milliseconds so that only the next timeouts/intervals will run. Optionally, you can provide steps, so it will run steps amount of next timeouts/intervals.

                        method autoMockOff

                        autoMockOff: () => Jest;
                        • Disables automatic mocking in the module loader.

                        method autoMockOn

                        autoMockOn: () => Jest;
                        • Enables automatic mocking in the module loader.

                        method clearAllMocks

                        clearAllMocks: () => Jest;
                        • Clears the mock.calls and mock.instances properties of all mocks. Equivalent to calling .mockClear() on every mocked function.

                        method clearAllTimers

                        clearAllTimers: () => void;
                        • Removes any pending timers from the timer system. If any timers have been scheduled, they will be cleared and will never have the opportunity to execute in the future.

                        method createMockFromModule

                        createMockFromModule: (moduleName: string) => unknown;
                        • Given the name of a module, use the automatic mocking system to generate a mocked version of the module for you.

                          This is useful when you want to create a manual mock that extends the automatic mock's behavior.

                        method deepUnmock

                        deepUnmock: (moduleName: string) => Jest;
                        • Indicates that the module system should never return a mocked version of the specified module, including all of the specified module's dependencies.

                        method disableAutomock

                        disableAutomock: () => Jest;
                        • Disables automatic mocking in the module loader.

                          After this method is called, all require()s will return the real versions of each module (rather than a mocked version).

                        method doMock

                        doMock: (moduleName: string, moduleFactory?: () => unknown) => Jest;
                        • When using babel-jest, calls to mock will automatically be hoisted to the top of the code block. Use this method if you want to explicitly avoid this behavior.

                        method dontMock

                        dontMock: (moduleName: string) => Jest;
                        • Indicates that the module system should never return a mocked version of the specified module from require() (e.g. that it should always return the real module).

                        method enableAutomock

                        enableAutomock: () => Jest;
                        • Enables automatic mocking in the module loader.

                        method genMockFromModule

                        genMockFromModule: (moduleName: string) => unknown;
                        • Given the name of a module, use the automatic mocking system to generate a mocked version of the module for you.

                          This is useful when you want to create a manual mock that extends the automatic mock's behavior.

                          Deprecated

                          Use jest.createMockFromModule() instead

                        method getRealSystemTime

                        getRealSystemTime: () => number;
                        • When mocking time, Date.now() will also be mocked. If you for some reason need access to the real current time, you can invoke this function.

                          > Note: This function is only available when using Lolex as fake timers implementation

                        method getTimerCount

                        getTimerCount: () => number;
                        • Returns the number of fake timers still left to run.

                        method isMockFunction

                        isMockFunction: (fn: (...args: Array<any>) => unknown) => fn is any;
                        • Determines if the given function is a mocked function.

                        method isolateModules

                        isolateModules: (fn: () => void) => Jest;
                        • jest.isolateModules(fn) goes a step further than jest.resetModules() and creates a sandbox registry for the modules that are loaded inside the callback function. This is useful to isolate specific modules for every test so that local module state doesn't conflict between tests.

                        method mock

                        mock: (
                        moduleName: string,
                        moduleFactory?: () => unknown,
                        options?: { virtual?: boolean }
                        ) => Jest;
                        • Mocks a module with an auto-mocked version when it is being required.

                        method resetAllMocks

                        resetAllMocks: () => Jest;
                        • Resets the state of all mocks. Equivalent to calling .mockReset() on every mocked function.

                        method resetModules

                        resetModules: () => Jest;
                        • Resets the module registry - the cache of all required modules. This is useful to isolate modules where local state might conflict between tests.

                        method restoreAllMocks

                        restoreAllMocks: () => Jest;
                        • Restores all mocks back to their original value. Equivalent to calling .mockRestore on every mocked function.

                          Beware that jest.restoreAllMocks() only works when the mock was created with jest.spyOn; other mocks will require you to manually restore them.

                        method retryTimes

                        retryTimes: (numRetries: number) => Jest;
                        • Runs failed tests n-times until they pass or until the max number of retries is exhausted. This only works with jest-circus!

                        method runAllImmediates

                        runAllImmediates: () => void;
                        • Exhausts tasks queued by setImmediate().

                          > Note: This function is not available when using Lolex as fake timers implementation

                        method runAllTicks

                        runAllTicks: () => void;
                        • Exhausts the micro-task queue (usually interfaced in node via process.nextTick).

                        method runAllTimers

                        runAllTimers: () => void;
                        • Exhausts the macro-task queue (i.e., all tasks queued by setTimeout() and setInterval()).

                        method runOnlyPendingTimers

                        runOnlyPendingTimers: () => void;
                        • Executes only the macro-tasks that are currently pending (i.e., only the tasks that have been queued by setTimeout() or setInterval() up to this point). If any of the currently pending macro-tasks schedule new macro-tasks, those new tasks will not be executed by this call.

                        method setMock

                        setMock: (moduleName: string, moduleExports: unknown) => Jest;
                        • Explicitly supplies the mock object that the module system should return for the specified module.

                          Note It is recommended to use jest.mock() instead. The jest.mock API's second argument is a module factory instead of the expected exported module object.

                        method setSystemTime

                        setSystemTime: (now?: number | Date) => void;
                        • Set the current system time used by fake timers. Simulates a user changing the system clock while your program is running. It affects the current time but it does not in itself cause e.g. timers to fire; they will fire exactly as they would have done without the call to jest.setSystemTime().

                          > Note: This function is only available when using Lolex as fake timers implementation

                        method setTimeout

                        setTimeout: (timeout: number) => Jest;
                        • Set the default timeout interval for tests and before/after hooks in milliseconds.

                          Note: The default timeout interval is 5 seconds if this method is not called.

                        method unmock

                        unmock: (moduleName: string) => Jest;
                        • Indicates that the module system should never return a mocked version of the specified module from require() (e.g. that it should always return the real module).

                        method useFakeTimers

                        useFakeTimers: (implementation?: 'modern' | 'legacy') => Jest;
                        • Instructs Jest to use fake versions of the standard timer functions.

                        method useRealTimers

                        useRealTimers: () => Jest;
                        • Instructs Jest to use the real versions of the standard timer functions.

                        Type Aliases

                        type EnvironmentContext

                        type EnvironmentContext = {
                        console: Console;
                        docblockPragmas: Record<string, string | Array<string>>;
                        testPath: Config.Path;
                        };

                          type Module

                          type Module = NodeModule;

                            type ModuleWrapper

                            type ModuleWrapper = (
                            this: Module['exports'],
                            module: Module,
                            exports: Module['exports'],
                            require: Module['require'],
                            __dirname: string,
                            __filename: Module['filename'],
                            jest?: Jest,
                            ...extraGlobals: Array<Global.Global[keyof Global.Global]>
                            ) => unknown;

                              Package Files (1)

                              Dependencies (4)

                              Dev Dependencies (0)

                              No dev dependencies.

                              Peer Dependencies (0)

                              No peer dependencies.

                              Badge

                              To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                              You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@jest/environment.

                              • Markdown
                                [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@jest/environment)
                              • HTML
                                <a href="https://www.jsdocs.io/package/@jest/environment"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>