SeleniumBase
4.33.7 - CDP Mode - Patch 17
Marco de automatización del navegador todo en uno:
Rastreo web / Pruebas / Raspado / Sigilo
Inicio | ? Características | ?️ Opciones | Ejemplos | ? Guiones | Móvil
API | ? Formatos | ? Grabadora | Panel de control | ? Lugares | Granja
?️ GUI | ? Página de prueba | ? Modo UC | ? Modo CDP | ? Gráficos | Red
?️ Cómo | ? Migrar | Planes de casos | ♻️ Plantilla | ? Híbrido | ? Visitas guiadas
? CI/CD | ?️ JSMgr | ? Traductor | Presentador | ? Diálogo | ?️ visuales
SeleniumBase es el conjunto de herramientas profesional para actividades de automatización web. Creado para probar sitios web, evitar CAPTCHA, mejorar la productividad, completar tareas y escalar su negocio.
Aprenda de más de 200 ejemplos en la carpeta SeleniumBase/examples/ .
? Tenga en cuenta que el modo UC SeleniumBase (modo sigiloso) tiene su propio archivo Léame.
? También tenga en cuenta que el modo CDP de Seleniumbase tiene su propio archivo Léame independiente.
Los scripts se pueden llamar a través de python , aunque algunos formatos de sintaxis esperan pytest (un marco de pruebas unitarias de Python incluido con SeleniumBase que puede descubrir, recopilar y ejecutar pruebas automáticamente).
? Aquí está my_first_test.py, que prueba el inicio de sesión, las compras y el pago:
pytest my_first_test.py
pytestusa--chromede forma predeterminada a menos que se configure de manera diferente.
? Aquí está test_coffee_cart.py, que verifica un sitio de comercio electrónico:
pytest test_coffee_cart.py --demo(
--demoralentiza las pruebas y resalta las acciones)
? Aquí está test_demo_site.py, que cubre varias acciones:
pytest test_demo_site.pyFácil de escribir, hacer clic, seleccionar, alternar, arrastrar y soltar, y más.
(Para obtener más ejemplos, consulte la carpeta SeleniumBase/examples/).
Explora el archivo LÉAME:
- Comenzar / Instalación
- Ejemplo básico/uso
- Métodos de prueba comunes
- Datos curiosos/Más información
- Modo de demostración/depuración
- Opciones de línea de comando
- Configuración del directorio
- Panel de control de SeleniumBase
- Generando informes de prueba
SeleniumBase es un marco de Python para pruebas y automatización de navegadores. SeleniumBase utiliza las API de Selenium/WebDriver e incorpora ejecutores de pruebas como pytest , pynose y behave para proporcionar una estructura organizada, descubrimiento de pruebas, ejecución de pruebas, estado de la prueba ( por ejemplo, aprobado, fallido u omitido ) y opciones de línea de comandos para cambiar. configuración predeterminada ( por ejemplo, selección del navegador ). Con Selenium sin formato, necesitaría configurar su propio analizador de opciones para configurar pruebas desde la línea de comandos.
El administrador de controladores de SeleniumBase le brinda más control sobre las descargas automáticas de controladores. (Utilice --driver-version=VER con su comando de ejecución pytest para especificar la versión). De forma predeterminada, SeleniumBase descargará una versión del controlador que coincida con la versión principal de su navegador si no está configurada.
SeleniumBase detecta automáticamente entre selectores CSS y XPath, lo que significa que no necesita especificar el tipo de selector en sus comandos ( pero opcionalmente puede hacerlo ).
Los métodos de SeleniumBase a menudo realizan múltiples acciones en una sola llamada al método. Por ejemplo, self.type(selector, text) hace lo siguiente:
1. Espera a que el elemento sea visible.
2. Espera a que el elemento sea interactivo.
3. Borra el campo de texto.
4. Escribe el nuevo texto.
5. Presiona Enter/Enviar si el texto termina en "n" .
Con Selenium sin formato, esas acciones requieren múltiples llamadas a métodos.
SeleniumBase usa valores de tiempo de espera predeterminados cuando no está configurado:
✅ self.click("button")
Con Selenium sin formato, los métodos fallarían instantáneamente ( de forma predeterminada ) si un elemento necesitara más tiempo para cargarse:
self.driver.find_element(by="css selector", value="button").click()
(El código confiable es mejor que el código no confiable).
SeleniumBase le permite cambiar los valores de tiempo de espera explícitos de los métodos:
✅ self.click("button", timeout=10)
Con Selenium sin formato, eso requiere más código:
WebDriverWait(driver, 10).until(EC.element_to_be_clickable("css selector", "button")).click()
(El código simple es mejor que el código complejo).
SeleniumBase le brinda una salida de error limpia cuando falla una prueba. Con Selenium sin formato, los mensajes de error pueden resultar muy complicados.
SeleniumBase le brinda la opción de generar un panel e informes para las pruebas. También guarda capturas de pantalla de pruebas fallidas en la carpeta ./latest_logs/ . Raw Selenium no tiene estas opciones listas para usar.
SeleniumBase incluye aplicaciones GUI de escritorio para ejecutar pruebas, como SeleniumBase Commander para pytest y SeleniumBase Behave GUI para behave .
SeleniumBase tiene su propio grabador/generador de pruebas para crear pruebas a partir de acciones manuales del navegador.
SeleniumBase viene con un software de gestión de casos de prueba ("CasePlans"), para organizar pruebas y descripciones de pasos.
SeleniumBase incluye herramientas para crear aplicaciones de datos ("ChartMaker"), que pueden generar JavaScript desde Python.
Conozca las diferentes formas de redactar exámenes:
Aquí está test_simple_login.py, que usa la herencia de clases BaseCase y se ejecuta con pytest o pynose. (Utilice self.driver para acceder driver sin formato de 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" ) ? Aquí hay una prueba de sb_fixture_tests.py, que utiliza el dispositivo sb pytest . Se ejecuta con pytest. (Utilice sb.driver para acceder driver sin formato de 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" ) ? Aquí está raw_login_sb.py, que utiliza SB Context Manager. Se ejecuta con python puro. (Utilice sb.driver para acceder driver sin formato de 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" ) ? Aquí está raw_login_context.py, que utiliza DriverContext Manager. Se ejecuta con python puro. (El driver es una versión mejorada del driver sin formato de Selenium, con más 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" ) ? Aquí está raw_login_driver.py, que utiliza el Administrador Driver . Se ejecuta con python puro. (El driver es una versión mejorada del driver sin formato de Selenium, con más 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 () Aquí está login_app.feature, que utiliza la sintaxis de comportarse-BDD Gherkin. Corre con behave . (Obtenga más información sobre la integración de comportamiento-BDD de SeleniumBase )
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" ? Agregue Python y Git a la RUTA de su sistema.
? Se recomienda utilizar un entorno virtual de Python.
Puede instalar seleniumbase desde PyPI o GitHub:
? Cómo instalar seleniumbase desde PyPI:
pip install seleniumbase--upgrade O -U para actualizar SeleniumBase).--force-reinstall para actualizar los paquetes indirectos).pip3 si hay varias versiones de Python). ? Cómo instalar seleniumbase desde un clon de GitHub:
git clone https://github.com/seleniumbase/SeleniumBase.git
cd SeleniumBase/
pip install -e .? Cómo actualizar una instalación existente desde un clon de GitHub:
git pull
pip install -e . ? Escriba seleniumbase o sbase para verificar que SeleniumBase se haya instalado correctamente:
___ _ _ ___
/ __ | ___ | | ___ _ _ (_)_ _ _ __ | _ ) __ _ ______
_ _ / -_) / -_) ' | | | | ' | _ / _ ` (_- < -_)
| ___/ _ __ | _ _ __ | _ || _ | _ | _ ,_ | _ | _ | _ | ___/ _ _,_/__ | ___ |
----------------------------------------------------
╭──────────────────────────────────────────────────╮
│ * 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 descarga automáticamente los controladores web según sea necesario, 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 ! ? Si ha clonado SeleniumBase, puede ejecutar pruebas desde la carpeta ejemplos/.
Aquí está my_first_test.py:
cd examples/
pytest my_first_test.pyAquí está el 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 obtener la lista completa de métodos de SeleniumBase, consulte: Resumen de métodos
✅ SeleniumBase maneja automáticamente acciones comunes de WebDriver, como iniciar navegadores web antes de las pruebas, guardar capturas de pantalla durante fallas y cerrar navegadores web después de las pruebas.
✅ SeleniumBase te permite personalizar las pruebas mediante opciones de línea de comandos.
✅ SeleniumBase utiliza una sintaxis simple para los comandos. Ejemplo:
self . type ( "input" , "dogs n " ) # (The "n" presses ENTER) La mayoría de los scripts de SeleniumBase se pueden ejecutar con pytest , pynose o pure python . No todos los ejecutores de pruebas pueden ejecutar todos los formatos de prueba. Por ejemplo, las pruebas que utilizan el dispositivo sb pytest solo se pueden ejecutar con pytest . (Ver Formatos de sintaxis) También hay un formato de prueba Gherkin que se ejecuta con comportamiento.
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 incluye descubrimiento automático de pruebas. Si no especifica un archivo o carpeta específica para ejecutar, pytest buscará automáticamente en todos los subdirectorios pruebas para ejecutar según los siguientes criterios:
test_ o terminan con _test.py .test_ . Con un archivo SeleniumBase pytest.ini presente, puede modificar la configuración de descubrimiento predeterminada. El nombre de la clase Python puede ser cualquier cosa porque seleniumbase.BaseCase hereda unittest.TestCase para activar el descubrimiento automático.
✅ Puede realizar una verificación previa al vuelo para ver qué pruebas descubriría pytest antes de la ejecución real:
pytest --co -q ✅ Puedes ser más específico al llamar pytest o pynose en un archivo:
pytest [FILE_NAME.py]::[CLASS_NAME]::[METHOD_NAME]
pynose [FILE_NAME.py]:[CLASS_NAME].[METHOD_NAME] ✅ ¡No más pruebas inestables! Los métodos de SeleniumBase esperan automáticamente a que los elementos de la página terminen de cargarse antes de interactuar con ellos ( hasta un límite de tiempo de espera ). Esto significa que ya no necesita declaraciones aleatorias time.sleep() en sus scripts.
✅ SeleniumBase es compatible con todos los principales navegadores y sistemas operativos:
Navegadores: Chrome, Edge, Firefox y Safari.
Sistemas: Linux/Ubuntu, macOS y Windows.
✅ SeleniumBase funciona en todas las plataformas CI/CD populares:
✅ SeleniumBase incluye una solución híbrida automatizada/manual llamada MasterQA para acelerar las pruebas manuales con automatización mientras los probadores manuales se encargan de la validación.
✅ SeleniumBase admite la ejecución de pruebas sin conexión ( suponiendo que los controladores web se hayan descargado previamente cuando se está en línea ).
✅ Para obtener una lista completa de las funciones de SeleniumBase, haga clic aquí.
? El modo de demostración le ayuda a ver lo que está haciendo una prueba. Si una prueba avanza demasiado rápido para sus ojos, ejecútela en modo de demostración para pausar brevemente el navegador entre acciones, resaltar los elementos de la página sobre los que se actúa y mostrar aserciones:
pytest my_first_test.py --demo ? time.sleep(seconds) se puede utilizar para hacer que una prueba espere en un lugar específico:
import time ; time . sleep ( 3 ) # Do nothing for 3 seconds.? El modo de depuración con la biblioteca pdb incorporada de Python le ayuda a depurar pruebas:
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 una prueba activa que arroja una excepción o error ( y mantener abierta la ventana del navegador mientras comienza el modo de depuración en la consola ), agregue --pdb como una opción pytest :
pytest test_fail.py --pdb ? Para iniciar pruebas en modo de depuración, agregue --trace como opción pytest :
pytest test_coffee_cart.py --trace ✅ Aquí hay algunas opciones útiles de línea de comandos que vienen con 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 proporciona opciones adicionales de línea de comandos pytest para pruebas:
--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.)(Consulte la lista completa de definiciones de opciones de línea de comandos aquí . Para obtener ejemplos detallados de opciones de línea de comandos, consulte customizing_test_runs.md ).
? Durante las fallas de las pruebas, los registros y las capturas de pantalla de la ejecución de la prueba más reciente se guardarán en la carpeta latest_logs/ . Esos registros se moverán a archived_logs/ si agrega --archive_logs a las opciones de la línea de comandos, o si tiene ARCHIVE_EXISTING_LOGS configurado en True en settings.py; de lo contrario, los archivos de registro se limpiarán al inicio de la siguiente ejecución de prueba. La colección test_suite.py contiene pruebas que fallan intencionalmente para que puedas ver cómo funciona el registro.
cd examples/
pytest test_suite.py --chrome
pytest test_suite.py --firefox Una forma sencilla de anular seleniumbase/config/settings.py es mediante el uso de un archivo de configuración personalizado. Aquí está la opción de línea de comandos para agregar a las pruebas: (Ver ejemplos/custom_settings.py) --settings_file=custom_settings.py (Las configuraciones incluyen valores de tiempo de espera predeterminados, una clave de autenticación de dos factores, credenciales de base de datos, credenciales de S3 y otras configuraciones importantes utilizado por las pruebas.)
? Para pasar datos adicionales desde la línea de comandos a las pruebas, agregue --data="ANY STRING" . Dentro de tus pruebas, puedes usar self.data para acceder a ellas.
? Cuando ejecute pruebas con pytest , querrá una copia de pytest.ini en sus carpetas raíz. Cuando ejecute pruebas con pynose , querrá una copia de setup.cfg en sus carpetas raíz. Estos archivos especifican detalles de configuración predeterminados para las pruebas. Las carpetas de prueba también deben incluir un archivo init .py en blanco para permitir que sus archivos de prueba importen otros archivos desde esa carpeta.
? sbase mkdir DIR crea una carpeta con archivos de configuración y pruebas de muestra:
sbase mkdir ui_testsEsa nueva carpeta tendrá estos archivos:
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™: También puede crear una carpeta repetitiva sin pruebas de muestra agregando -b o --basic al comando sbase mkdir :
sbase mkdir ui_tests --basicEsa nueva carpeta tendrá estos archivos:
ui_tests/
├── __init__.py
├── pytest.ini
├── requirements.txt
└── setup.cfg De esos archivos, el archivo de configuración pytest.ini es el más importante, seguido de un archivo __init__.py en blanco. También hay un archivo setup.cfg (para pynose). Finalmente, el archivo requirements.txt se puede utilizar para ayudarle a instalar seleniumbase en sus entornos (si aún no está instalado).
Probemos un ejemplo de una prueba que falla:
""" 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 Puedes ejecutarlo desde la carpeta examples/ así:
pytest test_fail.py ? Notará que se creó una carpeta de registros, "latest_logs", para contener información sobre la prueba fallida y capturas de pantalla. Durante las ejecuciones de prueba, los resultados anteriores se mueven a la carpeta archived_logs si tiene ARCHIVE_EXISTING_LOGS configurado en True en settings.py, o si su ejecución prueba con --archive-logs . Si elige no archivar los registros existentes, se eliminarán y reemplazarán por los registros de la última ejecución de prueba.
? La opción --dashboard para pytest genera un panel de SeleniumBase ubicado en dashboard.html , que se actualiza automáticamente a medida que se ejecutan las pruebas y producen resultados. Ejemplo:
pytest --dashboard --rs --headless ? Además, puede alojar su propio SeleniumBase Dashboard Server en el puerto que elija. Aquí hay un ejemplo de eso usando http.server de Python:
python -m http.server 1948 ? Ahora puede navegar a http://localhost:1948/dashboard.html para ver el panel como una aplicación web. Esto requiere dos ventanas de terminal diferentes: una para ejecutar el servidor y otra para ejecutar las pruebas, que deben ejecutarse desde el mismo directorio. (Utilice Ctrl+C para detener el servidor http).
? Aquí hay un ejemplo completo de cómo se vería el panel de SeleniumBase:
pytest test_suite.py test_image_saving.py --dashboard --rs --headlesspytest : ✅ El uso de --html=report.html le brinda un informe elegante del nombre especificado una vez que se completa su conjunto de pruebas.
pytest test_suite.py --html=report.html ✅ Al combinar informes html de pytest con el uso del Panel de SeleniumBase, el gráfico circular del Panel se agregará al informe html. Además, si configura la URL del informe HTML para que sea la misma que la URL del Panel cuando también utiliza el Panel (ejemplo: --dashboard --html=dashboard.html ), el Panel se convertirá en un informe HTML avanzado cuando todos los pruebas completas.
✅ Aquí hay un ejemplo de un informe html actualizado:
pytest test_suite.py --dashboard --html=report.htmlSi visualiza informes html de pytest en Jenkins, es posible que deba configurar los ajustes de Jenkins para que el html se represente correctamente. Esto se debe a los cambios del CSP de Jenkins.
También puedes usar --junit-xml=report.xml para obtener un informe xml. Jenkins puede usar este archivo para mostrar mejores informes para sus pruebas.
pytest test_suite.py --junit-xml=report.xmlpynose : La opción --report le brinda un informe elegante una vez que se completa su conjunto de pruebas.
pynose test_suite.py --report (NOTA: puede agregar --show-report para mostrar inmediatamente los informes de pynose después de que se complete el conjunto de pruebas. Utilice --show-report solo cuando ejecute pruebas localmente porque detiene la ejecución de la prueba).
behave Panel e informes:(La carpeta comportarse_bdd/ se puede encontrar en la carpeta ejemplos/.)
behave behave_bdd/features/ -D dashboard -D headless También puede utilizar --junit para obtener informes .xml para cada característica behave . Jenkins puede usar estos archivos para mostrar mejores informes para sus pruebas.
behave behave_bdd/features/ --junit -D rs -D headlessVer: https://allurereport.org/docs/pytest/
SeleniumBase ya no incluye allure-pytest como parte de las dependencias instaladas. Si quieres usarlo, instálalo primero:
pip install allure-pytestAhora sus pruebas pueden crear archivos de resultados de Allure, que pueden ser procesados por Allure Reports.
pytest test_suite.py --alluredir=allure_results Si desea utilizar un servidor proxy para las pruebas de su navegador (Chromium o Firefox), puede agregar --proxy=IP_ADDRESS:PORT como argumento en la línea de comando.
pytest proxy_test.py --proxy=IP_ADDRESS:PORTSi el servidor proxy que desea utilizar requiere autenticación, puede hacer lo siguiente (solo Chromium):
pytest proxy_test.py --proxy=USERNAME:PASSWORD@IP_ADDRESS:PORTSeleniumBase también admite proxies SOCKS4 y SOCKS5:
pytest proxy_test.py --proxy= " socks4://IP_ADDRESS:PORT "
pytest proxy_test.py --proxy= " socks5://IP_ADDRESS:PORT " Para facilitar las cosas, puede agregar sus servidores proxy de uso frecuente a PROXY_LIST en proxy_list.py y luego usar --proxy=KEY_FROM_PROXY_LIST para usar IP_ADDRESS:PORT de esa clave.
pytest proxy_test.py --proxy=proxy1 ? Si desea cambiar el User-Agent para las pruebas de su navegador (solo Chromium y Firefox), puede agregar --agent="USER AGENT STRING" como argumento en la línea de comandos.
pytest user_agent_test.py --agent= " Mozilla/5.0 (Nintendo 3DS; U; ; en) Version/1.7412.EU " ? self.accept_alert() espera y acepta automáticamente ventanas emergentes de alerta. self.dismiss_alert() espera y descarta automáticamente las ventanas emergentes de alerta. En ocasiones, algunos métodos como self.click(SELECTOR) pueden descartar una ventana emergente por sí solos porque llaman a JavaScript para asegurarse de que el readyState de la página esté complete antes de avanzar. Si está intentando aceptar una ventana emergente que se descartó de esta manera, utilice esta solución alternativa: llame self.find_element(SELECTOR).click() en su lugar (lo que permitirá que la ventana emergente permanezca en la pantalla) y luego use self.accept_alert() para aceptar la ventana emergente (más sobre eso aquí). Si las ventanas emergentes son intermitentes, incluya el código en un bloque try/except.
? Obtenga más información sobre los tutoriales interactivos de SeleniumBase (en la carpeta examples/tour_examples/ ). Es excelente para crear prototipos de una experiencia de incorporación de sitios web.
--with-s3-logging en la línea de comandos cuando ejecute sus pruebas.A continuación se muestra un ejemplo de ejecución de pruebas con algunas funciones adicionales habilitadas:
pytest [YOUR_TEST_FILE.py] --with-db-reporting --with-s3-logging? Navegar a una página web: (y 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™: Puede utilizar el método self.get_page_source() con el comando find() de Python para analizar HTML y encontrar algo específico. (Para un análisis más avanzado, consulte el ejemplo de 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 ]? Haciendo clic:
Para hacer clic en un elemento de la página:
self . click ( "div#my_id" ) ProTip™: en la mayoría de los navegadores web, puede hacer clic derecho en una página y seleccionar Inspect Element para ver los detalles del selector CSS que necesitará para crear sus propios scripts.
? Escribir texto:
self.type(selector, text) # actualiza el texto del elemento especificado con el valor especificado. Se genera una excepción si falta el elemento o si el campo de texto no es editable. Ejemplo:
self . type ( "input#id_value" , "2012" ) También puede usar self.add_text() o el comando WebDriver .send_keys() , pero no borrarán el cuadro de texto primero si ya hay texto dentro.
? Obtener el texto de un elemento en una página:
text = self . get_text ( "header h2" )? Obtener el valor del atributo de un elemento en una página:
attribute = self . get_attribute ( "#comic img" , "title" )? Afirmar la existencia de un elemento en una página dentro de una cierta cantidad de segundos:
self . wait_for_element_present ( "div.my_class" , timeout = 10 ) (NOTA: También puedes usar: self.assert_element_present(ELEMENT) )
? Afirmar la visibilidad de un elemento en una página dentro de una cierta cantidad de segundos:
self . wait_for_element_visible ( "a.my_class" , timeout = 5 ) (NOTA: Las versiones cortas de eso son self.find_element(ELEMENT) y self.assert_element(ELEMENT) . La versión find_element() devuelve el elemento).
Dado que la línea anterior devuelve el elemento, puede combinarlo con .click() como se muestra a continuación:
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™: Puede utilizar puntos para indicar nombres de clases (por ejemplo, div.class_name ) como una versión simplificada de div[class="class_name"] dentro de un selector CSS.
También puedes usar *= para buscar cualquier valor parcial en un selector CSS como se muestra a continuación:
self . click ( 'a[name*="partial_name"]' )? Afirmar la visibilidad del texto dentro de un elemento en una página dentro de una cierta cantidad de 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) y self.wait_for_text(TEXT, ELEMENT) también hacen esto. Para compatibilidad con versiones anteriores, se mantuvieron los nombres de métodos más antiguos, pero el tiempo de espera predeterminado puede ser diferente).
? Afirmar cualquier cosa:
self . assert_true ( var1 == var2 )
self . assert_false ( var1 == var2 )
self . assert_equal ( var1 , var2 )? Declaraciones condicionales útiles: (con ejemplos creativos)
❓ is_element_visible(selector): (visible en la página)
if self . is_element_visible ( 'div#warning' ):
print ( "Red Alert: Something bad might be happening!" ) ❓ is_element_present(selector): (presente en el 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 visible en el 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!" ) Si su prueba abre una nueva pestaña/ventana, puede cambiar a ella. (SeleniumBase cambia automáticamente a pestañas nuevas que no se abren en direcciones URL about:blank ).
self . switch_to_window ( 1 ) # This switches to the new tab (0 is the first one)? Los iframes siguen el mismo principio que las ventanas nuevas: primero debes cambiar al iframe si quieres realizar acciones allí:
self . switch_to_frame ( "iframe" )
# ... Now perform actions inside the iframe
self . switch_to_parent_frame () # Exit the current iframe Para salir de múltiples iframes, use self.switch_to_default_content() . (Si está dentro de un solo iframe, esto tiene el mismo efecto 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? También puedes utilizar un administrador de contexto para actuar dentro de iframes:
with self . frame_switch ( "iframe" ):
# ... Now perform actions while inside the code block
# You have left the iframeEsto también funciona con iframes anidados:
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 es una poderosa biblioteca de JavaScript que le permite realizar acciones avanzadas en un navegador web. Si la página web en la que te encuentras ya tiene jQuery cargado, puedes comenzar a ejecutar scripts jQuery inmediatamente. Lo sabrías porque la página web contendría algo como lo siguiente en el HTML:
< script src =" https://ajax.googleapis.com/ajax/libs/jquery/3.6.3/jquery.min.js " > </ script >? Está bien si deseas utilizar jQuery en una página que aún no lo tiene cargado. Para hacerlo, ejecute primero el siguiente 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(La mayoría de los comandos anteriores se pueden realizar directamente con los métodos integrados de SeleniumBase).
❗ Algunos sitios web tienen una Política de seguridad de contenido restrictiva para evitar que los usuarios carguen jQuery y otras bibliotecas externas en sus sitios web. Si necesita usar jQuery u otra biblioteca JS en esos sitios web, agregue --disable-csp como una opción de línea de comandos pytest para cargar una extensión de Chromium que omita el 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 (Debido a la demanda popular, este ejemplo de generación de tráfico se ha incluido en SeleniumBase con los métodos self.generate_referral(start_page, end_page) y self.generate_traffic(start_page, end_page, loops) .)
Supongamos que desea verificar varios elementos diferentes en una página web en una sola prueba, pero no quiere que la prueba falle hasta que haya verificado varios elementos a la vez para no tener que volver a ejecutar la prueba para encontrar más elementos faltantes. elementos en la misma página. Ahí es donde entran en juego las afirmaciones diferidas. Aquí hay un ejemplo:
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() y deferred_assert_text() guardarán cualquier excepción que se genere. Para eliminar todas las afirmaciones diferidas fallidas en una sola excepción, asegúrese de llamar self.process_deferred_asserts() al final de su método de prueba. Si su prueba llega a varias páginas, puede llamar a self.process_deferred_asserts() antes de navegar a una nueva página para que la captura de pantalla de sus archivos de registro coincida con la URL donde se realizaron las afirmaciones diferidas.
Si necesita acceso a algún comando que viene con WebDriver estándar, puede llamarlo directamente así:
self . driver . delete_all_cookies ()
capabilities = self . driver . capabilities
self . driver . find_elements ( "partial link text" , "GitHub" )(En general, querrás utilizar las versiones de métodos de SeleniumBase cuando estén disponibles).
Puede usar pytest --reruns=NUM para volver a intentar las pruebas fallidas tantas veces. Agregue --reruns-delay=SECONDS para esperar esa cantidad de segundos entre reintentos. Ejemplo:
pytest --reruns=1 --reruns-delay=1 Puede utilizar el decorador @retry_on_exception() para volver a intentar los métodos fallidos. (Primera importación: from seleniumbase import decorators ). Para obtener más información sobre los decoradores de SeleniumBase, haga clic aquí.
"¡Detecte errores en el control de calidad antes de implementar el código en producción!"
