sélénium
Selenium
Selenium est un projet parapluie encapsulant une variété d'outils et de bibliothèques permettant l'automatisation du navigateur Web. Selenium fournit spécifiquement une infrastructure pour la spécification W3C WebDriver – une plate-forme et une interface de codage neutre en termes de langage, compatible avec tous les principaux navigateurs Web.
Le projet est rendu possible grâce à des contributeurs bénévoles qui ont généreusement consacré des milliers d'heures au développement et à la maintenance du code.
Le code source de Selenium est mis à disposition sous la licence Apache 2.0.
Ce README est destiné aux développeurs intéressés à contribuer au projet. Pour les personnes souhaitant commencer à utiliser Selenium, veuillez consulter notre manuel d'utilisation pour des exemples et des descriptions détaillés, et si vous êtes bloqué, il existe plusieurs façons d'obtenir de l'aide.
Veuillez lire CONTRIBUTING.md avant de soumettre vos demandes de tirage.
Ce sont les conditions requises pour créer votre propre environnement de développement local afin de contribuer à Selenium.
Bazelisk, un wrapper Bazel qui télécharge automatiquement la version de Bazel spécifiée dans le fichier .bazelversion et transmet de manière transparente tous les arguments de ligne de commande au véritable binaire Bazel.
Java JDK version 17 ou supérieure (par exemple, Java 17 Temurin)
Définissez la variable d'environnement JAVA_HOME sur l'emplacement de l'exécutable Java (le JDK et non le JRE)
Pour tester cela, essayez d'exécuter la commande javac . Cette commande n’existera pas si seul le JRE est installé. Si vous rencontrez une liste d’options de ligne de commande, vous faites correctement référence au JDK.
Xcode incluant les outils de ligne de commande. Installez la dernière version en utilisant : xcode-select --install
Rosetta pour les Mac Apple Silicon. Ajoutez build --host_platform=//:rosetta au fichier .bazelrc.local . Nous travaillons pour garantir que cela ne soit pas nécessaire à long terme.
Il y a plusieurs années, Jim Evans a publié un excellent article sur la configuration d'un environnement de développement Windows pour les liaisons de langage Selenium .NET ; Cet article est obsolète, mais il comprend des descriptions plus détaillées et des captures d’écran que certaines personnes pourraient trouver utiles.
Ce script garantira un environnement de développement complet et prêt à être exécuté. (rien n'est installé ou défini qui est déjà présent, sauf indication contraire)
Ouvrez Powershell en tant qu'administrateur
Exécuter : Set-ExecutionPolicy Bypass -Scope Process -Force pour autoriser l'exécution du script dans le processus
Accédez au répertoire dans lequel vous souhaitez cloner Selenium ou au répertoire parent d'un dépôt Selenium déjà cloné.
Téléchargez et exécutez ce script dans le terminal PowerShell : [scripts/dev-environment-setup.ps1]`
Autoriser l'exécution de scripts dans Selenium en général :
Set-ExecutionPolicy -ExecutionPolicy RemoteSigned
Activer le mode développeur :
reg add "HKEY_LOCAL_MACHINESOFTWAREMicrosoftWindowsCurrentVersionAppModelUnlock" /t REG_DWORD /f /v "AllowDevelopmentWithoutDevLicense" /d "1"
Installez MSYS2, qui est un environnement shell alternatif qui fournit des commandes de type Unix
Ajoutez le répertoire bin à la variable d'environnement PATH (par exemple, "C:toolsmsys64usrbin" )
Ajoutez l'emplacement bash.exe comme variable d'environnement BAZEL_SH (par exemple, "C:toolsmsys64usrbinbash.exe" )
Installez la dernière version de Visual Studio Community
Utilisez le programme d'installation de Visual Studio pour modifier et ajouter la charge de travail « Développement de bureau avec C++ »
Ajoutez l'emplacement du répertoire d'installation des outils de build Visual C++ à la variable d'environnement BAZEL_VC (par exemple "C:Program FilesMicrosoft Visual Studio2022CommunityVC" )
Ajoutez la version des outils Visual C++ Build à la variable d'environnement BAZEL_VC_FULL_VERSION (cela peut être découvert à partir du nom du répertoire dans "$BAZEL_VCToolsMSVC )
Ajout de la prise en charge des noms de fichiers longs (bazel possède de nombreux répertoires imbriqués qui peuvent dépasser les limites par défaut de Windows)
reg ajoute "HKEY_LOCAL_MACHINESOFTWAREMicrosoftCommand Processor" /t REG_DWORD /f /v "DisableUNCCheck" /d "1"reg ajoute "HKEY_LOCAL_MACHINESYSTEMCurrentControlSetControlFileSystem" /t REG_DWORD /f /v "LongPathsEnabled" /d "1"
Créer un fichier selenium/.bazelrc.windows.local
Ajoutez "startup --output_user_root=C:/tmp" au fichier
Autoriser Bazel à créer des versions de noms courts de chemins de fichiers longs : fsutil 8dot3name set 0
Définissez la sortie de Bazel sur C:/tmp au lieu d'être imbriquée dans le répertoire du projet :
Activez la prise en charge des chemins longs avec ces 2 commandes de registre :
Si vous souhaitez contribuer au projet, mais ne souhaitez pas configurer votre propre environnement de développement local, deux alternatives sont disponibles.
Plutôt que de créer votre propre environnement de développement local, GitPod vous fournit un environnement prêt à l'emploi.
Comme alternative, vous pouvez créer un conteneur de développement - essentiellement un conteneur Docker - adapté à la création et au test de Selenium à l'aide de devcontainer.json dans le répertoire .devcontainer. La prise en charge des IDE comme VS Code ou IntelliJ IDEA devrait vous indiquer comment un tel conteneur peut être créé.
Vous pouvez également créer une image Docker adaptée à la création et au test de Selenium à l'aide du Dockerfile dans le répertoire de l'image dev.
Selenium est construit à l'aide d'un outil de construction commun appelé Bazel, pour nous permettre de gérer facilement les téléchargements de dépendances, de générer les binaires requis, de créer et de publier des packages et d'exécuter des tests ; le tout de manière rapide et efficace. Pour une discussion plus détaillée, lisez l'article de Simon Stewart sur Building Selenium
Nous enveloppons souvent les commandes Bazel avec notre wrapper Rake personnalisé. Ceux-ci sont exécutés avec la commande ./go .
Les commandes Bazel courantes sont :
bazel build - évalue les dépendances, compile les fichiers source et génère des fichiers de sortie pour la cible spécifiée. Il est utilisé pour créer des binaires exécutables, des bibliothèques ou d'autres artefacts.
bazel run - construit la cible puis l'exécute. Il est généralement utilisé pour les cibles qui produisent des binaires exécutables.
bazel test - construit et exécute la cible dans un contexte avec des fonctionnalités de test supplémentaires
bazel query - identifie les cibles disponibles pour le chemin fourni.
Chaque module pouvant être construit est défini dans un fichier BUILD.bazel . Pour exécuter le module, vous y faites référence en commençant par un // , puis incluez le chemin relatif du fichier qui le définit, puis : , puis le nom de la cible. Par exemple, la cible pour construire la grille est nommée executable-grid et elle est définie dans le fichier 'selenium/java/src/org/openqa/selenium/grid/BAZEL.build' . Donc, pour construire la grille, vous exécuteriez : bazel build //java/src/org/openqa/selenium/grid:executable-grid .
La documentation Bazel contient un guide pratique pour divers raccourcis et toutes les façons de créer plusieurs cibles, que Selenium utilise fréquemment.
Pour tout construire pour une langue donnée :
construction bazel ///...
Pour construire uniquement la grille, vous devez utiliser un nom d'alias (le journal indiquera où se trouve le fichier jar de sortie) :
grille de construction de bazel
Pour simplifier les choses, la construction de chacune des liaisons est disponible avec cette commande ./go
./go:build
La plupart des membres de l'équipe utilisent Intellij pour leurs éditions quotidiennes. Si vous travaillez dans IntelliJ, nous vous recommandons fortement d'installer le plugin Bazel IJ qui est documenté sur son propre site.
Pour utiliser Selenium avec le plugin IntelliJ Bazel, importez le référentiel en tant que projet Bazel et sélectionnez le fichier de vue du projet dans le répertoire des scripts. ij.bazelproject pour Mac/Linux et ij-win.bazelproject pour Windows.
Nous utilisons également le format Google Java pour le peluchage, il est donc utile d'utiliser le plug-in Google Java Formatter ; il y a quelques étapes pour le faire fonctionner, alors lisez leur documentation de configuration. Il existe également un script de formatage automatique qui peut être exécuté : ./scripts/format.sh
Bien que Selenium ne soit pas construit avec Maven, vous pouvez créer et installer les éléments Selenium que Maven pourra utiliser localement en les déployant sur votre référentiel Maven local ( ~/.m2/repository ), en utilisant :
./go java:installer
Les dépendances sont définies dans le fichier maven_deps.bzl. Pour mettre à jour et épingler automatiquement de nouvelles dépendances, exécutez :
./go java:mise à jour
Vous pouvez exécuter du code Python localement en mettant à jour les fichiers générés dans le répertoire python en utilisant :
./go py:mettre à jour
Pour installer Selenium localement en fonction d'un commit spécifique, vous pouvez utiliser :
./go py:installer
Au lieu d'utiliser irb , vous pouvez créer un REPL interactif avec toutes les gemmes chargées en utilisant : bazel run //rb:console
Si vous souhaitez déboguer du code, vous pouvez le faire via debug gem :
Ajoutez binding.break au code où vous souhaitez que le débogueur démarre.
Exécutez des tests avec la configuration ruby_debug : bazel test --config ruby_debug .
Lorsque le débogueur démarre, exécutez ce qui suit dans un terminal séparé pour vous connecter au débogueur :
bazel-sélénium/externe/bundle/bin/rdbg -A
Si vous souhaitez utiliser RubyMine pour le développement, vous pouvez le configurer à l'aide des artefacts Bazel :
Ouvrez rb/ comme répertoire principal du projet.
Exécutez bundle exec rake update si nécessaire pour créer des artefacts à jour. Si cela ne fonctionne pas, exécutez ./go rb:update à partir du répertoire selenium (parent).
Dans Paramètres / Langages et frameworks / Ruby SDK et Gems, ajoutez un nouvel interprète pointant vers ../bazel-selenium/external/rules_ruby_dist/dist/bin/ruby .
Vous devriez maintenant pouvoir exécuter et déboguer n'importe quelle spécification. Il utilise Chrome par défaut, mais vous pouvez le modifier à l'aide des variables d'environnement spécifiées dans la section Ruby Testing ci-dessous.
Pour garder Carbo.Bazel.lock synchronisé avec Cargo.lock , exécutez :
CARGO_BAZEL_REPIN = vraie synchronisation bazel --only = caisses
Il existe un certain nombre de configurations Bazel spécifiques aux tests.
Voici des exemples d'arguments que nous utilisons pour tester le code Selenium :
--pin_browsers - exécute des versions de navigateur spécifiques définies dans la build (les versions sont mises à jour régulièrement)
--headless - exécute les navigateurs en mode sans tête (pris en charge par Chrome, Edge et Firefox)
--flaky_test_attempts 3 - réexécutez les tests ayant échoué jusqu'à 3 fois
--local_test_jobs 1 - contrôle le parallélisme des tests
--cache_test_results=no , -t- - désactive la mise en cache des résultats des tests et les réexécute tous
--test_output all - affiche toutes les sorties des tests, pas seulement les erreurs
--test_output streamed - exécute tous les tests un par un et imprime immédiatement sa sortie
--test_env FOO=bar - passe une variable d'environnement supplémentaire au processus de test
--run_under="xvfb-run -a" - préfixe à insérer avant l'exécution
Les tests de sélénium peuvent être filtrés par taille :
petit - généralement des tests unitaires où aucun navigateur n'est ouvert
large – généralement des tests qui pilotent réellement un navigateur
medium : des tests plus complexes que de simples tests unitaires, mais qui ne pilotent pas entièrement un navigateur
Ceux-ci peuvent être filtrés à l'aide de l'argument test_size_filters comme ceci :
test bazel ///... --test_size_filters=small
Les tests peuvent également être filtrés par balise comme :
test bazel ///... --test_tag_filters=this,-not-this
Pour exécuter des tests unitaires :
test bazel //java/... --test_size_filters=small
Pour exécuter des tests d'intégration :
test bazel //java/... --test_size_filters=medium
Pour exécuter des tests de navigateur :
test bazel //java/... --test_size_filters=large --test_tag_filters=
Pour exécuter un test spécifique :
test bazel //java/test/org/openqa/selenium/chrome:ChromeDriverFunctionalTest
Pour exécuter les tests, exécutez :
test bazel //javascript/node/selenium-webdriver:tests
Vous pouvez utiliser --test_env pour transmettre le nom du navigateur sous la forme SELENIUM_BROWSER .
test bazel //javascript/node/selenium-webdriver:tests --test_env=SELENIUM_BROWSER=firefox
Exécutez des tests unitaires avec :
test bazel //py:unité
Pour exécuter des tests avec un navigateur spécifique :
test bazel //py:test-
Pour exécuter tous les tests Python :
test bazel //py: tous
Cibles de test :
| Commande | Description |
|---|---|
bazel test //rb/... | Exécuter l'unité, tous les tests d'intégration et les peluches |
bazel test //rb:lint | Exécuter le linter RuboCop |
bazel test //rb/spec/... | Exécutez des tests unitaires et d’intégration pour tous les navigateurs |
bazel test //rb/spec/... --test_size_filters small | Exécuter des tests unitaires |
bazel test //rb/spec/unit/... | Exécuter des tests unitaires |
bazel test //rb/spec/... --test_size_filters large | Exécutez des tests d'intégration pour tous les navigateurs |
bazel test //rb/spec/integration/... | Exécutez des tests d'intégration pour tous les navigateurs |
bazel test //rb/spec/integration/... --test_tag_filters firefox | Exécutez des tests d'intégration pour Firefox local uniquement |
bazel test //rb/spec/integration/... --test_tag_filters firefox-remote | Exécuter des tests d'intégration pour Firefox distant uniquement |
bazel test //rb/spec/integration/... --test_tag_filters firefox,firefox-remote | Exécutez des tests d'intégration pour Firefox local et distant |
Les cibles de test Ruby portent le même nom que le fichier de spécifications avec _spec.rb supprimé, vous pouvez donc les exécuter individuellement. Les cibles des tests d'intégration disposent également d'un navigateur et d'un suffixe distant pour contrôler le navigateur à choisir et s'il faut utiliser Grid.
| Fichier de test | Cible de test |
|---|---|
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 |
Navigateurs pris en charge :
chrome
edge
firefox
firefox-beta
ie
safari
safari-preview
En plus des exemples d'options communes, voici quelques exemples supplémentaires spécifiques à Ruby :
--test_arg "-eTimeouts" - teste uniquement les spécifications dont le nom inclut "Timeouts"
--test_arg " - transmet tous les arguments RSpec supplémentaires (voir bazel run @bundle//bin:rspec -- --help )
Variables d'environnement prises en charge à utiliser avec --test_env :
WD_SPEC_DRIVER - le pilote à tester ; soit le nom du navigateur, soit « distant » (défini par Bazel)
WD_REMOTE_BROWSER - lorsque WD_SPEC_DRIVER est remote ; le nom du navigateur à tester (défini par Bazel)
WD_REMOTE_URL - URL d'un serveur déjà en cours d'exécution à utiliser pour les tests à distance
DOWNLOAD_SERVER - lorsque WD_REMOTE_URL n'est pas défini ; s'il faut télécharger et utiliser la version du serveur la plus récente pour les tests à distance
DEBUG - active le débogage détaillé
HEADLESS - pour Chrome, Edge et Firefox ; exécute des tests en mode sans tête
DISABLE_BUILD_CHECK - pour le chrome et les bords ; s'il faut ignorer les incompatibilités de version du pilote et du navigateur (permet de tester les builds Canary)
CHROME_BINARY - chemin pour tester un navigateur Chrome spécifique
CHROMEDRIVER_BINARY - chemin pour tester un ChromeDriver spécifique
EDGE_BINARY - chemin pour tester un navigateur Edge spécifique
MSEDGEDRIVER_BINARY - chemin pour tester un msedgedriver spécifique
FIREFOX_BINARY - chemin pour tester un navigateur Firefox spécifique
GECKODRIVER_BINARY - chemin pour tester un GeckoDriver spécifique
Pour exécuter avec une version spécifique de Ruby, vous pouvez modifier la version dans rb/.ruby-version ou depuis la ligne de commande :
echo '' > rb/.ruby-version
Les tests .NET ne fonctionnent actuellement qu'avec les navigateurs épinglés, alors assurez-vous de les inclure.
Exécutez tous les tests avec :
test bazel //dotnet/test/common:AllTests --pin_browsers=true
Vous pouvez exécuter des tests spécifiques en spécifiant le nom de la classe :
test bazel //dotnet/test/common:ElementFindingTest --pin_browsers=true
Si le module prend en charge plusieurs navigateurs :
test bazel //dotnet/test/common:ElementFindingTest-edge --pin_browsers=true
Les tests Rust sont exécutés avec :
test bazel //rouille/...
Par défaut, Bazel exécute ces tests dans l'interface utilisateur actuelle de votre serveur X. Si vous préférez, vous pouvez également les exécuter sur un serveur X virtuel ou imbriqué.
Exécutez le serveur X Xvfb :99 ou Xnest :99
Exécutez un gestionnaire de fenêtres, par exemple, DISPLAY=:99 jwm
Exécutez les tests qui vous intéressent :
test bazel --test_env=DISPLAY=:99 //java/... --test_tag_filters=chrome
Un moyen simple d'exécuter des tests sur un serveur X virtuel consiste à utiliser la fonctionnalité --run_under de Bazel :
bazel test --run_under="xvfb-run -a" //java/...
La documentation de l'API peut être trouvée ici :
C#
Javascript
Java
Python
Rubis
Pour mettre à jour la documentation de l'API pour une langue spécifique : ./go
Pour mettre à jour toute la documentation : ./go all:docs
Notez que la génération JavaScript est actuellement interrompue.
Le processus complet pour réaliser une version peut être trouvé sur le wiki
La publication est une combinaison de création et de publication, qui nécessite souvent la coordination de plusieurs exécutions et un traitement supplémentaire. Comme indiqué dans la section Construction, nous utilisons les tâches Rake avec la commande ./go pour ces choses. Ces commandes ./go incluent l'argument --stamp pour fournir les informations nécessaires sur l'actif construit.
Vous pouvez tout construire et tout publier avec :
./aller à tous : libérer
Pour créer et publier un langage spécifique :
./go:release
Si vous avez accès au référentiel Selenium EngFlow, vous pouvez créer les ressources à distance et les télécharger localement en utilisant :
./go all:release['--config', 'release']
