Uso do Selenium, uma ferramenta de testes automatizados web

Selênio

Visão geral

Selenium é uma estrutura de código aberto para automatizar as operações do navegador. Ele fornece um conjunto de ferramentas e bibliotecas para testar a funcionalidade e a interface do usuário de aplicativos da web.

Usando Selenium, você pode escrever scripts para simular a interação do usuário no navegador, como clicar, preencher formulários, selecionar caixas suspensas, etc. Esses scripts podem ser executados automaticamente e verificar se o aplicativo se comporta conforme o esperado.

Selenium oferece suporte a uma variedade de linguagens de programação diferentes, incluindo Java, Python, C#, etc., permitindo que os desenvolvedores escrevam e executem scripts de teste em uma linguagem com a qual estejam familiarizados.

O Selenium também possui diferentes ferramentas e componentes, incluindo Selenium WebDriver para interagir diretamente com navegadores, Selenium Grid para executar testes em paralelo em vários navegadores e plataformas e fornece uma API rica e funcionalidade para lidar com pesquisa de navegação, interação e afirmações em elementos de página.

Website oficial:https://www.selenium.dev/

Documento do site oficial:https://www.selenium.dev/documentation/

Documentação chinesa:https://python-selenium-zh.readthedocs.io/zh_CN/latest/

princípio de trabalho

Utilize a API nativa do navegador e encapsule-a na API Selenium WebDriver orientada a objetos (que encapsula várias funções do navegador).O script do programa controla o navegador (Google e Microsoft) por meio da API Selenium, opera os elementos da página do navegador ou opera o próprio navegador (captura de tela, tamanho da janela, inicialização, desligamento)

Cenários de aplicação

teste automatizado:

Selenium é uma das ferramentas de teste automatizado mais comumente usadas. Ele pode simular o comportamento de interação de usuários reais e executar automaticamente vários casos de teste, incluindo testes funcionais, testes de regressão e testes de desempenho. Com o Selenium, você pode testar automaticamente várias funções da sua aplicação web, verificar a exatidão da interface do usuário e capturar e relatar problemas.

Teste de compatibilidade:

Usando o Selenium, scripts de teste automatizados podem ser executados em diferentes navegadores e sistemas operacionais para verificar a compatibilidade de aplicações web em vários ambientes. Isso garante que o aplicativo seja executado de forma consistente em navegadores e plataformas.

Extração de dados e resumo da web:

O Selenium pode ser usado para rastrear conteúdo da web para obter os dados necessários. Ao escrever scripts, você pode simular usuários operando o navegador, acessando páginas da web e extraindo dados, como comparações de preços, resumos de notícias, etc.

Preenchimento automatizado de formulários:

Quando uma grande quantidade de dados de formulário precisa ser preenchida, fazê-lo manualmente pode consumir muito tempo e esforço. Usando o Selenium, você pode escrever scripts para preencher formulários automaticamente e melhorar a eficiência.

Teste de automação de IU:

O Selenium pode verificar a exatidão e consistência da interface do usuário. Ao simular interações e operações do usuário, vários cenários de interfaces de usuário podem ser testados automaticamente para garantir sua correção e funcionalidade.

Desenvolvimento front-end e depuração:

Os desenvolvedores podem usar o Selenium para depurar e verificar o código front-end. Com scripts de teste automatizados, você pode simular ações do usuário e verificar se a renderização e a funcionalidade da página funcionam corretamente.

Instale o driver do navegador

Tome o navegador Chrome como exemplo para instalar o driver do navegador.

Perceber:必须下载对应的 chrome 版本对应的驱动

driver cromado:https://sites.google.com/chromium.org/driver/

driver cromado (antigo):https://sites.google.com/a/chromium.org/chromedriver/

Espelho doméstico Taobao:http://npm.taobao.org/mirrors/chromedriver/

1. Determine a versão do Chrome

Determine a versão do Chrome como: 110.0.5481.100

2. Determine a versão do ChromeDriver

1. Obtenha o número da versão do Chrome, exclua a última parte e obtenha 110.0.5481.

2. Divida os resultados na https://chromedriver.storage.googleapis.com/LATEST_RELEASE_parte de trás.

