SeleniumBase
4.33.7 - CDP Mode - Patch 17
Estrutura completa de automação do navegador:
Rastreamento / teste / raspagem / furtividade da Web
Iniciar | ? Recursos | ?️ Opções | Exemplos | ? Roteiros | Móvel
APIs | ? Formatos | ? Gravador | Painel | ? Locais | Fazenda
?️GUI | ? Página de teste | ? Modo UC | ? Modo CDP | ? Gráficos | Grade
?️ Como | ? Migrar | Planos de Caso | ♻️ Modelo | ? Híbrido | ? Passeios
? CI/CD | ?️ JSMgr | ? Tradutor | Apresentador | ? Diálogo | ?️ Visuais
SeleniumBase é o kit de ferramentas profissional para atividades de automação web. Desenvolvido para testar sites, contornar CAPTCHAs, aumentar a produtividade, concluir tarefas e expandir seus negócios.
Aprenda com mais de 200 exemplos na pasta SeleniumBase/examples/ .
? Observe que o modo SeleniumBase UC (modo Stealth) possui seu próprio ReadMe.
? Observe também que o modo Seleniumbase CDP possui seu próprio ReadMe separado.
Os scripts podem ser chamados via python , embora alguns formatos de sintaxe esperem pytest (uma estrutura de teste de unidade Python incluída no SeleniumBase que pode descobrir, coletar e executar testes automaticamente).
? Aqui está my_first_test.py, que testa login, compras e checkout:
pytest my_first_test.py
pytestusa--chromepor padrão, a menos que seja definido de forma diferente.
? Aqui está test_coffee_cart.py, que verifica um site de comércio eletrônico:
pytest test_coffee_cart.py --demo(
--demomode retarda testes e destaca ações)
? Aqui está test_demo_site.py, que cobre várias ações:
pytest test_demo_site.pyFácil de digitar, clicar, selecionar, alternar, arrastar e soltar e muito mais.
(Para mais exemplos, consulte a pasta SeleniumBase/examples/.)
Explore o README:
- Primeiros passos / Instalação
- Exemplo Básico/Uso
- Métodos de teste comuns
- Curiosidades / Saiba mais
- Modo de demonstração/depuração
- Opções de linha de comando
- Configuração de diretório
- Painel SeleniumBase
- Gerando Relatórios de Teste
SeleniumBase é uma estrutura Python para automação e testes de navegadores. SeleniumBase usa APIs Selenium/WebDriver e incorpora executores de teste como pytest , pynose e behave para fornecer estrutura organizada, descoberta de teste, execução de teste, estado de teste ( por exemplo, aprovado, reprovado ou ignorado ) e opções de linha de comando para alteração configurações padrão ( por exemplo, seleção do navegador ). Com o Selenium bruto, você precisaria configurar seu próprio analisador de opções para configurar testes na linha de comando.
O gerenciador de driver do SeleniumBase oferece mais controle sobre downloads automáticos de driver. (Use --driver-version=VER com seu comando pytest run para especificar a versão.) Por padrão, o SeleniumBase baixará uma versão do driver que corresponda à versão principal do seu navegador, se não estiver definida.
SeleniumBase detecta automaticamente entre seletores CSS e XPath, o que significa que você não precisa especificar o tipo de seletor em seus comandos ( mas opcionalmente você poderia ).
Os métodos SeleniumBase geralmente executam várias ações em uma única chamada de método. Por exemplo, self.type(selector, text) faz o seguinte:
1. Aguarda que o elemento fique visível.
2. Aguarda que o elemento seja interativo.
3. Limpa o campo de texto.
4. Digite o novo texto.
5. Pressione Enter/Enviar se o texto terminar em "n" .
Com o Selenium bruto, essas ações requerem múltiplas chamadas de método.
SeleniumBase usa valores de tempo limite padrão quando não definido:
✅ self.click("button")
Com o Selenium bruto, os métodos falhariam instantaneamente ( por padrão ) se um elemento precisasse de mais tempo para carregar:
self.driver.find_element(by="css selector", value="button").click()
(Código confiável é melhor que código não confiável.)
SeleniumBase permite alterar os valores de tempo limite explícitos dos métodos:
✅ self.click("button", timeout=10)
Com o Selenium bruto, isso requer mais código:
WebDriverWait(driver, 10).until(EC.element_to_be_clickable("css selector", "button")).click()
(Código simples é melhor que código complexo.)
SeleniumBase fornece saída de erro limpa quando um teste falha. Com o Selenium bruto, as mensagens de erro podem ficar muito confusas.
SeleniumBase oferece a opção de gerar um painel e relatórios para testes. Ele também salva capturas de tela de testes com falha na pasta ./latest_logs/ . Raw Selenium não tem essas opções prontas para uso.
SeleniumBase inclui aplicativos GUI de desktop para execução de testes, como SeleniumBase Commander para pytest e SeleniumBase Behave GUI para behave .
SeleniumBase possui seu próprio Gravador/Gerador de Testes para criação de testes a partir de ações manuais do navegador.
SeleniumBase vem com software de gerenciamento de casos de teste, ("CasePlans"), para organizar testes e descrições de etapas.
SeleniumBase inclui ferramentas para construção de aplicativos de dados, ("ChartMaker"), que podem gerar JavaScript a partir de Python.
Aprenda sobre diferentes maneiras de escrever testes:
Aqui está test_simple_login.py, que usa herança de classe BaseCase e é executado com pytest ou pynose. (Use self.driver para acessar driver bruto do Selenium.)
from seleniumbase import BaseCase
BaseCase . main ( __name__ , __file__ )
class TestSimpleLogin ( BaseCase ):
def test_simple_login ( self ):
self . open ( "seleniumbase.io/simple/login" )
self . type ( "#username" , "demo_user" )
self . type ( "#password" , "secret_pass" )
self . click ( 'a:contains("Sign in")' )
self . assert_exact_text ( "Welcome!" , "h1" )
self . assert_element ( "img#image1" )
self . highlight ( "#image1" )
self . click_link ( "Sign out" )
self . assert_text ( "signed out" , "#top_message" ) ? Aqui está um teste de sb_fixture_tests.py, que usa o fixture sb pytest . Funciona com pytest. (Use sb.driver para acessar driver bruto do Selenium.)
def test_sb_fixture_with_no_class ( sb ):
sb . open ( "seleniumbase.io/simple/login" )
sb . type ( "#username" , "demo_user" )
sb . type ( "#password" , "secret_pass" )
sb . click ( 'a:contains("Sign in")' )
sb . assert_exact_text ( "Welcome!" , "h1" )
sb . assert_element ( "img#image1" )
sb . highlight ( "#image1" )
sb . click_link ( "Sign out" )
sb . assert_text ( "signed out" , "#top_message" ) ? Aqui está raw_login_sb.py, que usa o SB Context Manager. Funciona com python puro. (Use sb.driver para acessar driver bruto do Selenium.)
from seleniumbase import SB
with SB () as sb :
sb . open ( "seleniumbase.io/simple/login" )
sb . type ( "#username" , "demo_user" )
sb . type ( "#password" , "secret_pass" )
sb . click ( 'a:contains("Sign in")' )
sb . assert_exact_text ( "Welcome!" , "h1" )
sb . assert_element ( "img#image1" )
sb . highlight ( "#image1" )
sb . click_link ( "Sign out" )
sb . assert_text ( "signed out" , "#top_message" ) ? Aqui está raw_login_context.py, que usa o DriverContext Manager. Funciona com python puro. (O driver é uma versão melhorada do driver bruto do Selenium, com mais métodos.)
from seleniumbase import DriverContext
with DriverContext () as driver :
driver . open ( "seleniumbase.io/simple/login" )
driver . type ( "#username" , "demo_user" )
driver . type ( "#password" , "secret_pass" )
driver . click ( 'a:contains("Sign in")' )
driver . assert_exact_text ( "Welcome!" , "h1" )
driver . assert_element ( "img#image1" )
driver . highlight ( "#image1" )
driver . click_link ( "Sign out" )
driver . assert_text ( "signed out" , "#top_message" ) ? Aqui está raw_login_driver.py, que usa o Driver Manager. Funciona com python puro. (O driver é uma versão melhorada do driver bruto do Selenium, com mais métodos.)
from seleniumbase import Driver
driver = Driver ()
try :
driver . open ( "seleniumbase.io/simple/login" )
driver . type ( "#username" , "demo_user" )
driver . type ( "#password" , "secret_pass" )
driver . click ( 'a:contains("Sign in")' )
driver . assert_exact_text ( "Welcome!" , "h1" )
driver . assert_element ( "img#image1" )
driver . highlight ( "#image1" )
driver . click_link ( "Sign out" )
driver . assert_text ( "signed out" , "#top_message" )
finally :
driver . quit () Aqui está login_app.feature, que usa a sintaxe behavior-BDD Gherkin. Executa com behave . (Saiba mais sobre a integração SeleniumBase behavior-BDD )
Feature : SeleniumBase scenarios for the Simple App
Scenario : Verify the Simple App (Login / Logout)
Given Open "seleniumbase.io/simple/login"
And Type "demo_user" into "#username"
And Type "secret_pass" into "#password"
And Click 'a:contains("Sign in")'
And Assert exact text "Welcome!" in "h1"
And Assert element "img#image1"
And Highlight "#image1"
And Click link "Sign out"
And Assert text "signed out" in "#top_message" ? Adicione Python e Git ao PATH do sistema.
? É recomendado usar um ambiente virtual Python.
Você pode instalar seleniumbase do PyPI ou GitHub:
? Como instalar seleniumbase do PyPI:
pip install seleniumbase--upgrade OU -U para atualizar o SeleniumBase.)--force-reinstall para atualizar pacotes indiretos.)pip3 se várias versões do Python estiverem presentes.) ? Como instalar seleniumbase a partir de um clone do GitHub:
git clone https://github.com/seleniumbase/SeleniumBase.git
cd SeleniumBase/
pip install -e .? Como atualizar uma instalação existente de um clone do GitHub:
git pull
pip install -e . ? Digite seleniumbase ou sbase para verificar se o SeleniumBase foi instalado com sucesso:
___ _ _ ___
/ __ | ___ | | ___ _ _ (_)_ _ _ __ | _ ) __ _ ______
_ _ / -_) / -_) ' | | | | ' | _ / _ ` (_- < -_)
| ___/ _ __ | _ _ __ | _ || _ | _ | _ ,_ | _ | _ | _ | ___/ _ _,_/__ | ___ |
----------------------------------------------------
╭──────────────────────────────────────────────────╮
│ * USAGE: " seleniumbase [COMMAND] [PARAMETERS] " │
│ * OR: " sbase [COMMAND] [PARAMETERS] " │
│ │
│ COMMANDS: PARAMETERS / DESCRIPTIONS: │
│ get / install [DRIVER_NAME] [OPTIONS] │
│ methods (List common Python methods) │
│ options (List common pytest options) │
│ behave-options (List common behave options) │
│ gui / commander [OPTIONAL PATH or TEST FILE] │
│ behave-gui (SBase Commander for Behave) │
│ caseplans [OPTIONAL PATH or TEST FILE] │
│ mkdir [DIRECTORY] [OPTIONS] │
│ mkfile [FILE.py] [OPTIONS] │
│ mkrec / codegen [FILE.py] [OPTIONS] │
│ recorder (Open Recorder Desktop App.) │
│ record (If args: mkrec. Else: App.) │
│ mkpres [FILE.py] [LANG] │
│ mkchart [FILE.py] [LANG] │
│ print [FILE] [OPTIONS] │
│ translate [SB_FILE.py] [LANG] [ACTION] │
│ convert [WEBDRIVER_UNITTEST_FILE.py] │
│ extract-objects [SB_FILE.py] │
│ inject-objects [SB_FILE.py] [OPTIONS] │
│ objectify [SB_FILE.py] [OPTIONS] │
│ revert-objects [SB_FILE.py] [OPTIONS] │
│ encrypt / obfuscate │
│ decrypt / unobfuscate │
│ proxy (Start a basic proxy server) │
│ download server (Get Selenium Grid JAR file) │
│ grid-hub [start | stop] [OPTIONS] │
│ grid-node [start | stop] --hub=[HOST/IP] │
│ │
│ * EXAMPLE = > " sbase get chromedriver stable " │
│ * For command info = > " sbase help [COMMAND] " │
│ * For info on all commands = > " sbase --help " │
╰──────────────────────────────────────────────────╯ ✅ SeleniumBase baixa automaticamente webdrivers conforme necessário, como chromedriver .
*** chromedriver to download = 121.0.6167.85 (Latest Stable)
Downloading chromedriver-mac-arm64.zip from:
https://storage.googleapis.com/chrome-for-testing-public/121.0.6167.85/mac-arm64/chromedriver-mac-arm64.zip ...
Download Complete !
Extracting [ ' chromedriver ' ] from chromedriver-mac-arm64.zip ...
Unzip Complete !
The file [chromedriver] was saved to:
/Users/michael/github/SeleniumBase/seleniumbase/drivers/chromedriver
Making [chromedriver 121.0.6167.85] executable ...
[chromedriver 121.0.6167.85] is now ready for use ! ? Se você clonou o SeleniumBase, você pode executar testes na pasta samples/.
Aqui está my_first_test.py:
cd examples/
pytest my_first_test.pyAqui está o código para my_first_test.py:
from seleniumbase import BaseCase
BaseCase . main ( __name__ , __file__ )
class MyTestClass ( BaseCase ):
def test_swag_labs ( self ):
self . open ( "https://www.saucedemo.com" )
self . type ( "#user-name" , "standard_user" )
self . type ( "#password" , "secret_sauce n " )
self . assert_element ( "div.inventory_list" )
self . assert_exact_text ( "Products" , "span.title" )
self . click ( 'button[name*="backpack"]' )
self . click ( "#shopping_cart_container a" )
self . assert_exact_text ( "Your Cart" , "span.title" )
self . assert_text ( "Backpack" , "div.cart_item" )
self . click ( "button#checkout" )
self . type ( "#first-name" , "SeleniumBase" )
self . type ( "#last-name" , "Automation" )
self . type ( "#postal-code" , "77123" )
self . click ( "input#continue" )
self . assert_text ( "Checkout: Overview" )
self . assert_text ( "Backpack" , "div.cart_item" )
self . assert_text ( "29.99" , "div.inventory_item_price" )
self . click ( "button#finish" )
self . assert_exact_text ( "Thank you for your order!" , "h2" )
self . assert_element ( 'img[alt="Pony Express"]' )
self . js_click ( "a#logout_sidebar_link" )
self . assert_element ( "div#login_button_container" ) self . open ( url ) # Navigate the browser window to the URL.
self . type ( selector , text ) # Update the field with the text.
self . click ( selector ) # Click the element with the selector.
self . click_link ( link_text ) # Click the link containing text.
self . go_back () # Navigate back to the previous URL.
self . select_option_by_text ( dropdown_selector , option )
self . hover_and_click ( hover_selector , click_selector )
self . drag_and_drop ( drag_selector , drop_selector )
self . get_text ( selector ) # Get the text from the element.
self . get_current_url () # Get the URL of the current page.
self . get_page_source () # Get the HTML of the current page.
self . get_attribute ( selector , attribute ) # Get element attribute.
self . get_title () # Get the title of the current page.
self . switch_to_frame ( frame ) # Switch into the iframe container.
self . switch_to_default_content () # Leave the iframe container.
self . open_new_window () # Open a new window in the same browser.
self . switch_to_window ( window ) # Switch to the browser window.
self . switch_to_default_window () # Switch to the original window.
self . get_new_driver ( OPTIONS ) # Open a new driver with OPTIONS.
self . switch_to_driver ( driver ) # Switch to the browser driver.
self . switch_to_default_driver () # Switch to the original driver.
self . wait_for_element ( selector ) # Wait until element is visible.
self . is_element_visible ( selector ) # Return element visibility.
self . is_text_visible ( text , selector ) # Return text visibility.
self . sleep ( seconds ) # Do nothing for the given amount of time.
self . save_screenshot ( name ) # Save a screenshot in .png format.
self . assert_element ( selector ) # Verify the element is visible.
self . assert_text ( text , selector ) # Verify text in the element.
self . assert_exact_text ( text , selector ) # Verify text is exact.
self . assert_title ( title ) # Verify the title of the web page.
self . assert_downloaded_file ( file ) # Verify file was downloaded.
self . assert_no_404_errors () # Verify there are no broken links.
self . assert_no_js_errors () # Verify there are no JS errors.? Para obter a lista completa de métodos SeleniumBase, consulte: Resumo do método
✅ SeleniumBase lida automaticamente com ações comuns do WebDriver, como iniciar navegadores antes dos testes, salvar capturas de tela durante falhas e fechar navegadores após os testes.
✅ SeleniumBase permite personalizar testes por meio de opções de linha de comando.
✅ SeleniumBase usa sintaxe simples para comandos. Exemplo:
self . type ( "input" , "dogs n " ) # (The "n" presses ENTER) A maioria dos scripts SeleniumBase podem ser executados com pytest , pynose ou python puro . Nem todos os executores de teste podem executar todos os formatos de teste. Por exemplo, testes que usam o fixture sb pytest só podem ser executados com pytest . (Veja Formatos de Sintaxe) Há também um formato de teste Gherkin que é executado com comportamento.
pytest coffee_cart_tests.py --rs
pytest test_sb_fixture.py --demo
pytest test_suite.py --rs --html=report.html --dashboard
pynose basic_test.py --mobile
pynose test_suite.py --headless --report --show-report
python raw_sb.py
python raw_test_scripts.py
behave realworld.feature
behave calculator.feature -D rs -D dashboard ✅ pytest inclui descoberta automática de testes. Se você não especificar um arquivo ou pasta específico para execução, pytest pesquisará automaticamente em todos os subdiretórios os testes a serem executados com base nos seguintes critérios:
test_ ou terminam com _test.py .test_ . Com um arquivo SeleniumBase pytest.ini presente, você pode modificar as configurações de descoberta padrão. O nome da classe Python pode ser qualquer coisa porque seleniumbase.BaseCase herda unittest.TestCase para acionar a descoberta automática.
✅ Você pode fazer uma verificação pré-voo para ver quais testes seriam descobertos pelo pytest antes da execução real:
pytest --co -q ✅ Você pode ser mais específico ao chamar pytest ou pynose em um arquivo:
pytest [FILE_NAME.py]::[CLASS_NAME]::[METHOD_NAME]
pynose [FILE_NAME.py]:[CLASS_NAME].[METHOD_NAME] ✅ Chega de testes esquisitos! Os métodos SeleniumBase aguardam automaticamente que os elementos da página terminem de carregar antes de interagir com eles ( até um limite de tempo limite ). Isso significa que você não precisa mais de instruções time.sleep() aleatórias em seus scripts.
✅ SeleniumBase suporta todos os principais navegadores e sistemas operacionais:
Navegadores: Chrome, Edge, Firefox e Safari.
Sistemas: Linux/Ubuntu, macOS e Windows.
✅ SeleniumBase funciona em todas as plataformas CI/CD populares:
✅ SeleniumBase inclui uma solução híbrida automatizada/manual chamada MasterQA para acelerar os testes manuais com automação enquanto os testadores manuais cuidam da validação.
✅ SeleniumBase suporta a execução de testes offline ( supondo que os webdrivers tenham sido baixados anteriormente quando online ).
✅ Para obter uma lista completa dos recursos do SeleniumBase, clique aqui.
? O Modo Demo ajuda você a ver o que um teste está fazendo. Se um teste estiver se movendo rápido demais para seus olhos, execute-o no modo de demonstração para pausar brevemente o navegador entre as ações, destacar os elementos da página que estão sendo executados e exibir afirmações:
pytest my_first_test.py --demo ? time.sleep(seconds) pode ser usado para fazer um teste esperar em um local específico:
import time ; time . sleep ( 3 ) # Do nothing for 3 seconds.? O modo de depuração com a biblioteca pdb integrada do Python ajuda a depurar testes:
import pdb ; pdb . set_trace ()
import pytest ; pytest . set_trace ()
breakpoint () # Shortcut for "import pdb; pdb.set_trace()"(comandos
pdb:n,c,s,u,d=>next,continue,step,up,down)
? Para pausar um teste ativo que gera uma exceção ou erro ( e manter a janela do navegador aberta enquanto o modo de depuração inicia no console ), adicione --pdb como uma opção pytest :
pytest test_fail.py --pdb ? Para iniciar testes no modo de depuração, adicione --trace como opção pytest :
pytest test_coffee_cart.py --trace ✅ Aqui estão algumas opções úteis de linha de comando que vêm com pytest :
-v # Verbose mode. Prints the full name of each test and shows more details.
-q # Quiet mode. Print fewer details in the console output when running tests.
-x # Stop running the tests after the first failure is reached.
--html=report.html # Creates a detailed pytest-html report after tests finish.
--co | --collect-only # Show what tests would get run. (Without running them)
--co -q # (Both options together!) - Do a dry run with full test names shown.
-n=NUM # Multithread the tests using that many threads. (Speed up test runs!)
-s # See print statements. (Should be on by default with pytest.ini present.)
--junit-xml=report.xml # Creates a junit-xml report after tests finish.
--pdb # If a test fails, enter Post Mortem Debug Mode. (Don't use with CI!)
--trace # Enter Debug Mode at the beginning of each test. (Don't use with CI!)
-m=MARKER # Run tests with the specified pytest marker. ✅ SeleniumBase fornece opções adicionais de linha de comando pytest para testes:
--browser=BROWSER # (The web browser to use. Default: "chrome".)
--chrome # (Shortcut for "--browser=chrome". On by default.)
--edge # (Shortcut for "--browser=edge".)
--firefox # (Shortcut for "--browser=firefox".)
--safari # (Shortcut for "--browser=safari".)
--settings-file=FILE # (Override default SeleniumBase settings.)
--env=ENV # (Set the test env. Access with "self.env" in tests.)
--account=STR # (Set account. Access with "self.account" in tests.)
--data=STRING # (Extra test data. Access with "self.data" in tests.)
--var1=STRING # (Extra test data. Access with "self.var1" in tests.)
--var2=STRING # (Extra test data. Access with "self.var2" in tests.)
--var3=STRING # (Extra test data. Access with "self.var3" in tests.)
--variables=DICT # (Extra test data. Access with "self.variables".)
--user-data-dir=DIR # (Set the Chrome user data directory to use.)
--protocol=PROTOCOL # (The Selenium Grid protocol: http|https.)
--server=SERVER # (The Selenium Grid server/IP used for tests.)
--port=PORT # (The Selenium Grid port used by the test server.)
--cap-file=FILE # (The web browser's desired capabilities to use.)
--cap-string=STRING # (The web browser's desired capabilities to use.)
--proxy=SERVER:PORT # (Connect to a proxy server:port as tests are running)
--proxy=USERNAME:PASSWORD@SERVER:PORT # (Use an authenticated proxy server)
--proxy-bypass-list=STRING # (";"-separated hosts to bypass, Eg "*.foo.com")
--proxy-pac-url=URL # (Connect to a proxy server using a PAC_URL.pac file.)
--proxy-pac-url=USERNAME:PASSWORD@URL # (Authenticated proxy with PAC URL.)
--proxy-driver # (If a driver download is needed, will use: --proxy=PROXY.)
--multi-proxy # (Allow multiple authenticated proxies when multi-threaded.)
--agent=STRING # (Modify the web browser's User-Agent string.)
--mobile # (Use the mobile device emulator while running tests.)
--metrics=STRING # (Set mobile metrics: "CSSWidth,CSSHeight,PixelRatio".)
--chromium-arg= " ARG=N,ARG2 " # (Set Chromium args, ","-separated, no spaces.)
--firefox-arg= " ARG=N,ARG2 " # (Set Firefox args, comma-separated, no spaces.)
--firefox-pref=SET # (Set a Firefox preference:value set, comma-separated.)
--extension-zip=ZIP # (Load a Chrome Extension .zip|.crx, comma-separated.)
--extension-dir=DIR # (Load a Chrome Extension directory, comma-separated.)
--disable-features= " F1,F2 " # (Disable features, comma-separated, no spaces.)
--binary-location=PATH # (Set path of the Chromium browser binary to use.)
--driver-version=VER # (Set the chromedriver or uc_driver version to use.)
--sjw # (Skip JS Waits for readyState to be "complete" or Angular to load.)
--wfa # (Wait for AngularJS to be done loading after specific web actions.)
--pls=PLS # (Set pageLoadStrategy on Chrome: "normal", "eager", or "none".)
--headless # (The default headless mode. Linux uses this mode by default.)
--headless1 # (Use Chrome's old headless mode. Fast, but has limitations.)
--headless2 # (Use Chrome's new headless mode, which supports extensions.)
--headed # (Run tests in headed/GUI mode on Linux OS, where not default.)
--xvfb # (Run tests using the Xvfb virtual display server on Linux OS.)
--xvfb-metrics=STRING # (Set Xvfb display size on Linux: "Width,Height".)
--locale=LOCALE_CODE # (Set the Language Locale Code for the web browser.)
--interval=SECONDS # (The autoplay interval for presentations & tour steps)
--start-page=URL # (The starting URL for the web browser when tests begin.)
--archive-logs # (Archive existing log files instead of deleting them.)
--archive-downloads # (Archive old downloads instead of deleting them.)
--time-limit=SECONDS # (Safely fail any test that exceeds the time limit.)
--slow # (Slow down the automation. Faster than using Demo Mode.)
--demo # (Slow down and visually see test actions as they occur.)
--demo-sleep=SECONDS # (Set the wait time after Slow & Demo Mode actions.)
--highlights=NUM # (Number of highlight animations for Demo Mode actions.)
--message-duration=SECONDS # (The time length for Messenger alerts.)
--check-js # (Check for JavaScript errors after page loads.)
--ad-block # (Block some types of display ads from loading.)
--host-resolver-rules=RULES # (Set host-resolver-rules, comma-separated.)
--block-images # (Block images from loading during tests.)
--do-not-track # (Indicate to websites that you don't want to be tracked.)
--verify-delay=SECONDS # (The delay before MasterQA verification checks.)
--ee | --esc-end # (Lets the user end the current test via the ESC key.)
--recorder # (Enables the Recorder for turning browser actions into code.)
--rec-behave # (Same as Recorder Mode, but also generates behave-gherkin.)
--rec-sleep # (If the Recorder is enabled, also records self.sleep calls.)
--rec-print # (If the Recorder is enabled, prints output after tests end.)
--disable-cookies # (Disable Cookies on websites. Pages might break!)
--disable-js # (Disable JavaScript on websites. Pages might break!)
--disable-csp # (Disable the Content Security Policy of websites.)
--disable-ws # (Disable Web Security on Chromium-based browsers.)
--enable-ws # (Enable Web Security on Chromium-based browsers.)
--enable-sync # (Enable "Chrome Sync" on websites.)
--uc | --undetected # (Use undetected-chromedriver to evade bot-detection.)
--uc-cdp-events # (Capture CDP events when running in "--undetected" mode.)
--log-cdp # ("goog:loggingPrefs", {"performance": "ALL", "browser": "ALL"})
--remote-debug # (Sync to Chrome Remote Debugger chrome://inspect/#devices)
--ftrace | --final-trace # (Debug Mode after each test. Don't use with CI!)
--dashboard # (Enable the SeleniumBase Dashboard. Saved at: dashboard.html)
--dash-title=STRING # (Set the title shown for the generated dashboard.)
--enable-3d-apis # (Enables WebGL and 3D APIs.)
--swiftshader # (Chrome "--use-gl=angle" / "--use-angle=swiftshader-webgl")
--incognito # (Enable Chrome's Incognito mode.)
--guest # (Enable Chrome's Guest mode.)
--dark # (Enable Chrome's Dark mode.)
--devtools # (Open Chrome's DevTools when the browser opens.)
--rs | --reuse-session # (Reuse browser session for all tests.)
--rcs | --reuse-class-session # (Reuse session for tests in class.)
--crumbs # (Delete all cookies between tests reusing a session.)
--disable-beforeunload # (Disable the "beforeunload" event on Chrome.)
--window-position=X,Y # (Set the browser's starting window position.)
--window-size=WIDTH,HEIGHT # (Set the browser's starting window size.)
--maximize # (Start tests with the browser window maximized.)
--screenshot # (Save a screenshot at the end of each test.)
--no-screenshot # (No screenshots saved unless tests directly ask it.)
--visual-baseline # (Set the visual baseline for Visual/Layout tests.)
--wire # (Use selenium-wire's webdriver for replacing selenium webdriver.)
--external-pdf # (Set Chromium "plugins.always_open_pdf_externally":True.)
--timeout-multiplier=MULTIPLIER # (Multiplies the default timeout values.)
--list-fail-page # (After each failing test, list the URL of the failure.)(Veja a lista completa de definições de opções de linha de comando aqui . Para exemplos detalhados de opções de linha de comando, consulte customizing_test_runs.md )
? Durante falhas de teste, os logs e capturas de tela da execução de teste mais recente serão salvos na pasta latest_logs/ . Esses logs serão movidos para archived_logs/ se você adicionar --archive_logs às opções de linha de comando ou tiver ARCHIVE_EXISTING_LOGS definido como True em settings.py, caso contrário, os arquivos de log serão limpos no início da próxima execução de teste. A coleção test_suite.py contém testes que falham propositalmente para que você possa ver como o log funciona.
cd examples/
pytest test_suite.py --chrome
pytest test_suite.py --firefox Uma maneira fácil de substituir seleniumbase/config/settings.py é usar um arquivo de configurações personalizado. Aqui está a opção de linha de comando para adicionar aos testes: (Veja exemplos/custom_settings.py) --settings_file=custom_settings.py (As configurações incluem valores de tempo limite padrão, uma chave de autenticação de dois fatores, credenciais de banco de dados, credenciais S3 e outras configurações importantes usado por testes.)
? Para passar dados adicionais da linha de comando para testes, adicione --data="ANY STRING" . Dentro dos seus testes, você pode usar self.data para acessar isso.
? Ao executar testes com pytest , você desejará uma cópia de pytest.ini em suas pastas raiz. Ao executar testes com pynose , você desejará uma cópia de setup.cfg em suas pastas raiz. Esses arquivos especificam detalhes de configuração padrão para testes. As pastas de teste também devem incluir um arquivo init .py em branco para permitir que seus arquivos de teste importem outros arquivos dessa pasta.
? sbase mkdir DIR cria uma pasta com arquivos de configuração e testes de amostra:
sbase mkdir ui_testsEssa nova pasta terá estes arquivos:
ui_tests/
├── __init__.py
├── my_first_test.py
├── parameterized_test.py
├── pytest.ini
├── requirements.txt
├── setup.cfg
├── test_demo_site.py
└── boilerplates/
├── __init__.py
├── base_test_case.py
├── boilerplate_test.py
├── classic_obj_test.py
├── page_objects.py
├── sb_fixture_test.py
└── samples/
├── __init__.py
├── google_objects.py
├── google_test.py
├── sb_swag_test.py
└── swag_labs_test.py ProTip™: Você também pode criar uma pasta padrão sem nenhum teste de amostra adicionando -b ou --basic ao comando sbase mkdir :
sbase mkdir ui_tests --basicEssa nova pasta terá estes arquivos:
ui_tests/
├── __init__.py
├── pytest.ini
├── requirements.txt
└── setup.cfg Desses arquivos, o arquivo de configuração pytest.ini é o mais importante, seguido por um arquivo __init__.py em branco. Há também um arquivo setup.cfg (para pynose). Finalmente, o arquivo requirements.txt pode ser usado para ajudá-lo a instalar o seleniumbase em seus ambientes (se ainda não estiver instalado).
Vamos tentar um exemplo de teste que falha:
""" test_fail.py """
from seleniumbase import BaseCase
BaseCase . main ( __name__ , __file__ )
class MyTestClass ( BaseCase ):
def test_find_army_of_robots_on_xkcd_desert_island ( self ):
self . open ( "https://xkcd.com/731/" )
self . assert_element ( "div#ARMY_OF_ROBOTS" , timeout = 1 ) # This should fail Você pode executá-lo a partir da pasta examples/ assim:
pytest test_fail.py ? Você notará que uma pasta de logs, "latest_logs", foi criada para armazenar informações sobre o teste com falha e capturas de tela. Durante as execuções de teste, os resultados anteriores são movidos para a pasta archived_logs se você tiver ARCHIVE_EXISTING_LOGS definido como True em settings.py ou se sua execução for testada com --archive-logs . Se você optar por não arquivar os logs existentes, eles serão excluídos e substituídos pelos logs da última execução de teste.
? A opção --dashboard para pytest gera um painel SeleniumBase localizado em dashboard.html , que é atualizado automaticamente conforme os testes são executados e produzem resultados. Exemplo:
pytest --dashboard --rs --headless ? Além disso, você pode hospedar seu próprio SeleniumBase Dashboard Server em uma porta de sua escolha. Aqui está um exemplo disso usando http.server do Python:
python -m http.server 1948 ? Agora você pode navegar até http://localhost:1948/dashboard.html para visualizar o painel como um aplicativo da web. Isso requer duas janelas de terminal diferentes: uma para executar o servidor e outra para executar os testes, que devem ser executados no mesmo diretório. (Use Ctrl+C para parar o servidor http.)
? Aqui está um exemplo completo da aparência do painel SeleniumBase:
pytest test_suite.py test_image_saving.py --dashboard --rs --headlesspytest : ✅ Usar --html=report.html fornece um relatório sofisticado com o nome especificado após a conclusão do conjunto de testes.
pytest test_suite.py --html=report.html ✅ Ao combinar relatórios HTML pytest com o uso do SeleniumBase Dashboard, o gráfico de pizza do Dashboard será adicionado ao relatório HTML. Além disso, se você definir o URL do relatório HTML como igual ao URL do painel ao usar o painel (exemplo: --dashboard --html=dashboard.html ), o Painel se tornará um relatório HTML avançado quando todos os testes concluídos.
✅ Aqui está um exemplo de relatório HTML atualizado:
pytest test_suite.py --dashboard --html=report.htmlSe estiver visualizando relatórios pytest HTML no Jenkins, pode ser necessário definir as configurações do Jenkins para que o HTML seja renderizado corretamente. Isso se deve às alterações do Jenkins CSP.
Você também pode usar --junit-xml=report.xml para obter um relatório xml. Jenkins pode usar esse arquivo para exibir melhores relatórios para seus testes.
pytest test_suite.py --junit-xml=report.xmlpynose : A opção --report fornece um relatório sofisticado após a conclusão do conjunto de testes.
pynose test_suite.py --report (NOTA: Você pode adicionar --show-report para exibir imediatamente relatórios pynose após a conclusão do conjunto de testes. Use --show-report apenas ao executar testes localmente porque ele pausa a execução do teste.)
behave Painel e Relatórios:(A pasta behavior_bdd/ pode ser encontrada na pasta samples/.)
behave behave_bdd/features/ -D dashboard -D headless Você também pode usar --junit para obter relatórios .xml para cada recurso behave . Jenkins pode usar esses arquivos para exibir melhores relatórios para seus testes.
behave behave_bdd/features/ --junit -D rs -D headlessVeja: https://allurereport.org/docs/pytest/
SeleniumBase não inclui mais allure-pytest como parte das dependências instaladas. Se você quiser usá-lo, instale-o primeiro:
pip install allure-pytestAgora seus testes podem criar arquivos de resultados do Allure, que podem ser processados pelo Allure Reports.
pytest test_suite.py --alluredir=allure_results Se desejar usar um servidor proxy para testes de navegador (Chromium ou Firefox), você pode adicionar --proxy=IP_ADDRESS:PORT como argumento na linha de comando.
pytest proxy_test.py --proxy=IP_ADDRESS:PORTSe o servidor proxy que você deseja usar exigir autenticação, você poderá fazer o seguinte (somente Chromium):
pytest proxy_test.py --proxy=USERNAME:PASSWORD@IP_ADDRESS:PORTSeleniumBase também suporta proxies SOCKS4 e SOCKS5:
pytest proxy_test.py --proxy= " socks4://IP_ADDRESS:PORT "
pytest proxy_test.py --proxy= " socks5://IP_ADDRESS:PORT " Para facilitar as coisas, você pode adicionar seus proxies usados com frequência a PROXY_LIST em proxy_list.py e, em seguida, usar --proxy=KEY_FROM_PROXY_LIST para usar o IP_ADDRESS:PORT dessa chave.
pytest proxy_test.py --proxy=proxy1 ? Se desejar alterar o User-Agent para os testes do seu navegador (somente Chromium e Firefox), você pode adicionar --agent="USER AGENT STRING" como argumento na linha de comando.
pytest user_agent_test.py --agent= " Mozilla/5.0 (Nintendo 3DS; U; ; en) Version/1.7412.EU " ? self.accept_alert() espera e aceita automaticamente pop-ups de alerta. self.dismiss_alert() espera e descarta automaticamente pop-ups de alerta. Ocasionalmente, alguns métodos como self.click(SELECTOR) podem descartar um pop-up por conta própria porque chamam JavaScript para garantir que o readyState da página esteja complete antes de avançar. Se você estiver tentando aceitar um pop-up que foi descartado dessa forma, use esta solução alternativa: em vez disso, chame self.find_element(SELECTOR).click() (o que permitirá que o pop-up permaneça na tela) e, em seguida, use self.accept_alert() para aceitar o pop-up (mais sobre isso aqui). Se os pop-ups forem intermitentes, envolva o código em um bloco try/except.
? Aprenda sobre os tutoriais interativos do SeleniumBase (na pasta examples/tour_examples/ ). É ótimo para criar um protótipo de experiência de integração de um site.
--with-s3-logging na linha de comando ao executar seus testes.Aqui está um exemplo de execução de testes com alguns recursos adicionais habilitados:
pytest [YOUR_TEST_FILE.py] --with-db-reporting --with-s3-logging? Navegando para uma página da web: (e comandos relacionados)
self . open ( "https://xkcd.com/378/" ) # This method opens the specified page.
self . go_back () # This method navigates the browser to the previous page.
self . go_forward () # This method navigates the browser forward in history.
self . refresh_page () # This method reloads the current page.
self . get_current_url () # This method returns the current page URL.
self . get_page_source () # This method returns the current page source. ProTip™: Você pode usar o método self.get_page_source() com o comando find() do Python para analisar HTML e encontrar algo específico. (Para uma análise mais avançada, consulte o exemplo BeautifulSoup.)
source = self . get_page_source ()
head_open_tag = source . find ( '<head>' )
head_close_tag = source . find ( '</head>' , head_open_tag )
everything_inside_head = source [ head_open_tag + len ( '<head>' ): head_close_tag ]? Clicando:
Para clicar em um elemento da página:
self . click ( "div#my_id" ) ProTip™: Na maioria dos navegadores da web, você pode clicar com o botão direito em uma página e selecionar Inspect Element para ver os detalhes do seletor CSS necessários para criar seus próprios scripts.
? Digitando Texto:
self.type(selector, text) # atualiza o texto do elemento especificado com o valor especificado. Uma exceção será gerada se o elemento estiver faltando ou se o campo de texto não for editável. Exemplo:
self . type ( "input#id_value" , "2012" ) Você também pode usar self.add_text() ou o comando WebDriver .send_keys() , mas eles não limparão a caixa de texto primeiro se já houver texto dentro.
? Obtendo o texto de um elemento em uma página:
text = self . get_text ( "header h2" )? Obtendo o valor do atributo de um elemento em uma página:
attribute = self . get_attribute ( "#comic img" , "title" )? Afirmar a existência de um elemento em uma página em alguns segundos:
self . wait_for_element_present ( "div.my_class" , timeout = 10 ) (NOTA: Você também pode usar: self.assert_element_present(ELEMENT) )
? Afirmar a visibilidade de um elemento em uma página em alguns segundos:
self . wait_for_element_visible ( "a.my_class" , timeout = 5 ) (NOTA: As versões curtas disso são self.find_element(ELEMENT) e self.assert_element(ELEMENT) . A versão find_element() retorna o elemento.)
Como a linha acima retorna o elemento, você pode combiná-lo com .click() conforme mostrado abaixo:
self . find_element ( "a.my_class" , timeout = 5 ). click ()
# But you're better off using the following statement, which does the same thing:
self . click ( "a.my_class" ) # DO IT THIS WAY! ProTip™: Você pode usar pontos para indicar nomes de classes (Ex: div.class_name ) como uma versão simplificada de div[class="class_name"] dentro de um seletor CSS.
Você também pode usar *= para procurar qualquer valor parcial em um seletor CSS conforme mostrado abaixo:
self . click ( 'a[name*="partial_name"]' )? Afirmar a visibilidade do texto dentro de um elemento em uma página em alguns segundos:
self . assert_text ( "Make it so!" , "div#trek div.picard div.quotes" )
self . assert_text ( "Tea. Earl Grey. Hot." , "div#trek div.picard div.quotes" , timeout = 3 ) (NOTA: self.find_text(TEXT, ELEMENT) e self.wait_for_text(TEXT, ELEMENT) também fazem isso. Para compatibilidade com versões anteriores, os nomes dos métodos mais antigos foram mantidos, mas o tempo limite padrão pode ser diferente.)
? Afirmando qualquer coisa:
self . assert_true ( var1 == var2 )
self . assert_false ( var1 == var2 )
self . assert_equal ( var1 , var2 )? Declarações condicionais úteis: (com exemplos criativos)
❓ is_element_visible(selector): (visível na página)
if self . is_element_visible ( 'div#warning' ):
print ( "Red Alert: Something bad might be happening!" ) ❓ is_element_present(selector): (presente no HTML)
if self . is_element_present ( 'div#top_secret img.tracking_cookie' ):
self . contact_cookie_monster () # Not a real SeleniumBase method
else :
current_url = self . get_current_url ()
self . contact_the_nsa ( url = current_url , message = "Dark Zone Found" ) # Not a real SeleniumBase method def is_there_a_cloaked_klingon_ship_on_this_page ():
if self . is_element_present ( "div.ships div.klingon" ):
return not self . is_element_visible ( "div.ships div.klingon" )
return False ❓ is_text_visible(text, selector): (texto visível no elemento)
if self . is_text_visible ( "You Shall Not Pass!" , "h1" ):
self . open ( "https://www.youtube.com/watch?v=3xYXUeSmb-Y" )is_text_visible(): def get_mirror_universe_captain_picard_superbowl_ad ( superbowl_year ):
selector = "div.superbowl_%s div.commercials div.transcript div.picard" % superbowl_year
if self . is_text_visible ( "Yes, it was I who summoned you all here." , selector ):
return "Picard Paramount+ Superbowl Ad 2020"
elif self . is_text_visible ( "Commander, signal the following: Our Network is Secure!" ):
return "Picard Mirror Universe iboss Superbowl Ad 2018"
elif self . is_text_visible ( "For the Love of Marketing and Earl Grey Tea!" , selector ):
return "Picard Mirror Universe HubSpot Superbowl Ad 2015"
elif self . is_text_visible ( "Delivery Drones... Engage" , selector ):
return "Picard Mirror Universe Amazon Superbowl Ad 2015"
elif self . is_text_visible ( "Bing it on Screen!" , selector ):
return "Picard Mirror Universe Microsoft Superbowl Ad 2015"
elif self . is_text_visible ( "OK Glass, Make it So!" , selector ):
return "Picard Mirror Universe Google Superbowl Ad 2015"
elif self . is_text_visible ( "Number One, I've Never Seen Anything Like It." , selector ):
return "Picard Mirror Universe Tesla Superbowl Ad 2015"
elif self . is_text_visible ( "Let us make sure history never forgets the name ... Facebook" , selector ):
return "Picard Mirror Universe Facebook Superbowl Ad 2015"
elif self . is_text_visible ( """With the first link, the chain is forged.
The first speech censored, the first thought forbidden,
the first freedom denied, chains us all irrevocably.""" , selector ):
return "Picard Mirror Universe Wikimedia Superbowl Ad 2015"
else :
raise Exception ( "Reports of my assimilation are greatly exaggerated." ) ❓ is_link_text_visible(link_text):
if self . is_link_text_visible ( "Stop! Hammer time!" ):
self . click_link ( "Stop! Hammer time!" ) Se o seu teste abrir uma nova guia/janela, você poderá alternar para ela. (SeleniumBase muda automaticamente para novas guias que não abrem para URLs about:blank .)
self . switch_to_window ( 1 ) # This switches to the new tab (0 is the first one)? Os iframes seguem o mesmo princípio das novas janelas: você deve primeiro mudar para o iframe se quiser realizar ações nele:
self . switch_to_frame ( "iframe" )
# ... Now perform actions inside the iframe
self . switch_to_parent_frame () # Exit the current iframe Para sair de vários iframes, use self.switch_to_default_content() . (Se estiver dentro de um único iframe, terá o mesmo efeito que self.switch_to_parent_frame() .)
self . switch_to_frame ( 'iframe[name="frame1"]' )
self . switch_to_frame ( 'iframe[name="frame2"]' )
# ... Now perform actions inside the inner iframe
self . switch_to_default_content () # Back to the main page? Você também pode usar um gerenciador de contexto para atuar dentro de iframes:
with self . frame_switch ( "iframe" ):
# ... Now perform actions while inside the code block
# You have left the iframeIsso também funciona com iframes aninhados:
with self . frame_switch ( 'iframe[name="frame1"]' ):
with self . frame_switch ( 'iframe[name="frame2"]' ):
# ... Now perform actions while inside the code block
# You are now back inside the first iframe
# You have left all the iframesjQuery é uma poderosa biblioteca JavaScript que permite executar ações avançadas em um navegador da web. Se a página da web em que você está já tiver o jQuery carregado, você poderá começar a executar scripts jQuery imediatamente. Você saberia disso porque a página da web conteria algo como o seguinte no HTML:
< script src =" https://ajax.googleapis.com/ajax/libs/jquery/3.6.3/jquery.min.js " > </ script >? Não há problema se você quiser usar jQuery em uma página que ainda não está carregada. Para fazer isso, execute primeiro o seguinte comando:
self . activate_jquery () self . execute_script ( "jQuery, window.scrollTo(0, 600)" ) # Scrolling the page
self . execute_script ( "jQuery('#annoying-widget').hide()" ) # Hiding elements on a page
self . execute_script ( "jQuery('#hidden-widget').show(0)" ) # Showing hidden elements on a page
self . execute_script ( "jQuery('#annoying-button a').remove()" ) # Removing elements on a page
self . execute_script ( "jQuery('%s').mouseover()" % ( mouse_over_item )) # Mouse-over elements on a page
self . execute_script ( "jQuery('input#the_id').val('my_text')" ) # Fast text input on a page
self . execute_script ( "jQuery('div#dropdown a.link').click()" ) # Click elements on a page
self . execute_script ( "return jQuery('div#amazing')[0].text" ) # Returns the css "text" of the element given
self . execute_script ( "return jQuery('textarea')[2].value" ) # Returns the css "value" of the 3rd textarea element on the page(A maioria dos comandos acima pode ser executada diretamente com métodos SeleniumBase integrados.)
❗ Alguns sites possuem uma Política de Segurança de Conteúdo restritiva para evitar que os usuários carreguem jQuery e outras bibliotecas externas em seus sites. Se você precisar usar jQuery ou outra biblioteca JS nesses sites, adicione --disable-csp como uma opção de linha de comando pytest para carregar uma extensão do Chromium que ignora o CSP.
start_page = "https://xkcd.com/465/"
destination_page = "https://github.com/seleniumbase/SeleniumBase"
self . open ( start_page )
referral_link = '''<a class='analytics test' href='%s'>Free-Referral Button!</a>''' % destination_page
self . execute_script ( '''document.body.innerHTML = " %s " ''' % referral_link )
self . click ( "a.analytics" ) # Clicks the generated button (Devido à demanda popular, este exemplo de geração de tráfego foi incluído no SeleniumBase com os métodos self.generate_referral(start_page, end_page) e self.generate_traffic(start_page, end_page, loops) .)
Digamos que você queira verificar vários elementos diferentes em uma página da Web em um único teste, mas não deseja que o teste falhe até verificar vários elementos de uma vez, para não precisar executar novamente o teste para encontrar mais elementos ausentes. elementos na mesma página. É aí que entram as declarações diferidas. Aqui está um exemplo:
from seleniumbase import BaseCase
BaseCase . main ( __name__ , __file__ )
class DeferredAssertTests ( BaseCase ):
def test_deferred_asserts ( self ):
self . open ( "https://xkcd.com/993/" )
self . wait_for_element ( "#comic" )
self . deferred_assert_element ( 'img[alt="Brand Identity"]' )
self . deferred_assert_element ( 'img[alt="Rocket Ship"]' ) # Will Fail
self . deferred_assert_element ( "#comicmap" )
self . deferred_assert_text ( "Fake Item" , "ul.comicNav" ) # Will Fail
self . deferred_assert_text ( "Random" , "ul.comicNav" )
self . deferred_assert_element ( 'a[name="Super Fake !!!"]' ) # Will Fail
self . deferred_assert_exact_text ( "Brand Identity" , "#ctitle" )
self . deferred_assert_exact_text ( "Fake Food" , "#comic" ) # Will Fail
self . process_deferred_asserts () deferred_assert_element() e deferred_assert_text() salvarão quaisquer exceções que seriam levantadas. Para eliminar todas as declarações adiadas com falha em uma única exceção, certifique-se de chamar self.process_deferred_asserts() no final do seu método de teste. Se o seu teste atingir várias páginas, você poderá chamar self.process_deferred_asserts() antes de navegar para uma nova página para que a captura de tela dos seus arquivos de log corresponda ao URL onde as declarações adiadas foram feitas.
Se precisar de acesso a qualquer comando que vem com o WebDriver padrão, você pode chamá-los diretamente assim:
self . driver . delete_all_cookies ()
capabilities = self . driver . capabilities
self . driver . find_elements ( "partial link text" , "GitHub" )(Em geral, você desejará usar as versões dos métodos SeleniumBase, quando disponíveis.)
Você pode usar pytest --reruns=NUM para tentar novamente testes com falha muitas vezes. Adicione --reruns-delay=SECONDS para esperar tantos segundos entre novas tentativas. Exemplo:
pytest --reruns=1 --reruns-delay=1 Você pode usar o decorador @retry_on_exception() para tentar novamente métodos com falha. (Primeira importação: from seleniumbase import decorators ). Para saber mais sobre os decoradores SeleniumBase, clique aqui.
"Capture bugs no controle de qualidade antes de implantar o código na produção!"
