Sign in Subscribe

A Importância dos Testes Unitários no Desenvolvimento de Software

wederson

• 5 min read
A Importância dos Testes Unitários no Desenvolvimento de Software

Nesta publicação, vamos explorar a importância dos testes unitários e realizar exemplos práticos em formulários de login, seguindo as melhores práticas de desenvolvimento.

Introdução:

Testes unitários são uma prática de desenvolvimento de software na qual partes individuais do código, como funções, métodos ou componentes, são testadas de forma isolada para garantir que funcionem conforme o esperado. Essas partes isoladas são chamadas de "unidades" e o objetivo dos testes unitários é validar se cada unidade se comporta corretamente em diferentes cenários, de acordo com suas especificações.

Testes de Unidade não são apenas uma questão de detecção de bugs. Eles nos proporcionam uma série de benefícios que vão muito além disso. Ao escrever testes, estamos forjando uma espécie de contrato entre nós e o nosso código, garantindo que ele se comporte conforme o esperado em diferentes cenários. Isso nos dá uma sensação de confiança e segurança ao desenvolver novos recursos ou fazer alterações em partes existentes do sistema.

Além disso, os Testes de Unidade nos permitem iterar com mais agilidade. Eles nos dão a liberdade de experimentar novas ideias sem o medo de quebrar funcionalidades existentes, pois sabemos que nossos testes estarão lá para nos alertar se algo der errado. Essa sensação de liberdade e confiança é inestimável em um ambiente de desenvolvimento, onde a pressão por entregas rápidas muitas vezes pode levar a cortes de qualidade.

Benefícios dos Testes Unitários:

  1. Detecção Precoce de Erros: Testes unitários ajudam a identificar bugs e falhas de lógica logo no início do processo de desenvolvimento, quando são mais fáceis e baratos de corrigir.
  2. Facilidade de Manutenção: Ao escrever testes unitários para cada parte do código, torna-se mais fácil entender o comportamento esperado de cada unidade, facilitando a manutenção e a modificação do código no futuro.
  3. Refatoração Segura: Testes unitários oferecem uma rede de segurança ao realizar refatorações no código. Eles garantem que as alterações não introduzam regressões ou quebras de funcionalidade.
  4. Documentação Viva: Os testes unitários servem como uma forma de documentação viva do código, descrevendo o comportamento esperado de cada unidade de forma clara e concisa.
  5. Aceleração do Desenvolvimento: Embora escrever testes unitários possa parecer demandar mais tempo inicialmente, a longo prazo, eles aceleram o desenvolvimento ao reduzir a quantidade de tempo gasto em depuração e correção de bugs.
  6. Promoção da Qualidade do Código: Testes unitários incentivam a escrita de código modular e coeso, facilitando a manutenção e melhorando a qualidade geral do software.
  7. Integração Contínua: Testes unitários são essenciais para a implementação de práticas de integração contínua e entrega contínua (CI/CD), permitindo que mudanças no código sejam validadas automaticamente antes de serem integradas ao código principal.

Testes Unitários em React:

Vamos começar com um formulário de login em React e realizar testes unitários para cada componente. Utilizaremos conceitos de clean architecture e clean code para garantir um código limpo e de fácil manutenção. Como referência, vamos nos inspirar em livros reconhecidos, como "Clean Code" de Robert C. Martin.

// Componente de Formulário de Login em React
import React, { useState } from 'react';

function LoginForm() {
  const [username, setUsername] = useState('');
  const [password, setPassword] = useState('');

  const handleUsernameChange = (e) => {
    setUsername(e.target.value);
  };

  const handlePasswordChange = (e) => {
    setPassword(e.target.value);
  };

  const handleSubmit = (e) => {
    e.preventDefault();
    // Lógica de autenticação
  };

  return (
    <form onSubmit={handleSubmit}>
      <input type="text" value={username} onChange={handleUsernameChange} placeholder="Usuário" data-testid="username-input" />
      <input type="password" value={password} onChange={handlePasswordChange} placeholder="Senha" data-testid="password-input" />
      <button type="submit" data-testid="submit-button">Entrar</button>
    </form>
  );
}

export default LoginForm;

Teste Unitário em React usando React Testing Library:

// Teste Unitário para Componente de Formulário de Login em React
import React from 'react';
import { render, fireEvent } from '@testing-library/react';
import LoginForm from './LoginForm';

test('Teste de renderização do formulário de login', () => {
  const { getByTestId } = render(<LoginForm />);
  const usernameInput = getByTestId('username-input');
  const passwordInput = getByTestId('password-input');
  const submitButton = getByTestId('submit-button');

  expect(usernameInput).toBeInTheDocument();
  expect(passwordInput).toBeInTheDocument();
  expect(submitButton).toBeInTheDocument();
});