3. Obtenha o URL: https://chromedriver.storage.googleapis.com/LATEST_RELEASE_110.0.5481e acesse o link para obter o número da versão do ChromeDriver

3. Baixe o ChromeDriver

Basta encontrar a versão correspondente do ChromeDriver e baixá-la. Como é o navegador Chrome mais recente, você pode encontrá-lo imediatamente na página inicial.

Baixe diferentes ChromeDrivers de acordo com o sistema operacional

3. Configure variáveis ​​de ambiente (opcional)

Após descompactar o pacote compactado, você obterá chromedriver.exeo arquivo executável e o código python poderá ser chamado diretamente.

Na variável de ambiente path, adicione chromedriver.exe o diretório onde está localizado

Uso básico

Instale o módulo Selenium

pip install selenium

ponto importante

Devido à iteração da versão, a nova versão do Selenium não usa mais find_element_by_idmétodos, mas sim find_element(By.ID, ''). Para obter detalhes, consulte a versão do Selenium.

Devido à iteração da versão, podem ocorrer exceções:AttributeError: 'WebDriver' object has no attribute 'find_element_by_id'

from selenium import webdriver
from selenium.webdriver.common.by import By

# 老版本
input_element = browser.find_element_by_id("kw")

# 新版本
input_element = browser.find_element(By.ID, 'kw')

Use análises

Use o Baidu para pesquisar seleniumpalavras-chave automaticamente e clicar automaticamente para ir para um resultado de pesquisa.

Obtenha o elemento da caixa de entrada e as informações do elemento do botão de pesquisa

Obtenha as informações de endereço do primeiro resultado da pesquisa

Código

# 导入模块
import time

from selenium import webdriver
from selenium.webdriver.common.by import By

# 创建浏览器对象，需指定驱动。驱动有2种方式获取
# 1.通过手动指定浏览器驱动路径
browser = webdriver.Chrome('D:\Development\chromedriver_win32\chromedriver.exe')
# 2.通过$PATH环境变量寻找驱动，如果寻找不到就报错
# browser = webdriver.Chrome()

# 指定操作浏览器对象的行为
# 让浏览器访问网页
browser.get("https://www.baidu.com/")
# 获取输入框元素
# input_element = browser.find_element_by_id("kw")
input_element = browser.find_element(By.ID, 'kw')
# 输入内容
input_element.send_keys('selenium')
# 获取搜索按钮
button_element = browser.find_element(By.ID, 'su')
# 点击搜索
button_element.click()

time.sleep(3)

# 获取地址
url_element = browser.find_element(By.CLASS_NAME, "c-gap-bottom-small").find_element(By.TAG_NAME, 'a')
url_element.click()

time.sleep(5)

# 退出浏览器
browser.quit()

Métodos comuns

objeto motorista

No processo de uso do selênio, após instanciar o objeto driver, o objeto driver possui algumas propriedades e métodos comumente usados.

driver.page_source 当前标签页浏览器渲染之后的网页源代码
driver.current_url 当前标签页的url
driver.close() 关闭当前标签页，如果只有一个标签页则关闭整个浏览器
driver.quit() 关闭浏览器
driver.forward() 页面前进
driver.back() 页面后退
driver.screen_shot(img_name) 页面截图

Localizando elementos de rótulo e obtendo objetos de rótulo

Há muitas maneiras de localizar tags no selênio e retornar objetos de elemento de tag.

versão antiga

find_element_by_xxx 返回第一个符合条件

find_elements_by_xxx 返回符合条件所有元素的WebEelemnt列表

find_element匹配不到就抛出异常，find_elements匹配不到就返回空列表

find_element_by_id 通过ID
find_element_by_class_name 通过class查询元素
find_element_by_name 通过name
find_element_by_tag_name 通过标签名称
find_element_by_css_selector css样式选择
find_element_by_link_text 通过链接内容查找
find_element_by_partial_link_text 通过链接内容包含的内容查找，模糊查询
find_element_by_xpath 通过xpath查找数据

nova versão

find_element(BY, 'str')

find_elements(BY, 'str')

