better testing

package.json

@@ -19,7 +19,7 @@
     "test:unit:ci": "jest --testPathPattern 'tests/unit/' --coverage",
     "test:integration": "npm run migrate:test && dotenv -e .env.test -- jest --testPathPattern 'tests/integration/' --verbose",
     "test:integration:ci": "npm run migrate:test:ci && dotenv -e ci/.env.ci -- jest --testPathPattern 'tests/integration/'",
-    "test:cov": "npm run migrate:test && dotenv -e .env.test -- jest --coverage",
+    "test:cov": "jest --testPathPattern 'tests/unit/' --coverage",
     "test:e2e": "jest --config ./test/jest-e2e.json",
     "migrate": "docker exec v3-user sh -c 'npx prisma migrate dev'",
     "migrate:test": "dotenv -e .env.test -- npx prisma migrate deploy",
@@ -70,6 +70,7 @@
       "json",
       "ts"
     ],
+    "modulePathIgnorePatterns": [".controller.ts",".module.ts"],
     "rootDir": "src",
     "testRegex": ".*\\.spec\\.ts$",
     "transform": {

src/modules/users/adapters/primaries/users.controller.ts

@@ -3,7 +3,7 @@ import { InjectMapper } from '@automapper/nestjs';
 import { Controller, UsePipes } from '@nestjs/common';
 import { CommandBus, QueryBus } from '@nestjs/cqrs';
 import { GrpcMethod, RpcException } from '@nestjs/microservices';
-import { DatabaseException } from 'src/modules/database/src/exceptions/DatabaseException';
+import { DatabaseException } from '../../../database/src/exceptions/DatabaseException';
 import { CreateUserCommand } from '../../commands/create-user.command';
 import { DeleteUserCommand } from '../../commands/delete-user.command';
 import { UpdateUserCommand } from '../../commands/update-user.command';
@@ -48,9 +48,7 @@ export class UsersController {
   @GrpcMethod('UsersService', 'FindOneByUuid')
   async findOneByUuid(data: FindUserByUuidRequest): Promise<UserPresenter> {
     try {
-      const user = await this._queryBus.execute(
+      const user = await this._queryBus.execute(new FindUserByUuidQuery(data));
-        new FindUserByUuidQuery(data.uuid),
-      );
       return this._mapper.map(user, User, UserPresenter);
     } catch (error) {
       throw new RpcException({

src/modules/users/queries/find-user-by-uuid.query.ts

@@ -1,7 +1,9 @@
+import { FindUserByUuidRequest } from '../domain/dtos/find-user-by-uuid.request';
+
 export class FindUserByUuidQuery {
   readonly uuid: string;
 
-  constructor(uuid: string) {
+  constructor(findUserByUuidRequest: FindUserByUuidRequest) {
-    this.uuid = uuid;
+    this.uuid = findUserByUuidRequest.uuid;
   }
 }

src/modules/users/tests/unit/create-user.usecase.spec.ts

@@ -19,9 +19,16 @@ const newUserRequest: CreateUserRequest = {
 const newUserCommand: CreateUserCommand = new CreateUserCommand(newUserRequest);
 
 const mockUsersRepository = {
-  create: jest.fn().mockResolvedValue({
+  create: jest
+    .fn()
+    .mockImplementationOnce(() => {
+      return Promise.resolve({
         ...newUserRequest,
         uuid: 'bb281075-1b98-4456-89d6-c643d3044a91',
+      });
+    })
+    .mockImplementation(() => {
+      throw new Error('Already exists');
     }),
 };
 
@@ -67,5 +74,11 @@ describe('CreateUserUseCase', () => {
       expect(newUser.lastName).toBe(newUserRequest.lastName);
       expect(newUser.uuid).toBeDefined();
     });
+
+    it('should throw an error if user already exists', async () => {
+      await expect(
+        createUserUseCase.execute(newUserCommand),
+      ).rejects.toBeInstanceOf(Error);
+    });
   });
 });

src/modules/users/tests/unit/delete-user.usecase.spec.ts

@@ -30,7 +30,9 @@ const mockUsers = [
 ];
 
 const mockUsersRepository = {
-  delete: jest.fn().mockImplementation((uuid: string) => {
+  delete: jest
+    .fn()
+    .mockImplementationOnce((uuid: string) => {
       let savedUser = {};
       mockUsers.forEach((user, index) => {
         if (user.uuid === uuid) {
@@ -39,6 +41,9 @@ const mockUsersRepository = {
         }
       });
       return savedUser;
+    })
+    .mockImplementation(() => {
+      throw new Error('Error');
     }),
 };
 
@@ -84,5 +89,10 @@ describe('DeleteUserUseCase', () => {
       const deletedUser = mockUsers.find((user) => user.uuid === savedUuid);
       expect(deletedUser).toBeUndefined();
     });
+    it('should throw an error if user does not exist', async () => {
+      await expect(
+        deleteUserUseCase.execute(new DeleteUserCommand('wrong uuid')),
+      ).rejects.toBeInstanceOf(Error);
+    });
   });
 });

src/modules/users/tests/unit/find-all-users.usecase.spec.ts

@@ -1,8 +1,17 @@
 import { Test, TestingModule } from '@nestjs/testing';
 import { UsersRepository } from '../../adapters/secondaries/users.repository';
+import { FindAllUsersRequest } from '../../domain/dtos/find-all-users.request';
 import { FindAllUsersUseCase } from '../../domain/usecases/find-all-users.usecase';
 import { FindAllUsersQuery } from '../../queries/find-all-users.query';
 
+const findAllUsersRequest: FindAllUsersRequest = new FindAllUsersRequest();
+findAllUsersRequest.page = 1;
+findAllUsersRequest.perPage = 10;
+
+const findAllUsersQuery: FindAllUsersQuery = new FindAllUsersQuery(
+  findAllUsersRequest,
+);
+
 const mockUsers = [
   {
     uuid: 'bb281075-1b98-4456-89d6-c643d3044a91',
@@ -57,7 +66,7 @@ describe('FindAllUsersUseCase', () => {
 
   describe('execute', () => {
     it('should return an array filled with users', async () => {
-      const users = await findAllUsersUseCase.execute(new FindAllUsersQuery());
+      const users = await findAllUsersUseCase.execute(findAllUsersQuery);
 
       expect(users).toBe(mockUsers);
     });

src/modules/users/tests/unit/find-user-by-uuid.usecase.spec.ts

@@ -1,6 +1,8 @@
+import { NotFoundException } from '@nestjs/common';
 import { Test, TestingModule } from '@nestjs/testing';
 import { LoggingMessager } from '../../adapters/secondaries/logging.messager';
 import { UsersRepository } from '../../adapters/secondaries/users.repository';
+import { FindUserByUuidRequest } from '../../domain/dtos/find-user-by-uuid.request';
 import { FindUserByUuidUseCase } from '../../domain/usecases/find-user-by-uuid.usecase';
 import { FindUserByUuidQuery } from '../../queries/find-user-by-uuid.query';
 
@@ -13,9 +15,14 @@ const mockUser = {
 };
 
 const mockUserRepository = {
+  findOneByUuid: jest
+    .fn()
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  findOneByUuid: jest.fn().mockImplementation((query?: FindUserByUuidQuery) => {
+    .mockImplementationOnce((query?: FindUserByUuidQuery) => {
       return Promise.resolve(mockUser);
+    })
+    .mockImplementation(() => {
+      return Promise.resolve(undefined);
     }),
 };
 
@@ -53,11 +60,23 @@ describe('FindUserByUuidUseCase', () => {
 
   describe('execute', () => {
     it('should return a user', async () => {
+      const findUserByUuidRequest: FindUserByUuidRequest =
+        new FindUserByUuidRequest();
+      findUserByUuidRequest.uuid = 'bb281075-1b98-4456-89d6-c643d3044a91';
       const user = await findUserByUuidUseCase.execute(
-        new FindUserByUuidQuery('bb281075-1b98-4456-89d6-c643d3044a91'),
+        new FindUserByUuidQuery(findUserByUuidRequest),
       );
-
       expect(user).toBe(mockUser);
     });
+    it('should throw an error if user does not exist', async () => {
+      const findUserByUuidRequest: FindUserByUuidRequest =
+        new FindUserByUuidRequest();
+      findUserByUuidRequest.uuid = 'bb281075-1b98-4456-89d6-c643d3044a90';
+      await expect(
+        findUserByUuidUseCase.execute(
+          new FindUserByUuidQuery(findUserByUuidRequest),
+        ),
+      ).rejects.toBeInstanceOf(NotFoundException);
+    });
   });
 });

src/modules/users/tests/unit/update-user.usecase.spec.ts

@@ -24,10 +24,15 @@ const updateUserCommand: UpdateUserCommand = new UpdateUserCommand(
 );
 
 const mockUsersRepository = {
-  update: jest.fn().mockImplementation((uuid: string, params: any) => {
+  update: jest
+    .fn()
+    .mockImplementationOnce((uuid: string, params: any) => {
       originalUser.lastName = params.lastName;
 
       return Promise.resolve(originalUser);
+    })
+    .mockImplementation(() => {
+      throw new Error('Error');
     }),
 };
 
@@ -75,5 +80,10 @@ describe('UpdateUserUseCase', () => {
 
       expect(updatedUser.lastName).toBe(updateUserRequest.lastName);
     });
+    it('should throw an error if user does not exist', async () => {
+      await expect(
+        updateUserUseCase.execute(updateUserCommand),
+      ).rejects.toBeInstanceOf(Error);
+    });
   });
 });