✔️test(produto): aplica testes de unidade automatizados e testes manu…

…ais de integração nos novos casos de uso - domínio e infra | Parte 22

- Implementa testes automatizados de unidade nos casos de uso "adicionar e remover categoria" no âmbito da entidade de domínio - testa as regras de negócio
- Implementa testes manuais de integração nso casos de uso "adicionar e remover categoria", "Alterar Status" e "Recuperar por Categoria"

src/index.ts

@@ -1,5 +1,6 @@
 import { Categoria } from '@modules/catalogo/domain/categoria/categoria.entity';
 import { Produto } from '@modules/catalogo/domain/produto/produto.entity';
+import { StatusProduto } from '@modules/catalogo/domain/produto/produto.types';
 import { CategoriaPrismaRepository } from '@modules/catalogo/infra/database/categoria.prisma.repository';
 import { ProdutoPrismaRepository } from '@modules/catalogo/infra/database/produto.prisma.repository';
 import { PrismaClient } from '@prisma/client';
@@ -91,31 +92,32 @@ async function main() {
     ///////////////////
 	//Inserir Produto//
 	///////////////////
-
-    /*
+	/*
+    
     const categoria01: Categoria = Categoria.recuperar({
-        id: "34b051a9-ccb5-4c4c-a850-52f6cfb08da5",
-        nome: 'Sala'
+        id: "03f890b0-684a-44ba-a887-170e26bb2cd2",
+        nome: 'Cozinha'
     });     
 
     const categoria02: Categoria = Categoria.recuperar({
-        id: "73d77a06-9a29-4f91-8f7d-c7158fb13a6a",
-        nome: 'Quarto'
+        id: "fc762da1-8d2c-4ffa-9559-901db94cb92e",
+        nome: 'Banho'
     })
 
     const produto: Produto = Produto.criar({
-        nome:'Toalha de Cozinha',
-        descricao:'toalha de algodão',
-        valor:85,
-        categorias:[categoria01, categoria02]
+        nome:'Pano de Pratro',
+        descricao:'Algodão fio 60',
+        valor:30,
+        categorias:[categoria01]
     });
 
 	const produtoInserido = await produtoRepo.inserir(produto);
 
 	console.log(produtoInserido);
-
     */
 
+
+
     /////////////////////////////////////////////////
 	//Recuperar Todos os Produtos e Suas Categorias//
 	/////////////////////////////////////////////////
@@ -147,6 +149,46 @@ async function main() {
 
 	//console.log(produtoDeletado);
 
+    ////////////////////////////////////////////
+	//Adicionar e Remover Categoria ao Produto//
+	////////////////////////////////////////////
+
+    //const produtoRecuperado: Produto | null = await produtoRepo.recuperarPorUuid("737f111b-eba1-457f-9552-5b5f28511d5d");
+
+    //const categoriaRecuperada: Categoria | null = await categoriaRepo.recuperarPorUuid("03f890b0-684a-44ba-a887-170e26bb2cd2");
+
+    //if (produtoRecuperado && categoriaRecuperada){
+
+        //if (produtoRecuperado.adicionarCategoria(categoriaRecuperada)) {
+        //    await produtoRepo.adicionarCategoria(produtoRecuperado,categoriaRecuperada);
+        //}
+
+       //if (produtoRecuperado.removerCategoria(categoriaRecuperada)) {
+        //    await produtoRepo.removerCategoria(produtoRecuperado,categoriaRecuperada);
+        //}
+
+    //}
+
+    //////////////////////////
+    //Alterar Status Produto//
+    //////////////////////////
+
+    //const produtoRecuperado: Produto | null = await produtoRepo.recuperarPorUuid("ace8780f-1aac-4219-9b36-e13b60159e4b");
+
+    //if (produtoRecuperado) {
+    //    const alterouStatusProduto: boolean = await produtoRepo.alterarStatus(produtoRecuperado,StatusProduto.ATIVO)
+    //    console.log(alterouStatusProduto);
+    //}
+
+    ////////////////////////////////////
+	//Recuperar Produtos por Categoria//
+	////////////////////////////////////
+
+	//const todosProdutosPorCategoria: Array<Produto> = await produtoRepo.recuperarPorCategoria("03f890b0-684a-44ba-a887-170e26bb2cd2");
+
+	//console.log(todosProdutosPorCategoria);
+
+
 }
 
 main()

src/modules/catalogo/domain/produto/produto.spec.ts

@@ -2,7 +2,7 @@ import { faker } from '@faker-js/faker';
 import { beforeAll, describe, expect, test } from "vitest";
 import { Categoria } from "../categoria/categoria.entity";
 import { Produto } from "./produto.entity";
-import { DescricaoProdutoTamanhoMaximoInvalido, DescricaoProdutoTamanhoMinimoInvalido, NomeProdutoTamanhoMaximoInvalido, NomeProdutoTamanhoMinimoInvalido, QtdMaximaCategoriasProdutoInvalida, QtdMinimaCategoriasProdutoInvalida, ValorMinimoProdutoInvalido } from "./produto.exception";
+import { ProdutoExceptions } from "./produto.exception";
 import { CriarProdutoProps } from "./produto.types";
 
 let nomeProdutoValido: string;
@@ -16,6 +16,13 @@ let valorMinProdutoInvalido: number;
 let categoriasValidas: Array<Categoria>;
 let categoriasQtdMinInvalidas: Array<Categoria>;
 let categoriasQtdMaxInvalidas: Array<Categoria>;
+let UUIDValido: string;
+let categoriasQtdValidaAptaAdicao: Array<Categoria>;
+let categoriasQtdMaxValidaInaptaAdicao: Array<Categoria>;
+let categoriasQtdValidaInaptaAdicaoDuplicacao: Array<Categoria>;
+let categoriasQtdValidaAptaRemocao: Array<Categoria>;
+let categoriasQtdMinValidaInaptaRemocao: Array<Categoria>;
+let categoriasQtdValidaInaptaRemocaoNaoAssociada: Array<Categoria>;
 
 //Chamado uma vez antes de iniciar a execução de todos os testes no contexto atual.
 beforeAll(async () => {
@@ -42,7 +49,16 @@ beforeAll(async () => {
     categoriasValidas = faker.helpers.arrayElements<Categoria>([categoriaValida01,categoriaValida02,categoriaValida03], {min:1,max:3});
     categoriasQtdMinInvalidas = [];
     categoriasQtdMaxInvalidas = faker.helpers.arrayElements<Categoria>([categoriaValida01,categoriaValida02,categoriaValida03,categoriaValida04], { min: 4, max: 4});
-
+    categoriasQtdValidaAptaAdicao = faker.helpers.arrayElements<Categoria>([categoriaValida01,categoriaValida02], { min: 1, max: 2});
+    categoriasQtdMaxValidaInaptaAdicao = faker.helpers.arrayElements<Categoria>([categoriaValida01,categoriaValida02,categoriaValida03], { min: 3, max: 3});
+    categoriasQtdValidaInaptaAdicaoDuplicacao = faker.helpers.arrayElements<Categoria>([categoriaValida01,categoriaValida02], { min: 1, max: 2});
+    categoriasQtdValidaAptaRemocao = faker.helpers.arrayElements<Categoria>([categoriaValida01,categoriaValida02,categoriaValida03], { min: 2, max: 3});
+	categoriasQtdMinValidaInaptaRemocao = faker.helpers.arrayElements<Categoria>([categoriaValida01], { min: 1, max: 1});
+	categoriasQtdValidaInaptaRemocaoNaoAssociada = faker.helpers.arrayElements<Categoria>([categoriaValida01,categoriaValida02,categoriaValida03], { min: 2, max: 3});
+
+    //Preenche UUID Válido para Produto
+    UUIDValido = faker.string.uuid(); // Retorna um UUID v4
+
 });
 
 //Suite de Testes de Unidade - Entidade de Domínio
@@ -80,7 +96,7 @@ describe('Entidade de Domínio: Criar Produto', () => {
 
         //Quando (When) e Então (Then)
         expect(() => Produto.criar(produtoNomeInvalido))
-            .toThrowError(NomeProdutoTamanhoMinimoInvalido);
+            .toThrowError(ProdutoExceptions.NomeProdutoTamanhoMinimoInvalido);
 
     });
 
@@ -98,7 +114,7 @@ describe('Entidade de Domínio: Criar Produto', () => {
 
         //Quando (When) e Então (Then)
         expect(() => Produto.criar(produtoNomeInvalido))
-            .toThrowError(NomeProdutoTamanhoMaximoInvalido);
+            .toThrowError(ProdutoExceptions.NomeProdutoTamanhoMaximoInvalido);
 
     });
 
@@ -116,7 +132,7 @@ describe('Entidade de Domínio: Criar Produto', () => {
 
         //Quando (When) e Então (Then)
         expect(() => Produto.criar(produtoNomeInvalido))
-            .toThrowError(DescricaoProdutoTamanhoMinimoInvalido);
+            .toThrowError(ProdutoExceptions.DescricaoProdutoTamanhoMinimoInvalido);
 
     });
 
@@ -134,7 +150,7 @@ describe('Entidade de Domínio: Criar Produto', () => {
 
         //Quando (When) e Então (Then)
         expect(() => Produto.criar(produtoNomeInvalido))
-            .toThrowError(DescricaoProdutoTamanhoMaximoInvalido);
+            .toThrowError(ProdutoExceptions.DescricaoProdutoTamanhoMaximoInvalido);
 
     });
 
@@ -152,7 +168,7 @@ describe('Entidade de Domínio: Criar Produto', () => {
 
         //Quando (When) e Então (Then)
         expect(() => Produto.criar(produtoNomeInvalido))
-            .toThrowError(ValorMinimoProdutoInvalido);
+            .toThrowError(ProdutoExceptions.ValorMinimoProdutoInvalido);
 
     });
 
@@ -170,7 +186,7 @@ describe('Entidade de Domínio: Criar Produto', () => {
 
         //Quando (When) e Então (Then)
         expect(() => Produto.criar(produtoNomeInvalido))
-            .toThrowError(QtdMinimaCategoriasProdutoInvalida);
+            .toThrowError(ProdutoExceptions.QtdMinimaCategoriasProdutoInvalida);
 
     });
 
@@ -188,8 +204,143 @@ describe('Entidade de Domínio: Criar Produto', () => {
 
         //Quando (When) e Então (Then)
         expect(() => Produto.criar(produtoNomeInvalido))
-            .toThrowError(QtdMaximaCategoriasProdutoInvalida);
+            .toThrowError(ProdutoExceptions.QtdMaximaCategoriasProdutoInvalida);
+
+    });
+
+});
+
+describe('Entidade de Domínio: Adicionar Categoria ao Produto', () => {
+
+    test('Deve Adicionar Uma Categoria Válida a Um Produto Válido Apto a Ter Uma Nova Categoria', async () => {
+
+        //Dado (Given)
+        const produtoValidoAptoNovaCategoria: Produto = Produto.recuperar({
+            id: UUIDValido,
+            nome: nomeProdutoValido,
+            descricao: descricaoProdutoValido,
+            valor: valorProdutoValido,
+            categorias: categoriasQtdValidaAptaAdicao
+        });
+
+        //Categoria válida que não seja uma das categorias já adicionadas
+        const categoriaValida = Categoria.criar({nome:faker.string.alpha({length:{min:3,max:50}})});
+
+        //Quando (When) e Então (Then)
+		expect(produtoValidoAptoNovaCategoria.adicionarCategoria(categoriaValida))
+            .toBe(categoriaValida);
+
+        expect(produtoValidoAptoNovaCategoria.categorias)
+            .toContain(categoriaValida);
+
+    });
+
+    test('Não Deve Adicionar Uma Categoria Válida a Um Produto Válido Inapto a Ter Uma Nova Categoria - Quantidade Máxima de Categorias', async () => {
 
+        //Dado (Given)
+        const produtoValidoInaptoNovaCategoria: Produto = Produto.recuperar({
+            id: UUIDValido,
+            nome: nomeProdutoValido,
+            descricao: descricaoProdutoValido,
+            valor: valorProdutoValido,
+            categorias: categoriasQtdMaxValidaInaptaAdicao
+        });
+
+        //Categoria válida que não seja uma das categorias já adicionadas
+        const categoriaValida = Categoria.criar({nome:faker.string.alpha({length:{min:3,max:50}})});
+
+        //Quando (When) e Então (Then)
+        expect(() => produtoValidoInaptoNovaCategoria.adicionarCategoria(categoriaValida))
+            .toThrowError(ProdutoExceptions.ProdutoJaPossuiQtdMaximaCategorias);
+
     });
+
+    test('Não Deve Adicionar Uma Categoria Válida a Um Produto Válido Inapto a Ter Uma Nova Categoria - Categoria Já Adicionada', async () => {
+
+        //Dado (Given)
+        const produtoValidoInaptoNovaCategoria: Produto = Produto.recuperar({
+            id: UUIDValido,
+            nome: nomeProdutoValido,
+            descricao: descricaoProdutoValido,
+            valor: valorProdutoValido,
+            categorias: categoriasQtdValidaInaptaAdicaoDuplicacao
+        });
+
+        //Categoria válida já adicionada - recupera do array passado no produto anteriormete - garente que é um elemento que já existe
+        const categoriaValida = categoriasQtdValidaInaptaAdicaoDuplicacao[0];
+
+        //Quando (When) e Então (Then)
+        expect(() => produtoValidoInaptoNovaCategoria.adicionarCategoria(categoriaValida))
+            .toThrowError(ProdutoExceptions.ProdutoJaPossuiCategoriaInformada);
+
+    });
+
+});
+
+describe('Entidade de Domínio: Remover Categoria do Produto', () => {
+
+    test('Deve Remover Uma Categoria Válida de Um Produto Válido Apto a Ter Uma Categoria Removida', async () => {
+
+        //Dado (Given)
+        const produtoValidoAptoRemoverCategoria: Produto = Produto.recuperar({
+            id: UUIDValido,
+            nome: nomeProdutoValido,
+            descricao: descricaoProdutoValido,
+            valor: valorProdutoValido,
+            categorias: categoriasQtdValidaAptaRemocao
+        });
+
+        //Categoria válida que já esteja adicionada 
+        const categoriaValida = categoriasQtdValidaAptaRemocao[0];
+
+        //Quando (When) e Então (Then)
+        expect(produtoValidoAptoRemoverCategoria.removerCategoria(categoriaValida))
+            .toBe(categoriaValida);
+
+        expect(produtoValidoAptoRemoverCategoria.categorias)  
+            .not.toContain(categoriaValida);
+
+    });
+
+    test('Não Deve Remover Uma Categoria Válida de Um Produto Válido Inapto a Ter Uma Categoria Removida - Quantidade Mínima de Categorias', async () => {
+
+        //Dado (Given)
+        const produtoValidoInaptoRemoverCategoria: Produto = Produto.recuperar({
+            id: UUIDValido,
+            nome: nomeProdutoValido,
+            descricao: descricaoProdutoValido,
+            valor: valorProdutoValido,
+            categorias: categoriasQtdMinValidaInaptaRemocao
+        });
+
+        //Categoria válida que já esteja adicionada 
+        const categoriaValida = categoriasQtdMinValidaInaptaRemocao[0];
+
+        //Quando (When) e Então (Then)
+        expect(() => produtoValidoInaptoRemoverCategoria.removerCategoria(categoriaValida))
+            .toThrowError(ProdutoExceptions.ProdutoJaPossuiQtdMinimaCategorias);
+
+    });
+
+    test('Não Deve Remover Uma Categoria Válida de Um Produto Válido Inapto a Ter Uma Categoria Removida - Categoria Não Associada ao Produto', async () => {
+
+        //Dado (Given)
+        const produtoValidoInaptoRemoverCategoria: Produto = Produto.recuperar({
+            id: UUIDValido,
+            nome: nomeProdutoValido,
+            descricao: descricaoProdutoValido,
+            valor: valorProdutoValido,
+            categorias: categoriasQtdValidaInaptaRemocaoNaoAssociada
+        });
+
+        //Categoria válida que não seja uma das categorias já adicionadas
+        const categoriaValida = Categoria.criar({nome:faker.string.alpha({length:{min:3,max:50}})});
+
+        //Quando (When) e Então (Then)
+        expect(() => produtoValidoInaptoRemoverCategoria.removerCategoria(categoriaValida))
+            .toThrowError(ProdutoExceptions.ProdutoNaoPossuiCategoriaInformada);
+
+    });
+
+});
 
-});

