Testes de Automação em Python com Exemplos

Quando se trata de automatizar testes de front-end, escolher a linguagem de programação ideal se torna extremamente crucial. O Python é uma dessas linguagens que lidera a lista, devido à facilidade de uso e ao amplo suporte da comunidade.

Além disso, os testes de automação em Python permitem que você aproveite as capacidades oferecidas por bibliotecas e frameworks populares como o Selenium, pytest e Robot, entre outros. Usar o Selenium com o Python ajuda a aproveitar ao máximo as poderosas capacidades de automação do navegador do Selenium e a simplicidade e extensibilidade do Python. No geral, os testes de automação em Python são amplamente utilizados por QAs em todo o mundo, especialmente com o Selenium WebDriver.

Neste blog, iremos aprofundar-nos nas nuances do Python do ponto de vista de front-end. As aprendizagens deste blog serão úteis para alavancar as capacidades do Python na automatização de cenários de front-end simples e complexos.

O que é Teste de Automação em Python?

Como o próprio nome sugere, o teste de automação em Python é o processo de usar scripts Python para automatizar testes. É uma das linguagens de programação mais procuradas para a automação de tarefas manuais e repetitivas.

Um exemplo simples de teste de automação em Python envolve o uso do framework pytest com Selenium para automatizar testes de front-end em uma plataforma de eCommerce. Você pode verificar a funcionalidade de registro de um site de eCommerce e usar a mesma sessão para navegar pelo site e adicionar os itens necessários ao carrinho de compras. Ao final deste teste, você terá verificado as funcionalidades de registro, login e carrinho do site de eCommerce.

Por fim, você também pode aproveitar o Python para automatizar administração de sistemas, automação de e-mails e tarefas de processamento de dados. Como o Python é um pré-requisito para testes automatizados, consulte o vídeo abaixo, que explora profundamente a instalação do Python.

Por que Python para Testes Automatizados?

Agora que sabemos por que os testadores preferem Selenium com Python, vamos analisar algumas das razões essenciais para escolher Python para testes de automação:

1. Ampla Gama de Bibliotecas e Frameworks

PyUnit (ou unittest) é o framework de teste padrão para realizar testes unitários com Python. Embora o PyUnit esteja disponível prontamente, o Python suporta outros frameworks populares como pytest, Behave, Robot, Lettuce e Nose2.

Todos eles podem ser usados extensivamente com os frameworks Selenium e Playwright para automatizar testes em navegadores web.

2. Execução de Testes Paralelos Super Fácil

A execução de testes paralelos no Selenium e Python pode ser utilizada amplamente para realizar testes de automação em navegadores web em diferentes combinações de navegadores e plataformas. Embora todas as linguagens suportadas pelo Selenium suportem a execução paralela de testes, é extremamente fácil de usar com Python.

3. Linguagem de Programação Multi-Paradigma

O Python é uma linguagem de programação multi-paradigma. Portanto, há suporte completo para programação orientada a objetos e programação estruturada. A maioria dos recursos do Python suporta programação funcional e programação orientada a aspectos. O Python, juntamente com o Selenium, também pode ser usado para testar websites e aplicações web de forma funcional.

4. Tipagem Dinâmica

A linguagem Python utiliza tipagem dinâmica e ligação tardia (ou resolução dinâmica de nomes) que vincula os métodos e nomes de variáveis durante a execução. Essa característica é muito útil para automação de testes em Python.

O Python também oferece opções como Pyre (um verificador de tipo eficiente para Python 3) e Mypy, que são verificadores de tipo estático populares. Com esses verificadores, o Python permite combinar o poder da tipagem dinâmica e estática.

5. Web Scraping

O web scraping com Python é o processo de extrair informações/dados significativos e úteis de websites. É usado principalmente para pesquisa acadêmica, análise de concorrentes, agregação de conteúdo e muito mais.

O Python oferece uma série de bibliotecas e frameworks, como BeautifulSoup (bs4), Selenium, Puppeteer e Pyppeteer, que facilitam a tarefa de extrair conteúdo de websites.

6. Relatórios Poderosos e Livres de Problemas

