#Python # Unittest # Selenium # Automation
neste post, veremos como testar uma unidade de um aplicativo da Web em Python para verificar a exatidão da funcionalidade. Whoa! Essa frase tem um punhado de jargões: teste de unidade, aplicativo da web e teste de funcionalidade.
analisamos o teste de unidade de um programa Python em um post anterior. Nós encorajamos você a passar por isso, se você não estiver familiarizado com o teste de unidade.
o que é um teste unitário?
a unidade é a menor parte testável de um programa ou aplicativo.
portanto, os testes unitários são usados para testar programaticamente cada componente testável.
você pode testar um programa de back-end ou um programa de front-end, como um aplicativo da web.
para um programa de back-end, você escreveria um teste de unidade para cada função ou método no código, pois são unidades menores lógicas.
no entanto, para um frontend, você identificará diferentes funcionalidades que deseja verificar e escrever testes de unidade de acordo.
neste post, vamos testar um programa de front-end, ou seja, um aplicativo da web.
o que é um aplicativo da web?
qualquer aplicativo que renderize em um navegador da web, como Chrome, Firefox ou Safari.
todos os aplicativos da web têm uma coisa em comum-eles são visíveis para os usuários finais uma página HTML (Hypertext Markup Language). HTML é simplesmente uma linguagem de formatação para descrever como as coisas devem ser organizadas. É simplesmente um arquivo de texto.
navegadores obter esta página HTML e interpreta as tags (por exemplo, cabeça, corpo, HREF, tabela, etc.) para mostrar uma página bonita para você.
os aplicativos da Web funcionam na arquitetura cliente-servidor-onde o servidor da web hospeda o conteúdo que você deseja acessar e o navegador da web atua como cliente.
o que é teste de funcionalidade?
como o nome indica, quando você escreve código de Teste Funcional, seu objetivo é testar a funcionalidade do aplicativo. Em outras palavras, você quer ter certeza de que o aplicativo segue a especificação funcional.
existem outros tipos de testes, como testes de desempenho, testes de segurança (penetração) e testes de aceitabilidade do Usuário.
o código de teste funcional que você escreve pode ser incluído no que é chamado de teste de regressão que é executado periodicamente para garantir que a funcionalidade antiga não seja quebrada devido ao novo desenvolvimento.
no final deste post, você entenderá o código completo mencionado abaixo.
não fique desanimado se sentir que isso é demais. O objetivo deste post é dissecar isso e mostrar como você pode entender esse código e depois escrever o seu próprio!
o diagrama a seguir mostra a abordagem de alto nível para testar automaticamente um aplicativo da web (página).
para escrever nossos testes, usamos um framework de teste chamado unittest. É muito semelhante ao junit em Java ou nunit em. Net.
o unittest permite agrupar seu código de inicialização em uma função de configuração e limpar o código em uma função de desmontagem.
o diagrama a seguir mostra a abordagem geral por trás do teste unitário.
Como você pode ver no diagrama acima, um conjunto de teste consiste de um ou mais casos de teste.
um caso de teste pode ter um ou mais testes. Neste post, vamos nos concentrar em um caso de teste com um teste. Mostraremos no final como adicionar mais testes ao mesmo caso de teste, bem como criar um conjunto de testes.
Como mencionado anteriormente, cada caso de teste possui uma configuração (executado no início) e tearDown (executado no final) métodos para fazer a inicialização e limpar respectivamente.
o trecho de código acima mostra a estrutura de um caso de teste unitário.
linha 1: Importe as bibliotecas necessárias. No nosso caso, estamos usando bibliotecas selenium e unittest.
linha 3: você cria uma classe chamada MyTestCase que estende unittest.Classe TestCase. Nós dizemos que unittest.TestCase é a classe pai e MyTestCase é a classe filho.
Linha 4: adicionamos nosso código de inicialização no método de configuração. Você precisa usar o nome exato do método para que a unittest saiba que está adicionando seu código de inicialização aqui. Quando você executa este caso de teste, esse método é executado primeiro.
linha 7: um teste de amostra que queremos incluir no caso de teste.
linha 10: outro teste de amostra que temos em nosso caso de teste.
linha 16: adicionamos nosso código de limpeza dentro deste método de desmontagem. O oposto do método de configuração, o método de desmontagem é executado o último.
Assim, a ordem de invocação de método é:
configuração > teste1 > teste2 > … > subdivisão
Linha 20: Isto diz que o programa principal começa a partir deste lugar.
linha 21: é assim que você executa o caso de teste.
agora é hora de colocarmos as mãos no teste real que queríamos fazer. Lembre-se de que queremos testar se a caixa de pesquisa do Google retorna pelo menos 5 resultados para uma determinada palavra-chave de pesquisa.
vejamos primeiro o método de configuração:
neste trecho de código, criamos o driver do navegador Chrome.
você precisa baixar o driver selenium Chrome daqui, se ainda não o tiver. Até o momento, o Chrome também tem a versão 74. Como meu navegador Chrome é a versão 73, baixei a versão 73 para este exercício.
Linha 2 e 3 Crie a opção Chrome e deixe o selenium webdriver saber que não queremos tornar o navegador visível quando executamos o teste.
se você não adicionar esta opção, seu teste fica preso no ponto em que o navegador é aberto.
agora vamos olhar para o método de desmontagem:
simplesmente limpamos o driver chamando o método quit ().Finalmente, é hora de dar uma olhada no teste que queremos incluir neste caso de teste. Lembre-se de que podemos testar (afirmar) se o número de resultados de pesquisa retornados for maior ou igual a 5.
linha 1: o método de teste começa com a palavra “teste”.
linha 3: Carga www.google.com página da web no driver (observe que eu.driver é criado durante o tempo de configuração).
linha 6: Localize a caixa de pesquisa pelo nome do elemento HTML “q”. Você precisa inspecionar a página HTML para identificar isso.
linha 7: esvazie a caixa de pesquisa caso haja algum valor padrão.
linha 10: preencha a caixa de pesquisa com a string de pesquisa “teste automatizado”.
linha 11: envie a consulta de pesquisa para o Google.
linha 14: XPath identificando os títulos dos resultados da pesquisa.
Linha 17: aguarde 10 segundos até que a página de resultados do Google seja carregada.
linha 20: obtenha todos os títulos dos resultados da pesquisa usando o XPath definido na linha 14.
linhas 25 e 26: Os títulos dos resultados da pesquisa são, na verdade, uma lista e iteramos através deles para a saída na tela. Adicionamos essas duas linhas apenas para fins de demonstração. Normalmente, os scripts de teste não têm telas de impressão, pois não há ninguém disponível para olhar para a tela para ver essa saída quando automatizada.
linha 30: Esta é a afirmação real que estamos fazendo. assertGreater é um método definido em unittest.Classe TestCase que nos permite verificar se alguma saída é maior do que algum valor.
unittest.TestCase de fato nos fornece um conjunto de tal método para verificar a igualdade, maior que, menor que, etc. dependendo do que você deseja afirmar. O gráfico a seguir mostra alguns dos métodos de assert comuns disponíveis.
, Como mostrado no início, você pode escrever o caso de teste invocando o seguinte em seu código:
unittest.main()
Na linha de comando você pode simplesmente digitar o nome do arquivo que você usou para salvar o caso de teste.
python google_search_test.py
ele executa setUp (), test_result_count () e finalmente tearDown ().
Você deve ver uma saída semelhante à seguinte:
Se um teste falhar, você verá a mensagem de erro juntamente com o método de teste que falhou.
esse é o seu primeiro caso de teste Selenium/unittest bem-sucedido. Meus parabéns! É um marco importante.
Bônus
se você tiver o steam, eu encorajaria você a seguir o resto para se aprofundar ainda mais nos testes automatizados do Selenium/unittest base web application.
digamos que você queira testar se o título é igual a “Google”.
o código de teste tem a seguinte aparência:
def test_header(self):
self.driver.get("http://www.google.com")
self.assertEqual("Google", self.driver.title)
agora todo o nosso caso de teste parece o seguinte:
class GoogleSearchTest(unittest.TestCase):
def setUp(self): def test_header(self): def test_result_count(self): def tearDown(self):
if __name__ == "__main__":
unittest.main()
vamos supor que as telas de impressão acima sejam comentadas. Ao executar o caso de teste atualizado, você deve obter uma saída da seguinte maneira:
test_header (__main__.GoogleSearchTest) ... ok
test_result_count (__main__.GoogleSearchTest) ... ok----------------------------------------------------------------------
Ran 2 tests in 13.799s
OK
ele diz que realizou dois testes e ambos são bem-sucedidos.
digamos que eu altere a condição assertEqual no primeiro teste para o seguinte:
self.assertEqual("Microsoft", self.driver.title)
o que você acha que isso aconteceria aqui?
Sim, você adivinhou certo. O primeiro caso de teste falhará como auto.controlador.o título é igual ao Google, não à Microsoft.
você obterá uma saída semelhante à seguinte:
test_header (__main__.GoogleSearchTest) ... FAIL
test_result_count (__main__.GoogleSearchTest) ... ok
====================================================================
FAIL: test_header (__main__.GoogleSearchTest)
--------------------------------------------------------------------
Traceback (most recent call last):
File "google_search_test.py", line 19, in test_header
self.assertEqual("Microsoft", self.driver.title)
AssertionError: 'Microsoft' != 'Google'
- Microsoft
--------------------------------------------------------------------
Ran 2 tests in 14.011s
FAILED (failures=1)
a saída acima diz que apenas um teste foi bem-sucedido e o falhou.
quando você escreve seus casos de teste pela primeira vez, você pode encontrar situações como esta.
supondo que seu caso de teste esteja correto, você identificará bugs no código e obterá os respectivos desenvolvedores para corrigir o problema e testar novamente.
se esse erro acontecer em um teste de regressão, esse bug será introduzido devido ao novo desenvolvimento de software feito em cima da base de código existente.
isso mostra que há algo errado com a nova base de código que precisa ser corrigida para garantir que a funcionalidade antiga funcione. Mais uma vez, os desenvolvedores precisam cuidar disso.
que tal ter muitos casos de teste? Digamos que tenhamos TestCase1 e TestCase2, cada um com vários testes.
você pode criar o que é chamado de pacote de teste e executá-lo usando um executor de teste da seguinte maneira:
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(TestCase1))
suite.addTest(unittest.makeSuite(TestCase2))
runner = unittest.TextTestRunner()
runner.run(suite)
o código acima executará todos os testes em TestCase1 e depois em TestCase2.
é isso para hoje. Espero que ajude.