Question 1

Is Jest still relevant in 2026 with Vitest gaining ground?

Accepted Answer

Yes — Jest still has the largest install base in JS testing (npm downloads ~25M/week vs Vitest ~10M/week as of mid-2026) and is the default for Next.js Pages Router, Create React App migrations, and most React codebases older than 2023. Vitest is the better choice for new projects on Vite/Astro/SvelteKit, but Jest skills remain essential for the millions of existing React codebases — and the API is nearly identical, so the skill transfers.

Question 2

How much does a frontend developer with strong Jest skills earn in India?

Accepted Answer

₹5-18 LPA in 2026 for mid-level React developers, with strong testing skills (Jest + RTL + Cypress/Playwright) bumping you toward the upper end. Companies that pay well for testing rigor: Razorpay, Swiggy, CRED, Freshworks, Postman, Zomato. Senior-level (5+ years) with a focus on testing infrastructure can clear ₹25 LPA at FAANG offices in Bengaluru.

Question 3

Should I learn Jest or Vitest first if I'm new to JS testing?

Accepted Answer

Learn the concepts (matchers, mocking, async testing, RTL patterns) — they transfer between both tools. If you're learning to get a job in India, start with Jest because most interview questions and existing codebases use it. After 2-3 months, try Vitest for a side project; you'll find 90% of what you learned applies directly.

Question 4

Do I need to write tests for every component and function?

Accepted Answer

No. Test (1) anything with branching logic — every if/else, every map/filter with a non-trivial predicate, (2) anything that handles user input or external data — forms, API clients, parsers, (3) anything that has broken in production at least once. Skip trivial getters, pass-through wrappers, and dumb components that only render props. 80% coverage in critical paths beats 100% in trivia.

Question 5

How do I convince my team to invest in tests when we're shipping fast?

Accepted Answer

Show the cost of NOT testing: count the last 10 production bugs, count how many would have been caught by a 5-minute unit test, multiply by the actual incident hours. In Indian startups specifically, point at Razorpay/Postman/CRED engineering blogs — they all credit testing investment for sustained velocity. Start small: 70% coverage on the auth and payments paths only; let the rest stabilize organically.

Question 6

What is Jest and why did it become the default JavaScript testing framework?

Accepted Answer

Jest is a JavaScript testing framework built by Facebook (now Meta) in 2014, originally to test the React codebase, and open-sourced soon after. It became the de-facto standard for three reasons: (1) it's batteries-included — test runner, assertion library, mocking, code coverage (Istanbul), and snapshot testing all ship in one package, so you don't have to wire together Mocha + Chai + Sinon + Istanbul + Karma like the pre-Jest era required, (2) it runs tests in parallel across worker processes by default, which made the React monorepo's test suite (tens of thousands of tests) tractable to run in reasonable wall-clock time, (3) it has zero-config support for Babel/TypeScript/JSX out of the box — clone any React repo and `jest` Just Works. Before Jest, every JS project had a different testing setup; after Jest, the question became 'which Jest config do we use' instead of 'which testing libraries do we glue together.' In 2026, every major React shop in India (Razorpay, Swiggy, CRED, Freshworks, Zomato, Cure.fit) uses Jest — or its modern challenger Vitest — as the unit-test runner. The framework is maintained by OpenJS Foundation since 2022 (Facebook transferred ownership to ensure long-term community stewardship).

Question 7

What's the difference between describe, test, and it in Jest?

Accepted Answer

`describe` groups related tests into a block — it doesn't run anything itself, it just creates a logical scope (and a label in the test output). `test` and `it` are aliases for the same function — they declare an individual test case. `it` is preferred in BDD-style codebases because it reads naturally with the description (`it('should add two numbers')`), while `test` is more common in newer code. You can nest `describe` blocks, and `beforeEach`/`afterEach` hooks inside a block apply only to tests in that block and its descendants.

Question 8

What is the difference between toBe and toEqual? (the most-asked matcher question)

Accepted Answer

