Jest

https://jestjs.io/docs/30.0
Admin
Jest is a JavaScript testing framework that provides a complete testing solution with built-in...
Tokens:209,298
Snippets:1,676
Trust Score:9.9
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Test using custom Puppeteer setup (test.js)

Source: https://jestjs.io/docs/30.0/puppeteer

Example test using the custom setup. It creates a new page from the global browser instance and checks the page content.

```javascript
const timeout = 5000;

describe(
  '/ (Home Page)',
  () => {
    let page;
    beforeAll(async () => {
      page = await globalThis.__BROWSER_GLOBAL__.newPage();
      await page.goto('https://google.com');
    }, timeout);

    it('should load without error', async () => {
      const text = await page.evaluate(() => document.body.textContent);
      expect(text).toContain('google');
    });
  },
  timeout,
);
```

--------------------------------

### globalSetup and globalTeardown modules (setup.js and teardown.js)

Source: https://jestjs.io/docs/30.0/configuration

Example `setup.js` and `teardown.js` modules for `globalSetup` and `globalTeardown`. The setup module logs config values and sets a global reference to a MongoDB server; the teardown module stops it. These modules are triggered once before/after all test files and receive `globalConfig` and `projectConfig`.

```JavaScript
module.exports = async function (globalConfig, projectConfig) {  
  console.log(globalConfig.testPathPatterns);  
  console.log(projectConfig.cache);  

  // Set reference to mongod in order to close the server during teardown.  
  globalThis.__MONGOD__ = mongod;  
};  

```

```JavaScript
module.exports = async function (globalConfig, projectConfig) {  
  console.log(globalConfig.testPathPatterns);  
  console.log(projectConfig.cache);  

  await globalThis.__MONGOD__.stop();  
};  

```

--------------------------------

### setup-jest.js: extend matchers and reset timers

Source: https://jestjs.io/docs/30.0/configuration

Setup file for setupFilesAfterEnv that extends Jest with jest-extended matchers and resets to real timers after each test. Runs after the test framework is installed, so Jest globals, jest, and expect are available.

```javascript
const matchers = require('jest-extended');  

expect.extend(matchers);  

  

afterEach(() => {  
  jest.useRealTimers();  
});  

```

--------------------------------

### Global setup script (setup.js)

Source: https://jestjs.io/docs/30.0/puppeteer

Global setup script that launches Puppeteer and stores the browser instance and WebSocket endpoint for later use.

```javascript
const {mkdir, writeFile} = require('fs').promises;
const os = require('os');
const path = require('path');
const puppeteer = require('puppeteer');

const DIR = path.join(os.tmpdir(), 'jest_puppeteer_global_setup');

module.exports = async function () {
  const browser = await puppeteer.launch();
  // store the browser instance so we can teardown it later
  // this global is only available in the teardown but not in TestEnvironments
  globalThis.__BROWSER_GLOBAL__ = browser;

  // use the file system to expose the wsEndpoint for TestEnvironments
  await mkdir(DIR, {recursive: true});
  await writeFile(path.join(DIR, 'wsEndpoint'), browser.wsEndpoint());
};
```

--------------------------------

### One-time async setup with beforeAll and afterAll

Source: https://jestjs.io/docs/30.0/setup-teardown

Uses beforeAll and afterAll to set up and tear down an asynchronous city database once for the entire file, then runs two tests that rely on that setup.

```javascript
beforeAll(() => {  
  return initializeCityDatabase();  
});  
  
afterAll(() => {  
  return clearCityDatabase();  
});  
  
test('city database has Vienna', () => {  
  expect(isCity('Vienna')).toBeTruthy();  
});  
  
test('city database has San Juan', () => {  
  expect(isCity('San Juan')).toBeTruthy();  
});  

```

--------------------------------

### Jest config: setupFilesAfterEnv with setup-jest.js

Source: https://jestjs.io/docs/30.0/configuration

Jest configuration (JavaScript and TypeScript variants) that registers setup-jest.js via setupFilesAfterEnv. The setup file runs after the test framework is installed and before test code.

```javascript
/** @type {import('jest').Config} */  
const config = {  
  setupFilesAfterEnv: ['<rootDir>/setup-jest.js'],  
};  
  
module.exports = config;  

```

