Mastering Unit Testing in NestJS: A Comprehensive Guide with Examples

In the world of modern software development, writing tests is no longer just an afterthought but an integral part of the development process. Unit testing, in particular, plays a crucial role in ensuring the reliability and maintainability of your codebase. When it comes to building web applications with NestJS, a powerful framework for building efficient, reliable, and scalable server-side applications in Node.js, mastering unit testing is essential.

In this guide, we’ll delve into unit testing a controller in NestJS, exploring best practices and providing concrete examples to help you get started.

Why Unit Test Controllers?

Controllers in NestJS act as the entry points for incoming requests, handling the HTTP communication between the client and the server. Unit testing controllers allows you to verify that your endpoints behave as expected, handling requests correctly and returning the appropriate responses.

By thoroughly testing your controllers, you can:

• Ensure that your API endpoints respond correctly to various HTTP methods (GET, POST, PUT, DELETE, etc.).
• Validate the input and output data of your endpoints.
• Verify the behavior of your application under different scenarios and edge cases.
• Detect and fix bugs early in the development process.
• Facilitate code refactoring and maintenance by providing a safety net of tests.

Setting Up Your Project

Before diving into writing tests, make sure you have a NestJS project set up. If you haven’t already created one, you can do so by following the official NestJS documentation.

Once your project is set up, ensure that you have the necessary testing dependencies installed. NestJS utilizes testing utilities provided by Jest, a popular JavaScript testing framework. You can install Jest along with other testing dependencies by running:

npm install --save-dev @nestjs/testing jest @types/jest ts-jest

Writing Unit Tests for a Controller

Let’s consider a simple example of a UserController in a NestJS application. This controller exposes endpoints for managing users, such as fetching user details and creating new users.

// user.controller.ts

import { Controller, Get, Post, Body } from '@nestjs/common';
import { UserService } from './user.service';
import { CreateUserDto } from './dto/create-user.dto';
import { User } from './user.entity';

@Controller('users')
export class UserController {
  constructor(private readonly userService: UserService) {}

  @Get()
  async findAll(): Promise<User[]> {
    return this.userService.findAll();
  }

  @Post()
  async create(@Body() createUserDto: CreateUserDto): Promise<User> {
    return this.userService.create(createUserDto);
  }
}

Now, let’s write unit tests for this controller using Jest.

// user.controller.spec.ts

import { Test, TestingModule } from '@nestjs/testing';
import { UserController } from './user.controller';
import { UserService } from './user.service';
import { CreateUserDto } from './dto/create-user.dto';
import { User } from './user.entity';

describe('UserController', () => {
  let controller: UserController;
  let userService: UserService;

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

    controller = module.get<UserController>(UserController);
    userService = module.get<UserService>(UserService);
  });

  it('should be defined', () => {
    expect(controller).toBeDefined();
  });

  describe('findAll', () => {
    it('should return an array of users', async () => {
      const result: User[] = [{ id: 1, name: 'John' }];
      jest.spyOn(userService, 'findAll').mockResolvedValue(result);

      expect(await controller.findAll()).toBe(result);
    });
  });

  describe('create', () => {
    it('should create a new user', async () => {
      const createUserDto: CreateUserDto = { name: 'Alice' };
      const newUser: User = { id: 2, name: 'Alice' };
      jest.spyOn(userService, 'create').mockResolvedValue(newUser);

      expect(await controller.create(createUserDto)).toBe(newUser);
    });
  });
});

In the test suite above, we:

• Set up a testing module to initialize the UserController and its dependencies.
• Wrote tests for the findAll and create methods of the UserController, mocking the UserService’s behavior using Jest’s spyOn function.

Running the Tests

To run the tests, execute the following command in your terminal:

npm test

Jest will execute the tests and provide feedback on whether they pass or fail.

Conclusion

Unit testing controllers in NestJS is a fundamental aspect of ensuring the reliability and correctness of your applications. By following best practices and leveraging tools like Jest, you can write robust tests that validate the behavior of your endpoints under various conditions.

Remember, while writing tests may require additional effort upfront, the long-term benefits in terms of code quality, maintainability, and confidence in your application’s behavior make it a worthwhile investment. So, embrace unit testing in your NestJS projects and take your development process to the next level!