Mocking providers in NestJS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output when a mocked service returns a fixed value?

Given a NestJS service mocked to always return 42 for a method call, what will the controller return when calling that method?

NestJS

class RealService {
  getValue() {
    return Math.random();
  }
}

const mockService = {
  getValue: () => 42
};

class Controller {
  constructor(private service) {}
  fetch() {
    return this.service.getValue();
  }
}

const controller = new Controller(mockService);
console.log(controller.fetch());

A 42

B A random number between 0 and 1

C undefined

D Throws a TypeError

💡 Hint

Think about what the mocked method returns instead of the real one.

The mocked service's getValue method always returns 42. So the controller's fetch method returns 42 as well.

📝 Syntax

intermediate

Which option correctly mocks a provider in NestJS testing module?

Which code snippet correctly mocks a provider named DataService in a NestJS testing module?

NestJS

import { Test } from '@nestjs/testing';
import { DataService } from './data.service';

const mockDataService = { fetch: () => 'mocked data' };

async function setup() {
  const moduleRef = await Test.createTestingModule({
    providers: [
      DataService,
      // Mock provider here
    ],
  }).compile();
  return moduleRef;
}

A { useValue: mockDataService }

B { provide: DataService, useClass: mockDataService }

C { provide: 'DataService', useValue: mockDataService }

D { provide: DataService, useValue: mockDataService }

💡 Hint

Remember the syntax for replacing a provider with a mock object.

To mock a provider, use provide with the original class and useValue with the mock object. Option D follows this pattern correctly.

🔧 Debug

advanced

Why does the mocked provider override the real one?

In this NestJS test setup, the mock provider does override the real service. What is the cause?

NestJS

const moduleRef = await Test.createTestingModule({
  providers: [
    RealService,
    { provide: RealService, useValue: mockService },
  ],
}).compile();

A The real service is listed before the mock, so the mock is ignored

B NestJS merges providers and uses the last one, so this setup is correct

C The mock provider must be listed before the real service to override it

D The mock provider is ignored because useValue is invalid here

💡 Hint

Consider how NestJS handles multiple providers with the same token.

NestJS uses the last provider with the same token when resolving dependencies. So the mock provider correctly overrides the real one.

❓ state_output

advanced

What is the value of the call count after multiple calls to a mocked method?

Given a mocked provider method that tracks call count, what is the value of callCount after three calls?

NestJS

const mockService = {
  callCount: 0,
  fetch() {
    this.callCount++;
    return 'data';
  }
};

mockService.fetch();
mockService.fetch();
mockService.fetch();

console.log(mockService.callCount);

A 3

B 0

C undefined

D Throws a ReferenceError

💡 Hint

Think about how the method updates the callCount property.

Each call to fetch increments callCount by 1. After three calls, it becomes 3.

🧠 Conceptual

expert

Which statement best describes the purpose of mocking providers in NestJS tests?

Why do developers mock providers in NestJS unit tests?

A To automatically generate real service instances with default data

B To improve application performance by using faster mock implementations in production

C To isolate the unit under test by replacing dependencies with controlled mocks

D To avoid writing tests for services by mocking their behavior

💡 Hint

Think about the goal of unit testing and how mocks help.

Mocking providers isolates the unit under test by replacing real dependencies with controlled mocks, ensuring tests are focused and predictable.

Practice

1. What is the main purpose of mocking providers in NestJS tests?

easy

A. To replace real services with fake ones to isolate tests

B. To speed up the application in production

C. To add new features to the service

D. To automatically generate database records

Solution

1. Step 1: Understand the role of mocking in tests

   Mocking replaces real dependencies with controlled fake versions to isolate the code under test.

2. Step 2: Identify the purpose in NestJS context

   In NestJS, mocking providers helps avoid side effects and external calls during testing.

3. Final Answer:

   To replace real services with fake ones to isolate tests -> Option A

4. Quick Check:

   Mocking = isolate tests [OK]

Hint: Mocking means replacing real parts with fakes in tests [OK]

Common Mistakes:

• Thinking mocking speeds up production
• Confusing mocking with adding features
• Assuming mocking generates data automatically

2. Which syntax correctly mocks a provider in a NestJS test module?

easy

A. { provide: RealService, useValue: mockService }

B. { provide: mockService, useClass: RealService }

