selenio
Selenium
Selenium es un proyecto general que encapsula una variedad de herramientas y bibliotecas que permiten la automatización del navegador web. Selenium proporciona específicamente una infraestructura para la especificación W3C WebDriver: una plataforma y una interfaz de codificación de idioma neutro compatible con los principales navegadores web.
El proyecto es posible gracias a contribuyentes voluntarios que generosamente han donado miles de horas en desarrollo y mantenimiento de código.
El código fuente de Selenium está disponible bajo la licencia Apache 2.0.
Este README es para desarrolladores interesados en contribuir al proyecto. Para las personas que quieran comenzar a usar Selenium, consulte nuestro Manual del usuario para obtener ejemplos y descripciones detalladas y, si se queda atascado, hay varias formas de obtener ayuda.
Lea CONTRIBUTING.md antes de enviar sus solicitudes de extracción.
Estos son los requisitos para crear su propio entorno de desarrollo local para contribuir a Selenium.
Bazelisk, un contenedor de Bazel que descarga automáticamente la versión de Bazel especificada en el archivo .bazelversion y pasa de forma transparente todos los argumentos de la línea de comandos al binario real de Bazel.
Java JDK versión 17 o superior (por ejemplo, Java 17 Temurin)
Establezca la variable de entorno JAVA_HOME en la ubicación del ejecutable de Java (el JDK, no el JRE)
Para probar esto, intente ejecutar el comando javac . Este comando no existirá si solo tiene instalado el JRE. Si se encuentra con una lista de opciones de línea de comandos, está haciendo referencia al JDK correctamente.
Xcode, incluidas las herramientas de línea de comandos. Instale la última versión usando: xcode-select --install
Rosetta para Apple Silicon Mac. Agregue build --host_platform=//:rosetta al archivo .bazelrc.local . Estamos trabajando para asegurarnos de que esto no sea necesario a largo plazo.
Hace varios años, Jim Evans publicó un excelente artículo sobre Configuración de un entorno de desarrollo de Windows para enlaces de lenguaje Selenium .NET; Este artículo está desactualizado, pero incluye descripciones más detalladas y capturas de pantalla que algunas personas pueden resultar útiles.
Este script garantizará un entorno de desarrollador completo y listo para ejecutar. (No se instala ni configura nada que ya esté presente a menos que se indique lo contrario)
Abra Powershell como administrador
Ejecutar: Set-ExecutionPolicy Bypass -Scope Process -Force para permitir la ejecución del script en el proceso
Navegue hasta el directorio en el que desea clonar Selenium, o el directorio principal de un repositorio de Selenium ya clonado.
Descargue y ejecute este script en la terminal PowerShell: [scripts/dev-environment-setup.ps1]`
Permitir la ejecución de scripts en Selenium en general:
Set-ExecutionPolicy -ExecutionPolicy RemoteSigned
Habilitar el modo de desarrollador:
reg add "HKEY_LOCAL_MACHINESOFTWAREMicrosoftWindowsCurrentVersionAppModelUnlock" /t REG_DWORD /f /v "AllowDevelopmentWithoutDevLicense" /d "1"
Instale MSYS2, que es un entorno de shell alternativo que proporciona comandos similares a Unix.
Agregue el directorio bin a la variable de entorno PATH (por ejemplo, "C:toolsmsys64usrbin" )
Agregue la ubicación bash.exe como variable de entorno BAZEL_SH (por ejemplo, "C:toolsmsys64usrbinbash.exe" )
Instale la última versión de Visual Studio Community
Utilice el instalador de Visual Studio para modificar y agregar la carga de trabajo "Desarrollo de escritorio con C++"
Agregue la ubicación del directorio de instalación de las herramientas de compilación de Visual C++ a la variable de entorno BAZEL_VC (por ejemplo, "C:Program FilesMicrosoft Visual Studio2022CommunityVC" )
Agregue la versión de las herramientas de compilación de Visual C++ a la variable de entorno BAZEL_VC_FULL_VERSION (esto se puede descubrir en el nombre del directorio en "$BAZEL_VCToolsMSVC )
Agregue soporte para nombres de archivos largos (bazel tiene muchos directorios anidados que pueden exceder los límites predeterminados en Windows)
reg agregar "HKEY_LOCAL_MACHINESOFTWAREMicrosoftCommand Processor" /t REG_DWORD /f /v "DisableUNCCheck" /d "1"reg agregar "HKEY_LOCAL_MACHINESYSTEMCurrentControlSetControlFileSystem" /t REG_DWORD /f /v "LongPathsEnabled" /d "1"
Crea un archivo selenium/.bazelrc.windows.local
Agregue "startup --output_user_root=C:/tmp" al archivo
Permita que Bazel cree versiones con nombres cortos de rutas de archivos largas: fsutil 8dot3name set 0
Establezca la salida de Bazel en C:/tmp en lugar de anidarla dentro del directorio del proyecto:
Habilite la compatibilidad con Long Paths con estos 2 comandos de registro:
Si desea contribuir al proyecto, pero no desea configurar su propio entorno de desarrollo local, hay dos alternativas disponibles.
En lugar de crear su propio entorno de desarrollo local, GitPod le proporciona un entorno listo para usar.
Como alternativa, puede crear un contenedor de desarrollo, básicamente un contenedor acoplable, adecuado para compilar y probar Selenium utilizando devcontainer.json en el directorio .devcontainer. La compatibilidad con IDE como VS Code o IntelliJ IDEA debería indicarle cómo se puede crear dicho contenedor.
También puede crear una imagen de Docker adecuada para crear y probar Selenium utilizando Dockerfile en el directorio de imágenes de desarrollo.
Selenium se construye utilizando una herramienta de compilación común llamada Bazel, para permitirnos administrar fácilmente las descargas de dependencias, generar los archivos binarios necesarios, compilar y lanzar paquetes y ejecutar pruebas; todo de forma rápida y eficaz. Para una discusión más detallada, lea el artículo de Simon Stewart sobre Building Selenium
A menudo encapsulamos los comandos de Bazel con nuestro contenedor Rake personalizado. Estos se ejecutan con el comando ./go .
Los comandos comunes de Bazel son:
bazel build : evalúa dependencias, compila archivos fuente y genera archivos de salida para el destino especificado. Se utiliza para crear binarios ejecutables, bibliotecas u otros artefactos.
bazel run : construye el objetivo y luego lo ejecuta. Normalmente se utiliza para objetivos que producen archivos binarios ejecutables.
bazel test : construye y ejecuta el objetivo en un contexto con funcionalidad de prueba adicional
bazel query : identifica los objetivos disponibles para la ruta proporcionada.
Cada módulo que se puede construir se define en un archivo BUILD.bazel . Para ejecutar el módulo, haga referencia a él comenzando con // , luego incluya la ruta relativa al archivo que lo define, luego : luego el nombre del objetivo. Por ejemplo, el objetivo para construir Grid se llama executable-grid y se define en el archivo 'selenium/java/src/org/openqa/selenium/grid/BAZEL.build' . Entonces, para construir la cuadrícula, ejecutaría: bazel build //java/src/org/openqa/selenium/grid:executable-grid .
La documentación de Bazel tiene una guía útil para varios atajos y todas las formas de crear múltiples objetivos, que Selenium utiliza con frecuencia.
Para construir todo para un idioma determinado:
compilación de bazel ///...
Para construir solo la cuadrícula, hay un nombre de alias a usar (el registro mostrará dónde se encuentra el archivo jar de salida):
cuadrícula de construcción de bazel
Para simplificar las cosas, la creación de cada uno de los enlaces está disponible con este comando ./go
./go:compilar
La mayor parte del equipo utiliza Intellij para la edición diaria. Si está trabajando en IntelliJ, le recomendamos encarecidamente que instale el complemento Bazel IJ, que está documentado en su propio sitio.
Para usar Selenium con el complemento IntelliJ Bazel, importe el repositorio como un proyecto de Bazel y seleccione el archivo de vista del proyecto en el directorio de scripts. ij.bazelproject para Mac/Linux y ij-win.bazelproject para Windows.
También utilizamos Google Java Format para linting, por lo que es útil utilizar el complemento Google Java Formatter; Hay algunos pasos para que funcione, así que lea su documentación de configuración. También hay un script de formato automático que se puede ejecutar: ./scripts/format.sh
Si bien Selenium no está compilado con Maven, puede compilar e instalar las piezas de Selenium para que Maven las use localmente implementándolas en su repositorio local de Maven ( ~/.m2/repository ), usando:
./go java:instalar
Las dependencias se definen en el archivo maven_deps.bzl. Para actualizar y fijar automáticamente nuevas dependencias, ejecute:
./go java:actualizar
Puede ejecutar código Python localmente actualizando los archivos generados en el directorio de Python usando:
./go py:actualizar
Para instalar Selenium localmente en función de una confirmación específica, puede utilizar:
./go py:instalar
En lugar de usar irb , puedes crear un REPL interactivo con todas las gemas cargadas usando: bazel run //rb:console
Si desea depurar el código, puede hacerlo mediante la gema debug :
Agregue binding.break al código donde desea que se inicie el depurador.
Ejecute pruebas con la configuración ruby_debug : bazel test --config ruby_debug .
Cuando se inicie el depurador, ejecute lo siguiente en una terminal separada para conectarse al depurador:
bazel-selenio/externo/paquete/bin/rdbg -A
Si desea utilizar RubyMine para el desarrollo, puede configurarlo utilizando artefactos de Bazel:
Abra rb/ como directorio principal del proyecto.
Ejecute bundle exec rake update según sea necesario para crear artefactos actualizados. Si esto no funciona, ejecute ./go rb:update desde el directorio selenium (principal).
En Configuración/Idiomas y marcos/Ruby SDK y Gems, agregue un nuevo intérprete que apunte a ../bazel-selenium/external/rules_ruby_dist/dist/bin/ruby .
Ahora debería poder ejecutar y depurar cualquier especificación. Utiliza Chrome de forma predeterminada, pero puede modificarlo utilizando las variables de entorno especificadas en la sección Pruebas de Ruby a continuación.
Para mantener Carbo.Bazel.lock sincronizado con Cargo.lock , ejecute:
CARGO_BAZEL_REPIN=sincronización verdadera de Bazel --solo=cajas
Hay varias configuraciones de bazel específicas para realizar pruebas.
A continuación se muestran ejemplos de argumentos que utilizamos al probar el código de Selenium:
--pin_browsers : ejecuta versiones específicas del navegador definidas en la compilación (las versiones se actualizan periódicamente)
--headless : ejecuta navegadores en modo sin cabeza (compatible con Chrome, Edge y Firefox)
--flaky_test_attempts 3 : vuelve a ejecutar las pruebas fallidas hasta 3 veces
--local_test_jobs 1 - controla el paralelismo de las pruebas
--cache_test_results=no , -t- - desactiva el almacenamiento en caché de los resultados de las pruebas y los vuelve a ejecutar todos
--test_output all : imprime todos los resultados de las pruebas, no solo los errores
--test_output streamed : ejecuta todas las pruebas una por una e imprime su resultado inmediatamente
--test_env FOO=bar : pasa una variable de entorno adicional al proceso de prueba
--run_under="xvfb-run -a" - prefijo a insertar antes de la ejecución
Las pruebas de selenio se pueden filtrar por tamaño:
pequeño: normalmente pruebas unitarias en las que no se abre ningún navegador
grande: normalmente pruebas que realmente controlan un navegador
medio: pruebas que son más complicadas que las simples pruebas unitarias, pero que no manejan completamente un navegador
Estos se pueden filtrar usando el argumento test_size_filters como este:
prueba de bazel ///... --test_size_filters=small
Las pruebas también se pueden filtrar por etiquetas como:
prueba de bazel ///... --test_tag_filters=esto,-no-esto
Para ejecutar pruebas unitarias:
prueba de bazel //java/... --test_size_filters=small
Para ejecutar pruebas de integración:
prueba de bazel //java/... --test_size_filters=medio
Para ejecutar pruebas del navegador:
prueba de bazel //java/... --test_size_filters=large --test_tag_filters=
Para ejecutar una prueba específica:
prueba de bazel //java/test/org/openqa/selenium/chrome:ChromeDriverFunctionalTest
Para ejecutar las pruebas ejecute:
prueba de bazel //javascript/nodo/selenium-webdriver:pruebas
Puede utilizar --test_env para pasar el nombre del navegador como SELENIUM_BROWSER .
prueba de bazel //javascript/nodo/selenium-webdriver:pruebas --test_env=SELENIUM_BROWSER=firefox
Ejecute pruebas unitarias con:
prueba de bazel //py:unidad
Para ejecutar pruebas con un navegador específico:
prueba de bazel //py:prueba-
Para ejecutar todas las pruebas de Python:
prueba de bazel //py:todos
Objetivos de prueba:
| Dominio | Descripción |
|---|---|
bazel test //rb/... | Ejecutar unidad, todas las pruebas de integración y pelusa |
bazel test //rb:lint | Ejecute el linter RuboCop |
bazel test //rb/spec/... | Ejecute pruebas unitarias y de integración para todos los navegadores. |
bazel test //rb/spec/... --test_size_filters small | Ejecutar pruebas unitarias |
bazel test //rb/spec/unit/... | Ejecutar pruebas unitarias |
bazel test //rb/spec/... --test_size_filters large | Ejecute pruebas de integración para todos los navegadores. |
bazel test //rb/spec/integration/... | Ejecute pruebas de integración para todos los navegadores. |
bazel test //rb/spec/integration/... --test_tag_filters firefox | Ejecute pruebas de integración solo para Firefox local |
bazel test //rb/spec/integration/... --test_tag_filters firefox-remote | Ejecute pruebas de integración solo para Firefox remoto |
bazel test //rb/spec/integration/... --test_tag_filters firefox,firefox-remote | Ejecute pruebas de integración para Firefox local y remoto |
Los objetivos de prueba de Ruby tienen el mismo nombre que el archivo de especificaciones con _spec.rb eliminado, por lo que puede ejecutarlos individualmente. Los objetivos de las pruebas de integración también tienen un navegador y un sufijo remoto para controlar qué navegador elegir y si usar Grid.
| archivo de prueba | Objetivo de prueba |
|---|---|
rb/spec/unit/selenium/webdriver/proxy_spec.rb | //rb/spec/unit/selenium/webdriver:proxy |
rb/spec/integration/selenium/webdriver/driver_spec.rb | //rb/spec/integration/selenium/webdriver:driver-chrome |
rb/spec/integration/selenium/webdriver/driver_spec.rb | //rb/spec/integration/selenium/webdriver:driver-chrome-remote |
rb/spec/integration/selenium/webdriver/driver_spec.rb | //rb/spec/integration/selenium/webdriver:driver-firefox |
rb/spec/integration/selenium/webdriver/driver_spec.rb | //rb/spec/integration/selenium/webdriver:driver-firefox-remote |
Navegadores compatibles:
chrome
edge
firefox
firefox-beta
ie
safari
safari-preview
Además de los ejemplos de opciones comunes, aquí hay algunos adicionales específicos de Ruby:
--test_arg "-eTimeouts" - prueba solo especificaciones cuyo nombre incluya "Timeouts"
--test_arg " : pasa cualquier argumento de RSpec adicional (consulte bazel run @bundle//bin:rspec -- --help )
Variables de entorno admitidas para usar con --test_env :
WD_SPEC_DRIVER : el controlador a probar; ya sea el nombre del navegador o "remoto" (lo configura Bazel)
WD_REMOTE_BROWSER : cuando WD_SPEC_DRIVER es remote ; el nombre del navegador a probar (lo configura Bazel)
WD_REMOTE_URL : URL de un servidor que ya se está ejecutando para usar en pruebas remotas
DOWNLOAD_SERVER : cuando WD_REMOTE_URL no está configurado; si se debe descargar y utilizar la versión del servidor más reciente para pruebas remotas
DEBUG : activa la depuración detallada
HEADLESS : para Chrome, Edge y Firefox; ejecuta pruebas en modo sin cabeza
DISABLE_BUILD_CHECK - para cromo y borde; si se deben ignorar las discrepancias entre las versiones del controlador y del navegador (permite probar compilaciones de Canary)
CHROME_BINARY : ruta para probar el navegador Chrome específico
CHROMEDRIVER_BINARY : ruta para probar ChromeDriver específico
EDGE_BINARY : ruta para probar el navegador Edge específico
MSEDGEDRIVER_BINARY : ruta para probar msedgedriver específico
FIREFOX_BINARY : ruta para probar el navegador Firefox específico
GECKODRIVER_BINARY : ruta para probar GeckoDriver específico
Para ejecutar con una versión específica de Ruby, puedes cambiar la versión en rb/.ruby-version o desde la línea de comando:
echo '' > rb/.ruby-version
Actualmente, las pruebas de .NET solo funcionan con navegadores anclados, así que asegúrese de incluirlo.
Ejecute todas las pruebas con:
prueba de bazel //dotnet/test/common:AllTests --pin_browsers=true
Puede ejecutar pruebas específicas especificando el nombre de la clase:
prueba de bazel //dotnet/test/common:ElementFindingTest --pin_browsers=true
Si el módulo admite varios navegadores:
prueba de bazel //dotnet/test/common:ElementFindingTest-edge --pin_browsers=true
Las pruebas de oxidación se ejecutan con:
prueba de bazel //óxido/...
De forma predeterminada, Bazel ejecuta estas pruebas en la interfaz de usuario de su servidor X actual. Si lo prefiere, también puede ejecutarlos en un servidor X virtual o anidado.
Ejecute el servidor X Xvfb :99 o Xnest :99
Ejecute un administrador de ventanas, por ejemplo, DISPLAY=:99 jwm
Ejecute las pruebas que le interesen:
prueba de bazel --test_env=DISPLAY=:99 //java/... --test_tag_filters=chrome
Una forma sencilla de ejecutar pruebas en un servidor X virtual es utilizar la funcionalidad --run_under de Bazel:
bazel test --run_under="xvfb-run -a" //java/...
La documentación API se puede encontrar aquí:
DO#
javascript
Java
Pitón
Rubí
Para actualizar la documentación de API para un idioma específico: ./go
Para actualizar toda la documentación: ./go all:docs
Tenga en cuenta que la generación de JavaScript actualmente no funciona.
El proceso completo para realizar un lanzamiento se puede encontrar en la wiki.
El lanzamiento es una combinación de construcción y publicación, que a menudo requiere la coordinación de múltiples ejecuciones y procesamiento adicional. Como se analizó en la sección Construcción, utilizamos tareas de Rake con el comando ./go para estas cosas. Estos comandos ./go incluyen el argumento --stamp para proporcionar la información necesaria sobre el activo construido.
Puedes compilar y publicar todo con:
./ir a todo: liberar
Para construir y lanzar un lenguaje específico:
./go:liberar
Si tiene acceso al repositorio de Selenium EngFlow, puede crear los activos de forma remota y descargarlos localmente usando:
./go all:release['--config', 'release']
