Teste de unidade com o módulo unittest do Python

Nenhum bom desenvolvedor implanta código sem testes completos. O teste unitário é o processo de testar os módulos individuais de um grande programa.

Este artigo discutirá como você pode realizar testes de unidade do seu código usando o módulo unittest do Python. Primeiro, vamos entender quais são os tipos de testes.

Quando se trata de testes, existem testes manuais e testes automáticos. O teste manual é uma técnica de teste em que os humanos realizam o teste manualmente após a conclusão do desenvolvimento. O teste de automação é uma técnica de teste em que os programas executam o teste automaticamente e nos fornecem os resultados.

Você teria entendido que o teste manual é demorado e difícil de executar. Assim, os desenvolvedores escrevem código para realizar testes (testes automáticos). Existem diferentes tipos de testes em testes automatizados. Alguns deles são testes de unidade, testes de integração, testes de ponta a ponta, testes de estresse, etc.,

Vamos ver o fluxo padrão de testes.

  • Escreva ou atualize o código.
  • Escreva ou atualize testes para diferentes casos do seu código.
  • Execute os testes (manualmente ou usando um executor de testes).
  • Veja os resultados do teste. Se houver algum erro, corrija-o e repita as etapas.

Aqui, vamos discutir o tipo de teste mais essencial e básico chamado teste de unidade. Sem mais delongas, vamos mergulhar no tutorial real.

O que é Teste Unitário?

O teste de unidade é uma técnica para testar um pequeno bloco de código independente. O código de bloco pequeno será uma função na maioria dos casos. A palavra independente significa que não depende de outras partes do código no projeto.

Digamos que temos que verificar se uma string é igual a “etechpt.com” ou não. Para isso, escrevemos uma função que recebe um argumento e retorna se é igual a “etechpt.com” ou não.

def is_equal_to_geekflare(string):
	return string == "etechpt.com"

A função acima não depende de nenhum outro código. Assim, podemos testá-lo independentemente, fornecendo entradas diferentes. O pedaço de código independente pode ser usado em todo o projeto.

Importância do teste de unidade

Em geral, o código de blocos independentes pode ser usado em todo o projeto. Portanto, deve ser bem escrito e testado. Os testes de unidade são os testes usados ​​para testar esses tipos de blocos de código independentes. O que acontece se não usarmos testes de unidade para nosso projeto?

  Quão seguros são os gerenciadores de senhas?

Vamos supor que não testamos pequenos blocos de código que são usados ​​em todo o projeto. Todos os outros testes, como testes de integração, testes de ponta a ponta, etc., usando os outros pequenos blocos de código podem falhar. Isso quebra o aplicativo. É por isso que os blocos de construção básicos do código devem ser bem testados.

Agora, sabemos a importância do teste de unidade e testes de unidade escritos para todos os blocos de código independentes. Como realizamos testes de unidade, outros testes como testes de integração, testes de ponta a ponta, etc., não falharão por causa do bloco de códigos independente.

Nas próximas seções, veremos o que é o módulo unittest do Python e como usamos o módulo unittest para escrever testes de unidade em Python.

Nota: Estamos assumindo que você está familiarizado com classes, módulos, etc. do Python. Se você não estiver familiarizado com os conceitos intermediários do Python, como classes, módulos, etc., pode ser difícil entender as próximas seções.

O que é teste unitário do Python?

Python unittest é uma estrutura de teste integrada para testar o código Python. Possui um test runner, o que nos permite executar os testes sem muito esforço. Assim, podemos usar o módulo unittest integrado para teste sem usar os módulos de terceiros. Mas, ele muda com base em sua exigência. O módulo unittest integrado é bom para começar a testar em Python.

Temos que seguir as etapas abaixo para testar o código Python usando o módulo unittest.

#1. Escreva o código.

#2. Importe o módulo unittest.

#3. Crie um arquivo começando com a palavra-chave test. Por exemplo test_prime.py. A palavra-chave test é usada para identificar os arquivos de teste.

#4. Crie uma classe estendendo a classe unittest.TestCase.

#5. Escreva métodos (testes) dentro da classe. Cada método contém diferentes casos de teste com base em seus requisitos. Devemos nomear o método começando com a palavra-chave test.

#6. Execute os testes. Podemos executar os testes de diferentes maneiras.

  • Execute o comando python -m unittest test_filename.py.
  • Executamos os arquivos de teste como arquivos Python gerais com o comando python test_filename.py. Para que este método funcione, precisamos invocar o método main do unittest no arquivo de teste.
  • E, finalmente, usando o método Discover. Podemos executar os testes automaticamente usando o comando python -m unittestdiscover sem mencionar o nome do arquivo do teste. Ele encontrará os testes usando a convenção de nomenclatura que seguimos. Portanto, devemos nomear nossos arquivos de teste com a palavra-chave test no início.
  Como se livrar do pop-up de sobreposição de jogos do MS

Geralmente, nos testes, comparamos a saída do código com a saída esperada. Assim, para comparar as saídas, o unittest fornece métodos diferentes. Você pode encontrar a lista de funções de comparação aqui.

Você pode facilmente entendê-los sem qualquer dificuldade. Eles são diretos.