C. { useValue: RealService, provide: mockService }

D. { useClass: mockService, provide: RealService }

Solution

1. Step 1: Recall NestJS mocking syntax

   Mocking uses an object with keys 'provide' for the real service and 'useValue' for the mock.

2. Step 2: Match correct key order and values

   { provide: RealService, useValue: mockService } correctly uses 'provide' with the real service and 'useValue' with the mock object.

3. Final Answer:

   { provide: RealService, useValue: mockService } -> Option A

4. Quick Check:

   Mock syntax = provide + useValue [OK]

Hint: Remember: provide real, useValue mock [OK]

Common Mistakes:

• Swapping provide and useValue keys
• Using useClass instead of useValue for mocks
• Putting mock as provide instead of real service

3. Given this NestJS test setup:

const mockUserService = { findUser: () => ({ id: 1, name: 'Test' }) };

const moduleRef = await Test.createTestingModule({
  providers: [
    { provide: UserService, useValue: mockUserService },
  ],
}).compile();

const service = moduleRef.get(UserService);
const user = service.findUser();
console.log(user);

What will be logged to the console?

medium

A. Error: UserService not found

B. undefined

C. { id: 1, name: 'Test' }

D. { findUser: [Function] }

Solution

1. Step 1: Understand the mock provider setup

   The mockUserService has a method findUser returning an object with id and name.

2. Step 2: Check what service.findUser() returns

   Since the mock is used, calling findUser() returns { id: 1, name: 'Test' } as defined.

3. Final Answer:

   { id: 1, name: 'Test' } -> Option C

4. Quick Check:

   Mock method returns object [OK]

Hint: Mock methods return defined fake data [OK]

Common Mistakes:

• Expecting real service output instead of mock
• Assuming service is undefined
• Confusing method with object itself

4. You wrote this test code but get an error: TypeError: service.findUser is not a function. What is the likely cause?

const mockUserService = {};

const moduleRef = await Test.createTestingModule({
  providers: [
    { provide: UserService, useValue: mockUserService },
  ],
}).compile();

const service = moduleRef.get(UserService);
service.findUser();

medium

A. useClass should be used instead of useValue

B. UserService was not provided in the module

C. The compile() method was not awaited

D. The mockUserService does not define the findUser method

Solution

1. Step 1: Check the mock object definition

   The mockUserService is an empty object with no findUser method defined.

2. Step 2: Understand the error cause

   Calling findUser on an object without that method causes TypeError.

3. Final Answer:

   The mockUserService does not define the findUser method -> Option D

4. Quick Check:

   Missing method in mock = TypeError [OK]

Hint: Ensure mock defines all called methods [OK]

Common Mistakes:

• Assuming compile() missing await causes this error
• Confusing useClass and useValue for mocks
• Thinking provider missing causes this specific error

5. You want to test a service that depends on another service with a method returning a promise. How do you mock the provider to return a resolved promise with value 'done'?

hard

A. { provide: DepService, useValue: { asyncMethod: () => 'done' } }

B. { provide: DepService, useValue: { asyncMethod: () => Promise.resolve('done') } }

C. { provide: DepService, useValue: { asyncMethod: () => async () => 'done' } }

D. { provide: DepService, useValue: { asyncMethod: () => new Promise('done') } }

Solution

1. Step 1: Understand mocking async methods

   To mock a method returning a promise resolved with 'done', use Promise.resolve('done').

2. Step 2: Check each option for correct promise return

   { provide: DepService, useValue: { asyncMethod: () => Promise.resolve('done') } } correctly returns Promise.resolve('done'). { provide: DepService, useValue: { asyncMethod: () => 'done' } } returns a string, not a promise. { provide: DepService, useValue: { asyncMethod: () => async () => 'done' } } returns a function, not a promise. { provide: DepService, useValue: { asyncMethod: () => new Promise('done') } } incorrectly uses new Promise with a string argument.

3. Final Answer:

   { provide: DepService, useValue: { asyncMethod: () => Promise.resolve('done') } } -> Option B

4. Quick Check:

   Mock async with Promise.resolve(value) [OK]

Hint: Use Promise.resolve('value') to mock async returns [OK]

Common Mistakes:

• Returning plain value instead of promise
• Incorrect new Promise usage
• Confusing async function syntax with promise return