Teste de unidade parametrizado em Python: um guia para geração de testes dinâmicos

No desenvolvimento de software, o teste desempenha um papel crucial para garantir a confiabilidade e precisão do nosso código. O teste unitário, em particular, envolve a criação de testes individuais para funções ou módulos específicos. No entanto, ao lidar com grandes conjuntos de dados ou cenários de teste complexos, torna-se trabalhoso escrever testes manualmente para cada parâmetro.

Testes parametrizados: uma solução para geração de testes dinâmicos

Os testes parametrizados, também conhecidos como testes unitários parametrizados, abordam esse desafio automatizando o processo de geração de testes com base em parâmetros de entrada. Ele nos permite executar um único teste em vários conjuntos de dados, com os parâmetros de teste substituídos dinamicamente em tempo de execução.

Ferramentas e técnicas para parametrização

Python fornece uma variedade de ferramentas e bibliotecas para parametrização. Estes incluem:

1. Decorador do pytest:
pytest oferece um decorador conveniente @pytest.mark.parametrize que simplifica a parametrização. Ele nos permite passar uma lista de tuplas contendo parâmetros de teste, e o decorador expande o teste para cada conjunto de valores.

Exemplo:

import pytest

@pytest.mark.parametrize("name, a, b", [
    ("foo", "a", "a"),
    ("bar", "a", "b"),
    ("lee", "b", "b"),
])
def test_sequence(name, a, b):
    assert a == b

2. Biblioteca parametrizada:
A biblioteca parametrizada fornece uma abordagem alternativa para parametrização. Ele nos permite usar um decorador @parameterized.expand para especificar parâmetros de teste como listas ou geradores.

Exemplo:

from parameterized import parameterized

class TestSequence(unittest.TestCase):

    @parameterized.expand([
        ("foo", "a", "a"),
        ("bar", "a", "b"),
        ("lee", "b", "b"),
    ])
    def test_sequence(self, name, a, b):
        self.assertEqual(a, b)

Benefícios do teste parametrizado:

• Esforços de teste reduzidos: Elimina a necessidade de escrever separadamente testes para cada combinação de parâmetros, economizando tempo e esforço.
• Cobertura de teste aprimorada: Ao testar todos os valores de parâmetros possíveis, garante uma cobertura de teste abrangente e reduz o risco de casos extremos perdidos.
• Teste baseado em dados: Facilita o teste de cenários complexos onde os próprios dados orientam o comportamento de teste.
• Eficiente e escalável: O processo automatizado de geração de testes torna os testes mais eficientes e escaláveis, especialmente para grandes conjuntos de dados.

Abordagem legada:

Para contexto histórico, podemos mencionar uma abordagem mais antiga que envolve o uso da criação dinâmica de classes para gerar testes:

Exemplo:

import unittest

l = [["foo", "a", "a",], ["bar", "a", "b"], ["lee", "b", "b"]]

class TestSequense(unittest.TestCase):
    pass

def test_generator(a, b):
    def test(self):
        self.assertEqual(a,b)
    return test

if __name__ == '__main__':
    for t in l:
        test_name = 'test_%s' % t[0]
        test = test_generator(t[1], t[2])
        setattr(TestSequense, test_name, test)
    unittest.main()

Essa abordagem legada é menos comum no desenvolvimento Python moderno devido à disponibilidade de ferramentas de parametrização mais eficientes e fáceis de usar.