```typescript
import type {Config} from 'jest';  
  
const config: Config = {  
  setupFilesAfterEnv: ['<rootDir>/setup-jest.js'],  
};  
  
export default config;  

```

--------------------------------

### Install @shelf/jest-dynamodb with npm, Yarn, pnpm, or Bun

Source: https://jestjs.io/docs/30.0/dynamodb

Install the @shelf/jest-dynamodb preset using your preferred package manager. Choose one command based on your environment.

```bash
npm install --save-dev @shelf/jest-dynamodb
```

```bash
yarn add --dev @shelf/jest-dynamodb
```

```bash
pnpm add --save-dev @shelf/jest-dynamodb
```

```bash
bun add --dev @shelf/jest-dynamodb
```

--------------------------------

### Install @shelf/jest-mongodb with npm, Yarn, pnpm, or Bun

Source: https://jestjs.io/docs/30.0/mongodb

Install the @shelf/jest-mongodb preset using your preferred package manager. These commands are alternatives; choose one based on your environment.

```bash
npm install --save-dev @shelf/jest-mongodb
```

```bash
yarn add --dev @shelf/jest-mongodb
```

```bash
pnpm add --save-dev @shelf/jest-mongodb
```

```bash
bun add --dev @shelf/jest-mongodb
```

--------------------------------

### CJS module example (main.cjs)

Source: https://jestjs.io/docs/30.0/ecmascript-modules

Example of a CommonJS module that exports an 'example' function, requiring Electron's BrowserWindow and app. Used as the module under test.

```javascript
const {BrowserWindow, app} = require('electron');  

  // etc.  

module.exports = {example};  
```

--------------------------------

### Repeating Setup with beforeEach and afterEach

Source: https://jestjs.io/docs/30.0/setup-teardown

Use beforeEach and afterEach to run setup and teardown for multiple tests. Here, initializeCityDatabase() runs before each test and clearCityDatabase() after each test, with two tests verifying city existence.

```javascript
beforeEach(() => {  
  initializeCityDatabase();  
});  
  
afterEach(() => {  
  clearCityDatabase();  
});  
  
test('city database has Vienna', () => {  
  expect(isCity('Vienna')).toBeTruthy();  
});  
  
test('city database has San Juan', () => {  
  expect(isCity('San Juan')).toBeTruthy();  
});  

```

--------------------------------

### Install ts-jest

Source: https://jestjs.io/docs/30.0/getting-started

Install ts-jest, a TypeScript preprocessor with source map support for Jest. Choose the command for your package manager.

```bash
npm install --save-dev ts-jest
```

```bash
yarn add --dev ts-jest
```

```bash
pnpm add --save-dev ts-jest
```

```bash
bun add --dev ts-jest
```

--------------------------------

### Install @testing-library/react with npm, Yarn, pnpm, or Bun

Source: https://jestjs.io/docs/30.0/tutorial-react

Install @testing-library/react as a dev dependency using npm, Yarn, pnpm, or Bun. Choose the command matching your package manager.

```bash
npm install --save-dev @testing-library/react
```

```bash
yarn add --dev @testing-library/react
```

```bash
pnpm add --save-dev @testing-library/react
```

```bash
bun add --dev @testing-library/react
```

--------------------------------

### Asynchronous Setup with beforeEach returning a promise

Source: https://jestjs.io/docs/30.0/setup-teardown

Return a promise from beforeEach to handle asynchronous setup. If initializeCityDatabase() returns a promise, returning it ensures Jest waits for it to resolve before running tests.

```javascript
beforeEach(() => {  
  return initializeCityDatabase();  
});  

```

--------------------------------

### testPathIgnorePatterns with <rootDir> example

Source: https://jestjs.io/docs/30.0/configuration

Example of testPathIgnorePatterns using the <rootDir> token to match against the full path, preventing accidental ignoring of files in different environments.

```json
["<rootDir>/build/", "<rootDir>/node_modules/"]
```

--------------------------------

### Install @testing-library/react-native and test-renderer

Source: https://jestjs.io/docs/30.0/tutorial-react-native

Install @testing-library/react-native and its peer dependency test-renderer. @testing-library/react-native replaces the deprecated react-test-renderer.

