Mocking modules and functions in Node.js - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output when mocking a module function with Jest?

Consider the following Node.js module and test code using Jest. What will be the output of the test?

Node.js

// math.js
export function add(a, b) {
  return a + b;
}

// math.test.js
import * as math from './math';

test('mock add function', () => {
  jest.spyOn(math, 'add').mockImplementation(() => 42);
  const result = math.add(1, 2);
  console.log(result);
});

A 42

B 3

C undefined

D TypeError: math.add is not a function

💡 Hint

Think about what jest.spyOn with mockImplementation does to the original function.

The jest.spyOn replaces the original add function with a mock that returns 42 regardless of input. So calling math.add(1, 2) returns 42.

📝 Syntax

intermediate

Which option correctly mocks a default export function in Jest?

Given a module with a default export function, which Jest mock syntax correctly mocks it?

Node.js

// greet.js
export default function greet(name) {
  return `Hello, ${name}!`;
}

// greet.test.js
import greet from './greet';

jest.mock('./greet', () => {
  // Fill in the mock implementation
});

A return { greet: jest.fn(() => 'Hi!') };

B return jest.fn(() => 'Hi!');

C return { default: jest.fn(() => 'Hi!') };

D ;)'!iH' >= )((nf.tsej nruter

💡 Hint

Default exports are properties named 'default' in the mock object.

When mocking a default export, the mock must return an object with a default property that is the mocked function.

🔧 Debug

advanced

Why does this Jest mock not replace the imported function?

Look at this test code. Why does the mock not replace the original function when called?

Node.js

// utils.js
export function fetchData() {
  return 'real data';
}

// app.js
import { fetchData } from './utils';
export function getData() {
  return fetchData();
}

// app.test.js
import { getData } from './app';
import * as utils from './utils';

jest.mock('./utils');
test('mock fetchData', () => {
  utils.fetchData.mockReturnValue('mocked data');
  const result = getData();
  console.log(result);
});

A Because utils.fetchData is not imported correctly.

B Because fetchData is not a mock function and cannot use mockReturnValue.

C Because jest.mock must be called at the top level, not inside the test.

D Because getData imports fetchData before the mock is applied, so it uses the original.

💡 Hint

Consider when the module is imported and when the mock is applied.

The getData function imports fetchData before the mock is applied, so it uses the original function. Jest mocks must be set up before importing the module that uses the function.

❓ state_output

advanced

What is the output after resetting mocks in Jest?

Given this test code, what will be the output of the console.log statements?

Node.js

const utils = {
  getNumber: () => 5
};

jest.mock('./utils', () => ({
  getNumber: jest.fn(() => 10)
}));

import { getNumber } from './utils';

console.log(getNumber());

getNumber.mockReset();

console.log(getNumber());

A

10
5

B

10
undefined

C

10
10

D

5
undefined

💡 Hint

What does mockReset do to the mock function's implementation?

mockReset clears the mock implementation, so the function returns undefined after reset.

🧠 Conceptual

expert

Which statement about mocking ES modules with Jest is true?

Select the correct statement about mocking ES modules and their functions in Jest.

A You can mock named exports by replacing the entire module with jest.mock and returning an object with the named exports as jest.fn().

B jest.spyOn cannot be used on ES module functions because they are read-only.

C To mock a default export, you must always use jest.fn() directly without wrapping in an object.

D Jest automatically mocks all ES module functions without any configuration.

💡 Hint

Think about how jest.mock replaces modules and how named exports are mocked.

jest.mock can replace the entire module by returning an object with named exports mocked as jest.fn(). This is the standard way to mock named exports.