find_element(By.ID, 'id')
find_element(By.CLASS_NAME, 'calss_name')
find_element(By.NAME, 'name')
find_element(By.TAG_NAME, 'tag_name')
find_element(By.CSS_SELECTOR, 'css_selector')
find_element(By.LINK_TEXT, 'link_text')
find_element(By.PARTIAL_LINK_TEXT, 'partial_link_text')
find_element(By.XPATH, 'xpath')

Obtenha conteúdo de texto e valores de atributos

Obtenha o valor do atributo do elemento

element.get_attribute('属性名')

Obtenha o conteúdo do texto do elemento

element.text

Insira os dados na caixa de entrada

input_element.send_keys('selenium')

Clique em um elemento

button_element.click()

Use um navegador sem cabeça

A grande maioria dos servidores não tem interface. O Selenium também controla o Google Chrome no modo headless. O modo sem interface também é chamado de modo headless.

Usando o driver pyantomjs

Não é recomendado usar o driver pyantomjs. O método pyantomjs foi eliminado pelo Selenium.

Link para Download:http://phantomjs.org/download.html

Uso

# 导入模块
import time

from selenium import webdriver

# 创建浏览器对象
browser = webdriver.PhantomJS(executable_path=r"D:\Development\phantomjs-2.1.1-windows\bin\phantomjs.exe")

# 指定操作浏览器对象的行为
# 让浏览器访问网页
browser.get("https://www.baidu.com/")
# 保存截图调试
browser.save_screenshot('screenshot.png')

Exceção 1:

A nova versão do Selenium abandonou o PhantomJS, portanto ocorrerão AttributeError: module 'selenium.webdriver' has no attribute 'PhantomJS'exceções .

desinstalar selênio

pip uninstall selenium

Instale a versão especificada do Selenium

pip install selenium==3.14.0

Exceção 2:

selenium.common.exceptions.WebDriverException: Message: 'phantomjs.exe' executable needs to be in PATH. 

Solução 1: adicione um r na frente do caminho completo

browser = webdriver.PhantomJS(executable_path=r"D:\Development\phantomjs-2.1.1-windows\bin\phantomjs.exe")

Solução 2: adicione o caminho do arquivo bin à variável do sistema

C:\Users\Admin>phantomjs -v
2.1.1

Definir parâmetros de inicialização do Chrome

# 导入模块
from selenium import webdriver

# 创建浏览器对象,指定配置参数
options = webdriver.ChromeOptions()
options.add_argument('--headless')  # 开启无界面模式
options.add_argument('--disable-gpu')  # 禁用gpu
# 实例化带有配置对象的driver对象
browser = webdriver.Chrome('D:\Development\chromedriver_win32\chromedriver.exe', chrome_options=options)

# 指定操作浏览器对象的行为
# 让浏览器访问网页
browser.get("https://www.baidu.com/")
# 保存截图调试
browser.save_screenshot('screenshot.png')

Outras operações

Troca de janela

O navegador pode abrir várias páginas da web e precisa localizar qual é a forma do elemento da página da web obtido no momento. Alternar janelas através de browser.switch_to.window

# 获取当前所有的窗口
print(browser.window_handles)

# 获取当前选中窗体的名称
print(browser.current_window_handle)

print("切换前：", browser.title)

# 执行js新开一个标签页
js = 'window.open("https://www.baidu.com");'
browser.execute_script(js)
time.sleep(3)

# 获取当前所有的窗口
print(browser.window_handles)

# 切换窗体
browser.switch_to.window(browser.window_handles[1])
print("切换后:", browser.title)

interruptor ifrma

iframe é uma tecnologia comumente usada em HTML, ou seja, uma página está aninhada dentro de outra página web

A página do navegador pode conter uma página iframe. O Selenium não pode acessar o conteúdo do quadro por padrão, portanto, é necessário obter o elemento da página iframe. Alternar iframe via browser.switch_to.frame

import time

# 导入模块
from selenium import webdriver

# 创建浏览器对象
# 参数驱动路径
from selenium.webdriver.common.by import By
browser = webdriver.Chrome()

browser.get("https://mail.qq.com/cgi-bin/loginpage")
print("切换前:", browser.page_source)

# 获取iframe元素对象
iframe_element = browser.find_element(By.ID, 'login_frame')
# 切换 iframe
browser.switch_to.frame(iframe_element)
print("切换后:", browser.page_source)

