Entendendo o teste de unidade em Python by@terieyenike
1,457 leituras

Entendendo o teste de unidade em Python

2022/09/04
6 min
por @terieyenike 1,457 leituras
tldt arrow
PT
Read on Terminal Reader

Muito longo; Para ler

Testar seu código é uma parte vital do ciclo de vida de desenvolvimento de software e sempre deve acontecer antes de implantar o aplicativo na produção. Testes de unidade são programas lógicos que um programador escreve para testar uma base de código. O teste é crucial porque ajuda a rastrear e encontrar bugs no código. Este artigo ensinará como escrever testes básicos usando testes de unidade do Python para verificar se seu código passa ou falha durante o teste. O principal objetivo do teste de unidade é verificar se todas as funções do código funcionam conforme o esperado.
featured image - Entendendo o teste de unidade em Python
Teri Eyenike HackerNoon profile picture

@terieyenike

Teri Eyenike

I am a frontend developer with a particular interest in...

Aprender mais
LEARN MORE ABOUT @TERIEYENIKE'S EXPERTISE AND PLACE ON THE INTERNET.
react to story with heart

Testar seu código é uma parte vital do ciclo de vida de desenvolvimento de software e sempre deve acontecer antes de implantar o aplicativo na produção. O teste é crucial porque ajuda a rastrear e encontrar bugs no código.

O teste é um método de verificação de unidades individuais de código-fonte para confirmar se funciona de maneira ideal antes de enviar o código para produção. É importante observar que a implantação do arquivo de origem na produção para os usuários é desnecessária durante o teste de unidade.

Seria melhor se você também lembrasse que o teste não é específico do Python.

Este artigo ensinará como escrever testes básicos usando testes de unidade do Python para verificar se seu código passa ou falha durante o teste.

Pré-requisitos

Para concluir este tutorial, você precisa do seguinte:

  • Conhecimento em escrever código Python
  • Uma instalação do programa Python na sua máquina local
  • Um editor de código de sua escolha

Começando

Testes de escrita são programas lógicos que um programador escreve para testar uma base de código. Durante o desenvolvimento, um QA deve entender o processo para destacar o que precisa ser melhorado no aplicativo antes de enviar o produto ao usuário. Para isso, vamos escrever uma função que soma dois números e retorna o resultado.

Para começar, crie uma pasta contendo todos os arquivos para escrever o teste deste tutorial. Adicione um arquivo chamado main.py para escrever a função nesta nova pasta.

 # main.py # Add the sum of two numbers def add_sum(num1, num2): return int(num1) + int(num2)

Agora que temos o bloco de código acima, vamos verificar se o código funciona escrevendo uma função que permite aos usuários inserir o valor desejado por meio do prompt de entrada. A função add_sum() recebe dois números como parâmetros e retorna o valor usando o operador + sinal para obter a soma. Em outro arquivo, result.py , copie e cole o seguinte código:

 # result.py from main import add_sum print("Please enter the two values\n") num1 = int(input("Please enter the first number: \n")) num2 = int(input("Please enter the second number: \n")) total = add_sum(num1, num2) print(f"The sum of the values is {total}")

Este bloco de código faz o seguinte:

  • Importa add_sum() de main.py
  • converteu o valor do prompt de entrada em um número inteiro usando o método int
  • soma os valores que imprimem seu total usando as f-strings (sintaxe de formatação) para obter a saída

O que são testes de unidade e casos de teste?

O Python vem com um módulo de biblioteca padrão integrado chamado unittest, que fornece ferramentas para construir e executar testes para seu código. O principal objetivo do teste de unidade é verificar se todas as funções do código funcionam conforme o esperado.

Um caso de teste é uma forma padrão de trabalhar com um unittest, com funcionalidades disponíveis na classe de nome do teste. Além disso, um caso de teste é essencial no código do componente para teste de unidade individual. Ele usa diferentes métodos assert para verificar e relatar falhas imediatamente após a execução do código.

Passando em um teste

Esta seção é toda sobre como escrever uma série de testes.

Antes de criar o arquivo de teste para escrever todos os casos de teste para a função add_sum() , vamos atualizar o main.py . Copie e cole o seguinte código:

 # main.py def add_sum(num1, num2): try: return int(num1) + int(num2) except ValueError as err: return err

