Os testes unitários são uma parte fundamental no processo de desenvolvimento de software, garantindo que o código funciona conforme o esperado e minimizando a possibilidade de erros. Neste capítulo, vamos explorar o conceito de testes unitários em Python, utilizando a biblioteca unittest. Este capítulo assume que já estás familiarizado com conceitos básicos de Python e a estrutura de funções e classes, como discutido nos capítulos anteriores.

O que são Testes Unitários?

Um teste unitário é um tipo de teste automatizado desenvolvido para verificar o funcionamento de pequenas partes do código, geralmente funções ou métodos de classes. Cada teste é feito de modo a isolar uma parte específica do código e determinar se os resultados são os esperados.

Um bom teste unitário deveria:

• Ser automatizado e fácil de executar.
• Ser reprodutível, produzindo os mesmos resultados sempre que é executado nas mesmas condições.
• Cobrir casos particulares e gerais.

Introdução ao unittest

O módulo unittest é uma biblioteca padrão em Python que nos permite criar e correr testes unitários de forma estruturada e organizada. Vamos considerar um exemplo simples de uma função que queremos testar.

def soma(a, b):
    return a + b

Vamos criar um teste unitário para verificar se a função soma funciona corretamente.

Configuração do Ambiente de Teste

Para garantir que o ambiente de teste esteja configurado corretamente, segue os seguintes passos:

1. Cria uma nova pasta no teu projeto, chamada tests, onde guardarás todos os teus testes unitários.
2. Dentro da pasta tests, cria um novo ficheiro chamado test_soma.py.

Escrevendo o Primeiro Teste

No ficheiro test_soma.py, vamos importar o módulo unittest e criar a nossa primeira classe de testes.

import unittest
from caminho.das.ferramentas import soma  # Substitui 'caminho.das.ferramentas' pelo caminho correto da função 'soma'.

class TestSoma(unittest.TestCase):
    
    def test_soma_numeros_positivos(self):
        self.assertEqual(soma(1, 2), 3)
        
    def test_soma_numeros_negativos(self):
        self.assertEqual(soma(-1, -2), -3)
        
    def test_soma_zero(self):
        self.assertEqual(soma(0, 0), 0)

if __name__ == '__main__':
    unittest.main()

Neste exemplo, criamos uma classe chamada TestSoma que herda de unittest.TestCase. Dentro desta classe, definimos vários métodos de teste, cada um verificando diferentes cenários para a função soma. Cada método de teste usa self.assertEqual para verificar se a saída real da função corresponde à saída esperada.

Executando os Testes

Para correr os teus testes, abre um terminal, navega até à pasta dos testes e executa o ficheiro test_soma.py:

python -m unittest tests/test_soma.py

Se todos os testes passarem, verás uma saída indicando que os testes foram bem-sucedidos. Caso contrário, .unittest mostrará quais testes falharam e porquê.

Casos de Teste Adicionais

Para garantir uma cobertura abrangente, deves criar testes para cenários adicionais, como somas de números mistos (positivos e negativos), somas de grandes números, e validações de entradas inválidas.

def test_soma_numeros_mistos(self):
    self.assertEqual(soma(-1, 2), 1)
    
def test_soma_grandes_numeros(self):
    self.assertEqual(soma(1000000, 1000000), 2000000)
    
def test_soma_entradas_invalidas(self):
    with self.assertRaises(TypeError):
        soma("um", 2)

Resumo

Os testes unitários são cruciais para garantir a qualidade do código, permitindo descobrir erros mais cedo no ciclo de desenvolvimento. A biblioteca unittest torna a criação e execução de testes unitários em Python simples e eficiente. Testar pequenas partes do teu código de forma isolada ajuda a identificar problemas rapidamente, contribuindo para a manutenção da integridade do software.

Quiz

1. O que é um teste unitário?
2. Porque é importante utilizar testes unitários no desenvolvimento de software?
3. Qual a função do método self.assertEqual na biblioteca unittest?
4. Como podes assegurar que uma função lança uma exceção com determinado input utilizando unittest?