Relatórios em automação de testes oferecem maior visibilidade sobre as nuances da execução dos testes (ou seja, porcentagem de testes aprovados/reprovados, ambiente de teste, capturas de tela, etc.). Relatórios poderosos que fornecem as informações corretas de forma concisa e compreensível podem ser enviados aos stakeholders necessários (na equipe) para que eles estejam cientes do progresso na frente de testes.

Como Realizar Testes de Automação em Python?

Agora que analisamos a importância dos testes de automação em Python, vamos colocar a mão na massa executando alguns testes. Nossa discussão centrará principalmente em testes automatizados de front-end com Python.

Antes de começarmos os testes, vamos configurar o ambiente virtual (venv), que ajuda a gerenciar melhor o ambiente e as dependências. venv desempenha um papel fundamental em fornecer isolamento dos pacotes instalados no ambiente base.

Execute os comandos virtualenv venv e source venv/bin/activate no terminal para criar o ambiente virtual. Todas as dependências (ou pacotes Python), como pytest, selenium, etc., necessárias para a execução do projeto estão disponíveis no arquivo requirements.txt.

Plain Text

 

Dependências

As dependências podem ser instaladas acionando pip install -r requirements.txt no terminal. O Selenium v4.6.0 (ou superior) é instalado como parte do procedimento de instalação.

Para demonstração, iremos executar testes simples de Selenium em Python com os frameworks pytest e PyUnit (ou unittest). Se você está bem familiarizado com qualquer um desses frameworks, é recomendado que use fixtures em Python e o Modelo de Objeto de Página no Selenium Python para uma melhor manutenção dos testes. O pacote Selenium em si não fornece uma ferramenta ou framework de teste. Portanto, estaremos usando Selenium com pytest e PyUnit para automatizar interações com os elementos na página da web.

Cenário de Teste

  1. Navegue até o LambdaTest Selenium Playground.
  2. Localize o link de Enviar Formulário de Entrada na página.
  3. Insira as informações necessárias na página.
  4. Envie os detalhes e verifique se as informações não foram enviadas com sucesso.

Implementação (Framework pytest)

Abaixo está o script de teste para o cenário de teste acima:

Plain Text

 

Análise do Código

Para começar, primeiro importamos os módulos necessários para a implementação dos testes. Como estamos usando o pytest, o módulo pytest também é importado no código.

A classe WebDriverWait do módulo selenium.webdriver.support.ui é importada para que possamos usar esperas explícitas para cenários em que os WebElements são localizados dinamicamente. O módulo expected_conditions fornece um conjunto de ExpectedConditions pré-definidas no Selenium que podem ser usadas com esperas explícitas.

Como os elementos precisam ser localizados antes de realizarmos qualquer ação, primeiro definimos os localizadores dos elementos necessários. ID, Nome, XPath, Texto do Link, Texto Parcial do Link, etc., são alguns dos localizadores da web amplamente utilizados que ajudam a encontrar elementos dentro do Modelo de Objeto do Documento (DOM).

Você pode usar as ferramentas de inspeção disponíveis nativamente no navegador da web ou um plugin (ou complemento) como o POM Builder, que facilita a localização do XPath/Seletor CSS dos WebElements.

Uma vez que o localizador da web é identificado, o(s) respectivo(s) WebElement(s) é/estão localizado(s) combinando o localizador com o find_element() ou find_elements() método do Selenium Python. O método find_element() retorna um único WebElement, enquanto find_elements() retorna uma lista de WebElements que correspondem aos critérios do localizador.

Como mencionado anteriormente, o setup_method() é um fixture do pytest que faz parte da inicialização. O método é chamado antes de cada função de teste ser implementada na referida classe de teste.

Os testes sendo implementados podem ser executados no Selenium instalado na máquina local, bem como na grid online do Selenium oferecida por testes em nuvem. O LambdaTest é uma plataforma de execução de testes impulsionada por IA que permite executar testes automatizados em Python em larga escala em diferentes navegadores e sistemas operacionais. Ele vem com uma série de benefícios, sendo os principais a redução de manutenção, custos mais baixos e aceleração na execução dos testes.