# 切换回 主窗口
browser.switch_to.default_content()
print("切回后:", browser.page_source)

# 利用切换标签页的方式切出frame标签
# windows = driver.window_handles
# driver.switch_to.window(windows[0])
time.sleep(5)

# 退出浏览器
browser.quit()

Configurar User-Agent e proxy

Quando o Selenium controla o Google Chrome, o User-Agent assume como padrão o Google Chrome e pode ser substituído.

O Selenium também pode usar IP proxy para controlar o navegador.

options = webdriver.ChromeOptions()
# 切换User-Agent
options.add_argument('--user-agent=Mozilla/5.0 (iPhone; CPU iPhone OS 11_0 like Mac OS X) AppleWebKit/604.1.38 (KHTML, like Gecko) Version/11.0 Mobile/15A372 Safari/604.1')
# 设置代理
options.add_argument('--proxy-server=代理服务器地址') # 设置代理
browser = webdriver.Chrome('./chromedriver',chrome_options=options)

Obtenha o código-fonte da página da web

O código-fonte da página da web obtido é o código-fonte resultante após a execução da página JS.

browser.page_source

Operações de cookies

selenium pode ajudar a lidar com cookies em páginas

获取所有Cookies
browser.get_cookies()

把cookie转化为字典
cookies_dict = {
    
    cookie['name']: cookie['value'] for cookie in browser.get_cookies()}

通过名字获取Cookie
browser.get_cookie()

添加Cookie
browser.add_cookie()

通过名字删除Cookie
browser.delete_cookie()

删除所有Cookie
browser.delete_all_cookies()

executar javascript

selenium permite que o navegador execute código js especificado

# js语句：滚动
js = 'window.scrollTo(0,document.body.scrollHeight)' 
# 执行js的方法
browser.execute_script(js) 

js ="alert("hello world")"
browser.execute_script(js)

Página em espera

Durante o processo de carregamento, a página precisa ficar algum tempo aguardando a resposta do servidor do site. Durante esse processo, o elemento tag pode ainda não ter sido carregado e, ao mesmo tempo, os dados são obtidos, fazendo com que o navegador não consiga encontrar o elemento que precisa ser operado, causando assim uma exceção. Neste momento, o programa precisa esperar.Existem três maneiras:

página selenium aguardando classificação

强制等待
隐式等待
显式等待

1. Espera forçada

O tempo de configuração é muito curto e os elementos não são carregados. A configuração demora muito e é uma perda de tempo

time.sleep(秒数)

2. Espera oculta

A espera implícita visa o posicionamento do elemento. A espera implícita define um tempo para determinar se o elemento foi posicionado com sucesso dentro de um período de tempo. Se for concluído, prossiga para a próxima etapa. Se o posicionamento não for bem-sucedido dentro do tempo definido, será relatado um carregamento de tempo limite.

browser.implicitly_wait(等待时间)

3. Espera explícita, cada elemento pode definir suas próprias condições de verificação

A cada poucos segundos, verifique se a condição de espera foi atendida. Se for atendida, pare de esperar e continue a execução do código subsequente. Se não for atingido, ele continuará aguardando até que o tempo especificado seja excedido e uma exceção de tempo limite será relatada.

1. Implementar manualmente a espera de página

t = time.time()
# 定义超时时间
timeout = 60

while True:
    try:
        # 超时时间间隔
        time.sleep(1)
        url_element = browser.find_element(BY.ID, "OK")
        break
    except:
        # 超时处理
        if time.time() - t > timeout:
            break
        pass

2. Fornece API de espera explícita

# 等待对象模块
from selenium.webdriver.support.wait import WebDriverWait
# 导入等待条件模块
from selenium.webdriver.support import expected_conditions as EC
# 导入查询元素模块
from selenium.webdriver.common.by import By

# 使用selenium api 实现显性等待
# 创建等待对象,传入：浏览器对象、超时时间、检查元素时间间隔
wait = WebDriverWait(browser, 60, 0.1)
# 检查元素是否存在，参数是一个元祖，元祖内部描述等待元素查询方案
# EC.presence_of_element_located()
# 检查元素是否可见
# EC.visibility_of_element_located()
url_element = wait.until(EC.presence_of_element_located((By.CLASS_NAME, "OK")))