mkdir unit-testing-api-aula73
cd unit-testing-api-aula73
npm init -y
npm install mocha chai --save-dev

📋 Copiar

{
  "name": "unit-testing-api-aula73",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "mocha --timeout 5000" // Adiciona o script de teste, com timeout generoso para evitar falhas por lentidão
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "devDependencies": {
    "chai": "^4.3.4",
    "mocha": "^9.1.3"
  }
}

📋 Copiar

// src/utils/stringSanitizer.js

/* @file Contém funções utilitárias para sanitização de strings.
  @module StringSanitizer
 /
/* Sanitiza uma string, removendo espaços extras e limpando caracteres básicos.
  Esta função é um exemplo de uma unidade de código isolada e testável.
  @function sanitizeInput
  @param {string} input A string de entrada a ser sanitizada.
  @returns {string} A string sanitizada.
  @throws {Error} Se a entrada não for uma string.
 /
function sanitizeInput(input) {
    // 1. Logging profissional: É uma boa prática registrar entradas e saídas
    //    em ambientes de produção para debug e auditoria.
    //    Para testes unitários, geralmente usamos console.log para depuração interna,
    //    mas em uma aplicação real, usaria uma lib como Winston ou Pino.
    // console.log([sanitizeInput] Recebida entrada: "${input}");

    // 2. Validação de entrada robusta: Sempre valide os tipos de entrada.
    //    Isso previne erros em tempo de execução e torna a função mais previsível.
    if (typeof input !== 'string') {
        // Lançar um erro é uma forma eficaz de lidar com entradas inválidas.
        // É importante que o consumidor da função saiba o que esperar.
        throw new Error('A entrada deve ser uma string válida.');
    }
    // 3. Remove espaços em branco do início e do fim.
    let sanitized = input.trim();
    // 4. Substitui múltiplos espaços por um único espaço.
    sanitized = sanitized.replace(/\s+/g, ' ');
    // 5. Remove caracteres que não sejam letras, números, espaços ou hífens/sublinhados.
    //    Este é um exemplo simples. Em um cenário real, as regras seriam mais complexas
    //    dependendo do contexto (e.g., nome, email, descrição).
    sanitized = sanitized.replace(/[^a-zA-Z0-9\s\-_]/g, '');
    // 6. Converte para minúsculas para padronização (opcional, dependendo do caso de uso).
    sanitized = sanitized.toLowerCase();
    // console.log([sanitizeInput] Saída sanitizada: "${sanitized}");
    return sanitized;
}
/ Capitaliza a primeira letra de cada palavra em uma string.
  Exemplo de outra função utilitária para testar.
  @function capitalizeWords
  @param {string} input A string a ser capitalizada.
  @returns {string} A string com a primeira letra de cada palavra capitalizada.
  @throws {Error} Se a entrada não for uma string.
 /
function capitalizeWords(input) {
    if (typeof input !== 'string') {
        throw new Error('A entrada para capitalizeWords deve ser uma string válida.');
    }
    return input.toLowerCase().split(' ').map(word => {
        return word.charAt(0).toUpperCase() + word.slice(1);
    }).join(' ');
}

module.exports = {
    sanitizeInput,
    capitalizeWords
};

// test/unit/stringSanitizer.test.js

/ @file Testes unitários para as funções de sanitização de string.
  @module StringSanitizerTests
 /
// Importa as bibliotecas de teste. 'assert' é uma das interfaces do Chai.
const expect = require('chai').expect;
// Importa a unidade sob teste (Unit Under Test - UUT).
const { sanitizeInput, capitalizeWords } = require('../../src/utils/stringSanitizer');
/* Bloco de testes para a função sanitizeInput.
  O 'describe' organiza os testes em grupos lógicos.
 /
describe('StringSanitizer - sanitizeInput', () => {
    // Teste 1: Cenário de sucesso - entrada básica.
    // Cada 'it' descreve um caso de teste específico.
    it('deve remover espaços em branco extras do início e do fim e unificar múltiplos espaços', () => {
        // AAA Pattern (Arrange-Act-Assert) - Padrão de Melhores Práticas Enterprise
        // Arrange: Configura o estado inicial e as entradas.
        const input = '   Olá,   Mundo!   Node.js   ';
        // Act: Executa a função sob teste.
        const result = sanitizeInput(input);
        // Assert: Verifica se o resultado é o esperado.
        // O Chai's 'expect' torna as asserções muito legíveis.
        expect(result).to.equal('olá, mundo! node.js');
    });
    // Teste 2: Cenário de sucesso - entrada com caracteres especiais permitidos.
    it('deve permitir hífens e sublinhados', () => {
        const input = 'nome-de_usuario_com-hifen';
        const result = sanitizeInput(input);
        expect(result).to.equal('nome-de_usuario_com-hifen');
    });
    // Teste 3: Cenário de sucesso - entrada vazia.
    it('deve retornar uma string vazia para entrada vazia ou apenas espaços', () => {
        expect(sanitizeInput('')).to.equal('');
        expect(sanitizeInput('   ')).to.equal('');
    });
    // Teste 4: Cenário de sucesso - remoção de caracteres proibidos.
    it('deve remover caracteres especiais não permitidos', () => {
        const input = 'Nome@Usuário#123!$%^&()';
        const result = sanitizeInput(input);
        // Esperamos que apenas letras, números e espaços sejam mantidos,
        // e que a string seja convertida para minúsculas.
        expect(result).to.equal('nomeusuário123');
    });

    // Teste 5: Cenário de erro - entrada não string.
    it('deve lançar um erro se a entrada não for uma string', () => {
        // Para testar se uma função lança um erro, envolvemos a chamada em uma função anônima.
        // O Chai permite assertar sobre o tipo e a mensagem do erro.
        expect(() => sanitizeInput(123)).to.throw('A entrada deve ser uma string válida.');
        expect(() => sanitizeInput(null)).to.throw('A entrada deve ser uma string válida.');
        expect(() => sanitizeInput(undefined)).to.throw('A entrada deve ser uma string válida.');
        expect(() => sanitizeInput({})).to.throw('A entrada deve ser uma string válida.');
    });
    // Teste 6: Cenário de sucesso - números na string.
    it('deve lidar corretamente com números na string', () => {
        const input = 'Produto SKU 12345';
        const result = sanitizeInput(input);
        expect(result).to.equal('produto sku 12345');
    });
});
/ Bloco de testes para a função capitalizeWords.
 /
describe('StringSanitizer - capitalizeWords', () => {

    // Teste 1: Cenário de sucesso - frase comum.
    it('deve capitalizar a primeira letra de cada palavra', () => {
        const input = 'olá mundo, como vai?';
        const result = capitalizeWords(input);
        expect(result).to.equal('Olá Mundo, Como Vai?');
    });
    // Teste 2: Cenário de sucesso - string vazia.
    it('deve retornar uma string vazia para entrada vazia', () => {
        expect(capitalizeWords('')).to.equal('');
    });
    // Teste 3: Cenário de sucesso - string já capitalizada.
    it('deve lidar corretamente com strings já capitalizadas ou com letras maiúsculas misturadas', () => {
        const input = 'IsSo É Um TesTe';
        const result = capitalizeWords(input);
        expect(result).to.equal('Isso É Um Teste');
    });
    // Teste 4: Cenário de erro - entrada não string.
    it('deve lançar um erro se a entrada não for uma string', () => {
        expect(() => capitalizeWords(123)).to.throw('A entrada para capitalizeWords deve ser uma string válida.');
        expect(() => capitalizeWords(null)).to.throw('A entrada para capitalizeWords deve ser uma string válida.');
    });
});

// src/utils/priceCalculator.js

/ Calcula o preço de um item após a aplicação de um desconto.
  @function calculateDiscountedPrice
  @param {number} price O preço original do item.
  @param {number} discountPercentage A porcentagem de desconto a ser aplicada (0-100).
  @returns {number} O preço final com desconto, arredondado para duas casas decimais.
  @throws {Error} Se os parâmetros forem inválidos.
 /
function calculateDiscountedPrice(price, discountPercentage) {
    // Validação de entrada: Verificamos os tipos dos parâmetros.
    if (typeof price !== 'number' || typeof discountPercentage !== 'number') {
        throw new Error('Preço e porcentagem de desconto devem ser números.');
    }

    // Validação de regras de negócio: Preço deve ser positivo.
    if (price <= 0) {
        throw new Error('O preço deve ser um número positivo.');
    }
    // Validação de regras de negócio: Porcentagem de desconto deve estar entre 0 e 100.
    if (discountPercentage < 0 || discountPercentage > 100) {
        throw new Error('A porcentagem de desconto deve estar entre 0 e 100.');
    }
    const discountAmount = price  (discountPercentage / 100);
    const finalPrice = price - discountAmount;
    // Arredonda para duas casas decimais.
    return parseFloat(finalPrice.toFixed(2));
}
module.exports = {
    calculateDiscountedPrice
};

📋 Copiar

// test/unit/priceCalculator.test.js

const expect = require('chai').expect;
const { calculateDiscountedPrice } = require('../../src/utils/priceCalculator');
describe('PriceCalculator - calculateDiscountedPrice', () => {
    // Testes de sucesso
    it('deve calcular o preço com 10% de desconto corretamente', () => {
        expect(calculateDiscountedPrice(100, 10)).to.equal(90);
    });
    it('deve calcular o preço com 0% de desconto (preço cheio)', () => {
        expect(calculateDiscountedPrice(50, 0)).to.equal(50);
    });
    it('deve calcular o preço com 100% de desconto (preço zero)', () => {
        expect(calculateDiscountedPrice(200, 100)).to.equal(0);
    });
    it('deve lidar com preços e descontos decimais e arredondar para 2 casas', () => {
        expect(calculateDiscountedPrice(99.99, 15)).to.equal(84.99); // 99.99  0.85 = 84.9915 -> 84.99
        expect(calculateDiscountedPrice(10.50, 5.5)).to.equal(9.92); // 10.50  0.945 = 9.9225 -> 9.92
    });
    // Testes de erro - Validação de tipos
    it('deve lançar um erro se o preço não for um número', () => {
        expect(() => calculateDiscountedPrice('abc', 10)).to.throw('Preço e porcentagem de desconto devem ser números.');
        expect(() => calculateDiscountedPrice(null, 10)).to.throw('Preço e porcentagem de desconto devem ser números.');
    });
    it('deve lançar um erro se a porcentagem de desconto não for um número', () => {
        expect(() => calculateDiscountedPrice(100, 'dez')).to.throw('Preço e porcentagem de desconto devem ser números.');
        expect(() => calculateDiscountedPrice(100, undefined)).to.throw('Preço e porcentagem de desconto devem ser números.');
    });
    // Testes de erro - Validação de regras de negócio
    it('deve lançar um erro se o preço for zero ou negativo', () => {
        expect(() => calculateDiscountedPrice(0, 10)).to.throw('O preço deve ser um número positivo.');
        expect(() => calculateDiscountedPrice(-10, 10)).to.throw('O preço deve ser um número positivo.');
    });
    it('deve lançar um erro se a porcentagem de desconto for negativa', () => {
        expect(() => calculateDiscountedPrice(100, -5)).to.throw('A porcentagem de desconto deve estar entre 0 e 100.');
    });
    it('deve lançar um erro se a porcentagem de desconto for maior que 100', () => {
        expect(() => calculateDiscountedPrice(100, 101)).to.throw('A porcentagem de desconto deve estar entre 0 e 100.');
    });
});

📋 Copiar

npm test

📋 Copiar

🚀 Pronto para a próxima aula?

Continue sua jornada no desenvolvimento de APIs e domine Node.js & Express!

📚 Ver todas as aulas