Course Title: Mastering NestJS: Building Scalable Server-Side Applications Section Title: Testing and Debugging in NestJS Topic: Write unit tests for your existing NestJS application to ensure code quality.(Lab topic)

Objective: By the end of this topic, you will be able to write effective unit tests for your NestJS application using Jest, ensuring that your code is reliable, maintainable, and scalable.

Prerequisites:

• Familiarity with NestJS and its ecosystem
• Basic understanding of testing concepts and principles
• Jest installed as the testing framework

Why Unit Testing is Important:

Unit testing is a crucial aspect of software development that helps ensure the quality and reliability of your code. It involves writing tests for individual units of code, such as functions, methods, or classes, to verify that they behave as expected.

Setting up Jest for NestJS:

To get started with unit testing in NestJS, you need to install Jest as the testing framework. You can do this by running the following command in your terminal:

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

Writing Unit Tests for Services:

Let's create a simple service that we can test. Create a new file called users.service.ts with the following code:

import { Injectable } from '@nestjs/common';

@Injectable()
export class UsersService {
  private users: any[] = [];

  getUsers(): any[] {
    return this.users;
  }

  addUser(user: any): void {
    this.users.push(user);
  }
}

Now, let's write a test for this service using Jest. Create a new file called users.service.spec.ts with the following code:

import { Test, TestingModule } from '@nestjs/testing';
import { UsersService } from './users.service';

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

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

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

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

  it('should return an empty array', () => {
    expect(service.getUsers()).toEqual([]);
  });

  it('should add a user', () => {
    const user = { id: 1, name: 'John Doe' };
    service.addUser(user);
    expect(service.getUsers()).toEqual([user]);
  });
});

In this example, we're using the @nestjs/testing module to create a testing module for our service. We're then using the Test.createTestingModule method to create a testing module with our service as a provider. We're then using the module.get to get an instance of our service.

We're then writing three tests:

1. The first test checks that our service is defined.
2. The second test checks that our service returns an empty array when we call the getUsers method.
3. The third test checks that our service adds a user when we call the addUser method.

Writing Unit Tests for Controllers:

Let's create a simple controller that we can test. Create a new file called users.controller.ts with the following code:

import { Controller, Get, Post } from '@nestjs/common';
import { UsersService } from './users.service';

@Controller('users')
export class UsersController {
  constructor(private readonly usersService: UsersService) {}

  @Get()
  async getUsers(): Promise<any[]> {
    return this.usersService.getUsers();
  }

  @Post()
  async addUser(user: any): Promise<void> {
    this.usersService.addUser(user);
  }
}

Now, let's write a test for this controller using Jest. Create a new file called users.controller.spec.ts with the following code:

import { Test, TestingModule } from '@nestjs/testing';
import { UsersController } from './users.controller';
import { UsersService } from './users.service';

describe('UsersController', () => {
  let controller: UsersController;

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

    controller = module.get<UsersController>(UsersController);
  });

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

  it('should return an empty array', async () => {
    const res = await controller.getUsers();
    expect(res).toEqual([]);
  });

  it('should add a user', async () => {
    const user = { id: 1, name: 'John Doe' };
    await controller.addUser(user);
    const res = await controller.getUsers();
    expect(res).toEqual([user]);
  });
});

In this example, we're using the @nestjs/testing module to create a testing module for our controller. We're then using the Test.createTestingModule method to create a testing module with our controller and service as providers. We're then using module.get to get an instance of our controller.

We're then writing three tests:

1. The first test checks that our controller is defined.
2. The second test checks that our controller returns an empty array when we call the getUsers method.
3. The third test checks that our controller adds a user when we call the addUser method.

Conclusion:

In this topic, we've learned how to write unit tests for our NestJS application using Jest. We've created a simple service and controller, and written tests for them using Jest. We've also learned how to use the @nestjs/testing module to create a testing module for our service and controller.

Exercise:

Try to write unit tests for your own service and controller using Jest. Use the @nestjs/testing module to create a testing module for your service and controller. Write tests for your service and controller using Jest.

Additional Resources:

• Jest Documentation
• NestJS Testing Documentation

Leave a comment or ask for help:

If you have any questions or need help with writing unit tests for your NestJS application, please leave a comment below.