```bash
yarn add --dev @testing-library/react-native test-renderer
```

--------------------------------

### Install Jest with npm, Yarn, pnpm, or Bun

Source: https://jestjs.io/docs/30.0/getting-started

Install Jest as a dev dependency using your preferred package manager. Choose one of these commands based on your environment.

```bash
npm install --save-dev jest
```

```bash
yarn add --dev jest
```

```bash
pnpm add --save-dev jest
```

```bash
bun add --dev jest
```

--------------------------------

### Install @babel/preset-typescript

Source: https://jestjs.io/docs/30.0/getting-started

Install the Babel preset for TypeScript support in Jest. Choose the command for your package manager (npm, Yarn, pnpm, or Bun).

```bash
npm install --save-dev @babel/preset-typescript
```

```bash
yarn add --dev @babel/preset-typescript
```

```bash
pnpm add --save-dev @babel/preset-typescript
```

```bash
bun add --dev @babel/preset-typescript
```

--------------------------------

### Descriptive snapshot names example

Source: https://jestjs.io/docs/30.0/snapshot-testing

Example of descriptive snapshot names that clearly state the expected output, improving review clarity.

```javascript
exports[`<UserName /> should render null`] = `null`;

exports[`<UserName /> should render Alan Turing`] = `
<div>
  Alan Turing
</div>
`;
```

--------------------------------

### Install jest-puppeteer with npm, Yarn, pnpm, or Bun

Source: https://jestjs.io/docs/30.0/puppeteer

Install the jest-puppeteer package using your preferred package manager. These commands are alternatives; choose one based on your environment.

```bash
npm install --save-dev jest-puppeteer
```

```bash
yarn add --dev jest-puppeteer
```

```bash
pnpm add --save-dev jest-puppeteer
```

```bash
bun add --dev jest-puppeteer
```

--------------------------------

### Install jest-environment-jsdom with npm, Yarn, pnpm, or Bun

Source: https://jestjs.io/docs/30.0/tutorial-jquery

Install commands for the jest-environment-jsdom package using npm, Yarn, pnpm, and Bun. Required to simulate a DOM environment in Jest tests.

```bash
npm install --save-dev jest-environment-jsdom
```

```bash
yarn add --dev jest-environment-jsdom
```

```bash
pnpm add --save-dev jest-environment-jsdom
```

```bash
bun add --dev jest-environment-jsdom
```

--------------------------------

### Install @babel/preset-env with npm, Yarn, pnpm, or Bun

Source: https://jestjs.io/docs/30.0/webpack

Install @babel/preset-env as a dev dependency using npm, Yarn, pnpm, or Bun. Required in addition to babel-jest for using Jest with webpack.

```bash
npm install --save-dev @babel/preset-env
```

```bash
yarn add --dev @babel/preset-env
```

```bash
pnpm add --save-dev @babel/preset-env
```

```bash
bun add --dev @babel/preset-env
```

--------------------------------

### mock.instances array example

Source: https://jestjs.io/docs/30.0/mock-function-api

Shows how mock.instances stores the object instances created with new from a mock function. The example creates two instances and verifies they are stored in order.

```javascript
const mockFn = jest.fn();

const a = new mockFn();
const b = new mockFn();

mockFn.mock.instances[0] === a; // true
mockFn.mock.instances[1] === b; // true
```

--------------------------------

### Example test file with .t.js extension

Source: https://jestjs.io/docs/30.0/configuration

Example source file named sum.t.js that contains a test inside a conditional block. This file is normally ignored for coverage but can be included using forceCoverageMatch.

```javascript
export function sum(a, b) {  

  return a + b;  

}  

  

if (process.env.NODE_ENV === 'test') {  

  test('sum', () => {  

    expect(sum(1, 2)).toBe(3);  

  });  

}  

```

--------------------------------

### webpack.config.js example

Source: https://jestjs.io/docs/30.0/webpack

A typical webpack configuration that uses babel-loader for JS/JSX, style-loader and css-loader for CSS, and asset modules for images and fonts. This is the starting point for translating a webpack setup to Jest.

