refactor: test and add test schema,error,controller (#170)

* refactor: test and add test schema,error,controller

* refactor: organizing the description

* refactor: fixing delte to delete

Author: Frompaje

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

@@ -1,35 +1,93 @@
-import type { NextFunction, Request, Response } from 'express';
-import type { MockProxy } from 'vitest-mock-extended';
-import { mock } from 'vitest-mock-extended';
+import type { Request, Response } from 'express';
+import { mock, mockDeep } from 'vitest-mock-extended';
 
 import { AccountController } from '@/features/account/controllers/account-controller';
-import type { AccountRepository } from '@/features/account/repositories/account-repository/account-repository';
-import { DeleteUserAccountsService } from '@/features/account/services/delete-user-accounts-service';
-
-describe('Account Controller', () => {
-  let accountRepository: MockProxy<AccountRepository>;
-  let deleteAccountByIdService: DeleteUserAccountsService;
-  let accountController: AccountController;
-
-  beforeEach(() => {
-    accountRepository = mock<AccountRepository>();
-    deleteAccountByIdService = new DeleteUserAccountsService(accountRepository);
-    accountController = new AccountController(deleteAccountByIdService);
+import type { DeleteUserAccountsService } from '@/features/account/services/delete-user-accounts-service';
+import { accountDeleteBySchema } from '@/features/account/validators/account-find-by-id-schema';
+import { HttpError } from '@/shared/errors/http-error';
+import { HttpStatusCode } from '@/shared/protocols/http-client';
+
+const makeSut = () => {
+  const deleteUserAccountServiceMock = mock<DeleteUserAccountsService>({
+    execute: vi.fn(),
   });
 
-  it('should be able to delete an account by id', async () => {
-    const req = mock<Request>();
-    req.params.id = 'f19c169c-5fa2-406d-8de9-4d2c36dc6529';
+  const accountController = new AccountController(deleteUserAccountServiceMock);
+
+  const req = mockDeep<Request>();
+
+  const res = {
+    send: vi.fn(),
+
+    status: vi.fn().mockReturnThis(),
+  } as unknown as Response;
+
+  const next = vi.fn();
+
+  return {
+    accountController,
+
+    deleteUserAccountService: deleteUserAccountServiceMock,
 
-    const res = mock<Response>();
-    res.status.mockReturnThis();
-    res.send.mockReturnThis();
+    next,
 
-    const next = mock<NextFunction>();
+    req,
+
+    res,
+  };
+};
+
+describe('deleteAccountById', () => {
+  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')
+      .mockResolvedValue();
 
     await accountController.deleteAccountById(req, res, next);
 
-    expect(res.status).toHaveBeenCalledWith(204);
+    expect(executeSpy).toHaveBeenCalledWith({
+      socialMediaId: Number(socialMediaId),
+    });
+
+    expect(res.status).toHaveBeenCalledWith(HttpStatusCode.noContent);
+
     expect(res.send).toHaveBeenCalled();
+
+    expect(next).not.toHaveBeenCalled();
+  });
+
+  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);
+
+    await accountController.deleteAccountById(req, res, next);
+
+    expect(next).toHaveBeenCalledWith(error);
+
+    expect(res.status).not.toHaveBeenCalled();
+    expect(res.send).not.toHaveBeenCalled();
+  });
+
+  describe('accountDeleteByschema', () => {
+    it('should pass validation when id is a valid number', () => {
+      const validInput = { id: 123 };
+      const parsedData = accountDeleteBySchema.parse(validInput);
+
+      expect(parsedData).toEqual({ id: validInput.id });
+    });
   });
 });

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

@@ -3,13 +3,15 @@ import type { Controller } from '@/shared/protocols/controller';
 import type { AsyncRequestHandler } from '@/shared/protocols/handlers';
 import { HttpStatusCode } from '@/shared/protocols/http-client';
 
+import { accountDeleteBySchema } from '../validators/account-find-by-id-schema';
+
 export class AccountController implements Controller {
   deleteAccountById: AsyncRequestHandler = async (req, res, next) => {
     try {
-      const accountId = Number(req.params.id);
+      const { id } = accountDeleteBySchema.parse(req.params);
 
       await this.deleteUserAccountService.execute({
-        socialMediaId: accountId,
+        socialMediaId: id,
       });
 
       return res.status(HttpStatusCode.noContent).send();

src/features/account/validators/account-find-by-id-schema.ts

@@ -1,9 +1,5 @@
 import { z } from 'zod';
 
-export const accountDeleteByParamsSchema = z.object({
-  id: z.string().uuid(),
-});
-
 export const accountDeleteBySchema = z.object({
-  params: accountDeleteByParamsSchema,
+  id: z.coerce.number().min(1),
 });