`toBe` uses `Object.is` (essentially `===` but with NaN === NaN being true) — it checks reference equality for objects and arrays, and value equality for primitives. `toEqual` recursively walks the structure and compares values field by field — it's what you want for objects and arrays. Using `toBe` on objects is the #1 Jest mistake: `expect({a: 1}).toBe({a: 1})` ALWAYS fails because they're different references in memory. Use `toBe` only for primitives (numbers, strings, booleans, null, undefined). For deep equality with `undefined`-vs-missing-key distinctions, use `toStrictEqual` — it also checks that both sides have the same constructor (a class instance vs a plain object are NOT strictly equal even if their fields match) and won't treat `{a: undefined}` as equal to `{}`. Interviewers ask this question constantly because it's the single most common source of cargo-culted Jest tests — junior devs reach for `toBe` because it's shorter, then are confused why their object-comparison tests fail.

Question 9

What are the most common Jest matchers and when do you use each?

Accepted Answer

Beyond `toBe`/`toEqual`, the matchers you'll reach for daily: `toBeNull`/`toBeUndefined`/`toBeDefined` for null/undefined checks, `toBeTruthy`/`toBeFalsy` for boolean coercion, `toBeGreaterThan`/`toBeLessThan` for numeric comparisons, `toBeCloseTo(value, digits)` for floating-point (because `0.1 + 0.2 !== 0.3`), `toMatch(/regex/)` for string patterns, `toContain` for array/string includes, `toHaveLength(n)` for array/string length, `toThrow()` for asserting a function throws. For functions/mocks: `toHaveBeenCalled`, `toHaveBeenCalledTimes(n)`, `toHaveBeenCalledWith(args)`. Use `.not` to negate any matcher: `expect(x).not.toBe(5)`.

Question 10

How do beforeEach, afterEach, beforeAll, and afterAll work?

Accepted Answer

These are lifecycle hooks that let you share setup and teardown. `beforeEach`/`afterEach` run before/after EVERY test in the current `describe` block (and its descendants). `beforeAll`/`afterAll` run ONCE for the whole block — before/after all tests. Use `beforeEach` for state that should be fresh per test (in-memory DB, mock reset, new instance of a class). Use `beforeAll` for expensive one-time setup (starting a server, connecting to a real DB). Hooks nest: a parent's `beforeEach` runs before the child's `beforeEach`. The biggest mistake is sharing mutable state across tests via `beforeAll` — leads to flaky tests where order matters.

Question 11

How do you test asynchronous code in Jest?

Accepted Answer

Three patterns. (1) Return a promise from the test function — Jest waits for it: `test('fetches', () => fetchData().then(d => expect(d).toBe(...)))`. (2) Use async/await — cleanest and most common: `test('fetches', async () => { const d = await fetchData(); expect(d).toBe(...) })`. (3) For callback-style code, accept a `done` callback and call it when finished — though async/await has made this nearly obsolete in 2026. The most common bug is forgetting to `await` or `return` — without it, the test ends before the assertion runs and FALSE-PASSES (the test reports green even though the assertion never executed). A second pattern that helps: `expect.assertions(n)` at the top of an async test tells Jest 'this test MUST run exactly n assertions or it fails' — catches the case where a promise rejection skips your assertion entirely. For rejected promises, use `await expect(fn()).rejects.toThrow(...)` — the `rejects` modifier is critical because without it, the rejection bubbles up and the test fails with an uncaught error instead of a clean assertion failure. ESLint's `jest/valid-expect-in-promise` and `jest/no-conditional-expect` catch most of the missing-await bugs at lint time.

Question 12

What is jest.fn() and how do you use it?

Accepted Answer

