**Course Title:** Mastering NestJS: Building Scalable Server-Side Applications **Section Title:** Testing and Debugging in NestJS **Topic:** Writing unit tests for services and controllers with Jest **Overview** In this topic, we will explore how to write unit tests for services and controllers in a NestJS application using Jest. Unit testing is an essential part of software development that helps ensure our code is correct, reliable, and maintainable. We will cover the basics of unit testing, how to set up Jest for testing, and provide examples of testing services and controllers. **Setting up Jest for Testing** Before we start writing tests, we need to set up Jest for testing. Jest is a popular testing framework for JavaScript that provides a lot of features out of the box, such as code coverage, mocking, and snapshot testing. To set up Jest for testing, follow these steps: 1. Install Jest using npm or yarn: ```bash npm install --save-dev jest ``` 2. Create a `jest.config.js` file in the root of your project: ```javascript module.exports = { preset: 'ts-jest', testEnvironment: 'node', collectCoverage: true, coverageReporters: ['json', 'text', 'lcov', 'clover'], }; ``` This configuration tells Jest to use the `ts-jest` preset, which is a popular preset for testing TypeScript projects. We also set the test environment to `node`, which tells Jest to run tests in a Node.js environment. **Writing Unit Tests for Services** Services are a crucial part of a NestJS application, and they should be tested thoroughly. Here's an example of how to write unit tests for a service: ```typescript // src/services/user.service.ts import { Injectable } from '@nestjs/common'; import { InjectRepository } from '@nestjs/typeorm'; import { Repository } from 'typeorm'; import { User } from './user.entity'; @Injectable() export class UserService { constructor( @InjectRepository(User) private readonly userRepository: Repository<User>, ) {} async findAll(): Promise<User[]> { return this.userRepository.find(); } async findOne(id: number): Promise<User> { return this.userRepository.findOne(id); } } ``` ```typescript // src/services/user.service.spec.ts import { Test, TestingModule } from '@nestjs/testing'; import { UserService } from './user.service'; import { TypeOrmModule } from '@nestjs/typeorm'; import { User } from './user.entity'; describe('UserService', () => { let service: UserService; beforeEach(async () => { const module: TestingModule = await Test.createTestingModule({ imports: [TypeOrmModule.forFeature([User])], providers: [UserService], }).compile(); service = module.get<UserService>(UserService); }); it('should be defined', () => { expect(service).toBeDefined(); }); it('should find all users', async () => { const users = await service.findAll(); expect(users).toBeInstanceOf(Array); }); it('should find one user', async () => { const user = await service.findOne(1); expect(user) && expect(user).toBeInstanceOf(User); }); }); ``` In this example, we create a `UserService` that has two methods: `findAll` and `findOne`. We then create a test suite for the `UserService` using Jest. We use the `beforeEach` hook to create a testing module that imports the `TypeOrmModule` and provides the `UserService`. We then write three tests: one to check if the service is defined, one to check if the `findAll` method returns an array of users, and one to check if the `findOne` method returns a user. **Writing Unit Tests for Controllers** Controllers are another crucial part of a NestJS application, and they should be tested thoroughly. Here's an example of how to write unit tests for a controller: ```typescript // src/controllers/user.controller.ts import { Controller, Get, Param } from '@nestjs/common'; import { UserService } from './user.service'; @Controller('users') export class UserController { constructor(private readonly userService: UserService) {} @Get() async findAll(): Promise<any> { return this.userService.findAll(); } @Get(':id') async findOne(@Param('id') id: number): Promise<any> { return this.userService.findOne(id); } } ``` ```typescript // src/controllers/user.controller.spec.ts import { Test, TestingModule } from '@nestjs/testing'; import { UserController } from './user.controller'; import { UserService } from './user.service'; describe('UserController', () => { let controller: UserController; beforeEach(async () => { const module: TestingModule = await Test.createTestingModule({ providers: [UserController, UserService], }).compile(); controller = module.get<UserController>(UserController); }); it('should be defined', () => { expect(controller).toBeDefined(); }); it('should find all users', async () => { const users = await controller.findAll(); expect(users).toBeInstanceOf(Array); }); it('should find one user', async () => { const user = await controller.findOne(1); expect(user).toBeInstanceOf(Object); }); }); ``` In this example, we create a `UserController` that has two methods: `findAll` and `findOne`. We then create a test suite for the `UserController` using Jest. We use the `beforeEach` hook to create a testing module that provides the `UserController` and `UserService`. We then write three tests: one to check if the controller is defined, one to check if the `findAll` method returns an array of users, and one to check if the `findOne` method returns a user. **Conclusion** In this topic, we covered how to write unit tests for services and controllers in a NestJS application using Jest. We created test suites for a `UserService` and a `UserController` and wrote tests to check if the services and controllers are defined, if the `findAll` method returns an array of users, and if the `findOne` method returns a user. We also covered how to set up Jest for testing and how to use the `beforeEach` hook to create a testing module. **Exercise** Write a test suite for a `ProductService` that has two methods: `findAll` and `findOne`. The `findAll` method should return an array of products, and the `findOne` method should return a product. **Solution** ```typescript // src/services/product.service.ts import { Injectable } from '@nestjs/common'; import { InjectRepository } from '@nestjs/typeorm'; import { Repository } from 'typeorm'; import { Product } from './product.entity'; @Injectable() export class ProductService { constructor( @InjectRepository(Product) private readonly productRepository: Repository<Product>, ) {} async findAll(): Promise<Product[]> { return this.productRepository.find(); } async findOne(id: number): Promise<Product> { return this.productRepository.findOne(id); } } ``` ```typescript // src/services/product.service.spec.ts import { Test, TestingModule } from '@nestjs/testing'; import { ProductService } from './product.service'; import { TypeOrmModule } from '@nestjs/typeorm'; import { Product } from './product.entity'; describe('ProductService', () => { let service: ProductService; beforeEach(async () => { const module: TestingModule = await Test.createTestingModule({ imports: [TypeOrmModule.forFeature([Product])], providers: [ProductService], }).compile(); service = module.get<ProductService>(ProductService); }); it('should be defined', () => { expect(service).toBeDefined(); }); it('should find all products', async () => { const products = await service.findAll(); expect(products).toBeInstanceOf(Array); }); it('should find one product', async () => { const product = await service.findOne(1); expect(product).toBeInstanceOf(Product); }); }); ``` **Note** This is just a simple example of how to write unit tests for a service. In a real-world application, you would need to write more tests to cover all the scenarios and edge cases.