Training Example: Jest – Review the Data, Give Your Score & Compare to the Real AI Evaluation

Skip to main contentFollow @jestjs_StarJESTJESTJESTJESTJESTJESTJESTJESTJESTJESTGet StartedDocsConfigGet helpJest is a delightful JavaScript Testing Framework with a focus on simplicity.It works with projects using: Babel, TypeScript, Node, React, Angular, Vue and more!
[H2] Zero config
Jest aims to work out of the box, config free, on most JavaScript projects.
[H2] Snapshots
Make tests which keep track of large objects with ease. Snapshots live either alongside your tests, or embedded inline.
[H2] Isolated
Tests are parallelized by running them in their own processes to maximize performance.
[H2] Great api
From it to expect - Jest has the entire toolkit in one place. Well documented, well maintained, well good.
[H2] Fast and safe
By ensuring your tests have unique global state, Jest can reliably run tests in parallel. To make things quick, Jest runs previously failed tests first and re-organizes runs based on how long test files take.
[H2] Code coverage
Generate code coverage by adding the flag --coverage. No additional setup needed. Jest can collect code coverage information from entire projects, including untested files.
[H2] Easy Mocking
Jest uses a custom resolver for imports in your tests, making it simple to mock any object outside of your test’s scope. You can use mocked imports with the rich Mock Functions API to spy on function calls with readable test syntax.
[H2] Great Exceptions
Tests fail—when they do, Jest provides rich context why. Here are some examples:
[H2] Philosophy
Jest is a JavaScript testing framework designed to ensure correctness of any JavaScript codebase. It allows you to write tests with an approachable, familiar and feature-rich API that gives you results quickly.Jest is well-documented, requires little configuration and can be extended to match your requirements.Jest makes testing delightful.- Jest Core Team- Jest Core TeamWatch
[H2] Docs and talks
The Jest core team and contributors regularly speak about Jest and Delightful JavaScript Testing. Check out our talk about Building High-Quality JavaScript Tools at jsconf.eu 2017 and our talk about Jest as a Platform at ReactiveConf 2017.
[H2] Open Collective
Jest uses Open Collective to support developers contributing to Jest.
[H3] Gold Sponsors
[IMG: Thordata logo]
[H3] Featured Sponsors
[IMG: Airbnb]
[IMG: Principal Financial Group]
[IMG: Datadog]
Join 600+ donors who sponsor Jest for $3 or more per month on opencollective.com.
[H2] Who uses Jest?
A lot of people! With 100m+ million downloads in the last month, and used on over 15,000,000 public repos on GitHub.Jest is used extensively at these companies:
[IMG: Facebook]
[IMG: Twitter]
[IMG: The New York Times]
[IMG: Spotify]
[IMG: Airbnb]
[IMG: Instagram]

