Tutorial PyUnit: Python Estrutura de teste unitário (com exemplo)

O que é teste de unidade?

Teste de Unidade in Python é feito para identificar bugs no início do estágio de desenvolvimento do aplicativo, quando os bugs são menos recorrentes e menos dispendiosos para serem corrigidos.

Um teste de unidade é um teste de nível de código com script projetado em Python para verificar uma pequena “unidade” de funcionalidade. O teste de unidade é uma estrutura orientada a objetos baseada em acessórios de teste.

Python Técnicas de teste unitário

Python O teste de unidade envolve principalmente testar um módulo específico sem acessar nenhum código dependente. Os desenvolvedores podem usar técnicas como stubs e mocks para separar o código em “unidades” e executar testes em nível de unidade nas partes individuais.

• TDD de desenvolvimento orientado a testes: O teste unitário deve ser feito junto com o Python, e para isso os desenvolvedores usam o método Test-Driven Development. No método TDD, você primeiro projeta Python Testes unitários e só então você continua escrevendo o código que implementará esse recurso.
• Esboços e simulações: São duas técnicas principais que simulam métodos falsos que estão sendo testados. A Stub é usado para preencher alguma dependência necessária para que o teste de unidade seja executado corretamente. A Zombar por outro lado é um objeto falso que executa os testes onde colocamos assert.

  As intenções de ambos os métodos são as mesmas para eliminar o teste de todas as dependências de uma classe ou função.

Python Estrutura de testes unitários

Para facilitar o processo de Testes Unitários e melhorar a qualidade do seu projeto, recomenda-se o Python Estrutura de teste de unidade. A estrutura de teste de unidade inclui

• Unidade Py: PyUnit oferece suporte a fixtures, casos de teste, suítes de teste e um executor de teste para teste automatizado do código. No PyUnit, você pode organizar casos de teste em suítes com os mesmos equipamentos
• Nariz: Os plug-ins integrados do Nose ajudam você com captura de saída, cobertura de código, doctests, etc. A sintaxe do Nose é bem mais simples e reduz as barreiras para escrever testes. Ele se estende Python unittest para facilitar o teste.
• Documento: O script de teste Doctest entra em docstring com uma pequena função na parte inferior do arquivo. Doctest permite testar seu código executando exemplos incluídos na documentação e verificando se eles retornaram os resultados esperados. O caso de uso do doctest é menos detalhado e não captura casos especiais. Eles são úteis como documentação expressiva do principal caso de uso de um módulo e seus componentes.

Teste de unidade com PyUnit

Pyunit é um Python Porto de JUnit. Como parte do Pyunit, no módulo unittest existem cinco classes principais.

• Classe TestCase: A classe TestCase suporta as rotinas de teste e fornece ganchos para fazer cada rotina e limpar depois
• Classe TestSuite: Ele funciona como um contêiner de coleção e pode possuir vários objetos testcase e vários objetos testsuites
• Classe TestLoader: esta classe carrega casos de teste e suítes definidos localmente ou de um arquivo externo. Ele emite objetos testsuite que possuem essas suítes e casos
• Classe TextTestRunner: Para executar os testes dispõe de uma plataforma padrão para executar os testes
• A classe TestResults: Oferece um contêiner padrão para os resultados do teste

Projetando um caso de teste para Python Testando usando PyUnit

Um teste unitário fornece uma classe base, um caso de teste, que pode ser usado para criar novos casos de teste. Para projetar o caso de teste, existem três conjuntos de métodos usados:

unittest.TestCase

setUp()
teardown()

skipTest(aMesg:string)
fail(aMesg:string)

id():string
shortDescription():string

No primeiro conjunto estão os ganchos pré e pós-teste. O método setup() começa antes de cada rotina de teste, o teardown() após a rotina.

O segundo conjunto de métodos controla a execução do teste. Ambos os métodos recebem uma string de mensagem como entrada e cancelam um teste em andamento. Mas o método skiptest() aborta o teste atual enquanto o método fail() falha completamente.

O último ou terceiro método ajuda a determinar o teste. O método id() retorna uma string que consiste no nome do objeto testcase e da rotina de teste. E o método curtoDescription() retorna o comentário docstr no início de cada rotina de teste.

Python Exemplo de teste unitário

O exemplo abaixo testa uma função simples `add()` com o módulo `unittest`. Cada método nomeado com o prefixo `test_` é executado automaticamente, e `assertEqual` verifica se o resultado corresponde ao valor esperado.

import unittest

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

class TestAdd(unittest.TestCase):
    def test_add_positive(self):
        self.assertEqual(add(2, 3), 5)

    def test_add_negative(self):
        self.assertEqual(add(-1, -1), -2)

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

Salve o código e execute-o com `python filename.py`. O executor de testes unitários informará quantos testes foram aprovados ou reprovados.

Vantagens de usar Python Teste unitário

• Ajuda você a detectar bugs no início do ciclo de desenvolvimento
• Ajuda você a escrever programas melhores
• Ele sincroniza facilmente com outros métodos e ferramentas de teste
• Terá muito menos bugs
• É mais fácil modificar no futuro com muito menos consequências

Perguntas Frequentes