Desenvolvimento orientado a testes em Python: guia para iniciantes

Testes dão a você a confiança de que seu código faz exatamente o que deveria. Neste tutorial, vamos aprender o básico de desenvolvimento orientado a testes (TDD) usando Python. Para começar, veremos um pouco do contexto do TDD – o que é e por que escrever os testes primeiro ajuda na hora de programar. Vamos adotar uma abordagem de testes primeiro: antes de escrever as funções de fato, criaremos casos de teste que falham para a funcionalidade que queremos implementar.

Pré-requisitos do tutorial

Para acompanhar este tutorial, você precisa ter noções básicas de Python. Se quiser revisar seus conhecimentos, confira este curso: Introduction to Python for Developers.

Uma abordagem de testes primeiro permite refletir sobre o comportamento desejado e os resultados esperados. Você pode usar várias bibliotecas para testar em Python, como pytest e unnitest. Porém, por enquanto, vamos focar em como escrever casos de teste simples usando o Python nativo para validar se a funcionalidade desejada produz o resultado esperado.

Começaremos com um caso de teste simples e vamos ampliar os testes, aos poucos, para cobrir diferentes cenários. À medida que expandimos nossos casos de teste, podemos encontrar bugs ou lacunas na lógica inicial da implementação que precisaremos melhorar. Esse processo de escrever casos de teste cada vez mais avançados, vê-los falhar e voltar para aprimorar a implementação está no coração do desenvolvimento orientado a testes com Python.

Neste tutorial, usaremos o DataLab, o notebook de dados em nuvem da DataCamp que permite escrever e executar código Python sem instalar nada localmente. Vamos lá!

Primeiros passos com o DataLab

Antes de começarmos com desenvolvimento orientado a testes, precisamos explorar o DataLab e entender como usá-lo para apoiar sua jornada de aprendizado. Ao abrir o DataLab, você vai notar várias opções. Por enquanto, vamos focar em escrever Python no DataLab.

Ao selecionar Python, o workbook abre uma célula de código para você escrever em Python. Vai ficar mais ou menos assim:

Você tem algumas opções úteis aqui. Por exemplo, dá para executar a célula para gerar o output, adicionar comentários ou anotações para apoiar seu aprendizado e usar IA para começar ou destravar bloqueios. Você também pode adicionar ou excluir quantas células precisar. Vamos focar em executar a célula com a opção "Run". Como você vê no código abaixo, qualquer saída produzida pelo seu código é mostrada logo abaixo quando você executa a célula.

Observação rápida: se você estiver usando várias células e definiu uma variável em uma delas, mas quer acessá-la em outra, é preciso executar cada célula separadamente ou o workbook inteiro (pelo botão "Run" no canto superior direito do seu workbook).

Agora que vimos o básico do DataLab, vamos começar com desenvolvimento orientado a testes.

Desenvolvimento orientado a testes

Desenvolvimento orientado a testes significa escrever testes para o seu código antes de escrever o código. Para explicar o TDD, vamos começar com um exemplo bem simples: escrever um script em Python para somar números. No entanto, antes de escrever a função, vamos criar um teste para verificar se 1 + 1 é igual a 2. Você pode fazer isso usando Python nativo, como mostrado abaixo.

assert 1 + 1 == 2

A palavra-chave assert em Python é usada para escrever casos de teste e confirmar que as condições do programa avaliam como True. Ela permite validar o comportamento e as saídas do seu código. Quando uma instrução assert falha, é gerado um AssertionError, indicando um problema no código. Isso vai aparecer assim no seu workbook do DataLab:

Exemplo 1: testando uma função simples

Vamos começar com o teste. Primeiro, abra um arquivo Python no DataLab. Desenvolvimento orientado a testes envolve escrever primeiro um teste que falha. Então, vamos escrever um teste que falha chamando a função add(), que ainda não foi definida.

assert add(1, 1) == 2

