Unit testing services in NestJS

Introduction

Unit testing services helps you check if each part of your app works right by itself. It finds mistakes early so your app stays reliable.

When you want to check if a service method returns the correct result.

When you change service code and want to make sure nothing breaks.

When you want to test service logic without running the whole app.

When you want to catch bugs before users see them.

When you want to write safe, maintainable code that others can trust.

Syntax

NestJS

import { Test, TestingModule } from '@nestjs/testing';
import { MyService } from './my.service';

describe('MyService', () => {
  let service: MyService;

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      providers: [MyService],
    }).compile();

    service = module.get<MyService>(MyService);
  });

  it('should do something', () => {
    expect(service.someMethod()).toBe(expectedValue);
  });
});

Use Test.createTestingModule to create a test environment for your service.

Use module.get to get the service instance for testing.

Examples

This tests the add method of a calculator service.

NestJS

import { Test, TestingModule } from '@nestjs/testing';
import { CalculatorService } from './calculator.service';

describe('CalculatorService', () => {
  let service: CalculatorService;

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      providers: [CalculatorService],
    }).compile();

    service = module.get<CalculatorService>(CalculatorService);
  });

  it('should add two numbers', () => {
    expect(service.add(2, 3)).toBe(5);
  });
});

This shows how to mock a dependency when testing a service.

NestJS

import { Test, TestingModule } from '@nestjs/testing';
import { UserService } from './user.service';

// Mock dependency
const mockUserRepository = {
  findOne: jest.fn().mockReturnValue({ id: 1, name: 'Alice' }),
};

describe('UserService', () => {
  let service: UserService;

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      providers: [
        UserService,
        { provide: 'UserRepository', useValue: mockUserRepository },
      ],
    }).compile();

    service = module.get<UserService>(UserService);
  });

  it('should return user by id', async () => {
    const user = await service.findUserById(1);
    expect(user.name).toBe('Alice');
  });
});

Sample Program

This test checks if the multiply method in MathService returns the correct product of two numbers.

NestJS

import { Test, TestingModule } from '@nestjs/testing';

class MathService {
  multiply(a: number, b: number): number {
    return a * b;
  }
}

describe('MathService', () => {
  let service: MathService;

  beforeEach(async () => {
    const module: TestingModule = await Test.createTestingModule({
      providers: [MathService],
    }).compile();

    service = module.get<MathService>(MathService);
  });

  it('should multiply two numbers correctly', () => {
    const result = service.multiply(4, 5);
    expect(result).toBe(20);
  });
});

Important Notes

Always test one small piece of logic per test to keep tests clear.

Use mocks to replace dependencies so tests focus only on the service.

Run tests often to catch errors early.

Summary

Unit testing services checks if each service works alone.

Use NestJS testing tools to create a test module and get the service.

Mock dependencies to isolate service logic during tests.

Practice

1. What is the main purpose of unit testing a service in NestJS?

easy

A. To verify the service works correctly on its own without dependencies

B. To test the entire application including all modules

C. To check the UI components connected to the service

D. To deploy the service to production automatically

Solution

1. Step 1: Understand unit testing scope

   Unit testing focuses on testing a single piece of code in isolation, here the service alone.

2. Step 2: Identify what unit testing excludes

   It excludes integration with other modules or UI, focusing only on the service logic.

3. Final Answer:

   To verify the service works correctly on its own without dependencies -> Option A

4. Quick Check:

   Unit testing = isolated service check [OK]

Hint: Unit test means testing one piece alone, no dependencies [OK]

Common Mistakes:

• Confusing unit test with integration test
• Thinking unit test covers UI or deployment
• Assuming unit test runs the whole app

2. Which of the following is the correct way to get a service instance in a NestJS unit test?

easy

A. const service = require('MyService');

B. const service = new MyService();

C. const service = module.get<MyService>(MyService);

D. const service = app.getService(MyService);

Solution

1. Step 1: Use NestJS TestingModule

   In unit tests, you create a TestingModule and get the service instance via module.get.

2. Step 2: Identify correct syntax

   The syntax module.get<MyService>(MyService) is the official way to retrieve the service from the test module.

3. Final Answer:

   const service = module.get<MyService>(MyService); -> Option C

4. Quick Check:

   Use module.get to get service instance [OK]

Hint: Always get service from TestingModule with module.get<Type>(Type) [OK]

Common Mistakes:

• Instantiating service directly without module
• Using app.getService which is not a NestJS method
• Using require which is not for NestJS DI

3. Given this test code snippet, what will be the output of service.getData()?

const mockData = ['a', 'b'];
const mockRepo = { findAll: () => mockData };

const module = await Test.createTestingModule({
  providers: [
    MyService,
    { provide: MyRepository, useValue: mockRepo },
  ],
}).compile();

const service = module.get<MyService>(MyService);

console.log(service.getData());

medium

A. An error because MyRepository is not mocked

B. undefined

C. [] (empty array)

D. ['a', 'b']

Solution

1. Step 1: Understand mocking of MyRepository

   The mockRepo object replaces MyRepository with a findAll method returning ['a', 'b'].

2. Step 2: Analyze service.getData()

   Assuming getData calls repository.findAll(), it will return ['a', 'b'] from the mock.

3. Final Answer:

   ['a', 'b'] -> Option D

4. Quick Check:

   Mocked repo returns ['a', 'b'] so service returns same [OK]

Hint: Mocked methods return mock values used by service [OK]

Common Mistakes:

• Forgetting to mock repository causing undefined
• Expecting real database call instead of mock
• Assuming empty array without mock data

4. What is the main issue in this test setup code?

const module = await Test.createTestingModule({
  providers: [MyService],
}).compile();

const service = module.get<MyService>(MyService);

jest.spyOn(service, 'findAll').mockReturnValue(['x', 'y']);

medium

A. You cannot spy on service methods before mocking dependencies

B. The service method findAll should be mocked on the dependency, not service

C. jest.spyOn syntax is incorrect here

D. Missing async keyword on test function

Solution

1. Step 1: Identify what to mock in unit tests

   In unit tests, you mock dependencies of the service, not the service's own methods.

2. Step 2: Understand why mocking service method is wrong

   Mocking service.findAll replaces the method under test, defeating the purpose of testing it.

3. Final Answer:

   The service method findAll should be mocked on the dependency, not service -> Option B

4. Quick Check:

   Mock dependencies, not the service itself [OK]

Hint: Mock dependencies, never the service method you test [OK]

Common Mistakes:

• Mocking the service method instead of its dependencies
• Confusing spyOn usage with mocking dependencies
• Ignoring async test function requirements

5. You want to test a service method that calls two different repository methods internally. How should you set up your unit test to isolate the service logic correctly?

hard

A. Mock both repository methods with expected return values and inject them into the test module

B. Call the real repository methods to test the full flow

C. Mock only one repository method and leave the other real

D. Do not mock anything and test the service directly

Solution

1. Step 1: Identify dependencies to mock

   Since the service calls two repository methods, both should be mocked to isolate service logic.

2. Step 2: Setup test module with mocks

   Provide mock implementations for both methods in the test module providers to control their outputs.

3. Step 3: Avoid real calls in unit tests

   Calling real repository methods would make it an integration test, not a unit test.

4. Final Answer:

   Mock both repository methods with expected return values and inject them into the test module -> Option A

5. Quick Check:

   Mock all dependencies to isolate service logic [OK]

Hint: Mock all called dependencies to isolate service logic [OK]

Common Mistakes:

• Mocking only some dependencies causing partial isolation
• Calling real methods making it integration test
• Not injecting mocks properly into test module