Jest interview questions and answers

jest.fn() creates a standalone mock function that records calls and can return set values. jest.spyOn(obj, 'method') wraps an existing method to observe it, optionally replacing the implementation, and can be restored. jest.mock('module') replaces a whole module with automatic or factory-made mocks, hoisted above imports.

Return the promise or use async/await in the test, and assert after awaiting. For rejections use await expect(promise).rejects.toThrow(). Never forget to await, or the test passes before the assertion runs. Callback-style code can use the done argument.

It tests one behaviour through the public interface, is independent of other tests and of order, is deterministic (no real time, network or randomness), reads clearly as arrange–act–assert, and fails with a useful message. Mock only boundaries such as network, time and external services.

Use jest.mock('./api', () => ({ __esModule: true, default: jest.fn() })), then import the default and control it with mockResolvedValue or mockImplementation. For native ESM mode, use jest.unstable_mockModule before a dynamic import.

For sync code, expect(() => fn()).toThrow('message') (wrapping the call in a function). For async code, await expect(fn()).rejects.toThrow(). Mock dependencies to fail with mockRejectedValue to test the code paths that handle failures.

Mock things that are slow, nondeterministic or outside your control: network, time, randomness, third-party services. Avoid mocking the code under test or simple pure helpers; too many mocks make tests pass while the real integration is broken.

jest.useFakeTimers() replaces timers and Date with controllable versions. Advance time with jest.advanceTimersByTime(ms), runAllTimers or runOnlyPendingTimers, and set the clock with jest.setSystemTime. Restore with jest.useRealTimers(). Async code with timers may need the async variants.

For stable, serialisable output where any change should be reviewed: small rendered components, generated configs, error messages. Avoid huge snapshots that people update blindly; inline snapshots and focused assertions are often better.

toBe uses Object.is, for primitives or the same reference. toEqual compares values recursively, ignoring undefined properties. toStrictEqual also checks undefined properties, array sparseness and class types.

mockClear resets calls and results, mockReset also removes implementations, mockRestore restores spied originals. Config options clearMocks, resetMocks and restoreMocks do this automatically before each test, which avoids leaking state between tests.

beforeAll/afterAll run once per file or describe block, for expensive setup such as starting a test database. beforeEach/afterEach run around every test, for fresh state. Hooks in a describe apply only to its tests.

Use ts-jest (type-checks during tests) or a transformer like babel-jest or @swc/jest (faster, no type checking), set testEnvironment, moduleNameMapper for path aliases and assets, and run tsc --noEmit separately for types.

It maps import paths to other modules, for path aliases like ^@/(.*)$ to <rootDir>/src/$1, and for replacing CSS or image imports with stubs (for example identity-obj-proxy for CSS modules).

Use fake timers with jest.setSystemTime(new Date(...)) to fix the current time, and spy on Math.random with jest.spyOn(Math, 'random').mockReturnValue(0.5), restoring afterwards.

Functions added with expect.extend({ toBeWithinRange(received, floor, ceiling) {...} }) that return pass and a message. They make domain assertions readable; jest-dom is a popular set of custom matchers.

Run in parallel (default workers), avoid real network and timers, share expensive setup with beforeAll, use faster transformers like SWC, run only changed tests with --onlyChanged locally, and shard in CI with --shard.

setupFiles run before the test framework is installed, for polyfills and environment variables. setupFilesAfterEach run after it, so they can use expect and hooks, for example importing jest-dom matchers or global mocks.

Use toHaveBeenCalledTimes(n), toHaveBeenNthCalledWith(n, ...args) and toHaveBeenLastCalledWith. Inspect mock.calls and mock.invocationCallOrder for order across several mocks.

Run jest --coverage to report statement, branch, function and line coverage, and set coverageThreshold to fail builds that drop below targets. Coverage shows untested code but not test quality; aim tests at behaviour and risky branches.

Use jest.mock with a factory that spreads jest.requireActual('module') and overrides only some exports, so the rest keep their real behaviour.

Each test file runs in its own module registry and environment (node or jsdom), often in separate worker processes in parallel. Module-level state does not leak between files, but it does between tests in the same file.

Mock the network boundary: jest.spyOn(global, 'fetch') with resolved responses, or better, Mock Service Worker (MSW) to intercept requests at the network level, so code under test runs unchanged.

Files in a __mocks__ folder next to a module (or at the root for node_modules packages) replace that module when jest.mock('module') is called, keeping reusable mock implementations in one place.

Save process.env, set values in beforeEach, reset modules with jest.resetModules() if the code reads them at import time, and restore the original object in afterEach.

toMatchInlineSnapshot() writes the snapshot into the test file itself, so reviewers see the expected output next to the test. File snapshots live in __snapshots__. Inline ones suit small outputs.

It reruns tests related to changed files (using Git) as you work, with an interactive menu to filter by file name or test name, which gives fast feedback during development.

Use fake timers and the async helpers await jest.advanceTimersByTimeAsync(ms) or runAllTimersAsync(), which also flush promise callbacks between timers, avoiding tests that hang or finish too early.

A way to run the same test with a table of inputs and expected outputs, so you can cover many cases without repeating code; titles can include values with %s or $name.

