Quando se trata de automatizar testes de front-end, escolher a linguagem de programação ideal se torna extremamente crucial. Python é uma dessas linguagens que lidera a lista, devido à sua facilidade de uso e ao amplo suporte da comunidade.
Além disso, o teste automatizado em Python permite que você aproveite as capacidades oferecidas por bibliotecas e frameworks populares, como Selenium, pytest e Robot, entre outros. Usar Selenium com Python ajuda a maximizar as poderosas capacidades de automação de navegador do Selenium e a simplicidade e extensibilidade do Python. No geral, o teste automatizado em Python é amplamente utilizado por QAs em todo o mundo, especialmente com o Selenium WebDriver.
Neste blog, vamos nos aprofundar nas nuances do Python sob uma perspectiva de front-end. Os aprendizados deste blog serão úteis para aproveitar as capacidades do Python para automatizar cenários de front-end simples e complexos.
O que é o teste automatizado em Python?
Como o nome sugere, o teste automatizado em Python é o processo de usar scripts em 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 automatizado 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 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 último, 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 aborda profundamente a instalação do Python.
Por que Python para Testes Automatizados?
Agora que sabemos por que os testadores preferem Selenium com Python, vamos olhar algumas das razões essenciais para escolher Python para testes automatizados:
1. Ampla Variedade 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 de forma padrão, 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 amplamente utilizada 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 execução de testes paralelos, é extremamente fácil de usar com Python.
3. Linguagem de Programação Multi-Paradigma
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. Python, junto com 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 de nomes dinâmica) que vincula os métodos e os nomes das variáveis durante a execução. Esse recurso é extremamente útil para automação de testes em Python.
Python também oferece opções como Pyre (um verificador de tipos performático para Python 3) e Mypy, que são verificadores de tipos estáticos populares. Com esses verificadores, o Python permite combinar o poder da tipagem dinâmica e estática.
5. Web Scraping
Web scraping com Python é o processo de extrair informações/dados significativos e úteis de websites. É utilizado principalmente para pesquisa acadêmica, análise de concorrentes, agregação de conteúdo e mais.
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ório Poderoso e Sem Complicações
Relatórios em automação de testes proporcionam maior visibilidade sobre as nuances da execução dos testes (ou seja, percentual de testes passados/falhados, 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 área de testes.
Como Realizar Testes de Automação em Python?
Agora que examinamos a importância dos testes de automação em Python, vamos colocar a mão na massa executando alguns testes. Nossa discussão se concentrará principalmente na automação de testes 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.
pytest-selenium
pytest-xdist
selenium>=4.6.0
urllib3==1.26.12
requests
py
Dependências
As dependências podem ser instaladas acionando pip install -r requirements.txt no terminal. Selenium v4.6.0 (ou superior) é instalado como parte do procedimento de instalação.
Para demonstração, executaríamos testes simples de Selenium em Python com os frameworks pytest e PyUnit (ou unittest). Se você tiver bom conhecimento em qualquer um desses frameworks, é recomendável que você use fixtures em Python e o Modelo de Objetos de Página (Page Object Model) no Selenium Python para melhorar a manutenção dos testes. O pacote Selenium em si não fornece uma ferramenta ou framework de testes. Portanto, usaremos Selenium com pytest e PyUnit para automatizar interações com os elementos na página da web.
Cenário de Teste
- Navegue até o LambdaTest Selenium Playground.
- Localize o link de Enviar Formulário de Entrada na página.
- Insira as informações necessárias na página.
- 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:
import os
import pytest
from os import environ
import time
from selenium.webdriver import ChromeOptions
from selenium.webdriver.support.ui import WebDriverWait
from selenium import webdriver
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.ui import Select
from selenium.webdriver.common.by import By
exec_platform = os.getenv('EXEC_PLATFORM')
time_sleep = 2
########################## Locators #########################
xSubmitForm = "//a[.='Input Form Submit']"
xInpName = "//input[@id='name']"
cInpName = "#name"
xInpEmail = "//form[@id='seleniumform']//input[@name='email']"
xInpPassword = "//input[@name='password']"
cssCompany = "#company"
cWebName = "#websitename"
xInpCountry = "//select[@name='country']"
xInpCity = "//input[@id='inputCity']"
cssAddress1 = "[placeholder='Address 1']"
cssAddress2 = "[placeholder='Address 2']"
cssInpState = "#inputState"
cssInpZip = "#inputZip"
cssInpButton = ".bg-lambda-900"
nameSearchBox = "search"
class TestFormInput:
def setup_method(self):
if exec_platform == 'cloud':
username = environ.get('LT_USERNAME', None)
access_key = environ.get('LT_ACCESS_KEY', None)
ch_options = webdriver.ChromeOptions()
lt_options = {}
lt_options["build"] = "Build: Getting Started with Selenium PyTest"
lt_options["project"] = "Project: Getting Started with Selenium PyTest"
lt_options["name"] = "Test: Getting Started with Selenium PyTest"
lt_options["browserName"] = "Chrome"
lt_options["browserVersion"] = "latest"
lt_options["platformName"] = "macOS Sonoma"
lt_options["geoLocation"] = "US"
lt_options["console"] = "error"
lt_options["w3c"] = True
lt_options["headless"] = False
ch_options.set_capability('LT:Options', lt_options)
gridURL = "https://{}:{}@hub.lambdatest.com/wd/hub".format(username, access_key)
self.driver = webdriver.Remote(
command_executor = gridURL,
options = ch_options
)
elif exec_platform == 'local':
ch_options = ChromeOptions()
self.driver = webdriver.Chrome(options=ch_options)
def test_enter_form_details(self):
resultant_str = "Thanks for contacting us, we will get back to you shortly."
driver = self.driver
driver.get("https://www.lambdatest.com/selenium-playground/")
# Commented once the tests are executed in non-headless mode
driver.maximize_window()
wait = WebDriverWait(driver, 5)
try:
element = driver.find_element(By.XPATH, xSubmitForm)
element.click()
elem_name = driver.find_element(By.XPATH, xInpName)
elem_name.send_keys("Testing")
time.sleep(time_sleep)
elem_email = driver.find_element(By.XPATH, xInpEmail)
elem_email.send_keys("[email protected]")
time.sleep(time_sleep)
elem_pass = driver.find_element(By.XPATH, xInpPassword)
elem_pass.send_keys("password")
time.sleep(time_sleep)
elem_comp = driver.find_element(By.CSS_SELECTOR, cssCompany)
elem_comp.send_keys("LambdaTest")
elem = driver.find_element(By.CSS_SELECTOR, cWebName)
elem.send_keys("https://wwww.lambdatest.com")
country_dropdown = Select(driver.find_element(By.XPATH, xInpCountry))
country_dropdown.select_by_visible_text("United States")
time.sleep(time_sleep)
elem = driver.find_element(By.XPATH, xInpCity)
elem.send_keys("San Jose")
time.sleep(time_sleep)
elem = driver.find_element(By.CSS_SELECTOR, cssAddress1)
elem.send_keys("Googleplex, 1600 Amphitheatre Pkwy")
time.sleep(time_sleep)
elem = driver.find_element(By.CSS_SELECTOR, cssAddress2)
elem.send_keys("Mountain View, CA 94043")
time.sleep(time_sleep)
elem = driver.find_element(By.CSS_SELECTOR, cssInpState)
elem.send_keys("California")
time.sleep(time_sleep)
elem = driver.find_element(By.CSS_SELECTOR, cssInpZip)
elem.send_keys("94088")
time.sleep(time_sleep)
# Click on the Submit button
submit_button = driver.find_element(By.CSS_SELECTOR, cssInpButton)
submit_button.click()
time.sleep(2)
try:
element = wait.until(
EC.presence_of_element_located((By.CSS_SELECTOR, ".success-msg"))
)
assert resultant_str in element.text, f"'{resultant_str}' not found in the specified element."
except Exception as e:
if exec_platform == 'cloud':
driver.execute_script("lambda-status=failed")
pytest.fail(f"Text '{resultant_str}' not found: {str(e)}")
time.sleep(2)
except Exception as e:
# Catch other exceptions
print(f"Failed: Input Form Demo, generic exception - {e}")
if exec_platform == 'cloud':
driver.execute_script("lambda-status=failed")
if exec_platform == 'cloud':
driver.execute_script("lambda-status=passed")
print(f"PyTest Demo: Test Passed")
def teardown_method(self):
if (self.driver != None):
# self.driver.close()
self.driver.quit()
if __name__ == "__main__":
pytest.main()
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 para o 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.
À medida que os elementos precisam ser localizados antes de realizarmos qualquer ação, primeiro definimos os localizadores de elementos necessários. ID, Nome, XPath, Link Text, Partial Link Text, etc., são alguns dos localizadores da web amplamente utilizados que ajudam você a encontrar elementos dentro do Modelo de Objeto de 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.
Assim que o localizador da web é identificado, o(s) respectivo(s) WebElement(s) é/são localizado(s) combinando o localizador com o método find_element() ou find_elements() 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 que cada função de teste seja implementada sob a respectiva classe de teste.
Os testes sendo implementados podem ser executados no Selenium instalado na máquina local, bem como no grid Selenium online oferecido pelo teste em nuvem. O LambdaTest é uma plataforma de execução de testes com IA que permite executar testes automatizados em Python em escala em diferentes navegadores e sistemas operacionais. Ele vem com uma série de benefícios, sendo os principais a redução da manutenção, custos mais baixos e execução acelerada dos testes.
No que diz respeito à implementação, a única mudança está relacionada ao Selenium WebDriver, onde o Remote WebDriver no Selenium é instanciado ao executar testes em um grid na nuvem. O Automation Capabilities Generator ajuda a gerar capacidades para a combinação de testes destinada a ser usada nos testes.
No Selenium 4, as opções do navegador são usadas no lugar das Desired Capabilities. 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 LambdaTest > Senha e Segurança. A combinação, quando passada juntamente com a URL do grid do LambdaTest, ajuda na execução de testes no grid 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, pois é considerada uma das melhores práticas do Selenium.
Posteriormente, o elemento de envio do formulário é 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.
Uma vez que todos os passos de teste envolvem a localização de elementos e a realização de ações, focamos apenas em alguns métodos. A abordagem usada para localizar o elemento da empresa via Seletor CSS no Selenium está 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 usando 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 corresponde à string fornecida (ou seja, Estados Unidos).
Uma vez que todas as informações no formulário sejam inseridas e o botão Enviar seja 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.
Um assert é levantado 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 nuvem, invoque o seguinte comando no terminal para executar testes pytest na grade de nuvem LambdaTest:
pytest --verbose --capture=no tests/pytest/pytest_selenium_demo.py
Abaixo está a captura de tela do painel de Automação Web 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 usando 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 para o código. A classe de caso de teste é herdada de unittest.TestCase informa ao módulo unittest que este é um caso de teste.
Os fixtures 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 é inicialização e desinicialização, respectivamente.
Abaixo está o código básico para executar o conjunto de testes:
if __name__ == "__main__":
unittest.main()
Execução de Teste (Estrutura PyUnit)
Após configurar EXEC_PLATFORM para nuvem, invoque o seguinte comando no terminal para executar testes PyUnit na grade de nuvem:
python tests/pyunit/pyunit_selenium_demo.py
Abaixo está a captura de tela do painel de Automação Web do LambdaTest que indica que a execução do teste foi bem-sucedida:
Caso queira executar os testes acima no Selenium instalado na máquina local, basta configurar EXEC_PLATFORM para local e você estará pronto para a execução local.
Principais Frameworks de Teste em Python
Como o Python suporta diversos frameworks de automação de teste, a escolha do 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 expertise interna com o referido framework. Abaixo estão alguns dos melhores frameworks de teste em Python:
PyUnit (unittest)
É o framework padrão disponível em Python. Como o nome sugere, é usado principalmente para testes de unidade. PyUnit é inspirado no framework JUnit para Java e compartilha uma estrutura e funcionalidade semelhantes.
O framework unittest também suporta automação de testes compartilhamento de código de configuração e encerramento para testes, independência dos testes do framework de relatórios, e mais. Ele também suporta suítes de testes e casos de testes de forma orientada a objeto. Ele também 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 amigável ao usuário para implementar testes. pytest pode ser aproveitado para implementar testes unitários, bem como testes funcionais complexos para testar sites e aplicações web.
Testes escritos utilizando pytest são muito mais compactos, pois o framework não requer código de boilerplate. pytest possui funcionalidades integradas que ajudam na auto-descoberta de módulos e funções de testes.
Robot
É um framework Python de código aberto orientado a palavras-chave que é amplamente utilizado para Automação de Processos Robotizados (RPA) e automação de testes. Semelhante ao framework pytest, o Robot também é extensível. O uso de uma sintaxe/palavras-chave legível por humanos minimiza a curva de aprendizado envolvida em aprender o Robot.
Testes escritos no Robot são salvos com a extensão .robot. Caso planeje utilizar o Robot para testes de front-end, você pode fazer isso com a SeleniumLibrary, que é uma biblioteca de testes web para o Framework Robot. A biblioteca suporta uma ampla gama de palavras-chave (Clicar em Botão, Clicar em Imagem, Abrir Navegador, Arrastar e Soltar, entre outros).
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.
Comportar
É 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.
Como os testes são implementados em cenários e arquivos de recursos, 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 cruzados de navegadores e muito mais. Informe abaixo sua linguagem de programação preferida para testes do Selenium e como você a classifica em comparação com o Python, o rei incontestável dos testes de automação. Feliz teste!
Source:
https://dzone.com/articles/python-automation-testing-with-examples