src/modules/catalogo/requirements/remover-categoria-produto-caso-uso.feature

@@ -0,0 +1,28 @@
+Feature: Remover Categoria do Produto
+    Como um <Administrador>
+    Eu quero <Remover uma categoria do produto>
+    De modo que <O produto possa estar com suas categorias corretas>
+
+Scenario: Categoria válida e produto válido apto a ter uma categoria removida (Padrão)
+    Dado (Given) [
+        Um produto válido apto a ter uma categoria removida - Ter no mínimo (2) e no máximo (3) categorias já adicionadas
+        Uma categoria válida
+    ]
+    Quando (When) [Solicitar a remoção da categoria do produto]
+    Então (Then) [A categoria deve ser removida corretamente e retornada]
+
+Scenario: Categoria válida e produto válido inapto a ter uma categoria removida - quantidade mínima de categorias
+    Dado (Given) [
+        Um produto válido inapto a ter uma categoria removida - Ter apenas (1) categoria adicionada
+        Uma categoria válida
+    ]
+    Quando (When) [Solicitar a remoção da categoria do produto]
+    Então (Then) [Um erro informando que o produto já possui número mínimo de categorias]
+
+Scenario: Categoria válida e produto válido inapto a ter uma categoria removida - categoria não associada ao produto
+    Dado (Given) [
+        Um produto válido inapto a ter uma categoria removida - categoria não associada ao produto
+        Uma categoria válida
+    ]
+    Quando (When) [Solicitar a remoção da categoria do produto]
+    Então (Then) [Um erro informando que o produto não possui a categoria informada a ser removida]