Added tests

Author: WISNIOM

apps/car-rental-backend/src/common/pages/dto/page-options.dto.ts

@@ -4,6 +4,10 @@ import { Order } from '../../constants';
 import { IsEnum, IsInt, IsOptional, Max, Min } from 'class-validator';
 
 export class PageOptionsDto {
+  @ApiPropertyOptional()
+  @Type(() => String)
+  @IsOptional()
+  readonly sortField?: string;
   @ApiPropertyOptional({ enum: Order, default: Order.ASC })
   @IsEnum(Order)
   @IsOptional()

apps/car-rental-backend/src/vehicle-brands/vehicle-brands.controller.spec.ts

@@ -22,6 +22,7 @@ describe('VehicleBrandsController', () => {
             findVehicleBrands: jest.fn(),
             findOne: jest.fn(),
             update: jest.fn(),
+            remove: jest.fn(),
           },
         },
       ],
@@ -31,10 +32,6 @@ describe('VehicleBrandsController', () => {
     service = module.get<VehicleBrandsService>(VehicleBrandsService);
   });
 
-  it('should be defined', () => {
-    expect(controller).toBeDefined();
-  });
-
   describe('create', () => {
     it('should call service.create with correct parameters', async () => {
       const createVehicleBrandDto: CreateVehicleBrandDto = { name: 'Toyota' };
@@ -85,4 +82,14 @@ describe('VehicleBrandsController', () => {
       expect(service.update).toHaveBeenCalledWith(id, updateVehicleBrandDto);
     });
   });
+
+  describe('remove', () => {
+    it('should call service.remove with correct parameters', async () => {
+      const id = 1;
+      jest.spyOn(service, 'remove').mockResolvedValue(undefined);
+
+      expect(await controller.remove(id)).toBeUndefined();
+      expect(service.remove).toHaveBeenCalledWith(id);
+    });
+  });
 });

apps/car-rental-backend/src/vehicle-brands/vehicle-brands.service.spec.ts

@@ -1,9 +1,10 @@
 import { Test, TestingModule } from '@nestjs/testing';
 import { VehicleBrandsService } from './vehicle-brands.service';
 import { getRepositoryToken } from '@nestjs/typeorm';
-import { Repository } from 'typeorm';
+import { Repository, SelectQueryBuilder } from 'typeorm';
 import { HttpException, HttpStatus } from '@nestjs/common';
 import { VehicleBrand } from './entities/vehicle-brand.entity';
