Question 1

What is Jest, and what are its key advantages?

Accepted Answer

Jest is a delightful JavaScript testing framework maintained by Meta, designed with a focus on simplicity. Key advantages include: zero configuration out-of-the-box, built-in assertion library, built-in test runner, built-in mocking utilities, snapshot testing, parallel test execution, and fast watch mode.

Question 2

Explain the difference between `toBe()` and `toEqual()` matchers in Jest.

Accepted Answer

`toBe()` checks for strict identity equality using `Object.is` (compares memory references, like `===`). `toEqual()` checks for value/structural equality, recursively comparing all properties of objects or elements in arrays.
Code Example:
const obj1 = { value: 1 };
const obj2 = { value: 1 };

expect(obj1).toEqual(obj2); // Passes! Structural match
expect(obj1).toBe(obj2);    // Fails! Different memory references

Question 3

How do you test asynchronous code in Jest?

Accepted Answer

Jest supports testing async code using three main patterns:
1. Async/Await (Preferred): Write test with `async` and `await` promises.
2. Returning a Promise: Return the promise from the test body; Jest waits for resolution.
3. Using the `done` callback parameter: Call `done()` manually when the async code finishes.
Code Example:
// Async/Await example
test('fetches data', async () => {
  const data = await fetchData();
  expect(data).toBe('success');
});

Question 4

What is Snapshot Testing, and when should you use it?

Accepted Answer

Snapshot testing is a technique where Jest renders your UI component, takes a snapshot of its HTML/JSON structure, and saves it in a `.snap` file. On subsequent runs, Jest compares the rendered output with the saved snapshot. It is ideal for verifying that your UI structure does not change unexpectedly. If changes are intended, you update snapshots using the `-u` flag.

Question 5

Explain the difference between `jest.fn()`, `jest.spyOn()`, and `jest.mock()`.

Accepted Answer

- `jest.fn()`: Creates a new, blank mock function. Used to stub callbacks and track calls.
- `jest.spyOn()`: Spies on calls to an existing method of an object while keeping the original implementation. You can mock the implementation later.
- `jest.mock()`: Mocks an entire external module (like `axios` or local files), replacing all its exported functions with mocks automatically.

Question 6

How do you mock an external module (e.g., `axios`) in Jest?

Accepted Answer

You mock external modules by calling `jest.mock('module-name')` at the top of your test file, and then specifying mock values using mock controllers.
Code Example:
import axios from 'axios';
import { getUser } from './user';

jest.mock('axios');

test('should fetch user', async () => {
  axios.get.mockResolvedValue({ data: { name: 'Alice' } });
  const user = await getUser(1);
  expect(user.name).toBe('Alice');
});

Question 7

What are Jest setup and teardown lifecycle hooks?

Accepted Answer

Lifecycle hooks run at specific points during tests:
- `beforeAll()`: Runs once before any tests in the file start.
- `beforeEach()`: Runs before *every* individual test (useful for resetting database/states).
- `afterEach()`: Runs after *every* individual test (useful for cleanup).
- `afterAll()`: Runs once after all tests in the file complete.

Question 8

Explain how to check if a mock function was called.

Accepted Answer

You verify mock functions using Jest mock matchers such as `toHaveBeenCalled()`, `toHaveBeenCalledWith()` (asserts arguments), or `toHaveBeenCalledTimes()`.
Code Example:
const mockCallback = jest.fn();
runHandler(mockCallback);

expect(mockCallback).toHaveBeenCalled();
expect(mockCallback).toHaveBeenCalledWith('default-arg');

Question 9

What is `jest.useFakeTimers()`, and when is it used?

Accepted Answer

`jest.useFakeTimers()` replaces native global timer functions (`setTimeout`, `setInterval`, `clearTimeout`) with mocks. This allows tests to fast-forward through time instantly without blocking the test runner thread.
Code Example:
jest.useFakeTimers();
setTimeout(() => { callback(); }, 10000);

// Fast-forward all timers instantly
jest.runAllTimers();
expect(mockCallback).toHaveBeenCalled();

Question 10

What is a mock implementation vs a mock return value?

Accepted Answer

`mockReturnValue(val)` returns a static value when the mock is called. `mockImplementation(fn)` allows you to pass a custom mock function to calculate values dynamically, mimicking realistic system behaviors.

Question 11

How do you test that a function throws an error in Jest?

Accepted Answer

To test exceptions, you must wrap the target function call in a wrapper function inside the `expect()` statement. Otherwise, the exception will throw unchecked and fail the test runner.
Code Example:
test('throws error on bad input', () => {
  expect(() => {
    parseInput(null);
  }).toThrow('Input cannot be null');
});

Question 12