Version: 30.4On this pageInstall Jest using your favorite package manager:
npmYarnpnpmBunnpm install --save-dev jestyarn add --dev jestpnpm add --save-dev jestbun add --dev jest
Let's get started by writing a test for a hypothetical function that adds two numbers. First, create a sum.js file:
function sum(a, b) { return a + b;}module.exports = sum;
Then, create a file named sum.test.js. This will contain our actual test:
const sum = require('./sum');test('adds 1 + 2 to equal 3', () => { expect(sum(1, 2)).toBe(3);});
Add the following section to your package.json:
{ "scripts": { "test": "jest" }}
Finally, run yarn test or npm test and Jest will print this message:
PASS ./sum.test.js✓ adds 1 + 2 to equal 3 (5ms)
You just successfully wrote your first test using Jest!
This test used expect and toBe to test that two values were exactly identical. To learn about the other things that Jest can test, see Using Matchers.
[H2] Running from command line​
You can run Jest directly from the CLI (if it's globally available in your PATH, e.g. by yarn global add jest or npm install jest --global) with a variety of useful options.
Here's how to run Jest on files matching my-test, using config.json as a configuration file and display a native OS notification after the run:
jest my-test --notify --config=config.json
If you'd like to learn more about running jest through the command line, take a look at the Jest CLI Options page.
[H2] Additional Configuration​
[H3] Generate a basic configuration file​
Based on your project, Jest will ask you a few questions and will create a basic configuration file with a short description for each option:
npmYarnpnpmBunnpm init jest@latestyarn create jestpnpm create jestbunx create-jest
[H3] Using Babel​
To use Babel, install required dependencies:
npmYarnpnpmBunnpm install --save-dev babel-jest @babel/core @babel/preset-envyarn add --dev babel-jest @babel/core @babel/preset-envpnpm add --save-dev babel-jest @babel/core @babel/preset-envbun add --dev babel-jest @babel/core @babel/preset-env
Configure Babel to target your current version of Node by creating a babel.config.js file in the root of your project:
babel.config.jsmodule.exports = { presets: [['@babel/preset-env', {targets: {node: 'current'}}]],};
The ideal configuration for Babel will depend on your project. See Babel's docs for more details.
Making your Babel config jest-awareJest will set process.env.NODE_ENV to 'test' if it's not set to something else. You can use that in your configuration to conditionally setup only the compilation needed for Jest, e.g.babel.config.jsmodule.exports = api => { const isTest = api.env('test'); // You can use isTest to determine what presets and plugins to use. return { // ... };};notebabel-jest is automatically installed when installing Jest and will automatically transform files if a babel configuration exists in your project. To avoid this behavior, you can explicitly reset the transform configuration option:jest.config.jsmodule.exports = { transform: {},};
[H2] Using with bundlers​
Most of the time you do not need to do anything special to work with different bundlers - the exception is if you have some plugin or configuration which generates files or have custom file resolution rules.
[H3] Using webpack​
Jest can be used in projects that use webpack to manage assets, styles, and compilation. webpack does offer some unique challenges over other tools. Refer to the webpack guide to get started.
[H3] Using Vite​
Jest is not supported by Vite due to incompatibilities with the Vite plugin system.
There are examples for Jest integration with Vite in the vite-jest library. However, this library is not compatible with versions of Vite later than 2.4.2.
One alternative is Vitest which has an API that is compatible with Jest.
[H3] Using Parcel​
Jest can be used in projects that use parcel-bundler to manage assets, styles, and compilation similar to webpack. Parcel requires zero configuration. Refer to the official docs to get started.
[H3] Using TypeScript​
[H4] Via babel​
Jest supports TypeScript, via Babel. First, make sure you followed the instructions on using Babel above. Next, install the @babel/preset-typescript:
npmYarnpnpmBunnpm install --save-dev @babel/preset-typescriptyarn add --dev @babel/preset-typescriptpnpm add --save-dev @babel/preset-typescriptbun add --dev @babel/preset-typescript
Then add @babel/preset-typescript to the list of presets in your babel.config.js.
babel.config.jsmodule.exports = { presets: [ ['@babel/preset-env', {targets: {node: 'current'}}], '@babel/preset-typescript', ],};
However, there are some caveats to using TypeScript with Babel. Because TypeScript support in Babel is purely transpilation, Jest will not type-check your tests as they are run. If you want that, you can use ts-jest instead, or just run the TypeScript compiler tsc separately (or as part of your build process).
[H4] Via ts-jest​
ts-jest is a TypeScript preprocessor with source map support for Jest that lets you use Jest to test projects written in TypeScript.
npmYarnpnpmBunnpm install --save-dev ts-jestyarn add --dev ts-jestpnpm add --save-dev ts-jestbun add --dev ts-jest
In order for Jest to transpile TypeScript with ts-jest, you may also need to create a configuration file.
[H4] Type definitions​
There are two ways to have Jest global APIs typed for test files written in TypeScript.
You can use type definitions which ships with Jest and will update each time you update Jest. Install the @jest/globals package:
npmYarnpnpmBunnpm install --save-dev @jest/globalsyarn add --dev @jest/globalspnpm add --save-dev @jest/globalsbun add --dev @jest/globals
And import the APIs from it:
sum.test.tsimport {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); });});
tipSee the additional usage documentation of describe.each/test.each and mock functions.
Or you may choose to install the @types/jest package. It provides types for Jest globals without a need to import them.
npmYarnpnpmBunnpm install --save-dev @types/jestyarn add --dev @types/jestpnpm add --save-dev @types/jestbun add --dev @types/jest
info@types/jest is a third party library maintained at DefinitelyTyped, hence the latest Jest features or versions may not be covered yet. Try to match versions of Jest and @types/jest as closely as possible. For example, if you are using Jest 27.4.0 then installing 27.4.x of @types/jest is ideal.
[H3] Using ESLint​
Jest can be used with ESLint without any further configuration as long as you import the Jest global helpers (describe, it, etc.) from @jest/globals before using them in your test file. This is necessary to avoid no-undef errors from ESLint, which doesn't know about the Jest globals.
If you'd like to avoid these imports, you can configure your ESLint environment to support these globals by adding the jest environment:
import {defineConfig} from 'eslint/config';import globals from 'globals';export default defineConfig([ { files: ['**/*.js'], languageOptions: { globals: { ...globals.jest, }, }, rules: { 'no-unused-vars': 'warn', 'no-undef': 'warn', }, },]);
Or use eslint-plugin-jest, which has a similar effect:
{ "overrides": [ { "files": ["tests/**/*"], "plugins": ["jest"], "env": { "jest/globals": true } } ]}Running from command lineAdditional ConfigurationGenerate a basic configuration fileUsing BabelUsing with bundlersUsing webpackUsing ViteUsing ParcelUsing TypeScriptUsing ESLint