test('Teste de preenchimento e envio do formulário de login', () => {
  const { getByTestId } = render(<LoginForm />);
  const usernameInput = getByTestId('username-input');
  const passwordInput = getByTestId('password-input');
  const submitButton = getByTestId('submit-button');

  fireEvent.change(usernameInput, { target: { value: 'username' } });
  fireEvent.change(passwordInput, { target: { value: 'password' } });
  fireEvent.click(submitButton);

  // Adicione aqui as asserções para verificar o comportamento esperado após o envio do formulário
});

Teste Unitário em React usando Jest:

// Teste Unitário para Componente de Formulário de Login em React
import React from 'react';
import { render, fireEvent } from '@testing-library/react';
import LoginForm from './LoginForm';

test('Teste de renderização do formulário de login', () => {
  const { getByPlaceholderText } = render(<LoginForm />);
  const usernameInput = getByPlaceholderText('Usuário');
  const passwordInput = getByPlaceholderText('Senha');
  expect(usernameInput).toBeInTheDocument();
  expect(passwordInput).toBeInTheDocument();
});

// Adicione mais testes para os outros componentes conforme necessário

Testes Unitários em Node.js:

Agora, vamos desenvolver um formulário de login em Node.js e realizar testes unitários para cada função. Utilizaremos princípios de clean architecture para organizar nosso código de forma clara e modular. Como referência, vamos nos inspirar em "Clean Architecture: A Craftsman's Guide to Software Structure and Design" de Robert C. Martin.

// Funções de Autenticação em Node.js
function validarCredenciais(username, password) {
  // Lógica de validação das credenciais
  return true;
}

function fazerLogin(username, password) {
  if (validarCredenciais(username, password)) {
    // Lógica de login bem-sucedido
    return true;
  } else {
    // Lógica de login falhou
    return false;
  }
}

module.exports = { fazerLogin };

Teste Unitário em Node.js:

// Teste Unitário para Funções de Autenticação em Node.js
const { fazerLogin } = require('./auth');

test('Teste de autenticação com credenciais válidas', () => {
  expect(fazerLogin('usuario', 'senha')).toBe(true);
});

test('Teste de autenticação com credenciais inválidas', () => {
  expect(fazerLogin('usuario', 'senhaErrada')).toBe(false);
});

// Adicione mais testes conforme necessário

Boas Práticas:

  • Escreva testes independentes e isolados
  • Mantenha os testes simples e legíveis
  • Priorize a cobertura de código crítico
  • Atualize os testes conforme o código evolui
  • Utilize mocks e stubs quando necessário
  • Automatize a execução dos testes

Má Prática:

  • Criar testes que dependem do estado ou da implementação interna
  • Escrever testes excessivamente complexos
  • Ignorar a atualização dos testes após alterações no código
  • Depender exclusivamente de testes manuais

Cheat Sheet com Jest:

  1. Descreva um Teste:
test('Descrição do teste', () => {
  // Arrange (preparar)
  // Act (agir)
  // Assert (afirmar)
});

Matchers Simples:

expect(valor).toBe(valorEsperado);
expect(valor).toEqual(valorEsperado);
expect(valor).not.toBe(valorEsperado);

Testando Nulos e Undefined:

expect(valor).toBeNull();
expect(valor).toBeUndefined();
expect(valor).toBeDefined();

Testando Booleanos:

expect(valor).toBeTruthy();
expect(valor).toBeFalsy();

Testando Números:

expect(valor).toBeGreaterThan(3);
expect(valor).toBeGreaterThanOrEqual(3.5);
expect(valor).toBeLessThan(5);
expect(valor).toBeLessThanOrEqual(4.5);

Testando Strings:

expect(valor).toMatch(/regexp/);
expect(valor).toContain('substring');

Testando Arrays e Iteráveis:

expect(array).toContain(valor);
expect(array).toHaveLength(4);

Testando Objetos:

expect(objeto).toHaveProperty('chave');
expect(objeto).toHaveProperty('chave', valor);

Testando Funções:

const funcao = jest.fn();
funcao();
expect(funcao).toHaveBeenCalled();

Testando Exceções:

expect(() => { funcaoQueLancaErro(); }).toThrow();
expect(() => { funcaoQueLancaErro(); }).toThrow('Mensagem de Erro');

Testando Assincronicidade:

test('Teste Assíncrono', async () => {
  await expect(funcaoAsync()).resolves.toBe('resultado');
});

Mocking:

const modulo = require('modulo');
jest.mock('modulo');
modulo.funcao.mockResolvedValue('valorMockado');

Snapshot Testing:

expect(objeto).toMatchSnapshot();

Cobertura de Código:

jest --coverage

Temporizadores:

jest.useFakeTimers();
jest.runAllTimers();

Conclusão:

Investir em testes unitários é essencial para garantir a qualidade e a robustez do seu código em React e Node.js. Ao seguir as melhores práticas de desenvolvimento e utilizar referências reconhecidas da literatura técnica, você estará no caminho certo para construir software de alta qualidade. Continue aprendendo e aprimorando suas habilidades de teste unitário!