```javascript
module.exports = {  

  module: {  

    rules: [  

      {  

        test: /\.jsx?$/,  

        exclude: ['node_modules'],  

        use: ['babel-loader'],  

      },  

      {  

        test: /\.css$/,  

        use: ['style-loader', 'css-loader'],  

      },  

      {  

        test: /\.gif$/,  

        type: 'asset/inline',  

      },  

      {  

        test: /\.(ttf|eot|svg)$/,  

        type: 'asset/resource',  

      },  

    ],  

  },  

  resolve: {  

    alias: {  

      config$: './configs/app-config.js',  

      react: './vendor/react-master',  

    },  

    extensions: ['.js', '.jsx'],  

    modules: [  

      'node_modules',  

      'bower_components',  

      'shared',  

      '/shared/vendor/modules',  

    ],  

  },  

};  


```

--------------------------------

### Install @jest/globals

Source: https://jestjs.io/docs/30.0/getting-started

Install @jest/globals to get type definitions for Jest global APIs. These types update with each Jest release.

```bash
npm install --save-dev @jest/globals
```

```bash
yarn add --dev @jest/globals
```

```bash
pnpm add --save-dev @jest/globals
```

```bash
bun add --dev @jest/globals
```

--------------------------------

### Global setup with setupFilesAfterEnv (expect.extend call)

Source: https://jestjs.io/docs/30.0/expect

Shows how to enable the custom matcher for all tests by moving the expect.extend call to a setupFilesAfterEnv script, importing the matcher module.

```JavaScript
import {expect} from '@jest/globals';  
// remember to export `toBeWithinRange` as well  
import {toBeWithinRange} from './toBeWithinRange';  

expect.extend({  
  toBeWithinRange,  
});  
```

--------------------------------

### Install @types/jest

Source: https://jestjs.io/docs/30.0/getting-started

Install @types/jest to get types for Jest globals without importing them. This is a third-party package from DefinitelyTyped; match its version closely to your Jest version.

```bash
npm install --save-dev @types/jest
```

```bash
yarn add --dev @types/jest
```

```bash
pnpm add --save-dev @types/jest
```

```bash
bun add --dev @types/jest
```

--------------------------------

### Out-of-scope error example (will fail)

Source: https://jestjs.io/docs/30.0/es6-class-mocks

This example will throw an out-of-scope error because the variable is named 'fake' instead of starting with 'mock'. Jest's hoisting prevents access to out-of-scope variables.

```javascript
// Note: this will fail  

import SoundPlayer from './sound-player';  

const fakePlaySoundFile = jest.fn();  

jest.mock('./sound-player', () => {  

  return jest.fn().mockImplementation(() => {  

    return {playSoundFile: fakePlaySoundFile};  

  });  

});  
```

--------------------------------

### File structure for --runTestsByPath

Source: https://jestjs.io/docs/30.0/cli

Example file structure for the --runTestsByPath option.

```text
__tests__  

└── t1.test.js # test  

└── t2.test.js # test
```

--------------------------------

### expect.hasAssertions() example

Source: https://jestjs.io/docs/30.0/expect

Verifies that at least one assertion is called during a test. Useful for asynchronous code to ensure assertions in callbacks actually get called. The example tests a prepareState function that calls a callback with a state object.

```javascript
test('prepareState prepares a valid state', () => {  

  expect.hasAssertions();  

  prepareState(state => {  

    expect(validateState(state)).toBeTruthy();  

  });  

  return waitOnState();  

});  
```

--------------------------------

### Directory structure for manual mocks example

Source: https://jestjs.io/docs/30.0/manual-mocks

Shows the project structure with __mocks__ directories for fs and user modules.

```text
.

├── config

├── __mocks__

│   └── fs.js

├── models

│   ├── __mocks__

│   │   └── user.js

│   └── user.js

├── node_modules

└── views

```

--------------------------------

### expect.assertions(number) example

Source: https://jestjs.io/docs/30.0/expect

Verifies that a certain number of assertions are called during a test. Useful for asynchronous code to ensure assertions in callbacks actually get called. The example tests a doAsync function that calls two callbacks asynchronously.

```javascript
test('doAsync calls both callbacks', () => {  

  expect.assertions(2);  

  function callback1(data) {  

    expect(data).toBeTruthy();  

  }  

  function callback2(data) {  

    expect(data).toBeTruthy();  

  }  

  

  doAsync(callback1, callback2);  

});  
```

