Bugfix/76/cria categoria produto (#121)

* fix: resolve o problema de tentar recriar o cliente deletado

* fix: remove funções não usadas

* fix: resolve o problema de se criar uma categoria excluida

* fix: resolve o bug de criar produto depois de excluido

* fix: faz merge com a main

* feat: implementa o teste para cliente restaurado

* feat: faz o teste de restaurar categoria

* feat: implementa teste para produto restaurado

src/infrastructure/sql/repositories/categoria/categoria.repository.spec.ts

@@ -46,6 +46,7 @@ describe('CategoriaRepository', () => {
   });
 
   it('deve criar uma categoria', async () => {
+    categoriaTypeORMMock.findOne.mockReturnValue(null);
     categoriaTypeORMMock.create.mockReturnValue(categoriaModelMock);
     categoriaTypeORMMock.save.mockResolvedValue(
       Promise.resolve(categoriaModelMock),
@@ -67,6 +68,32 @@ describe('CategoriaRepository', () => {
     expect(result).toStrictEqual(categoriaEntityMock);
   });
 
+  it('deve restaurar uma categoria', async () => {
+    categoriaTypeORMMock.findOne.mockReturnValue(
+      Promise.resolve(categoriaModelMock),
+    );
+
+    categoriaTypeORMMock.restore.mockResolvedValue({
+      affected: 1,
+      raw: [{ categoriaModelMock }],
+      generatedMaps: [{}],
+    });
+    categoriaSQLDTOFactoryMock.criarCategoriaDTO.mockReturnValue(
+      categoriaEntityMock,
+    );
+
+    const result =
+      await categoriaRepository.criarCategoria(categoriaEntityMock);
+
+    expect(categoriaTypeORMMock.restore).toHaveBeenCalledWith({
+      id: categoriaModelMock.id
+    });
+    expect(categoriaSQLDTOFactoryMock.criarCategoriaDTO).toHaveBeenCalledWith(
+      categoriaModelMock,
+    );
+    expect(result).toStrictEqual(categoriaEntityMock);
+  });
+
   it('deve editar uma categoria', async () => {
     categoriaTypeORMMock.create.mockReturnValue(categoriaModelMock);
     categoriaTypeORMMock.findOne.mockResolvedValue(

src/infrastructure/sql/repositories/categoria/categoria.repository.ts

@@ -15,9 +15,21 @@ export class CategoriaRepository implements ICategoriaRepository {
   ) {}
 
   async criarCategoria(categoria: CategoriaEntity): Promise<CategoriaEntity> {
-    const categoriaModel = this.categoriaRepository.create(categoria);
-    await this.categoriaRepository.save(categoriaModel);
-    return this.sqlDTOFactory.criarCategoriaDTO(categoriaModel);
+    const categoriaExistente = await this.categoriaRepository.findOne({
+      where: { nome: categoria.nome },
+      withDeleted: true,
+    });
+
+    if (categoriaExistente) {
+      await this.categoriaRepository.restore({
+        id: categoriaExistente.id
+      });
+      return this.sqlDTOFactory.criarCategoriaDTO(categoriaExistente)
+    } else {
+      const categoriaModel = this.categoriaRepository.create(categoria);
+      await this.categoriaRepository.save(categoriaModel);
+      return this.sqlDTOFactory.criarCategoriaDTO(categoriaModel);
+    }
   }
 
   async editarCategoria(

src/infrastructure/sql/repositories/cliente/cliente.repository.spec.ts

@@ -50,6 +50,7 @@ describe('ClienteRepository', () => {
   });
 
   it('deve criar um cliente', async () => {
+    clienteTypeORMMock.findOne.mockResolvedValue(null);
     clienteTypeORMMock.create.mockReturnValue(clienteModelMock);
     clienteTypeORMMock.save.mockResolvedValue(
       Promise.resolve(clienteModelMock),
@@ -68,6 +69,28 @@ describe('ClienteRepository', () => {
     expect(result).toStrictEqual(clienteEntityMock);
   });
 
+  it('deve restaurar um cliente', async () => {
+    clienteTypeORMMock.findOne.mockResolvedValue(
+      Promise.resolve(clienteModelMock),
+    );
+    clienteTypeORMMock.restore.mockResolvedValue({
+      affected: 1,
+      raw: [{clienteModelMock}],
+      generatedMaps: [{}],
+    });
+    clienteSQLDTOFactoryMock.criarClienteDTO.mockReturnValue(clienteEntityMock);
+
+    const result = await clienteRepository.criarCliente(clienteEntityNotIdMock);
+
+    expect(clienteTypeORMMock.restore).toHaveBeenCalledWith({
+      id: clienteModelMock.id,
+    });
+    expect(clienteSQLDTOFactoryMock.criarClienteDTO).toHaveBeenCalledWith(
+      clienteModelMock,
+    );
+    expect(result).toStrictEqual(clienteEntityMock);
+  });
+
   it('deve editar um cliente', async () => {
     clienteTypeORMMock.create.mockReturnValue(clienteModelMock);
     clienteTypeORMMock.findOne.mockResolvedValue(

src/infrastructure/sql/repositories/cliente/cliente.repository.ts

@@ -19,8 +19,6 @@ export class ClienteRepository implements IClienteRepository {
       where: { cpf: cliente.cpf },
       withDeleted: true,
     });
-    console.log(clienteExistente);
-
     if (clienteExistente) {
       this.clienteRepository.restore({
         id: clienteExistente.id,

src/infrastructure/sql/repositories/produto/produto.repository.spec.ts

@@ -7,6 +7,7 @@ import {
   produtoEntityNotIdMock,
   produtoModelMock,
   produtoTypeORMMock,
+  produtoEntityMock,
 } from 'src/mocks/produto.mock';
 import { SQLDTOFactory } from '../../factories/sql.dto.factory';
 
@@ -50,6 +51,7 @@ describe('ProdutoRepository', () => {
   });
 
   it('deve criar um produto', async () => {
+    produtoTypeORMMock.findOne.mockResolvedValue(null);
     produtoTypeORMMock.create.mockReturnValue(produtoModelMock);
     produtoTypeORMMock.save.mockResolvedValue(
       Promise.resolve(produtoModelMock),
@@ -70,6 +72,45 @@ describe('ProdutoRepository', () => {
     expect(result).toStrictEqual(produtoEntityNotIdMock);
   });
 
+  it('deve restaurar um produto', async () => {
+    produtoTypeORMMock.findOne
+      .mockResolvedValue(Promise.resolve(produtoModelMock))
+      .mockResolvedValue(Promise.resolve(produtoModelMock));
+    produtoTypeORMMock.restore.mockResolvedValue({
+      affected: 1,
+      raw: [{ produtoModelMock }],
+      generatedMaps: [{}],
+    });
+    produtoTypeORMMock.findOne.mockResolvedValue(
+      Promise.resolve(produtoModelMock),
+    );
+    produtoSQLDTOFactoryMock.criarProdutoDTO.mockReturnValue(
+      produtoEntityNotIdMock,
+    );
+
+    const result = await produtoRepository.criarProduto(produtoEntityNotIdMock);
+
+    expect(produtoTypeORMMock.findOne).toHaveBeenCalledWith({
+      where: {
+        nome: produtoEntityMock.nome,
+      },
+      withDeleted: true,
+    });
+    expect(produtoTypeORMMock.restore).toHaveBeenCalledWith({
+      id: produtoModelMock.id,
+    });
+    expect(produtoTypeORMMock.findOne).toHaveBeenCalledWith({
+      where: {
+        id: produtoModelMock.id,
+      },
+      relations: ['categoria']
+    });
+    expect(produtoSQLDTOFactoryMock.criarProdutoDTO).toHaveBeenCalledWith(
+      produtoModelMock,
+    );
+    expect(result).toStrictEqual(produtoEntityNotIdMock);
+  });
+
   it('deve editar um produto', async () => {
     produtoTypeORMMock.create.mockReturnValue(produtoModelMock);
     produtoTypeORMMock.findOne.mockResolvedValue(

src/infrastructure/sql/repositories/produto/produto.repository.ts

@@ -16,9 +16,24 @@ export class ProdutoRepository implements IProdutoRepository {
   ) {}
 
   async criarProduto(produto: ProdutoEntity): Promise<ProdutoEntity> {
-    const produtoModel = this.produtoRepository.create(produto);
-    await this.produtoRepository.save(produtoModel);
-    return this.sqlDTOFactory.criarProdutoDTO(produtoModel);
+    const produtoExistente = await this.produtoRepository.findOne({
+      where: { nome: produto.nome },
+      withDeleted: true,
+    });
+
+    if (produtoExistente) {
+      await this.produtoRepository.restore({ id: produtoExistente.id });
+      const produtoRestaurado = await this.produtoRepository.findOne({
+        where: { id: produtoExistente.id },
+        relations: this.relations
+      });
+
+      return this.sqlDTOFactory.criarProdutoDTO(produtoRestaurado);
+    } else {
+      const produtoModel = this.produtoRepository.create(produto);
+      await this.produtoRepository.save(produtoModel);
+      return this.sqlDTOFactory.criarProdutoDTO(produtoModel);
+    }
   }
 
   async editarProduto(

src/mocks/categoria.mock.ts

@@ -58,6 +58,7 @@ export const categoriaTypeORMMock: jest.Mocked<Repository<CategoriaModel>> = {
   delete: jest.fn(),
   findOne: jest.fn(),
   find: jest.fn(),
+  restore: jest.fn(),
 } as Partial<jest.Mocked<Repository<CategoriaModel>>> as jest.Mocked<
   Repository<CategoriaModel>
 >;

src/mocks/cliente.mock.ts

@@ -64,6 +64,7 @@ export const clienteTypeORMMock: jest.Mocked<Repository<ClienteModel>> = {
   delete: jest.fn(),
   findOne: jest.fn(),
   find: jest.fn(),
+  restore: jest.fn(),
 } as Partial<jest.Mocked<Repository<ClienteModel>>> as jest.Mocked<
   Repository<ClienteModel>
 >;

src/mocks/produto.mock.ts

@@ -84,6 +84,7 @@ export const produtoTypeORMMock: jest.Mocked<Repository<ProdutoModel>> = {
   delete: jest.fn(),
   findOne: jest.fn(),
   find: jest.fn(),
+  restore: jest.fn(),
 } as Partial<jest.Mocked<Repository<ProdutoModel>>> as jest.Mocked<
   Repository<ProdutoModel>
 >;