What is the Jest configuration file, and what is its default name?

Accepted Answer

The Jest configuration file is `jest.config.js` (or `.json`, `.ts`). It is used to specify test environments (Node.js or jsdom), folder setups, code coverage thresholds, and transformer configurations (like babel-jest).

Question 13

What is the difference between `jest.runOnlyPendingTimers()` and `jest.runAllTimers()`?

Accepted Answer

`jest.runAllTimers()` executes all timers in the queue and any new timers scheduled *during* those executions (can result in infinite loops if a timer schedules another). `jest.runOnlyPendingTimers()` runs *only* the timers that are currently pending in the queue, ignoring new ones.

Question 14

What is the difference between `test()` and `describe()` in Jest?

Accepted Answer

`test()` (or `it()`) defines an individual test block that runs assertions. `describe()` defines a test suite group that organizes multiple related tests together, creating scope boundaries for lifecycle hooks.

Question 15

Explain `jest.clearMocks()`, `jest.resetMocks()`, and `jest.restoreMocks()`.

Accepted Answer

- `clearMocks()`: Clears the call history and arguments of all mocks (resets `.mock.calls`). Keeps implementation.
- `resetMocks()`: Clears call history and resets mock implementations to return `undefined`.
- `restoreMocks()`: Restores the original spy implementations created with `jest.spyOn()`, returning them to real functions.

Question 16

What is the difference between Jest's `node` and `jsdom` test environments?

Accepted Answer

The `node` environment is a lightweight environment matching Server-Side Node.js execution. The `jsdom` environment is a simulated browser environment inside Node.js, providing global browser objects (like `window`, `document`, `navigator`) without needing a real browser, ideal for React/Vue testing.

Question 17

Explain code coverage configuration in Jest.

Accepted Answer

Jest has built-in code coverage reporting. You enable it with the `--coverage` CLI flag, or configure thresholds in `jest.config.js` to fail the build if code coverage falls below a target percentage.
Code Example:
// jest.config.js snippet
module.exports = {
  collectCoverage: true,
  coverageThreshold: {
    global: { branches: 80, functions: 80, lines: 80 }
  }
};

Question 18

How do you run a specific single test file in Jest?

Accepted Answer

You run a specific test file by appending its path or filename pattern directly to the Jest execute command.
Code Example:
jest src/components/Button.test.js
# Or run matchers
npm test -- -t "adds 1 + 2"

Question 19

What is the `mockFn.mock.calls` property?

Accepted Answer

`mock.calls` is an array containing the arguments of all calls made to a mock function. The length of the array matches the call count, and each element contains the arguments array passed in that specific call.
Code Example:
// mockFn.mock.calls[0][1] yields second argument of the first call

Question 20

How do you mock modules located in `__mocks__` directory?

Accepted Answer

In Jest, if you create a folder named `__mocks__` adjacent to a module, Jest will automatically resolve mocks from there when you call `jest.mock('module-name')`. For native node modules (like `fs`), placing mocks in `__mocks__` at the root automatically mocks them globally.

Jest JavaScript Testing Interview

Difficulty Filters

Tools & Options

What is Jest, and what are its key advantages?

Explain the difference between `toBe()` and `toEqual()` matchers in Jest.

How do you test asynchronous code in Jest?

What is Snapshot Testing, and when should you use it?

Explain the difference between `jest.fn()`, `jest.spyOn()`, and `jest.mock()`.

How do you mock an external module (e.g., `axios`) in Jest?

What are Jest setup and teardown lifecycle hooks?

Explain how to check if a mock function was called.

What is `jest.useFakeTimers()`, and when is it used?

What is a mock implementation vs a mock return value?

How do you test that a function throws an error in Jest?

What is the Jest configuration file, and what is its default name?

What is the difference between `jest.runOnlyPendingTimers()` and `jest.runAllTimers()`?

What is the difference between `test()` and `describe()` in Jest?

Explain `jest.clearMocks()`, `jest.resetMocks()`, and `jest.restoreMocks()`.

What is the difference between Jest's `node` and `jsdom` test environments?

Explain code coverage configuration in Jest.

How do you run a specific single test file in Jest?

What is the `mockFn.mock.calls` property?

How do you mock modules located in `__mocks__` directory?

Explore Related Tools

Bulma Box Component – Simple Container with Shadow

Bulma Modal Component – Dialogs, Popups & Overlays

Permutation and Combination Calculator (nPr & nCr)

SQL SELECT Statement – Retrieve Data from Database

Bulma Button Component – Styles, Sizes & States

Introduction to Foundation CSS – Complete Guide

Follow Us

Our Tools

Our Company

Special Tools

How do you mock modules located in `mocks` directory?