--------------------------------

### jest.enableAutomock() example with utils.js and test

Source: https://jestjs.io/docs/30.0/jest-object

Example for `jest.enableAutomock()`: a `utils.js` module and a test that calls `enableAutomock()` to get mocked implementations. Returns the `jest` object for chaining. With `babel-jest`, the call is hoisted to the top of the code block; use `autoMockOn` to avoid that.

```JavaScript
export default {  
  authorize: () => {  
    return 'token';  
  },  
  isAuthorized: secret => secret === 'wizard',  
};  

```

```JavaScript
jest.enableAutomock();  

import utils from '../utils';  

test('original implementation', () => {  
  // now we have the mocked implementation,  
  expect(utils.authorize._isMockFunction).toBeTruthy();  
  expect(utils.isAuthorized._isMockFunction).toBeTruthy();  
});  

```

--------------------------------

### jest.disableAutomock() example with utils.js and test

Source: https://jestjs.io/docs/30.0/jest-object

Example for `jest.disableAutomock()`: a `utils.js` module and a test that calls `disableAutomock()` to get the real implementation. Useful when you want to mock fewer dependencies than you don't. Returns the `jest` object for chaining. With `babel-jest`, the call is hoisted to the top of the code block; use `autoMockOff()` to avoid that.

```JavaScript
export default {  
  authorize: () => {  
    return 'token';  
  },  
};  

```

```JavaScript
import utils from '../utils';  

jest.disableAutomock();  

test('original implementation', () => {  
  // now we have the original implementation,  
  // even if we set the automocking in a jest configuration  
  expect(utils.authorize()).toBe('token');  
});  

```

--------------------------------

### jestHooks.onFileChange example

Source: https://jestjs.io/docs/30.0/watch-plugins

Shows how to use onFileChange to receive project and test path information when the file system changes.

```javascript
class MyWatchPlugin {  

  apply(jestHooks) {  

    jestHooks.onFileChange(({projects}) => {  

      this._projects = projects;  

    });  

  }  

}  

```

--------------------------------

### Import Jest globals in a TypeScript test

Source: https://jestjs.io/docs/30.0/getting-started

Example test file (sum.test.ts) that imports Jest globals from @jest/globals to get TypeScript types. This is one way to have Jest global APIs typed.

```typescript
import {describe, expect, test} from '@jest/globals';
import {sum} from './sum';

describe('sum module', () => {
  test('adds 1 + 2 to equal 3', () => {
    expect(sum(1, 2)).toBe(3);
  });
});
```

--------------------------------

### Get type with jest-get-type

Source: https://jestjs.io/docs/30.0/jest-platform

Use jest-get-type to identify the primitive type of any JavaScript value. The getType function returns a string with the type of the value passed as argument. This example prints 'array', 'null', and 'undefined' for the respective values.

```javascript
const {getType} = require('@jest/get-type');

const array = [1, 2, 3];
const nullValue = null;
const undefinedValue = undefined;

// prints 'array'
console.log(getType(array));
// prints 'null'
console.log(getType(nullValue));
// prints 'undefined'
console.log(getType(undefinedValue));
```

--------------------------------

### package.json Jest configuration for React Native

Source: https://jestjs.io/docs/30.0/tutorial-react-native

Add this configuration to package.json when setting up Jest for React Native. It defines the test script and uses the react-native preset. This setup is included by default starting from react-native version 0.38.

```json
{
  "scripts": {
    "test": "jest"
  },
  "jest": {
    "preset": "react-native"
  }
}
```

--------------------------------

### Install identity-obj-proxy with npm, Yarn, pnpm, and Bun

Source: https://jestjs.io/docs/30.0/webpack

Install commands for the identity-obj-proxy package using npm, Yarn, pnpm, and Bun. This proxy is used to mock CSS Modules so that className lookups return as-is.

```bash
npm install --save-dev identity-obj-proxy  


```

```bash
yarn add --dev identity-obj-proxy  


```

```bash
pnpm add --save-dev identity-obj-proxy  


```

```bash
bun add --dev identity-obj-proxy  


```