`jest.fn()` creates a mock function — a stand-in for a real function that records every call. You use it to (1) replace a function in code under test (a callback, an event handler, an injected dependency), (2) assert it was called with the right arguments, (3) control what it returns. The returned mock has properties like `.mock.calls` (array of every call's arguments, where `.mock.calls[0]` is the first call's args), `.mock.results` (array of return values or thrown errors), `.mock.instances` (for constructor calls), and methods like `.mockReturnValue(x)`, `.mockResolvedValue(x)` (for async functions), `.mockRejectedValue(err)` (for async failures), and `.mockImplementation(fn)` for full custom behavior. The `Once` variants (`mockReturnValueOnce`, `mockResolvedValueOnce`) queue values consumed one per call — useful for testing retry logic where the first attempt fails but the second succeeds. Without arguments, `jest.fn()` returns `undefined` for every call.

Question 13

How does jest.mock() work and when do you use it?

Accepted Answer

`jest.mock('./path-to-module')` replaces an entire module with an auto-generated mock — every exported function becomes a `jest.fn()` returning `undefined`. You use it to isolate the unit under test from its dependencies (database, network, file system). The call is hoisted to the top of the file by Jest's Babel transform, so it runs BEFORE the imports — that's why you can put it anywhere in the file and it still works. To control what the mock returns, pass a factory: `jest.mock('./api', () => ({ fetchUser: jest.fn().mockResolvedValue({...}) }))`.

Question 14

What is jest.spyOn() and how is it different from jest.fn()?

Accepted Answer

`jest.spyOn(object, 'methodName')` wraps an existing method so you can spy on its calls — but UNLIKE `jest.fn()` or `jest.mock()`, the original implementation is still called by default. This is useful when you want to verify a method was invoked but still let it run (e.g., verifying `console.error` was called during error handling). You can override the behavior with `.mockImplementation(fn)` and restore the original with `.mockRestore()`. Always pair `spyOn` with `mockRestore` in `afterEach` — otherwise the spy leaks into other tests.

Question 15

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

Accepted Answer

Wrap the call in a function and pass that to `expect`, then use `.toThrow()`. You can match by error message (string substring or regex), by error type, or just assert that any error was thrown. The critical detail: you must wrap in a function — `expect(throwingFn()).toThrow()` actually calls the function during expect and throws BEFORE the matcher runs, leading to test failure for the wrong reason. For async functions, use `await expect(asyncFn()).rejects.toThrow(...)`.

Jest Interview Questions

What is Jest and why did it become the default JavaScript testing framework?

What's the difference between describe, test, and it in Jest?

What is the difference between toBe and toEqual? (the most-asked matcher question)

What are the most common Jest matchers and when do you use each?

How do beforeEach, afterEach, beforeAll, and afterAll work?

How do you test asynchronous code in Jest?

What is jest.fn() and how do you use it?

How does jest.mock() work and when do you use it?

What is jest.spyOn() and how is it different from jest.fn()?

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

What is snapshot testing and how do you use it?

How do you run Jest and what are common CLI flags?

How do you mock a specific function while keeping the rest of the module real?

How do you test code that uses setTimeout or setInterval?

What's the difference between 'legacy' and 'modern' fake timers?

How do you test a React component with Jest and React Testing Library?

How do you test asynchronous UI updates in React Testing Library?

What is mock pollution and how do you avoid it?

How does Jest's module resolution and resetModules work?

How do you enforce code coverage thresholds in Jest?

What's the difference between toBeInTheDocument, toBeVisible, and toBeInTheViewport?

How do you mock a global like fetch or localStorage in Jest?

When does snapshot testing go wrong, and what should you do instead?

How do you set up Jest for a TypeScript project?

How do you debug a failing or flaky Jest test?

How does Jest compare to Vitest, and which should you pick in 2026?

How does Jest compare to Mocha, Jasmine, and AVA?

What are the worst Jest gotchas you've debugged in production?

How would you architect a testing strategy for a large React monorepo?

What changed in the latest Jest releases, and what's coming?

Companies Hiring Jest

Salary Insights

Frequently Asked Questions

Is Jest still relevant in 2026 with Vitest gaining ground?

How much does a frontend developer with strong Jest skills earn in India?

Should I learn Jest or Vitest first if I'm new to JS testing?

Do I need to write tests for every component and function?

How do I convince my team to invest in tests when we're shipping fast?

Introduction