test.only runs only that test in the file (useful while debugging); test.skip skips it. Neither should be committed; lint rules can block them.

Both have similar APIs. Vitest uses Vite's transform pipeline, supports ESM and TypeScript natively and is usually faster in Vite projects. Jest is mature with a huge ecosystem. Migration is mostly renaming jest to vi.

1. AtoEqualCorrect answer
2. BtoBeTruthy
3. CtoContain
4. DtoBe

Why: toBe checks identity.

1. Ajest.stub()
2. Bjest.fn()Correct answer
3. Cjest.make()
4. Dmock()

Why: jest.fn records calls and returns.

1. Aexpect(p).toThrow()
2. Bawait expect(p).rejects.toThrow()Correct answer
3. Cexpect(await p).toBeFalsy()
4. Dp.catch(expect)

Why: .rejects unwraps the rejection.

1. Aexpect(fn()).toThrow()
2. Bexpect(fn).rejects
3. Cexpect.throws(fn)
4. Dexpect(() => fn()).toThrow()Correct answer

Why: Wrap the call in a function.

1. AmockThrow
2. BmockReturnValue(Error)
3. CmockFail
4. DmockRejectedValueCorrect answer

Why: For testing failure paths.

1. ANetwork calls and timeCorrect answer
2. BThe function under test
3. CPure helpers
4. DConstants

Why: Slow or nondeterministic parts.

1. Ajest.timers(false)
2. Bjest.useFakeTimers()Correct answer
3. Cjest.mockTime()
4. Djest.freeze()

Why: Then advance time manually.

1. AtoCalledWith
2. BtoHaveArgs
3. CtoBeCalledOnce
4. DtoHaveBeenCalledWithCorrect answer

Why: It checks any call's arguments.

1. ARun where written
2. BHoisted to the top of the fileCorrect answer
3. CIgnored in ESM
4. DOnly for JSON

Why: babel-jest hoists them above imports.

1. Asetup
2. Binit
3. CbeforeAll
4. DbeforeEachCorrect answer

Why: beforeEach gives fresh state per test.

1. AmoduleNameMapperCorrect answer
2. Broots
3. CtestMatch
4. DtransformIgnorePatterns

Why: Also stubs CSS imports.

1. Ajest.useRealTimers
2. BDate.mock
3. Cjest.freeze
4. Djest.setSystemTimeCorrect answer

Why: Works with fake timers.

1. Ajest.matcher
2. Bexpect.extendCorrect answer
3. Cjest.addMatcher
4. Dexpect.custom

Why: Returns pass and message.

1. AsetupFilesAfterEachCorrect answer
2. BsetupFiles
3. CglobalSetup
4. DtestEnvironment

Why: Can use expect.

1. AtoBeCalled
2. BtoHaveBeenNthCalledWith(2, ...)Correct answer
3. CtoHaveBeenCalledTimes(2)
4. DtoHaveReturned

Why: Index starts at 1.

1. AmockReset
2. BmockRestoreCorrect answer
3. CmockStop
4. DmockClear

Why: mockRestore puts back the original.

1. A--ci
2. B--watch
3. C--coverageCorrect answer
4. D--verbose

Why: It prints coverage tables and reports.

1. AtoInclude
2. BtoHave
3. CtoMatch
4. DtoContainCorrect answer

Why: toContain uses ===; toContainEqual compares values.

1. AjsdomCorrect answer
2. Bedge
3. Cdeno
4. Dnode

Why: jsdom provides a DOM.

1. A__mocks__ foldersCorrect answer
2. B__tests__ only
3. Cnode_modules/.mocks
4. Djest.config

Why: Used with jest.mock.

1. AtoMatchObject
2. BtoMatchInlineSnapshotCorrect answer
3. CtoMatchSnapshot
4. DtoEqual

Why: Reviewers see it inline.

1. Ajest.advanceTimersByTimeAsyncCorrect answer
2. Bjest.runOnlyPendingTimers
3. Cjest.clearAllTimers
4. Djest.useRealTimers

Why: The async variant.

1. Ajest.clearAllMocks
2. Bjest.restoreAllMocks
3. Cjest.unmock
4. Djest.resetModulesCorrect answer

Why: Re-import picks up new env.

1. A--bail
2. B--silent
3. C--ci
4. D--onlyChangedCorrect answer

Why: It uses Git to find changed files.

1. Ats-jest
2. Btsc
3. Ceslint
4. D@swc/jestCorrect answer

Why: Run tsc separately.

1. Adescribe.repeat
2. Btest.eachCorrect answer
3. Ctest.loop
4. Dtest.table

Why: test.each parameterises tests.

1. AAsync timing
2. BString length
3. CFloating-point comparisonsCorrect answer
4. DDates

Why: It tolerates rounding errors.

1. AfailUnder
2. BcoverageMin
3. CcoverageThresholdCorrect answer
4. DmaxCoverage

Why: Set global or per-file thresholds.

1. A--shardCorrect answer
2. B--split
3. C--workers
4. D--parallel

Why: e.g. --shard=1/3.

1. Ajest.doMock only
2. Bvi.mock
3. Cjest.unstable_mockModuleCorrect answer
4. Djest.mockESM

Why: For native ESM mode.