--------------------------------

### Set jsdom environment with @jest-environment pragma

Source: https://jestjs.io/docs/30.0/test-environment

Use the @jest-environment docblock pragma to set the jsdom environment for a specific test file. The pragma must be a comment starting with @jest-environment followed by the environment name. This example shows the same test in JavaScript and TypeScript.

```javascript
/**
 * @jest-environment jsdom
 */

test('use jsdom in this test file', () => {
  const element = document.createElement('div');
  expect(element).not.toBeNull();
});
```

```typescript
/**
 * @jest-environment jsdom
 */

test('use jsdom in this test file', () => {
  const element = document.createElement('div');
  expect(element).not.toBeNull();
});
```

--------------------------------

### Run tests sequentially with --runInBand (Bun)

Source: https://jestjs.io/docs/30.0/troubleshooting

Run tests sequentially in the same thread to improve speed on slow setups (e.g., Docker/CI). Shown for Bun.

```bash
# Using Jest CLI

jest --runInBand

# Using your package manager's `test` script (e.g. with create-react-app)

bun run test --runInBand
```

--------------------------------

### Get changed files with jest-changed-files

Source: https://jestjs.io/docs/30.0/jest-platform

Use jest-changed-files to identify modified files in a git/hg repository. The getChangedFilesForRoots function returns a promise that resolves to an object with changed files and repos. This example prints the set of modified files since the last commit in the current repo.

```javascript
const {getChangedFilesForRoots} = require('jest-changed-files');

// print the set of modified files since last commit in the current repo
getChangedFilesForRoots(['./'], {
  lastCommit: true,
}).then(result => console.log(result.changedFiles));
```

--------------------------------

### Manual mock for sound-player.js

Source: https://jestjs.io/docs/30.0/es6-class-mocks

Create a manual mock by saving a mock implementation in the __mocks__ folder. This allows specifying the implementation and reusing it across test files.

```javascript
// Import this named export into your test file:  

export const mockPlaySoundFile = jest.fn();  

const mock = jest.fn().mockImplementation(() => {  

  return {playSoundFile: mockPlaySoundFile};  

});  

  

export default mock;  
```

--------------------------------

### Using .toHaveBeenNthCalledWith to test nth call arguments

Source: https://jestjs.io/docs/30.0/expect

Test that uses .toHaveBeenNthCalledWith to verify the arguments of the nth call to a mock function. The example checks that drinkEach calls the drink function with 'lemon' first and 'octopus' second. Note that the nth argument must be a positive integer starting from 1.

```javascript
test('drinkEach drinks each drink', () => {  
  const drink = jest.fn();  
  drinkEach(drink, ['lemon', 'octopus']);  
  expect(drink).toHaveBeenNthCalledWith(1, 'lemon');  
  expect(drink).toHaveBeenNthCalledWith(2, 'octopus');  
});  
```

--------------------------------

### Generate a basic Jest configuration file

Source: https://jestjs.io/docs/30.0/getting-started

Run the Jest initialization command for your package manager to generate a basic configuration file. Jest will ask a few questions and create a configuration file with a short description for each option.

```bash
npm init jest@latest
```

```bash
yarn create jest
```

```bash
pnpm create jest
```

```bash
bunx create-jest
```

--------------------------------

### Import manual mock before tested file

Source: https://jestjs.io/docs/30.0/manual-mocks

When window.matchMedia is called directly in the tested file, import the manual mock file before the tested file to ensure the mock is set up first. The comment emphasizes the required import order.

```javascript
import './matchMedia.mock'; // Must be imported before the tested file  
import {myMethod} from './file-to-test';  
  
describe('myMethod()', () => {  
  // Test the method here...  
});  
```

--------------------------------

### Use jest.requireActual to mock a module while keeping original exports

Source: https://jestjs.io/docs/30.0/jest-object

Shows how to use jest.requireActual to get the real module inside a jest.mock factory, preserving the original exports while overriding a specific function. The TypeScript version adds a generic type parameter to requireActual for type safety. The example demonstrates that getRandom always returns 10 after the mock is applied.

