Mocking providers in NestJS - Mini Project: Build & Apply

Mocking Providers in NestJS

📖 Scenario: You are building a simple NestJS service that fetches user data. To test this service without calling the real database, you will create a mock provider.

🎯 Goal: Build a NestJS test setup that mocks a provider called UserService using a mock object. This will help you test your service without real dependencies.

📋 What You'll Learn

Create a mock object for UserService with a method findUser returning a fixed user

Create a testing module that provides the mock UserService

Inject the mock UserService into the test

Verify the mock method is called and returns the expected user

💡 Why This Matters

🌍 Real World

Mocking providers is essential for testing NestJS services without relying on real databases or external APIs. It helps isolate the code under test and speeds up testing.

💼 Career

Understanding how to mock providers is a key skill for backend developers working with NestJS to write reliable unit tests and maintain code quality.

1

Create a mock object for UserService

Create a constant called mockUserService that is an object with a method findUser which returns the object { id: 1, name: 'Alice' }.

NestJS

# Create mockUserService with findUser method returning { id: 1, name: 'Alice' }
# Your code here

Hint

Use an object with a method that returns the fixed user object.

2

Create a testing module with the mock provider

Use Test.createTestingModule to create a module that provides UserService using the value mockUserService. Assign the created module to a constant called moduleRef.

NestJS

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

// Create testing module with UserService provider using mockUserService
// Your code here

Hint

Use provide and useValue to replace UserService with the mock.

3

Inject the mock UserService from the testing module

Use moduleRef.get to get the UserService and assign it to a constant called userService.

NestJS

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

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

// Get UserService from moduleRef
// Your code here

Hint

Use moduleRef.get('UserService') to retrieve the mock.

4

Call the mock method and verify the returned user

Call userService.findUser() and assign the result to a constant called user. Then add a comment that this user should be { id: 1, name: 'Alice' }.

NestJS

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

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

const userService = moduleRef.get('UserService');

// Call findUser and assign to user
// Your code here

Hint

Call the mock method and store the returned user object.

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