É muita teoria. Agora devemos entrar na codificação.

Nota: Se você tiver alguma dúvida sobre o módulo unittest, você pode ir para o documentação e tire suas dúvidas. Sem mais delongas, vamos usar o módulo unittest.

Testes unitários em Python usando unittest

Vamos escrever algumas funções primeiro, e então vamos nos concentrar em escrever os testes. Primeiro, abra uma pasta em seu editor de código favorito. E crie um arquivo chamado utils.py. Cole o seguinte código no arquivo.

import math


def is_prime(n):
    if n < 0:
        return 'Negative numbers are not allowed'

    if n <= 1:
        return False

    if n == 2:
        return True

    if n % 2 == 0:
        return False

    for i in range(2, int(math.sqrt(n)) + 1):
        if n % i == 0:
            return False
    return True


def cubic(a):
    return a * a * a


def say_hello(name):
    return "Hello, " + name

Temos três funções diferentes no arquivo utils.py. Agora, temos que testar cada função com diferentes casos de teste. Vamos escrever os testes para a primeira função is_prime.

#1. Crie um arquivo chamado test_utils.py na pasta de amostra como utils.py.

#2. Importe o módulo utils e unittest.

#3. Crie uma classe com o nome TestUtils estendendo a classe unittest.TestCase. O nome da classe pode ser qualquer coisa. Tente dar à classe um nome significativo.

#4. Dentro da classe, escreva um método chamado test_is_prime que aceita self como argumento.

#5. Escreva diferentes casos de teste com argumentos para o is_prime e compare a saída com a saída esperada.

#6. Exemplo de caso de teste self.assertFalse(utils.is_prime(1)).

#7. Esperamos que a saída do is_prime(1) seja falsa no caso acima.

#8. Semelhante ao caso acima, faremos diferentes casos de teste com base na função que estamos testando.

  Por que o GroupMe não permite que você faça login?

Vamos ver os testes.

import unittest

import utils


class TestUtils(unittest.TestCase):
    def test_is_prime(self):
        self.assertFalse(utils.is_prime(4))
        self.assertTrue(utils.is_prime(2))
        self.assertTrue(utils.is_prime(3))
        self.assertFalse(utils.is_prime(8))
        self.assertFalse(utils.is_prime(10))
        self.assertTrue(utils.is_prime(7))
        self.assertEqual(utils.is_prime(-3),
                         "Negative numbers are not allowed")


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

Estamos invocando o método principal de unittest do módulo para executar os testes usando o comando python filename.py. Agora, execute os testes.

Você verá a saída semelhante à saída abaixo.

$ python test_utils.py 
.
----------------------------------------------------------------------
Ran 1 test in 0.001s

OK

Agora, tente escrever os casos de teste para outras funções também. Pense em diferentes casos para as funções e escreva testes para elas. Dê uma olhada nos seguintes testes que são adicionados à classe acima.

...


class TestUtils(unittest.TestCase):
    def test_is_prime(self):
        ...

    def test_cubic(self):
        self.assertEqual(utils.cubic(2), 8)
        self.assertEqual(utils.cubic(-2), -8)
        self.assertNotEqual(utils.cubic(2), 4)
        self.assertNotEqual(utils.cubic(-3), 27)

    def test_say_hello(self):
        self.assertEqual(utils.say_hello("etechpt.com"), "Hello, etechpt.com")
        self.assertEqual(utils.say_hello("Chandan"), "Hello, Chandan")
        self.assertNotEqual(utils.say_hello("Chandan"), "Hi, Chandan")
        self.assertNotEqual(utils.say_hello("Hafeez"), "Hi, Hafeez")


...

Usamos apenas algumas das funções de comparação do módulo unittest. Você pode encontrar a lista completa aqui.

Aprendemos como escrever testes de unidade usando o módulo unittest. Agora, é hora de ver diferentes maneiras de executar os testes.

Como executar testes usando unittest

Já vimos uma maneira de executar os casos de teste na seção acima. Vamos ver as outras duas maneiras de executar os testes usando o módulo unittest.

#1. Usando o nome do arquivo e o módulo unittest.

Neste método, usaremos o módulo unittest e o nome do arquivo para executar os testes. O comando para executar os testes é python -m unittest filename.py. No nosso caso, o comando para executar os testes é python -m unittest test_utils.py.

#2. Usando o método de descoberta

Usaremos o método de descoberta do módulo unittest para detectar automaticamente todos os arquivos de teste e executá-los. Para detectar automaticamente os arquivos de teste, precisamos nomeá-los começando com a palavra-chave test.

O comando para executar os testes usando o método Discover é python -m unittestdiscover. O comando detectará todos os arquivos cujos nomes começam com test e os executará.

Conclusão 👩‍💻

Os testes unitários são testes básicos no mundo da programação. Existem muitos outros testes no mundo real. Tente aprendê-los uma vez por um. Espero que este tutorial ajude você a escrever testes básicos em Python usando o módulo unittest. Existem bibliotecas de terceiros como pytest, Robot Framework, nose, nose2, slash, etc. Você pode explorá-las com base nos requisitos do seu projeto.

Boas provas 😎

Você também pode estar interessado em Perguntas e respostas da entrevista em Python.