Jest Testing Interview Questions India 2026: Unit Testing, Mocking, and Code Coverage

Understanding the philosophy behind unit testing is as important as knowing the Jest API. Interviewers at Indian product companies want to know that you write tests purposefully, not just to hit a coverage number.

Unit testing philosophy:

1. Test the smallest unit in isolation: a pure function, a class method, a React component — tested without depending on real databases, APIs, or other services
2. Tests should be FIRST: Fast (milliseconds per test), Independent (no shared state between tests), Repeatable (same result every run), Self-validating (pass or fail clearly), Timely (written alongside the code)
3. Arrange, Act, Assert (AAA) pattern: set up the test data (Arrange), call the function under test (Act), verify the result (Assert)
4. Test behaviour, not implementation: test what a function does, not how it does it internally; tests that depend on implementation details break when you refactor

Jest test structure:

1. describe('groupName', () => { ... }) — groups related tests; can be nested
2. it('should do X when Y', () => { ... }) or test('...', () => { ... }) — defines a single test case
3. expect(value).toBe(expected) — strict equality (Object.is); use for primitives
4. expect(value).toEqual(expected) — deep equality; use for objects and arrays
5. expect(fn).toThrow('error message') — assert that a function throws
6. expect(mock).toHaveBeenCalledWith(arg1, arg2) — assert a mock was called with specific arguments
7. expect(mock).toHaveBeenCalledTimes(2) — assert a mock was called exactly twice
8. expect(value).toBeTruthy() / .toBeFalsy() — loose truthiness checks
9. expect(array).toContain(item) — assert an array contains a value
10. expect(string).toMatch(/regex/) — assert a string matches a regex

Test lifecycle hooks:

1. beforeAll(() => { ... }) — runs once before all tests in the describe block
2. afterAll(() => { ... }) — runs once after all tests; use for cleanup
3. beforeEach(() => { ... }) — runs before each test; use to reset state
4. afterEach(() => { ... }) — runs after each test; use to clean up mocks (jest.clearAllMocks())

Mocking is the most important Jest skill tested in interviews. You need to isolate the unit under test from its dependencies.

jest.fn():

1. Creates a mock function that records all calls: const mockFn = jest.fn()
2. Returns undefined by default; configure a return value: mockFn.mockReturnValue(42)
3. mockFn.mockReturnValueOnce(value) — return a value only on the next call; subsequent calls revert to default
4. mockFn.mockImplementation(fn) — provide a full implementation: mockFn.mockImplementation((x) => x * 2)
5. mockFn.mock.calls — array of all calls: [[arg1, arg2], [arg1, arg2], ...]
6. mockFn.mock.results — array of return values: [{ type: 'return', value: 42 }, ...]
7. jest.clearAllMocks() — clear mock.calls and mock.results but keep the implementation
8. jest.resetAllMocks() — clear calls and reset implementation to undefined

jest.spyOn():

1. Spies on an existing method without fully replacing it: jest.spyOn(object, 'methodName')
2. The original method still runs unless you also call .mockImplementation() or .mockReturnValue()
3. Use spyOn to assert that a method was called without changing its behaviour: const spy = jest.spyOn(console, 'error').mockImplementation(() => {})
4. Restore the original after the test: spy.mockRestore()

jest.mock():

1. Auto-mocks an entire module: jest.mock('./userService') — all exported functions become jest.fn()
2. Manual mock: create a _mocks_ folder next to the module with a file of the same name
3. jest.mock('../api', () => ({ fetchUser: jest.fn() })) — provide a factory for more control
4. ES module mocking: jest.mock is hoisted to the top of the file by Babel; you must use jest.mock before imports that depend on it (or use jest.isolateModules)

Async testing:

1. Return a Promise: test('should fetch', () => { return fetchData().then(data => expect(data).toBeDefined()) })
2. async/await: test('should fetch', async () => { const data = await fetchData(); expect(data).toBeDefined(); })
3. Mocking async functions: mockFn.mockResolvedValue(data) and mockFn.mockRejectedValue(new Error('fail'))
4. Testing timers: jest.useFakeTimers() replaces setTimeout/setInterval with controllable mocks; call jest.runAllTimers() or jest.advanceTimersByTime(1000) to trigger them

Snapshot testing and code coverage are commonly discussed in Jest interviews. For frontend roles, React Testing Library integration is also expected.

Snapshot testing:

1. expect(component).toMatchSnapshot() — serialises the component/object and compares it to a stored snapshot file
2. On the first run, Jest creates the snapshot file; on subsequent runs it compares against the stored snapshot
3. If the output changes intentionally, update snapshots with: jest --updateSnapshot (or jest -u)
4. Snapshot files (*.snap) should be committed to version control
5. Use sparingly: snapshot tests catch accidental changes but can produce noisy diffs for large components; prefer explicit assertions for logic-critical behaviour
6. toMatchInlineSnapshot() — stores the snapshot inline in the test file; useful for small values

Code coverage:

1. jest --coverage generates a coverage report using Istanbul (built into Jest)
2. Four coverage metrics: Statements (each statement executed), Branches (each branch of if/else/ternary/switch executed), Functions (each function called), Lines (each line executed)
3. Configure in jest.config.js: coverageThreshold sets minimum coverage percentages; CI fails if below the threshold
4. coveragePathIgnorePatterns: exclude generated files, vendor code, and type definitions
5. Interpreting coverage: 100% coverage does not mean bug-free; test quality (assertions) matters more than coverage percentage; use coverage to find untested code paths, not as a goal in itself

React Testing Library:

1. @testing-library/react renders components in a simulated DOM (jsdom) and provides queries
2. Queries: getByText, getByRole, getByLabelText, getByTestId (use data-testid attributes); prefer getByRole (most accessible) and getByLabelText
3. getBy throws if not found; queryBy returns null; findBy returns a Promise (for async elements)
4. fireEvent.click(button) — trigger DOM events
5. userEvent.type(input, 'text') — @testing-library/user-event simulates real user interactions more accurately than fireEvent
6. waitFor(() => expect(...)) — retry the assertion until it passes or times out; use for async state updates
7. act(): React Testing Library wraps renders and events in act() automatically; you only need it manually for custom hooks or asynchronous state updates outside of the library's utilities