refactor: standardized and updated tests

src/features/account/controllers/account-controller.test.ts

@@ -1,4 +1,4 @@
-import type { Request, Response } from 'express';
+import type { NextFunction, Request, Response } from 'express';
 import { mock, mockDeep } from 'vitest-mock-extended';
 
 import { AccountController } from '@/features/account/controllers/account-controller';
@@ -7,47 +7,41 @@ import { accountDeleteBySchema } from '@/features/account/validators/account-fin
 import { HttpError } from '@/shared/errors/http-error';
 import { HttpStatusCode } from '@/shared/protocols/http-client';
 
-const makeSut = () => {
-  const deleteUserAccountServiceMock = mock<DeleteUserAccountsService>({
-    execute: vi.fn(),
-  });
-
-  const accountController = new AccountController(deleteUserAccountServiceMock);
-
-  const req = mockDeep<Request>();
-
-  const res = {
-    send: vi.fn(),
-
-    status: vi.fn().mockReturnThis(),
-  } as unknown as Response;
+describe('deleteAccountById', () => {
+  let deleteUserAccountServiceMock: DeleteUserAccountsService;
 
-  const next = vi.fn();
+  let accountController: AccountController;
 
-  return {
-    accountController,
+  let req: Request;
+  let res: Response;
+  let next: NextFunction;
+  let error: HttpError;
 
-    deleteUserAccountService: deleteUserAccountServiceMock,
+  beforeEach(() => {
+    deleteUserAccountServiceMock = mock<DeleteUserAccountsService>({
+      execute: vi.fn(),
+    });
+    accountController = new AccountController(deleteUserAccountServiceMock);
 
-    next,
+    req = mockDeep<Request>();
 
-    req,
+    res = {
+      json: vi.fn(),
+      send: vi.fn(),
+      status: vi.fn().mockReturnThis(),
+    } as unknown as Response;
 
-    res,
-  };
-};
+    next = vi.fn() as unknown as NextFunction;
 
-describe('deleteAccountById', () => {
+    error = new HttpError(HttpStatusCode.serverError, 'error');
+  });
   it('should delete an account and return no content status', async () => {
-    const { accountController, deleteUserAccountService, next, req, res } =
-      makeSut();
-
     const socialMediaId = '123';
 
     req.params = { id: socialMediaId };
 
     const executeSpy = vi
-      .spyOn(deleteUserAccountService, 'execute')
+      .spyOn(deleteUserAccountServiceMock, 'execute')
       .mockResolvedValue();
 
     await accountController.deleteAccountById(req, res, next);
@@ -64,15 +58,12 @@ describe('deleteAccountById', () => {
   });
 
   it('should call next with an error when service throws', async () => {
-    const { accountController, deleteUserAccountService, next, req, res } =
-      makeSut();
-
     const socialMediaId = '123';
     req.params = { id: socialMediaId };
 
-    const error = new HttpError(HttpStatusCode.badRequest, 'Service error');
-
-    vi.spyOn(deleteUserAccountService, 'execute').mockRejectedValueOnce(error);
+    vi.spyOn(deleteUserAccountServiceMock, 'execute').mockRejectedValueOnce(
+      error
+    );
 
     await accountController.deleteAccountById(req, res, next);
 
@@ -90,4 +81,15 @@ describe('deleteAccountById', () => {
       expect(parsedData).toEqual({ id: validInput.id });
     });
   });
+
+  it('should call next with an error if deleteUserAccountService.execute throws', async () => {
+    vi.spyOn(deleteUserAccountServiceMock, 'execute').mockRejectedValueOnce(
+      error
+    );
+
+    await accountController.deleteAccountById(req, res, next);
+
+    expect(res.send).not.toHaveBeenCalled();
+    expect(next).toBeCalledTimes(1);
+  });
 });

src/features/account/repositories/account-repository/account-repository.test.ts

@@ -1,36 +1,39 @@
+import type { Account } from '@prisma/client';
 import { prisma } from 'mocks/prisma';
 
 import { AccountRepository } from '@/features/account/repositories/account-repository/account-repository';
 import { database } from '@/shared/infra/database/database';
 import { AccountMock } from '@/shared/test-helpers/mocks/account.mock';
 
-const makeSut = () => {
-  const repository = new AccountRepository();
+describe('[Repositories] AccountRepository', () => {
+  let repository: AccountRepository;
+  let account: Account;
 
-  return { repository };
-};
+  beforeEach(() => {
+    repository = new AccountRepository();
+    account = AccountMock.create();
+  });
 
-describe('[Repositories] AccountRepository', () => {
   describe('getAccounts', () => {
     it('returns user accounts if found', async () => {
-      const { repository } = makeSut();
-
-      const account = AccountMock.create();
-
       const expectedResult = [
         {
           avatarUrl: account.avatarUrl,
           createdAt: new Date(),
+          favorite: false,
           id: account.id,
+          name: null,
           socialMediaId: account.socialMediaId,
+          socialMediaUserId: null,
           updatedAt: new Date(),
           userId: account.userId,
+          username: null,
         },
       ];
 
       prisma.account.findMany.mockResolvedValue(expectedResult);
 
-      const result = await repository.getAccounts(account.userId);
+      const result = await repository.getAccounts(account.userId!);
 
       expect(result[0]).toEqual(expectedResult[0]);
       expect(prisma.account.findMany).toHaveBeenCalledWith({
@@ -41,8 +44,6 @@ describe('[Repositories] AccountRepository', () => {
     });
 
     it('returns an empty array if user accounts are not found', async () => {
-      const { repository } = makeSut();
-
       const userId = 'non_existent_user_id';
 
       prisma.account.findMany.mockResolvedValue([]);
@@ -60,8 +61,6 @@ describe('[Repositories] AccountRepository', () => {
 
   describe('deleteAccountsBySocialMediaId', () => {
     it('deletes accounts associated with the given social media id', async () => {
-      const { repository } = makeSut();
-
       const socialMediaId = 123;
 
       const expectedResult = {
@@ -84,70 +83,77 @@ describe('[Repositories] AccountRepository', () => {
 
   describe('Create', () => {
     it('creates an account', async () => {
-      const { repository } = makeSut();
-
-      const { avatarUrl, id, socialMediaId, userId } = AccountMock.create();
-
       prisma.account.create.mockResolvedValue({
-        avatarUrl,
-        createdAt: new Date(),
-        id,
-        socialMediaId,
-        updatedAt: new Date(),
-        userId,
+        avatarUrl: 'avatar-url',
+        createdAt: account.createdAt,
+        favorite: false,
+        id: account.id,
+        name: 'account-name',
+        socialMediaId: 1,
+        socialMediaUserId: 'social-media-user-id',
+        updatedAt: account.updatedAt,
+        userId: 'account-id',
+        username: 'account-social-media-username',
       });
 
       const result = await repository.create({
-        avatarUrl,
-        socialMediaId,
-        userId,
+        avatarUrl: 'avatar-url',
+        socialMediaId: 1,
+        socialMediaUserId: 'social-media-user-id',
+        userId: 'account-id',
       });
 
       expect(result).toEqual({
-        avatarUrl,
+        avatarUrl: 'avatar-url',
         createdAt: expect.any(Date),
-        id,
-        socialMediaId,
+        favorite: false,
+        id: account.id,
+        name: 'account-name',
+        socialMediaId: 1,
+        socialMediaUserId: 'social-media-user-id',
         updatedAt: expect.any(Date),
-        userId,
+        userId: 'account-id',
+        username: 'account-social-media-username',
       });
     });
   });
 
   describe('findAccountByUser', () => {
     it('returns an account if found', async () => {
-      const { repository } = makeSut();
-
-      const { avatarUrl, id, socialMediaId, userId } = AccountMock.create();
-
       prisma.account.findMany.mockResolvedValue([
         {
-          avatarUrl,
+          avatarUrl: 'avatar-url',
           createdAt: new Date(),
-          id,
-          socialMediaId,
+          favorite: false,
+          id: 'account-id',
+          name: null,
+          socialMediaId: 1,
+          socialMediaUserId: null,
           updatedAt: new Date(),
-          userId,
+          userId: 'account-user-id',
+          username: null,
         },
       ]);
 
-      const result = await repository.findAccountsByUserId(userId);
+      const result = await repository.findAccountsByUserId(account.userId!);
 
       expect(result).toEqual([
         {
-          avatarUrl,
+          avatarUrl: 'avatar-url',
           createdAt: expect.any(Date),
-          id,
-          socialMediaId,
+          favorite: false,
+          id: 'account-id',
+          name: null,
+          socialMediaId: 1,
+          socialMediaUserId: null,
           updatedAt: expect.any(Date),
-          userId,
+          userId: 'account-user-id',
+          username: null,
         },
       ]);
     });
 
     it('returns null if account is not found', async () => {
-      const { repository } = makeSut();
-
       const userId = 'non_existent_user_id';
 
       prisma.account.findMany.mockResolvedValue([]);