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.