Mocking providers in NestJS - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a mock provider for testing.

NestJS

const mockService = { findAll: jest.[1]() };

Drag options to blanks, or click blank then click option'

Amock

Bcall

Cfn

DspyOn

Attempts:

3 left

💡 Hint

Common Mistakes

Using jest.mock instead of jest.fn

Using jest.spyOn without an object

Using jest.call which does not exist

jest.fn() creates a mock function that can be used to replace real implementations in tests.

2fill in blank

medium

Complete the code to provide the mock service in the testing module.

NestJS

providers: [{ provide: UserService, use[1]: mockService }],

Drag options to blanks, or click blank then click option'

AValue

BClass

CFactory

DExisting

Attempts:

3 left

💡 Hint

Common Mistakes

Using useClass instead of useValue

Using useFactory without a factory function

Using useExisting which references another provider

useValue allows you to provide a specific object or mock as the provider.

3fill in blank

hard

Fix the error in the test setup by completing the missing method to reset mocks.

NestJS

beforeEach(() => { jest.[1](); });

Drag options to blanks, or click blank then click option'

ArestoreAllMocks

BresetAllMocks

CresetModules

DclearAllMocks

Attempts:

3 left

💡 Hint

Common Mistakes

Using resetModules which resets the module registry

Using restoreAllMocks which restores original implementations

Using a non-existent resetAllMocks method

jest.clearAllMocks() resets the usage data of mocks between tests.

4fill in blank

hard

Fill both blanks to mock a method and specify its return value.

NestJS

mockService.findAll = jest.[1]().mock[2](['user1', 'user2']);

Drag options to blanks, or click blank then click option'

Afn

BmockReturnValue

CmockResolvedValue

DspyOn

Attempts:

3 left

💡 Hint

Common Mistakes

Using spyOn without an object

Using mockResolvedValue for synchronous return

Using mockReturnValue without jest.fn()

jest.fn() creates a mock function, and mockReturnValue sets its return value synchronously.

5fill in blank

hard

Fill all three blanks to create a testing module with a mocked provider and verify the mock was called.

NestJS

const module = await Test.createTestingModule({ providers: [{ provide: UserService, use[1]: mockService }] }).compile(); const service = module.get<UserService>(UserService); await service.findAll(); expect(mockService.findAll).toHaveBeenCalled[2](); jest.[3]();

Drag options to blanks, or click blank then click option'

AValue

BOnce

CclearAllMocks

Dmock

Attempts:

3 left

💡 Hint

Common Mistakes

Using useClass instead of useValue

Using toHaveBeenCalled() without once

Not clearing mocks after tests

useValue provides the mock object; toHaveBeenCalledOnce() checks the mock was called once; clearAllMocks resets mocks after test.

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