Teste de unidade com módulo de teste de unidade Python

Nenhum bom desenvolvedor implanta código sem um teste completo. O teste de unidade é o processo de testar os módulos individuais de um grande programa.

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

Quando se trata de teste, existe o teste manual e o teste automático. O teste manual é uma técnica de teste em que 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 realizam o teste automaticamente e fornecem os resultados para nós.

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

Vamos ver o fluxo padrão de teste.

• Escreva ou atualize o código.
• Escreva ou atualize testes para diferentes casos de seu código.
• Execute os testes (manualmente ou usando um executor de teste).
• 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 de unidade?

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 “Geekflare” ou não. Para isso, escrevemos uma função que recebe um argumento e retorna se é igual a “Geekflare” ou não.

 def is_equal_to_geekflare(string): return string == "Geekflare"

A função acima não depende de nenhum outro código. Portanto, podemos testá-lo independentemente, fornecendo diferentes entradas. A parte independente do código pode ser usada 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 independentes de código. O que acontece se não usarmos testes de unidade para nosso projeto?

Vamos supor que não testamos pequenos blocos de código usados ​​em todo o projeto. Todos os outros testes, como testes de integração, testes 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 dos testes de unidade escritos para todos os blocos de código independentes. Uma vez que realizamos testes de unidade, outros testes, como testes de integração, testes ponta a ponta, etc., não falharão por causa do bloco independente de códigos.

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.

Observação: presumimos que você esteja familiarizado com as classes, módulos, etc. do Python. Se 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 é o teste de unidade Python?

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

Temos que seguir os passos 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 o test palavra-chave. Por exemplo test_prime.py . A palavra-chave teste é 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 maneiras diferentes.

• Execute o comando python -m unittest test_filename.py .
• python test_filename.py os arquivos de teste como arquivos Python gerais com o comando python test_filename.py . Para que esse método funcione, precisamos invocar o método main do unittest no arquivo de teste.
• E, finalmente, usando o discover . Podemos executar os testes python -m unittest discover usando o comando python -m unittest discover sem mencionar o nome do arquivo do teste. Ele localizará 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.

Geralmente, nos testes, comparamos a saída do código com a saída esperada. Portanto, 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 entendê-los facilmente sem qualquer dificuldade. Eles são diretos.

Isso é muita teoria. Devemos agora entrar na codificação.

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

Testes de unidade em Python usando teste de unidade

Vamos escrever algumas funções primeiro e, em seguida, nos concentraremos 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 os utils e unittest módulo.

# 3. Crie uma classe com o nome TestUtils extending unittest.TestCase class. 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 um argumento.

# 5. Escreva diferentes casos de teste com argumentos para 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 de 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.

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 main de teste unittest do módulo para executar os testes usando o comando python filename.py . Agora, execute os testes.

Você verá uma 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 casos diferentes para as funções e escreva testes para eles. Dê uma olhada nos seguintes testes que foram 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("Geekflare"), "Hello, Geekflare") 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 de teste de unidade. Agora é hora de ver maneiras diferentes 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 . Em nosso caso, o comando para executar os testes é python -m unittest test_utils.py .

# 2. Usando o método de descoberta

Usaremos a discover método 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 de descoberta é python -m unittest discover . O comando detectará todos os arquivos cujos nomes começam com test e os executará.

Conclusão

Os testes de unidade são testes básicos no mundo da programação. Existem muitos outros testes no mundo real. Tente aprendê-los uma por uma. 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á-los com base nos requisitos do seu projeto.

Feliz teste

Você também pode estar interessado nas Perguntas e Respostas da Entrevista em Python.