O bloco de código usa a instrução try/except que lida com exceções em seu código, alertando você se houver um erro no bloco except. Este método de programação ajuda a detectar erros e aponta para o número da linha específica onde ocorreu o erro.

Agora, crie um arquivo de teste no mesmo diretório chamado test.py. Neste arquivo, copie e cole o seguinte código:

 # test.py import unittest from main import add_sum class MainTest(unittest.TestCase): def test_do_stuff(self): result = add_sum(5, 10) self.assertEqual(result, 15) if __name__ == '__main__': unittest.main()

Conforme mostrado no bloco de código acima, ocorre o seguinte:

  • Importe o unittest e a função que deseja testar (vem do main.py)
  • O Unittest funciona criando uma classe contendo os testes para a função add_sum(), que herda dentro da classe o que o unittest dá, que é o unittest.TestCase
  • Defina uma função com a palavra-chave self no test_do_stuff() que representa a instância da classe
  • Dentro do método de teste test_do_stuff(), declare uma variável e passe os dois argumentos com valores diferentes
  • A última linha usa o método assert unittest, assertEqual, que verifica se os argumentos que você passa da variável result correspondem ao resultado que você espera receber
  • Por fim, execute todo o arquivo de teste com unittest.main()

Lembre-se de iniciar todos os métodos com o “test_” pois o test.py é executado automaticamente. **
**

Sempre que você executa um teste, espera-se que todas as verificações sejam aprovadas com uma mensagem OK no console, o que significa que foi bem-sucedido.

 Ran 1 test in 0.000s OK

Falha em um teste

Durante o desenvolvimento e teste, deve haver cenários de falha. Isso mostra que todo programa tem vulnerabilidades e bugs.

No mesmo arquivo, test.py , vamos modificar o código e colar o seguinte:

 # test.py import unittest from main import add_sum class MainTest(unittest.TestCase): # other test def test_do_stuff2(self): result = add_sum("hulu", 5) self.assertEqual(result, 5) if __name__ == '__main__': unittest.main()

O resultado da execução deste código é algo como isto:

 FAIL: test_do_stuff2 (__main__.MainTest) ---------------------------------------------------------------------- Traceback (most recent call last): File "test.py", line 11, in test_do_stuff3 self.assertEqual(result, 5) AssertionError: ValueError("invalid literal for int() with base 10: 'hulu'") != 5

A partir da saída acima, o seguinte pode ser resolvido lendo o código de erro e corrigindo o código de acordo:

  • O erro ocorreu em um número de linha específico, solicitando que você verifique e resolva o número da linha.
  • Em seguida está o erro de assertion, que dá um erro de valor significando que a string 'hulu' não é um literal válido, sabendo que no arquivo main.py, os dois valores são do tipo int
  • Com esta etapa, você sabe o que corrigir para que o código execute o teste OK com os valores corretos a serem passados para que o código seja bem-sucedido.

Executando o código

Quando você tem muitos arquivos e módulos diferentes criados e precisa testar todos eles simultaneamente, em vez do padrão tentar um único arquivo, você pode usar este comando para executar todos os testes simultaneamente.

 python3 -m unittest

Além disso, para obter mais detalhes sobre o teste, use o comando com o sinalizador -v (detalhado), que mostra os testes que estão OK e os que falharam.

 python3 -m unittest -v

O resultado se parece com isto:

 test_do_stuff (test.MainTest) ... ok test_do_stuff2 (test.MainTest) ... ok ---------------------------------------------------------------------- Ran 2 tests in 0.000s OK

Conclusão

O teste de unidade deve ser uma prática feita pelos QAs e desenvolvedores envolvidos na escrita e envio do código sempre que um novo recurso é lançado antes que os usuários comecem a usar o aplicativo. Fazer testes regularmente ou periodicamente não deve ser uma reflexão tardia, mas sim criar confiança na funcionalidade e eficiência do aplicativo.

Este artigo forneceu uma visão geral de por que os testes são essenciais no desenvolvimento e como usar testes de unidade para verificar a função do código e atender a uma especificação padrão para usuários antes da implantação na produção.

Saber mais

HISTÓRIAS RELACIONADAS

L O A D I N G
. . . comments & more!
Hackernoon hq - po box 2206, edwards, colorado 81632, usa