Isso vai resultar em um NameError, indicando que não existe implementação — a chamada etapa "vermelha". Você recebe um NameError quando tenta chamar uma função ou variável que não foi definida.

Agora é hora de implementar a função. Podemos fazer isso definindo a função:

def add(num1, num2):
    return

Definimos nossa função add, que recebe dois parâmetros, num1 e num2. Nossa função ainda não retorna nada. Vamos ver se essa implementação passa nos testes!

O NameError não aparece mais. Porém, ao executar a célula, ainda vemos um erro! Desta vez é um AssertionError. Ou seja, nosso teste ainda falhou. Por que isso acontece? Porque definimos uma função que ainda não retorna nada.

Ao rodar o teste, recebemos um AssertionError porque 1 + 1 não é igual a 2 com nossa implementação vazia. Por fim, podemos fazer o teste passar implementando corretamente a lógica na função.

Você vai notar o ponto verde no canto da célula. Ele mostra que seu código é válido e passou ao executar a célula. Antes, ele aparecia em vermelho com um erro de execução e exibia o tipo de erro abaixo da célula. Esse recurso é útil para depurar seu código no DataLab.

Pronto: você escreveu seu primeiro teste em Python usando desenvolvimento orientado a testes. Mandou bem! Agora vamos ampliar nossos testes e pensar em capturar possíveis erros que façam a função falhar ou não gerar o resultado esperado.

Exemplo 2: múltiplos casos de teste

Testar com apenas um valor de entrada muitas vezes não revela erros potenciais. Bugs podem se esconder facilmente, especialmente se sua função depende de entradas variáveis do usuário ou de alguma lógica externa. Então, como testar uma função de forma mais completa, com vários valores?

Por exemplo, e se um tipo de dado incorreto for passado para a função? Você poderia usar frameworks de teste em Python, mas vamos ficar no básico do Python. Primeiro, vou definir uma lista de dicionários de entrada para simular diferentes cenários de uso:

test_cases = [
    {"num1": 1, "num2": 3, "expected": 4},
    {"num1": 1, "num2": "invalid", "expected": "Error: num2 must be a number"}, 
    {"num1": [1,2,3], "num2": 2, "expected": "Error: num1 must be a number"},
    {"num1": -1, "num2": 1, "expected": 0},
    {"num1": 3.5, "num2": 2.5, "expected": 6.0}, 
    {"num1": 100, "num2": 200, "expected": 300}
]

O código acima apresenta entradas para a função junto com as saídas esperadas. Mas precisamos atualizar nosso teste para iterar sobre esses casos. Podemos validar cada dicionário na lista colocando o assert dentro de um laço for.

for test in test_cases:
    assert add(test["num1"], test["num2"]) == test["expected"]

Como a função não mudou, esperamos que esse teste passe ou falhe? E que erro pode acontecer?

O teste gera um TypeError porque não tratamos entradas que não são números; e se uma string ou um booleano for passado em vez de um int? Podemos atualizar a função para capturar esses casos! Verificando se a variável de entrada é um inteiro ou float, dá para retornar uma mensagem personalizada em tipos inválidos.

def add(num1, num2):
    if type(num1) is not int and type(num1) is not float:
        return "Error: num1 must be a number"
    elif type(num2) is not int and type(num2) is not float:
        return "Error: num2 must be a number"
    else:
        return num1 + num2

Ao rodar os testes novamente, não vemos mais erros, então nossos testes passaram. Agora, o círculo verde indica que já temos testes passando. Muito bom!

Considerações finais

Neste tutorial, cobrimos os fundamentos do desenvolvimento orientado a testes em Python usando o DataLab. O DataLab oferece uma IDE em nuvem que permite escrever e executar código Python sem instalações locais. Testes validam o comportamento do código e capturam erros cedo. Instruções assert verificam condições e levantam exceções em caso de falhas.

Você pode explorar mais casos de teste e começar a escrever seus próprios testes no DataLab! Se quiser aprender mais sobre testes em Python, confira nosso curso da DataCamp — Introduction to Testing in Python.