```JavaScript
jest.mock('../myModule', () => {  

  // Require the original module to not be mocked...  

  const originalModule = jest.requireActual('../myModule');  

  

  return {  

    __esModule: true, // Use it when dealing with esModules  

    ...originalModule,  

    getRandom: jest.fn(() => 10),  

  };  

});  

  

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

  

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

```TypeScript
jest.mock('../myModule', () => {  

  // Require the original module to not be mocked...  

  const originalModule =  

    jest.requireActual<typeof import('../myModule')>('../myModule');  

  

  return {  

    __esModule: true, // Use it when dealing with esModules  

    ...originalModule,  

    getRandom: jest.fn(() => 10),  

  };  

});  

  

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

  

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

--------------------------------

### Generated snapshot file Intro-test.js.snap

Source: https://jestjs.io/docs/30.0/tutorial-react-native

Example snapshot file generated by the snapshot test. It shows the rendered output of the Intro component. The snapshot should be committed and compared on subsequent test runs.

```javascript
exports[`Intro renders correctly 1`] = `
<View
  style={
    Object {
      "alignItems": "center",
      "backgroundColor": "#F5FCFF",
      "flex": 1,
      "justifyContent": "center",
    }
  }>
  <Text
    style={
      Object {
        "fontSize": 20,
        "margin": 10,
        "textAlign": "center",
      }
    }>
    Welcome to React Native!
  </Text>
  <Text
    style={
      Object {
        "color": "#333333",
        "marginBottom": 5,
        "textAlign": "center",
      }
    }>
    This is a React Native snapshot test.
  </Text>
</View>
`;
```

--------------------------------

### Run tests sequentially with --runInBand (npm)

Source: https://jestjs.io/docs/30.0/troubleshooting

Run tests sequentially in the same thread to improve speed on slow setups (e.g., Docker/CI). Shown for npm.

```bash
# Using Jest CLI

jest --runInBand

# Using your package manager's `test` script (e.g. with create-react-app)

npm test -- --runInBand
```

--------------------------------

### toBeNaN matcher example

Source: https://jestjs.io/docs/30.0/expect

Use toBeNaN when checking that a value is NaN. The example shows both a passing and a failing assertion.

```javascript
test('passes when value is NaN', () => {  
  expect(NaN).toBeNaN();  
  expect(1).not.toBeNaN();  
});  
```

--------------------------------

### toBeUndefined matcher example

Source: https://jestjs.io/docs/30.0/expect

Use toBeUndefined to check that a variable is undefined. The example checks that bestDrinkForFlavor('octopus') returns undefined.

```javascript
test('the best drink for octopus flavor is undefined', () => {  
  expect(bestDrinkForFlavor('octopus')).toBeUndefined();  
});  
```

--------------------------------

### mockRejectedValueOnce combined example (TypeScript)

Source: https://jestjs.io/docs/30.0/mock-function-api

TypeScript version of the mockRejectedValueOnce combined example, using @jest/globals and a typed mock function.

```typescript
import {jest, test} from '@jest/globals';

test('async test', async () => {
  const asyncMock = jest
    .fn<() => Promise<string>>()
    .mockResolvedValueOnce('first call')
    .mockRejectedValueOnce(new Error('Async error message'));

  await asyncMock(); // 'first call'
  await asyncMock(); // throws 'Async error message'
});
```

--------------------------------

### mockFn.mockImplementationOnce(fn) - JavaScript and TypeScript examples

Source: https://jestjs.io/docs/30.0/mock-function-api

Shows how to use mockImplementationOnce to provide a one-time implementation for a single call. The implementations can be chained so multiple calls produce different results.

```JavaScript
const mockFn = jest  
  .fn()  
  .mockImplementationOnce(cb => cb(null, true))  
  .mockImplementationOnce(cb => cb(null, false));  

mockFn((err, val) => console.log(val)); // true  
mockFn((err, val) => console.log(val)); // false  
```

```TypeScript
import {jest} from '@jest/globals';  

const mockFn = jest  
  .fn<(cb: (a: null, b: boolean) => void) => void>()  
  .mockImplementationOnce(cb => cb(null, true))  
  .mockImplementationOnce(cb => cb(null, false));  

mockFn((err, val) => console.log(val)); // true  
mockFn((err, val) => console.log(val)); // false  
```

--------------------------------