No que diz respeito à implementação, a única alteração está relacionada ao Selenium WebDriver, onde o Remote WebDriver no Selenium é instanciado ao executar testes em uma grade na nuvem. O Gerador de Capacidades de Automação ajuda a gerar capacidades para a combinação de teste pretendida a ser usada nos testes.

No Selenium 4, as opções do navegador são usadas no lugar das Capacidades Desejadas. Você pode conferir o blog de diferenças entre o Selenium 3 e o Selenium 4 para saber mais sobre o que está obsoleto no Selenium 4. 

As variáveis de ambiente LT_USERNAME e LT_ACCESS_KEY podem ser obtidas nas Configurações da Conta do seu LambdaTest em Senha e Segurança. A combinação, quando passada juntamente com a URL da grade do LambdaTest, ajuda na execução de testes na grade na nuvem. No método test_enter_form_details(), primeiro navegamos para a URL do teste invocando o método driver.get()

Em seguida, a janela do navegador instanciada é maximizada, já que é considerada uma das melhores práticas do Selenium. 

Em seguida, o elemento de Envio de Formulário de Entrada é localizado usando o método find_element() juntamente com o localizador XPath no Selenium. Uma vez localizado, o clique no botão no Selenium é invocado para simular a ação de clique no elemento do botão localizado na etapa anterior. 

Como todos os passos de teste envolvem localizar elementos e realizar ações, focamos apenas em alguns métodos. A abordagem usada para localizar o elemento da empresa via o Seletor CSS no Selenium é mostrada abaixo. O send_keys() no Selenium WebDriver ajuda a enviar entrada de texto no elemento localizado.

Os dropdowns são amplamente utilizados em sites; portanto, automatizar interações com dropdowns usando Selenium se torna uma necessidade absoluta para seus casos de teste. A classe Select do módulo selenium.webdriver.support.ui fornece métodos que permitem lidar com dropdowns com Selenium.

Aqui, um objeto (ou seja, country_dropdown) da classe Select é criado com a entrada definida para o WebElement do dropdown localizado com XPath. O método select_by_visible_text() da classe Select ajuda a selecionar itens com texto visível que corresponda à string fornecida (ou seja, Estados Unidos).

Uma vez que todas as informações no formulário são preenchidas e o botão Enviar é clicado, aguardamos até que a string da mensagem de sucesso (padrão: oculta) esteja visível na página. Uma espera explícita com a ExpectedCondition (ou seja, presença do elemento localizado) é realizada até que a mensagem de sucesso não esteja na página.

Uma asserção é levantada se a string resultante não estiver presente na página. Para execução na nuvem, a variável lambda-status é marcada como passou/falhou dependendo do status da execução.

A fixture teardown_method() contém a implementação para limpar recursos ou estado após a execução dos testes na classe. A construção if __name__ == "__main__": garante que a execução do código ocorra apenas quando o script é executado diretamente. O pytest.main() chama o framework pytest que descobre e executa todos os testes habilitados (ou seja, não marcados como pulados) no script.

Execução de Teste (Framework pytest)

Após definir EXEC_PLATFORM como cloud, invoque o seguinte comando no terminal para executar testes pytest na grade de nuvem da LambdaTest:

 pytest --verbose --capture=no tests/pytest/pytest_selenium_demo.py 

Abaixo está a captura de tela do painel de Automação Web da LambdaTest que indica que a execução do teste foi bem-sucedida:

Implementação (Framework PyUnit)

O script de teste para o cenário de teste mencionado acima utilizando o framework PyUnit está localizado em tests/pyunit/pyunit_selenium_demo.py.

A lógica principal do teste permanece inalterada ao migrar de pytest para o framework PyUnit (ou unittest). Em vez do módulo pytest, o módulo unittest é importado no código. A classe de caso de teste é herdada do unittest.TestCase informa ao módulo unittest que este é um caso de teste. 

Os fixtures do pytest setup_method()/teardown() são semelhantes aos métodos setUp()/tearDown() do framework PyUnit. Os métodos setUp() e tearDown() consistem na implementação cuja responsabilidade é a inicialização e desinicialização, respectivamente. 

