Mocking providers in NestJS - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of mocking providers in NestJS testing?

Mocking providers allows you to replace real services with fake ones during tests. This helps isolate the unit being tested and avoid side effects like database calls.

beginner

How do you create a mock provider in NestJS?

You create a mock provider by defining an object with the same methods as the real provider but with fake implementations, then use it in the test module's providers array with the 'provide' and 'useValue' keys.

intermediate

What is the difference between 'useValue' and 'useClass' when mocking providers?

'useValue' lets you provide a specific object as the mock, while 'useClass' lets you provide a class that NestJS will instantiate as the mock provider.

intermediate

Why is it important to mock asynchronous methods in providers during tests?

Mocking async methods prevents real asynchronous operations like HTTP requests or database calls, making tests faster and more reliable by controlling the returned data.

intermediate

How can you verify that a mocked provider method was called in a NestJS test?

You can use Jest's spy functions like jest.fn() or jest.spyOn() to track calls and arguments of the mocked method, then assert on those in your test.

In NestJS testing, which property is used to replace a provider with a mock object?

A useValue

B useFactory

C useExisting

D useClass

The 'useValue' property lets you provide a specific mock object to replace the real provider.

What is the main benefit of mocking providers in unit tests?

A To increase the size of the test files

B To speed up tests by avoiding real dependencies

C To make the app run in production

D To add more features to the app

Mocking providers speeds up tests by avoiding real calls like database or network requests.

Which Jest function helps track calls to a mocked method?

A jest.spyOn()

B jest.mock()

C jest.fn()

D jest.clearAllMocks()

jest.fn() creates a mock function that tracks calls and arguments.

If you want NestJS to instantiate a mock class as a provider, which property do you use?

A useExisting

B useValue

C useFactory

D useClass

'useClass' tells NestJS to instantiate the given class as the provider.

Which of these is NOT a reason to mock a provider in NestJS tests?

A Make tests slower

B Avoid side effects like database calls

C Isolate the unit under test

D Control returned data

Mocking providers makes tests faster, not slower.

Explain how to mock a provider in a NestJS test module and why it is useful.

Think about how you replace a real helper with a pretend one in a test.

Describe how you can check if a mocked provider method was called during a test in NestJS.

Consider how you watch if a friend actually used your fake tool.

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