### mockResolvedValueOnce chaining example (TypeScript)

Source: https://jestjs.io/docs/30.0/mock-function-api

TypeScript version of the mockResolvedValueOnce chaining example, using @jest/globals and a typed mock function.

```typescript
import {jest, test} from '@jest/globals';

test('async test', async () => {
  const asyncMock = jest
    .fn<() => Promise<string>>()
    .mockResolvedValue('default')
    .mockResolvedValueOnce('first call')
    .mockResolvedValueOnce('second call');

  await asyncMock(); // 'first call'
  await asyncMock(); // 'second call'
  await asyncMock(); // 'default'
  await asyncMock(); // 'default'
});
```

--------------------------------

### Run tests sequentially with --runInBand (pnpm)

Source: https://jestjs.io/docs/30.0/troubleshooting

Run tests sequentially in the same thread to improve speed on slow setups (e.g., Docker/CI). Shown for pnpm.

```bash
# Using Jest CLI

jest --runInBand

# Using your package manager's `test` script (e.g. with create-react-app)

pnpm test --runInBand
```

--------------------------------

### mockReturnValueOnce chaining example (TypeScript)

Source: https://jestjs.io/docs/30.0/mock-function-api

TypeScript version of the mockReturnValueOnce chaining example, using @jest/globals and a typed mock function.

```typescript
import {jest} from '@jest/globals';

const mockFn = jest
  .fn<() => string>()
  .mockReturnValue('default')
  .mockReturnValueOnce('first call')
  .mockReturnValueOnce('second call');

mockFn(); // 'first call'
mockFn(); // 'second call'
mockFn(); // 'default'
mockFn(); // 'default'
```

--------------------------------

### Non-descriptive snapshot names example

Source: https://jestjs.io/docs/30.0/snapshot-testing

Example of non-descriptive snapshot names that do not convey the expected content, making review harder.

```javascript
exports[`<UserName /> should handle some test case`] = `null`;

exports[`<UserName /> should handle some other test case`] = `
<div>
  Alan Turing
</div>
`;
```

--------------------------------

### createUser function using fetch

Source: https://jestjs.io/docs/30.0/bypassing-module-mocks

Example of a function that uses fetch to create a user. It is the target function that needs to be tested with mocks.

```javascript
import fetch from 'node-fetch';  

  

export const createUser = async () => {  
  const response = await fetch('https://website.com/users', {method: 'POST'});  
  const userId = await response.text();  
  return userId;  
};  

  

```

--------------------------------

### Watch menu output with custom plugin

Source: https://jestjs.io/docs/30.0/watch-plugins

Example watch mode menu output after adding a custom plugin with key 's' and prompt 'do something'. The plugin's entry appears as 'Press s to do something.' in the menu.

```text
Watch Usage  

 › Press p to filter by a filename regex pattern.  

 › Press t to filter by a test name regex pattern.  

 › Press q to quit watch mode.  

 › Press s to do something. // <-- This is our plugin  

 › Press Enter to trigger a test run.  



```

--------------------------------

### Jest configuration for custom Puppeteer setup (jest.config.js)

Source: https://jestjs.io/docs/30.0/puppeteer

Jest configuration that references the custom setup, teardown, and test environment files.

```javascript
module.exports = {
  globalSetup: './setup.js',
  globalTeardown: './teardown.js',
  testEnvironment: './puppeteer_environment.js',
};
```

--------------------------------

### Create Jest config with npm, Yarn, or pnpm

Source: https://jestjs.io/docs/30.0/upgrading-to-jest30

Commands to create a Jest configuration file after the `jest --init` command was removed. Use the package manager of your choice: npm, Yarn, or pnpm.

```bash
npm init jest@latest  

# Or for Yarn  

yarn create jest  

# Or for pnpm  

pnpm create jest  

```

--------------------------------

### toBeLessThanOrEqual matcher example

Source: https://jestjs.io/docs/30.0/expect

Use toBeLessThanOrEqual to assert that received is <= expected for numbers or big integers. The example checks that ouncesPerCan() returns at most 12.

```javascript
test('ounces per can is at most 12', () => {  
  expect(ouncesPerCan()).toBeLessThanOrEqual(12);  
});  
```
Tokens:
Raw