Abaixo está o código básico para executar o conjunto de testes:

Plain Text

 

Execução de Testes (Framework PyUnit)

Após definir EXEC_PLATFORM como nuvem, invoque o comando a seguir no terminal para executar testes PyUnit na grade de nuvem:

Plain Text

 

Abaixo está a captura de tela do painel de Automação Web LambdaTest que indica que a execução do teste foi bem-sucedida:

 

Caso deseje executar os testes acima no Selenium instalado na máquina local, basta definir EXEC_PLATFORM como local, e você estará pronto para a execução local.

Principais Frameworks de Testes em Python

Como o Python suporta vários frameworks de automação de testes, escolher o framework correto se torna extremamente crucial para o seu projeto. A escolha realmente lança as bases para testes eficientes. Além das capacidades do framework, você também precisa considerar a experiência interna com o referido framework. Abaixo estão alguns dos melhores frameworks de testes em Python:

PyUnit (unittest)

É o framework padrão disponível em Python. Como o nome sugere, é principalmente usado para testes de unidade. PyUnit é inspirado no framework JUnit para Java e compartilha uma estrutura e funcionalidades semelhantes.

O framework unittest também suporta a automação de testes, compartilhamento de código de configuração e finalização para os testes, independência dos testes em relação ao framework de relatórios e mais. Ele também suporta suítes de testes e casos de teste de forma orientada a objetos. Além disso, possui um executor de testes que é um componente responsável por orquestrar a execução dos testes.

pytest

É um dos frameworks de automação de testes mais populares para Python. Ele utiliza uma sintaxe menos verbosa e mais amigável para implementar testes. O pytest pode ser aproveitado para implementar testes unitários, bem como testes funcionais complexos para testar sites e aplicações web.

Os testes escritos usando pytest são muito mais compactos, pois o framework não requer código padrão. O pytest possui recursos integrados que ajudam na descoberta automática de módulos e funções de teste.

Robot

É um framework de código aberto baseado em palavras-chave que é amplamente utilizado para Automação de Processos Robotizados (RPA) e automação de testes. Assim como o framework pytest, o Robot também é extensível. O uso de sintaxe/palavras-chave legíveis por humanos minimiza a curva de aprendizado envolvida na aprendizagem do Robot.

Os testes escritos em Robot são salvos com a extensão .robot. Caso você planeje usar o Robot para testes de front-end, pode fazê-lo com a SeleniumLibrary, que é uma biblioteca de testes web para o Robot Framework. A biblioteca suporta uma gama exaustiva de palavras-chave (Clicar Botão, Clicar Imagem, Abrir Navegador, Arrastar e Soltar, entre outras).

Nose2

É o sucessor do Nose e é um framework de teste Python que estende as capacidades do framework PyUnit (ou unittest). É relativamente fácil começar com o Nose2 se você tiver experiência de trabalho anterior com unittest.

A grande vantagem do Nose2 sobre o PyUnit é a disponibilidade de um grande número de plugins integrados do Nose que tornam os testes mais fáceis e rápidos. Os plugins no Nose2 ajudam na parametrização de testes, melhor organização de testes, suporte a fixtures, descoberta de testes e muito mais.

Behave

É um framework Python usado para Desenvolvimento Orientado a Comportamento (BDD). Os testes são baseados na sintaxe Gherkin, que segue o formato Dado-Quando-Então.

Uma vez que os testes são implementados em arquivos de cenário e de funcionalidade, até mesmo pessoal não técnico pode fazer parte do processo de QA. SpecFlow (C#) e Cucumber (Java, JS, Ruby) são alguns dos outros frameworks BDD populares.

Conclusão

Até agora, Python é de longe a melhor linguagem de script para automação de testes. É relativamente fácil começar com testes de automação em Python. Sua ampla gama de frameworks de teste pode ser usada para testes de unidade, testes em vários navegadores, e muito mais. Informe-nos abaixo sua linguagem de programação preferida para testes do Selenium e como você a classifica em comparação com o Python, o rei indiscutível para testes de automação. Feliz teste!

Source:
https://dzone.com/articles/python-automation-testing-with-examples