Skip to main contentJest is worked on by a team of volunteers in their spare time. You can find out ways to talk to community members below.
[H2] Browse the docs
Find what you're looking for in our detailed documentation and guides.
Learn how to get started with Jest.
Troubleshoot problems with Jest.
Learn how to configure Jest.
Look at the full API Reference.
[H2] Join the community
Ask questions and find answers from other Jest users like you.
Join the #testing channel on Reactiflux, a Discord community.
Many members of the community use Stack Overflow. Read through the existing questions tagged with jestjs or ask your own!
[H2] Stay up to date
Find out what's new with Jest.
Follow Jest on Twitter.
Subscribe to the Jest blog.
Look at the changelog.

Version: 30.4On this pageIn your test files, Jest puts each of these methods and objects into the global environment. You don't have to require or import anything to use them. However, if you prefer explicit imports, you can do import {describe, expect, test} from '@jest/globals'.
infoThe TypeScript examples from this page will only work as documented if you explicitly import Jest APIs:import {expect, jest, test} from '@jest/globals';Consult the Getting Started guide for details on how to setup Jest with TypeScript.
[H2] Methods​
ReferenceafterAll(fn, timeout)afterEach(fn, timeout)beforeAll(fn, timeout)beforeEach(fn, timeout)describe(name, fn)describe.each(table)(name, fn, timeout)describe.only(name, fn)describe.only.each(table)(name, fn)describe.skip(name, fn)describe.skip.each(table)(name, fn)test(name, fn, timeout)test.concurrent(name, fn, timeout)test.concurrent.each(table)(name, fn, timeout)test.concurrent.only.each(table)(name, fn)test.concurrent.skip.each(table)(name, fn)test.each(table)(name, fn, timeout)test.failing(name, fn, timeout)test.failing.each(name, fn, timeout)test.only.failing(name, fn, timeout)test.skip.failing(name, fn, timeout)test.only(name, fn, timeout)test.only.each(table)(name, fn)test.skip(name, fn)test.skip.each(table)(name, fn)test.todo(name)TypeScript Usage.each
[H2] Reference​
[H3] afterAll(fn, timeout)​
Runs a function after all the tests in this file have completed. If the function returns a promise or is a generator, Jest waits for that promise to resolve before continuing.
Optionally, you can provide a timeout (in milliseconds) for specifying how long to wait before aborting. The default timeout is 5 seconds.
This is often useful if you want to clean up some global setup state that is shared across tests.
For example:
const globalDatabase = makeGlobalDatabase();function cleanUpDatabase(db) { db.cleanUp();}afterAll(() => { cleanUpDatabase(globalDatabase);});test('can find things', () => { return globalDatabase.find('thing', {}, results => { expect(results.length).toBeGreaterThan(0); });});test('can insert a thing', () => { return globalDatabase.insert('thing', makeThing(), response => { expect(response.success).toBeTruthy(); });});
Here the afterAll ensures that cleanUpDatabase is called after all tests run.
If afterAll is inside a describe block, it runs at the end of the describe block.
If you want to run some cleanup after every test instead of after all tests, use afterEach instead.
[H3] afterEach(fn, timeout)​
Runs a function after each one of the tests in this file completes. If the function returns a promise or is a generator, Jest waits for that promise to resolve before continuing.
Optionally, you can provide a timeout (in milliseconds) for specifying how long to wait before aborting. The default timeout is 5 seconds.
This is often useful if you want to clean up some temporary state that is created by each test.
For example:
const globalDatabase = makeGlobalDatabase();function cleanUpDatabase(db) { db.cleanUp();}afterEach(() => { cleanUpDatabase(globalDatabase);});test('can find things', () => { return globalDatabase.find('thing', {}, results => { expect(results.length).toBeGreaterThan(0); });});test('can insert a thing', () => { return globalDatabase.insert('thing', makeThing(), response => { expect(response.success).toBeTruthy(); });});
Here the afterEach ensures that cleanUpDatabase is called after each test runs.
If afterEach is inside a describe block, it only runs after the tests that are inside this describe block.
If you want to run some cleanup just once, after all of the tests run, use afterAll instead.
[H3] beforeAll(fn, timeout)​
Runs a function before any of the tests in this file run. If the function returns a promise or is a generator, Jest waits for that promise to resolve before running tests.
Optionally, you can provide a timeout (in milliseconds) for specifying how long to wait before aborting. The default timeout is 5 seconds.
This is often useful if you want to set up some global state that will be used by many tests.
For example:
const globalDatabase = makeGlobalDatabase();beforeAll(() => { // Clears the database and adds some testing data. // Jest will wait for this promise to resolve before running tests. return globalDatabase.clear().then(() => { return globalDatabase.insert({testData: 'foo'}); });});// Since we only set up the database once in this example, it's important// that our tests don't modify it.test('can find things', () => { return globalDatabase.find('thing', {}, results => { expect(results.length).toBeGreaterThan(0); });});
Here the beforeAll ensures that the database is set up before tests run. If setup was synchronous, you could do this without beforeAll. The key is that Jest will wait for a promise to resolve, so you can have asynchronous setup as well.
If beforeAll is inside a describe block, it runs at the beginning of the describe block.
If you want to run something before every test instead of before any test runs, use beforeEach instead.
[H3] beforeEach(fn, timeout)​
Runs a function before each of the tests in this file runs. If the function returns a promise or is a generator, Jest waits for that promise to resolve before running the test.
Optionally, you can provide a timeout (in milliseconds) for specifying how long to wait before aborting. The default timeout is 5 seconds.
This is often useful if you want to reset some global state that will be used by many tests.
For example:
const globalDatabase = makeGlobalDatabase();beforeEach(() => { // Clears the database and adds some testing data. // Jest will wait for this promise to resolve before running tests. return globalDatabase.clear().then(() => { return globalDatabase.insert({testData: 'foo'}); });});test('can find things', () => { return globalDatabase.find('thing', {}, results => { expect(results.length).toBeGreaterThan(0); });});test('can insert a thing', () => { return globalDatabase.insert('thing', makeThing(), response => { expect(response.success).toBeTruthy(); });});
Here the beforeEach ensures that the database is reset for each test.
If beforeEach is inside a describe block, it runs for each test in the describe block.
If you only need to run some setup code once, before any tests run, use beforeAll instead.
[H3] describe(name, fn)​
describe(name, fn) creates a block that groups together several related tests. For example, if you have a myBeverage object that is supposed to be delicious but not sour, you could test it with:
const myBeverage = { delicious: true, sour: false,};describe('my beverage', () => { test('is delicious', () => { expect(myBeverage.delicious).toBeTruthy(); }); test('is not sour', () => { expect(myBeverage.sour).toBeFalsy(); });});
This isn't required - you can write the test blocks directly at the top level. But this can be handy if you prefer your tests to be organized into groups.
You can also nest describe blocks if you have a hierarchy of tests:
const binaryStringToNumber = binString => { if (!/^[01]+$/.test(binString)) { throw new CustomError('Not a binary number.'); } return parseInt(binString, 2);};describe('binaryStringToNumber', () => { describe('given an invalid binary string', () => { test('composed of non-numbers throws CustomError', () => { expect(() => binaryStringToNumber('abc')).toThrow(CustomError); }); test('with extra whitespace throws CustomError', () => { expect(() => binaryStringToNumber(' 100')).toThrow(CustomError); }); }); describe('given a valid binary string', () => { test('returns the correct number', () => { expect(binaryStringToNumber('100')).toBe(4); }); });});
[H3] describe.each(table)(name, fn, timeout)​
Use describe.each if you keep duplicating the same test suites with different data. describe.each allows you to write the test suite once and pass data in.
describe.each is available with two APIs:
[H4] 1. describe.each(table)(name, fn, timeout)​
table: Array of Arrays with the arguments that are passed into the fn for each row. If you pass in a 1D array of primitives, internally it will be mapped to a table i.e. [1, 2, 3] -> [[1], [2], [3]].
name: String the title of the test suite.
Generate unique test titles by positionally injecting parameters with printf formatting:
%p - pretty-format.
%s- String.
%d- Number.
%i - Integer.
%f - Floating point value.
%j - JSON.
%o - Object.
%# - Index of the test case.
%$ - Number of the test case.
%% - single percent sign ('%'). This does not consume an argument.
Or generate unique test titles by injecting properties of test case object with $variable
To inject nested object values use you can supply a keyPath i.e. $variable.path.to.value (only works for "own" properties, e.g. $variable.constructor.name wouldn't work)
You can use $# to inject the index of the test case
You cannot use $variable with the printf formatting except for %%
fn: Function the suite of tests to be run, this is the function that will receive the parameters in each row as function arguments.
Optionally, you can provide a timeout (in milliseconds) for specifying how long to wait for each row before aborting. The default timeout is 5 seconds.
Example:
describe.each([ [1, 1, 2], [1, 2, 3], [2, 1, 3],])('.add(%i, %i)', (a, b, expected) => { test(`returns ${expected}`, () => { expect(a + b).toBe(expected); }); test(`returned value not be greater than ${expected}`, () => { expect(a + b).not.toBeGreaterThan(expected); }); test(`returned value not be less than ${expected}`, () => { expect(a + b).not.toBeLessThan(expected); });});
describe.each([ {a: 1, b: 1, expected: 2}, {a: 1, b: 2, expected: 3}, {a: 2, b: 1, expected: 3},])('.add($a, $b)', ({a, b, expected}) => { test(`returns ${expected}`, () => { expect(a + b).toBe(expected); }); test(`returned value not be greater than ${expected}`, () => { expect(a + b).not.toBeGreaterThan(expected); }); test(`returned value not be less than ${expected}`, () => { expect(a + b).not.toBeLessThan(expected); });});
[H4] 2. describe.each`table`(name, fn, timeout)​
table: Tagged Template Literal
First row of variable name column headings separated with |
One or more subsequent rows of data supplied as template literal expressions using ${value} syntax.
name: String the title of the test suite, use $variable to inject test data into the suite title from the tagged template expressions, and $# for the index of the row.
To inject nested object values use you can supply a keyPath i.e. $variable.path.to.value (only works for "own" properties, e.g. $variable.constructor.name wouldn't work)
fn: Function the suite of tests to be run, this is the function that will receive the test data object.
Optionally, you can provide a timeout (in milliseconds) for specifying how long to wait for each row before aborting. The default timeout is 5 seconds.
Example:
describe.each` a | b | expected ${1} | ${1} | ${2} ${1} | ${2} | ${3} ${2} | ${1} | ${3}`('$a + $b', ({a, b, expected}) => { test(`returns ${expected}`, () => { expect(a + b).toBe(expected); }); test(`returned value not be greater than ${expected}`, () => { expect(a + b).not.toBeGreaterThan(expected); }); test(`returned value not be less than ${expected}`, () => { expect(a + b).not.toBeLessThan(expected); });});
[H3] describe.only(name, fn)​
Also under the alias: fdescribe(name, fn)
You can use describe.only if you want to run only one describe block:
describe.only('my beverage', () => { test('is delicious', () => { expect(myBeverage.delicious).toBeTruthy(); }); test('is not sour', () => { expect(myBeverage.sour).toBeFalsy(); });});describe('my other beverage', () => { // ... will be skipped});
[H3] describe.only.each(table)(name, fn)​
Also under the aliases: fdescribe.each(table)(name, fn) and fdescribe.each`table`(name, fn)
Use describe.only.each if you want to only run specific tests suites of data driven tests.
describe.only.each is available with two APIs:
[H4] describe.only.each(table)(name, fn)​
describe.only.each([ [1, 1, 2], [1, 2, 3], [2, 1, 3],])('.add(%i, %i)', (a, b, expected) => { test(`returns ${expected}`, () => { expect(a + b).toBe(expected); });});test('will not be run', () => { expect(1 / 0).toBe(Infinity);});
[H4] describe.only.each`table`(name, fn)​
describe.only.each` a | b | expected ${1} | ${1} | ${2} ${1} | ${2} | ${3} ${2} | ${1} | ${3}`('returns $expected when $a is added to $b', ({a, b, expected}) => { test('passes', () => { expect(a + b).toBe(expected); });});test('will not be run', () => { expect(1 / 0).toBe(Infinity);});
[H3] describe.skip(name, fn)​
Also under the alias: xdescribe(name, fn)
You can use describe.skip if you do not want to run the tests of a particular describe block:
describe('my beverage', () => { test('is delicious', () => { expect(myBeverage.delicious).toBeTruthy(); }); test('is not sour', () => { expect(myBeverage.sour).toBeFalsy(); });});describe.skip('my other beverage', () => { // ... will be skipped});
Using describe.skip is often a cleaner alternative to temporarily commenting out a chunk of tests. Beware that the describe block will still run. If you have some setup that also should be skipped, do it in a beforeAll or beforeEach block.
[H3] describe.skip.each(table)(name, fn)​
Also under the aliases: xdescribe.each(table)(name, fn) and xdescribe.each`table`(name, fn)
Use describe.skip.each if you want to stop running a suite of data driven tests.
describe.skip.each is available with two APIs:
[H4] describe.skip.each(table)(name, fn)​
describe.skip.each([ [1, 1, 2], [1, 2, 3], [2, 1, 3],])('.add(%i, %i)', (a, b, expected) => { test(`returns ${expected}`, () => { expect(a + b).toBe(expected); // will not be run });});test('will be run', () => { expect(1 / 0).toBe(Infinity);});
[H4] describe.skip.each`table`(name, fn)​
describe.skip.each` a | b | expected ${1} | ${1} | ${2} ${1} | ${2} | ${3} ${2} | ${1} | ${3}`('returns $expected when $a is added to $b', ({a, b, expected}) => { test('will not be run', () => { expect(a + b).toBe(expected); // will not be run });});test('will be run', () => { expect(1 / 0).toBe(Infinity);});
[H3] test(name, fn, timeout)​
Also under the alias: it(name, fn, timeout)
All you need in a test file is the test method which runs a test. For example, let's say there's a function inchesOfRain() that should be zero. Your whole test could be:
test('did not rain', () => { expect(inchesOfRain()).toBe(0);});
The first argument is the test name; the second argument is a function that contains the expectations to test. The third argument (optional) is timeout (in milliseconds) for specifying how long to wait before aborting. The default timeout is 5 seconds.
If a promise is returned from test, Jest will wait for the promise to resolve before letting the test complete. For example, let's say fetchBeverageList() returns a promise that is supposed to resolve to a list