Mocking providers in NestJS - Performance & Optimization

Performance: Mocking providers

MEDIUM IMPACT

This concept affects the speed and responsiveness of unit tests by controlling how dependencies are simulated during testing.

Testing a service with dependencies

NestJS

const mockService = { fetchData: jest.fn().mockResolvedValue('mocked data') };
const moduleRef = await Test.createTestingModule({
  providers: [
    DependentService,
    { provide: RealService, useValue: mockService },
  ],
}).compile();

const service = moduleRef.get(DependentService);
await service.callRealDependency();

Mocks replace real calls with fast, predictable responses, speeding up tests and isolating logic.

📈 Performance Gainreduces test runtime by avoiding real network/database calls

Testing a service with dependencies

NestJS

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

const service = moduleRef.get(DependentService);
await service.callRealDependency();

Using real providers triggers actual service logic, causing slower tests and possible side effects.

📉 Performance Costblocks test execution longer due to real network or database calls

Performance Comparison

Pattern	Dependency Calls	Test Runtime	Resource Usage	Verdict
Using real providers	Triggers real network/database calls	Longer due to real operations	High due to external resources	[X] Bad
Using mocked providers	Simulates calls with fast responses	Shorter due to no real calls	Low, no external resource usage	[OK] Good

Rendering Pipeline

Mocking providers does not affect browser rendering but impacts the test execution pipeline by replacing real dependencies with mocks to reduce runtime and resource usage.

→Test Setup

→Dependency Injection

→Test Execution

⚠️ BottleneckReal service calls during test execution cause delays and resource consumption.

Optimization Tips

1Always mock external dependencies to speed up tests.

2Avoid real network or database calls in unit tests.

3Use Jest mocks or custom providers to simulate services.

Performance Quiz - 3 Questions

What is the main performance benefit of mocking providers in NestJS tests?

A Improved browser rendering speed

B Faster test execution by avoiding real service calls

C Reduced bundle size in production

D Better CSS selector performance

DevTools: Node.js Profiler or Jest --runInBand with --detectOpenHandles

How to check: Run tests with profiling enabled and observe time spent in dependency calls; check for open handles or slow network/database calls.

What to look for: Long test durations or open handles indicate real calls; fast, isolated tests indicate effective mocking.

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