+import { Order } from '../common/constants';
 
 describe('VehicleBrandsService', () => {
   let service: VehicleBrandsService;
@@ -26,6 +27,116 @@ describe('VehicleBrandsService', () => {
     );
   });
 
+  describe('create', () => {
+    it('should create a vehicle brand if it does not exist', async () => {
+      const createVehicleBrandDto = { name: 'Toyota' };
+      const vehicleBrand = { id: 1, name: 'Toyota' } as VehicleBrand;
+      jest.spyOn(repository, 'find').mockResolvedValue([]);
+      jest.spyOn(repository, 'save').mockResolvedValue(vehicleBrand);
+
+      expect(await service.create(createVehicleBrandDto)).toEqual(vehicleBrand);
+      expect(repository.find).toHaveBeenCalledWith({
+        where: { name: 'Toyota' },
+      });
+      expect(repository.save).toHaveBeenCalledWith(createVehicleBrandDto);
+    });
+
+    it('should throw an exception if vehicle brand already exists', async () => {
+      const createVehicleBrandDto = { name: 'Toyota' };
+      jest
+        .spyOn(repository, 'find')
+        .mockResolvedValue([{ id: 1, name: 'Toyota' } as VehicleBrand]);
+
+      await expect(service.create(createVehicleBrandDto)).rejects.toThrow(
+        new HttpException(
+          {
+            status: HttpStatus.CONFLICT,
+            error: 'Vehicle brand already exists',
+          },
+          HttpStatus.CONFLICT
+        )
+      );
+      expect(repository.find).toHaveBeenCalledWith({
+        where: { name: 'Toyota' },
+      });
+    });
+  });
+
+  describe('findVehicleBrands', () => {
+    it('should return a list of vehicle brands', async () => {
+      const pageOptionsDto = {
+        order: Order.ASC,
+        take: 10,
+        skip: 0,
+        sortField: 'name',
+      };
+      const vehicleBrands = [
+        { id: 2, name: 'Mercedes' } as VehicleBrand,
+        { id: 1, name: 'Toyota' } as VehicleBrand,
+      ];
+      jest.spyOn(repository, 'createQueryBuilder').mockReturnValue({
+        orderBy: jest.fn().mockReturnThis(),
+        skip: jest.fn().mockReturnThis(),
+        take: jest.fn().mockReturnThis(),
+        getCount: jest.fn().mockResolvedValue(2),
+        getRawAndEntities: jest
+          .fn()
+          .mockResolvedValue({ entities: vehicleBrands }),
+      } as unknown as SelectQueryBuilder<VehicleBrand>);
+
+      const result = await service.findVehicleBrands(pageOptionsDto);
+      expect(result.data[0]).toEqual(vehicleBrands[0]);
+      expect(result.data[1]).toEqual(vehicleBrands[1]);
+      expect(result.meta.itemCount).toEqual(2);
+    });
+
+    it('should return a list of vehicle brands sorted by id if sortField is not provided', async () => {
+      const pageOptionsDto = {
+        order: Order.ASC,
+        take: 10,
+        skip: 0,
+      };
+      const vehicleBrands = [
+        { id: 1, name: 'Toyota' } as VehicleBrand,
+        { id: 2, name: 'Mercedes' } as VehicleBrand,
+      ];
+      jest.spyOn(repository, 'createQueryBuilder').mockReturnValue({
+        orderBy: jest.fn().mockReturnThis(),
+        skip: jest.fn().mockReturnThis(),
+        take: jest.fn().mockReturnThis(),
+        getCount: jest.fn().mockResolvedValue(2),
+        getRawAndEntities: jest
+          .fn()
+          .mockResolvedValue({ entities: vehicleBrands }),
+      } as unknown as SelectQueryBuilder<VehicleBrand>);
+
+      const result = await service.findVehicleBrands(pageOptionsDto);
+      expect(result.data[0]).toEqual(vehicleBrands[0]);
+      expect(result.data[1]).toEqual(vehicleBrands[1]);
+      expect(result.meta.itemCount).toEqual(2);
+    });
+
+    it('should return an empty list if no vehicle brands found', async () => {
+      const pageOptionsDto = {
+        order: Order.ASC,
+        take: 10,
+        skip: 0,
+        sortField: 'name',
+      };
+      jest.spyOn(repository, 'createQueryBuilder').mockReturnValue({
+        orderBy: jest.fn().mockReturnThis(),
+        skip: jest.fn().mockReturnThis(),
+        take: jest.fn().mockReturnThis(),
+        getCount: jest.fn().mockResolvedValue(0),
+        getRawAndEntities: jest.fn().mockResolvedValue({ entities: [] }),
+      } as unknown as SelectQueryBuilder<VehicleBrand>);
+
+      const result = await service.findVehicleBrands(pageOptionsDto);
+      expect(result.data).toEqual([]);
+      expect(result.meta.itemCount).toEqual(0);
+    });
+  });
+
   describe('findByField', () => {
     it('should return a vehicle brand if found', async () => {
       const vehicleBrand = { id: 1, name: 'Toyota' } as VehicleBrand;
@@ -49,6 +160,7 @@ describe('VehicleBrandsService', () => {
   describe('findOne', () => {
     it('should call findByField with id', async () => {
       const vehicleBrand = { id: 1, name: 'Toyota' };
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
       jest.spyOn(service as any, 'findByField').mockResolvedValue(vehicleBrand);
 
       expect(await service.findOne(1)).toEqual(vehicleBrand);
@@ -59,6 +171,7 @@ describe('VehicleBrandsService', () => {
   describe('findByName', () => {
     it('should call findByField with name', async () => {
       const vehicleBrand = { id: 1, name: 'Toyota' };
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
       jest.spyOn(service as any, 'findByField').mockResolvedValue(vehicleBrand);
 
       expect(await service.findByName('Toyota')).toEqual(vehicleBrand);
@@ -71,14 +184,7 @@ describe('VehicleBrandsService', () => {
       const vehicleBrand = { id: 1, name: 'Toyota' } as VehicleBrand;
       const updateVehicleBrandDto = { name: 'Mercedes' };
       const updatedVehicleBrand = { id: 1, name: 'Mercedes' } as VehicleBrand;
-      jest
-        .spyOn(service, 'findByName')
-        .mockRejectedValue(
-          new HttpException(
-            { status: HttpStatus.NOT_FOUND, error: 'Vehicle brand not found' },
-            HttpStatus.NOT_FOUND
-          )
-        );
+      jest.spyOn(repository, 'find').mockResolvedValue([]);
       jest
         .spyOn(service, 'findOne')
         .mockResolvedValueOnce(vehicleBrand)
@@ -88,7 +194,9 @@ describe('VehicleBrandsService', () => {
       expect(await service.update(1, updateVehicleBrandDto)).toEqual(
         updatedVehicleBrand
       );
-      expect(service.findByName).toHaveBeenCalledWith(updatedVehicleBrand.name);
+      expect(repository.find).toHaveBeenCalledWith({
+        where: { name: updatedVehicleBrand.name },
+      });
       expect(service.findOne).toHaveBeenCalledWith(vehicleBrand.id);
       expect(repository.save).toHaveBeenCalledWith({
         ...vehicleBrand,
@@ -98,14 +206,7 @@ describe('VehicleBrandsService', () => {
 
     it('should throw an exception if vehicle brand not found', async () => {
       const updateVehicleBrandDto = { name: 'Toyota' };
-      jest
-        .spyOn(service, 'findByName')
-        .mockRejectedValue(
-          new HttpException(
-            { status: HttpStatus.NOT_FOUND, error: 'Vehicle brand not found' },
-            HttpStatus.NOT_FOUND
-          )
-        );
+      jest.spyOn(repository, 'find').mockResolvedValue([]);
 
       jest
         .spyOn(service, 'findOne')
@@ -122,17 +223,17 @@ describe('VehicleBrandsService', () => {
           HttpStatus.NOT_FOUND
         )
       );
-      expect(service.findByName).toHaveBeenCalledWith(
-        updateVehicleBrandDto.name
-      );
+      expect(repository.find).toHaveBeenCalledWith({
+        where: { name: updateVehicleBrandDto.name },
+      });
       expect(service.findOne).toHaveBeenCalledWith(1);
     });
 
     it('should throw an exception if vehicle brand to be updated already exists', async () => {
       const updateVehicleBrandDto = { name: 'Toyota' };
       jest
-        .spyOn(service, 'findByName')
-        .mockResolvedValue({ id: 2, name: 'Toyota' } as VehicleBrand);
+        .spyOn(repository, 'find')
+        .mockResolvedValue([{ id: 2, name: 'Toyota' } as VehicleBrand]);
 
       jest
         .spyOn(service, 'findOne')
@@ -147,10 +248,45 @@ describe('VehicleBrandsService', () => {
           HttpStatus.CONFLICT
         )
       );
-      expect(service.findByName).toHaveBeenCalledWith(
-        updateVehicleBrandDto.name
-      );
+      expect(repository.find).toHaveBeenCalledWith({
+        where: { name: updateVehicleBrandDto.name },
+      });
       expect(service.findOne).not.toHaveBeenCalledWith(1);
     });
   });
+
+  describe('remove', () => {
+    it('should remove a vehicle brand if it exists', async () => {
+      const vehicleBrand = { id: 1, name: 'Toyota' } as VehicleBrand;
+      jest.spyOn(service, 'findOne').mockResolvedValue(vehicleBrand);
+      jest
+        .spyOn(repository, 'delete')
+        .mockResolvedValue(undefined);
+
+      expect(await service.remove(1)).toEqual(undefined);
+      expect(service.findOne).toHaveBeenCalledWith(1);
+      expect(repository.delete).toHaveBeenCalledWith(1);
+    });
+
+    it('should throw an exception if vehicle brand not found', async () => {
+      jest
+        .spyOn(service, 'findOne')
+        .mockRejectedValue(
+          new HttpException(
+            { status: HttpStatus.NOT_FOUND, error: 'Vehicle brand not found' },
+            HttpStatus.NOT_FOUND
+          )
+        );
+      jest.spyOn(repository, 'delete');
+
+      await expect(service.remove(1)).rejects.toThrow(
+        new HttpException(
+          { status: HttpStatus.NOT_FOUND, error: 'Vehicle brand not found' },
+          HttpStatus.NOT_FOUND
+        )
+      );
+      expect(service.findOne).toHaveBeenCalledWith(1);
+      expect(repository.delete).not.toHaveBeenCalled();
+    });
+  });
 });

apps/car-rental-backend/src/vehicle-brands/vehicle-brands.service.ts

@@ -18,10 +18,12 @@ export class VehicleBrandsService {
     private vehicleBrandsRepository: Repository<VehicleBrand>
   ) {}
 
-  async create(createVehicleBrandDto: CreateVehicleBrandDto) {
+  async create(createVehicleBrandDto: CreateVehicleBrandDto): Promise<VehicleBrandDto> {
     const { name } = createVehicleBrandDto;
-    const vehicleBrand = await this.findByName(name);
-    if (vehicleBrand) {
+    const vehicleBrand = await this.vehicleBrandsRepository.find({
+      where: { name },
+    });
+    if (vehicleBrand.length) {
       throw new HttpException(
         { status: HttpStatus.CONFLICT, error: 'Vehicle brand already exists' },
         HttpStatus.CONFLICT
@@ -30,11 +32,15 @@ export class VehicleBrandsService {
     return this.vehicleBrandsRepository.save(createVehicleBrandDto);
   }
 
-  async findVehicleBrands(pageOptionsDto: PageOptionsDto) {
-    const { order, take, skip } = pageOptionsDto;
+  async findVehicleBrands(pageOptionsDto: PageOptionsDto): Promise<PageDto<VehicleBrandDto>> {
+    const { order, take, skip, sortField } = pageOptionsDto;
     const queryBuilder =
       this.vehicleBrandsRepository.createQueryBuilder('vehicleBrand');
-    queryBuilder.orderBy('vehicleBrand.name', order).skip(skip).take(take);
+    const vehicleBrandSortField =
+      sortField && sortField in VehicleBrandDto
+        ? `vehicleBrand.${sortField}`
+        : 'vehicleBrand.id';
+    queryBuilder.orderBy(vehicleBrandSortField, order).skip(skip).take(take);
     const itemCount = await queryBuilder.getCount();
     const { entities } = await queryBuilder.getRawAndEntities();
     const pageMetaDto = new PageMetaDto({ itemCount, pageOptionsDto });
@@ -57,25 +63,20 @@ export class VehicleBrandsService {
     return vehicle;
   }
 
-  async findOne(id: number) {
+  async findOne(id: number): Promise<VehicleBrandDto> {
     return this.findByField('id', id);
   }
 
-  async findByName(name: string) {
+  async findByName(name: string): Promise<VehicleBrandDto> {
     return this.findByField('name', name);
   }
 
-  async update(id: number, updateVehicleBrandDto: UpdateVehicleBrandDto) {
+  async update(id: number, updateVehicleBrandDto: UpdateVehicleBrandDto): Promise<VehicleBrandDto> {
     const { name } = updateVehicleBrandDto;
-    let vehicleBrand: VehicleBrand;
-    try {
-      vehicleBrand = await this.findByName(name);
-    } catch (error) {
-      if (error.status !== HttpStatus.NOT_FOUND) {
-        throw error;
-      }
-    }
-    if (vehicleBrand) {
+    const vehicleBrand = await this.vehicleBrandsRepository.find({
+      where: { name },
+    });
+    if (vehicleBrand.length) {
       throw new HttpException(
         { status: HttpStatus.CONFLICT, error: 'Vehicle brand already exists' },
         HttpStatus.CONFLICT
@@ -89,17 +90,17 @@ export class VehicleBrandsService {
       );
     }
     await this.vehicleBrandsRepository.save({ id, name });
-    return await this.findOne(id);
+    return this.findOne(id);
   }
 
-  async remove(id: number) {
-    const vehicle = await this.vehicleBrandsRepository.findOneBy({ id });
+  async remove(id: number): Promise<void> {
+    const vehicle = await this.findOne(id);
     if (!vehicle) {
       throw new HttpException(
         { status: HttpStatus.NOT_FOUND, error: 'Vehicle brand not found' },
         HttpStatus.NOT_FOUND
       );
     }
-    return this.vehicleBrandsRepository.delete(id);
+    await this.vehicleBrandsRepository.delete(id);
   }
 }