SeleniumBase
4.33.7 - CDP Mode - Patch 17
Cadre d'automatisation du navigateur tout-en-un :
Exploration du Web / Tests / Scraping / Furtivité
Démarrer | ? Caractéristiques | ?️Options | Exemples | ? Scripts | Mobile
API | ? Formats | ? Enregistreur | Tableau de bord | ? Paramètres régionaux | Ferme
?️ Interface graphique | ? Page de test | ? Mode CU | ? Mode CDP | ? Graphiques | Grille
?️ Comment | ? Migrer | Plans de cas | ♻️ Modèle | ? Hybride | ? Visites
? CI/CD | ?️ JSMgr | ? Traducteur | Présentateur | ? Boîte de dialogue | ?️ Visuel
SeleniumBase est la boîte à outils professionnelle pour les activités d'automatisation Web. Conçu pour tester des sites Web, contourner les CAPTCHA, améliorer la productivité, accomplir des tâches et faire évoluer votre entreprise.
Apprenez de plus de 200 exemples dans le dossier SeleniumBase/examples/ .
? Notez que le mode SeleniumBase UC (mode furtif) possède son propre fichier ReadMe.
? Notez également que le mode CDP Seleniumbase possède son propre fichier ReadMe distinct.
Les scripts peuvent être appelés via python , bien que certains formats de syntaxe attendent pytest (un framework de tests unitaires Python inclus avec SeleniumBase qui peut découvrir, collecter et exécuter des tests automatiquement).
? Voici my_first_test.py, qui teste la connexion, les achats et le paiement :
pytest my_first_test.py
pytestutilise--chromepar défaut, sauf indication contraire.
? Voici test_coffee_cart.py, qui vérifie un site de commerce électronique :
pytest test_coffee_cart.py --demo( Le mode
--demoralentit les tests et met en évidence les actions)
? Voici test_demo_site.py, qui couvre plusieurs actions :
pytest test_demo_site.pyFacile à saisir, cliquer, sélectionner, basculer, glisser-déposer, et bien plus encore.
(Pour plus d'exemples, consultez le dossier SeleniumBase/examples/.)
Explorez le README :
- Commencer / Installation
- Exemple de base/utilisation
- Méthodes de test courantes
- Faits amusants / En savoir plus
- Mode démo/débogage
- Options de ligne de commande
- Configuration de l'annuaire
- Tableau de bord SeleniumBase
- Génération de rapports de tests
SeleniumBase est un framework Python pour l'automatisation et les tests des navigateurs. SeleniumBase utilise les API Selenium/WebDriver et intègre des exécuteurs de tests tels que pytest , pynose et behave pour fournir une structure organisée, une découverte de tests, une exécution de test, un état de test ( par exemple réussi, échoué ou ignoré ) et des options de ligne de commande pour modifier paramètres par défaut ( par exemple, sélection du navigateur ). Avec Selenium brut, vous devrez configurer votre propre analyseur d'options pour configurer les tests à partir de la ligne de commande.
Le gestionnaire de pilotes de SeleniumBase vous donne plus de contrôle sur les téléchargements automatiques de pilotes. (Utilisez --driver-version=VER avec votre commande pytest run pour spécifier la version.) Par défaut, SeleniumBase téléchargera une version du pilote qui correspond à la version principale de votre navigateur si elle n'est pas définie.
SeleniumBase détecte automatiquement entre les sélecteurs CSS et XPath, ce qui signifie que vous n'avez pas besoin de spécifier le type de sélecteur dans vos commandes ( mais vous pouvez éventuellement le faire ).
Les méthodes SeleniumBase effectuent souvent plusieurs actions dans un seul appel de méthode. Par exemple, self.type(selector, text) effectue les opérations suivantes :
1. Attend que l'élément soit visible.
2. Attend que l'élément soit interactif.
3. Efface le champ de texte.
4. Tapez le nouveau texte.
5. Appuyez sur Entrée/Soumettre si le texte se termine par "n" .
Avec Selenium brut, ces actions nécessitent plusieurs appels de méthode.
SeleniumBase utilise les valeurs de délai d'attente par défaut lorsqu'elles ne sont pas définies :
✅ self.click("button")
Avec Selenium brut, les méthodes échoueraient instantanément ( par défaut ) si un élément avait besoin de plus de temps pour se charger :
self.driver.find_element(by="css selector", value="button").click()
(Un code fiable vaut mieux qu’un code peu fiable.)
SeleniumBase vous permet de modifier les valeurs de délai d'attente explicites des méthodes :
✅ self.click("button", timeout=10)
Avec Selenium brut, cela nécessite plus de code :
WebDriverWait(driver, 10).until(EC.element_to_be_clickable("css selector", "button")).click()
(Un code simple vaut mieux qu’un code complexe.)
SeleniumBase vous donne une sortie d'erreur propre lorsqu'un test échoue. Avec le sélénium brut, les messages d'erreur peuvent devenir très compliqués.
SeleniumBase vous offre la possibilité de générer un tableau de bord et des rapports pour les tests. Il enregistre également les captures d'écran des tests ayant échoué dans le dossier ./latest_logs/ . Raw Selenium ne propose pas ces options prêtes à l'emploi.
SeleniumBase inclut des applications GUI de bureau pour exécuter des tests, telles que SeleniumBase Commander pour pytest et SeleniumBase Behave GUI pour behave .
SeleniumBase possède son propre enregistreur/générateur de tests pour créer des tests à partir d'actions manuelles du navigateur.
SeleniumBase est livré avec un logiciel de gestion de cas de test (« CasePlans »), pour organiser les tests et les descriptions d'étapes.
SeleniumBase comprend des outils pour créer des applications de données (« ChartMaker »), qui peuvent générer du JavaScript à partir de Python.
Découvrez les différentes manières de rédiger des tests :
Voici test_simple_login.py, qui utilise l'héritage de classe BaseCase et s'exécute avec pytest ou pynose. (Utilisez self.driver pour accéder driver brut 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" ) ? Voici un test de sb_fixture_tests.py, qui utilise le luminaire sb pytest . Fonctionne avec pytest. (Utilisez sb.driver pour accéder au driver brut 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" ) ? Voici raw_login_sb.py, qui utilise le SB Context Manager. Fonctionne avec python pur. (Utilisez sb.driver pour accéder au driver brut 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" ) ? Voici raw_login_context.py, qui utilise le DriverContext Manager. Fonctionne avec python pur. (Le driver est une version améliorée du driver brut de Selenium, avec plus de méthodes.)
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" ) ? Voici raw_login_driver.py, qui utilise le gestionnaire Driver . Fonctionne avec python pur. (Le driver est une version améliorée du driver brut de Selenium, avec plus de méthodes.)
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 () Voici login_app.feature, qui utilise la syntaxe Bebe-BDD Gherkin. Fonctionne avec behave . (En savoir plus sur l'intégration SeleniumBase Bebe-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" ? Ajoutez Python et Git à votre PATH système.
? L'utilisation d'un environnement virtuel Python est recommandée.
Vous pouvez installer seleniumbase depuis PyPI ou GitHub :
? Comment installer seleniumbase depuis PyPI :
pip install seleniumbase--upgrade OR -U pour mettre à niveau SeleniumBase.)--force-reinstall pour mettre à niveau les packages indirects.)pip3 si plusieurs versions de Python sont présentes.) ? Comment installer seleniumbase à partir d'un clone de GitHub :
git clone https://github.com/seleniumbase/SeleniumBase.git
cd SeleniumBase/
pip install -e .? Comment mettre à niveau une installation existante à partir d'un clone GitHub :
git pull
pip install -e . ? Tapez seleniumbase ou sbase pour vérifier que SeleniumBase a été installé avec succès :
___ _ _ ___
/ __ | ___ | | ___ _ _ (_)_ _ _ __ | _ ) __ _ ______
_ _ / -_) / -_) ' | | | | ' | _ / _ ` (_- < -_)
| ___/ _ __ | _ _ __ | _ || _ | _ | _ ,_ | _ | _ | _ | ___/ _ _,_/__ | ___ |
----------------------------------------------------
╭──────────────────────────────────────────────────╮
│ * 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 télécharge automatiquement les pilotes Web selon les besoins, tels que 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 vous avez cloné SeleniumBase, vous pouvez exécuter des tests à partir du dossier examples/.
Voici my_first_test.py :
cd examples/
pytest my_first_test.pyVoici le code de 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.? Pour la liste complète des méthodes SeleniumBase, voir : Résumé de la méthode
✅ SeleniumBase gère automatiquement les actions courantes de WebDriver telles que le lancement de navigateurs Web avant les tests, l'enregistrement de captures d'écran en cas d'échec et la fermeture des navigateurs Web après les tests.
✅ SeleniumBase vous permet de personnaliser les tests via les options de ligne de commande.
✅ SeleniumBase utilise une syntaxe simple pour les commandes. Exemple:
self . type ( "input" , "dogs n " ) # (The "n" presses ENTER) La plupart des scripts SeleniumBase peuvent être exécutés avec pytest , pynose ou pure python . Tous les exécuteurs de tests ne peuvent pas exécuter tous les formats de test. Par exemple, les tests qui utilisent le luminaire sb pytest ne peuvent être exécutés qu'avec pytest . (Voir Formats de syntaxe) Il existe également un format de test Gherkin qui s'exécute avec behavior.
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 inclut la découverte automatique des tests. Si vous ne spécifiez pas de fichier ou de dossier spécifique à exécuter, pytest recherchera automatiquement dans tous les sous-répertoires les tests à exécuter en fonction des critères suivants :
test_ ou se terminant par _test.py .test_ . Avec un fichier SeleniumBase pytest.ini présent, vous pouvez modifier les paramètres de découverte par défaut. Le nom de la classe Python peut être n'importe quoi car seleniumbase.BaseCase hérite de unittest.TestCase pour déclencher la découverte automatique.
✅ Vous pouvez effectuer une vérification avant vol pour voir quels tests seraient découverts par pytest avant l'exécution proprement dite :
pytest --co -q ✅ Vous pouvez être plus précis lorsque vous appelez pytest ou pynose sur un fichier :
pytest [FILE_NAME.py]::[CLASS_NAME]::[METHOD_NAME]
pynose [FILE_NAME.py]:[CLASS_NAME].[METHOD_NAME] ✅ Fini les tests feuilletés ! Les méthodes SeleniumBase attendent automatiquement la fin du chargement des éléments de la page avant d'interagir avec eux ( jusqu'à un délai d'expiration ). Cela signifie que vous n'avez plus besoin d'instructions time.sleep() aléatoires dans vos scripts.
✅ SeleniumBase prend en charge tous les principaux navigateurs et systèmes d'exploitation :
Navigateurs : Chrome, Edge, Firefox et Safari.
Systèmes : Linux/Ubuntu, macOS et Windows.
✅ SeleniumBase fonctionne sur toutes les plateformes CI/CD populaires :
✅ SeleniumBase comprend une solution hybride automatisée/manuelle appelée MasterQA pour accélérer les tests manuels grâce à l'automatisation tandis que les testeurs manuels gèrent la validation.
✅ SeleniumBase prend en charge l'exécution de tests hors ligne ( en supposant que les pilotes Web aient déjà été téléchargés en ligne ).
✅ Pour une liste complète des fonctionnalités de SeleniumBase, cliquez ici.
? Le mode démo vous aide à voir ce que fait un test. Si un test avance trop vite à vos yeux, exécutez-le en mode démo pour suspendre brièvement le navigateur entre les actions, mettre en évidence les éléments de la page sur lesquels une action est effectuée et afficher les assertions :
pytest my_first_test.py --demo ? time.sleep(seconds) peut être utilisé pour faire un test d'attente à un endroit précis :
import time ; time . sleep ( 3 ) # Do nothing for 3 seconds.? Le mode débogage avec la bibliothèque pdb intégrée de Python vous aide à déboguer les tests :
import pdb ; pdb . set_trace ()
import pytest ; pytest . set_trace ()
breakpoint () # Shortcut for "import pdb; pdb.set_trace()"( commandes
pdb:n,c,s,u,d=>next,continue,step,up,down)
? Pour suspendre un test actif qui génère une exception ou une erreur ( et garder la fenêtre du navigateur ouverte pendant que le mode débogage commence dans la console ), ajoutez --pdb comme option pytest :
pytest test_fail.py --pdb ? Pour démarrer les tests en mode débogage, ajoutez --trace comme option pytest :
pytest test_coffee_cart.py --trace ✅ Voici quelques options de ligne de commande utiles fournies avec 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 fournit des options de ligne de commande pytest supplémentaires pour les tests :
--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.)(Voir la liste complète des définitions d'options de ligne de commande ici . Pour des exemples détaillés d'options de ligne de commande, voir customizing_test_runs.md )
? En cas d'échec des tests, les journaux et les captures d'écran du test le plus récent seront enregistrés dans le dossier latest_logs/ . Ces journaux seront déplacés vers archived_logs/ si vous ajoutez --archive_logs aux options de ligne de commande, ou si ARCHIVE_EXISTING_LOGS est défini sur True dans settings.py, sinon les fichiers journaux seront nettoyés au début du prochain test. La collection test_suite.py contient des tests qui échouent volontairement afin que vous puissiez voir comment fonctionne la journalisation.
cd examples/
pytest test_suite.py --chrome
pytest test_suite.py --firefox Un moyen simple de remplacer seleniumbase/config/settings.py consiste à utiliser un fichier de paramètres personnalisés. Voici l'option de ligne de commande à ajouter aux tests : (Voir examples/custom_settings.py) --settings_file=custom_settings.py (Les paramètres incluent les valeurs de délai d'expiration par défaut, une clé d'authentification à deux facteurs, les informations d'identification DB, les informations d'identification S3 et d'autres paramètres importants. utilisé par les tests.)
? Pour transmettre des données supplémentaires de la ligne de commande aux tests, ajoutez --data="ANY STRING" . Dans vos tests, vous pouvez utiliser self.data pour y accéder.
? Lors de l'exécution de tests avec pytest , vous aurez besoin d'une copie de pytest.ini dans vos dossiers racine. Lors de l'exécution de tests avec pynose , vous aurez besoin d'une copie de setup.cfg dans vos dossiers racine. Ces fichiers spécifient les détails de configuration par défaut pour les tests. Les dossiers de test doivent également inclure un fichier init .py vierge pour permettre à vos fichiers de test d'importer d'autres fichiers à partir de ce dossier.
? sbase mkdir DIR crée un dossier avec des fichiers de configuration et des exemples de tests :
sbase mkdir ui_testsCe nouveau dossier contiendra ces fichiers :
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™ : vous pouvez également créer un dossier passe-partout sans aucun exemple de test en ajoutant -b ou --basic à la commande sbase mkdir :
sbase mkdir ui_tests --basicCe nouveau dossier contiendra ces fichiers :
ui_tests/
├── __init__.py
├── pytest.ini
├── requirements.txt
└── setup.cfg Parmi ces fichiers, le fichier de configuration pytest.ini est le plus important, suivi d'un fichier __init__.py vierge. Il existe également un fichier setup.cfg (pour pynose). Enfin, le fichier requirements.txt peut être utilisé pour vous aider à installer Seleniumbase dans vos environnements (s'il n'est pas déjà installé).
Essayons un exemple de test qui échoue :
""" 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 Vous pouvez l'exécuter à partir du dossier examples/ comme ceci :
pytest test_fail.py ? Vous remarquerez qu'un dossier de journaux, "latest_logs", a été créé pour contenir des informations sur l'échec du test et des captures d'écran. Pendant les exécutions de tests, les résultats antérieurs sont déplacés vers le dossier archived_logs si ARCHIVE_EXISTING_LOGS est défini sur True dans settings.py, ou si vous exécutez des tests avec --archive-logs . Si vous choisissez de ne pas archiver les journaux existants, ils seront supprimés et remplacés par les journaux du dernier test.
? L'option --dashboard pour pytest génère un tableau de bord SeleniumBase situé dans dashboard.html , qui se met à jour automatiquement à mesure que les tests s'exécutent et produisent des résultats. Exemple:
pytest --dashboard --rs --headless ? De plus, vous pouvez héberger votre propre serveur de tableau de bord SeleniumBase sur un port de votre choix. En voici un exemple utilisant http.server de Python :
python -m http.server 1948 ? Vous pouvez maintenant accéder à http://localhost:1948/dashboard.html afin d'afficher le tableau de bord en tant qu'application Web. Cela nécessite deux fenêtres de terminal différentes : une pour exécuter le serveur et une autre pour exécuter les tests, qui doivent être exécutés à partir du même répertoire. (Utilisez Ctrl+C pour arrêter le serveur http.)
? Voici un exemple complet de ce à quoi peut ressembler le tableau de bord SeleniumBase :
pytest test_suite.py test_image_saving.py --dashboard --rs --headlesspytest : ✅ L'utilisation --html=report.html vous donne un rapport sophistiqué du nom spécifié une fois votre suite de tests terminée.
pytest test_suite.py --html=report.html ✅ Lors de la combinaison des rapports HTML pytest avec l'utilisation du tableau de bord SeleniumBase, le diagramme circulaire du tableau de bord sera ajouté au rapport HTML. De plus, si vous définissez l'URL du rapport HTML pour qu'elle soit identique à l'URL du tableau de bord lorsque vous utilisez également le tableau de bord (exemple : --dashboard --html=dashboard.html ), le tableau de bord deviendra un rapport HTML avancé lorsque tous les tests terminés.
✅ Voici un exemple de rapport html mis à jour :
pytest test_suite.py --dashboard --html=report.htmlSi vous consultez des rapports HTML pytest dans Jenkins, vous devrez peut-être configurer les paramètres Jenkins pour que le HTML s'affiche correctement. Cela est dû aux modifications apportées à Jenkins CSP.
Vous pouvez également utiliser --junit-xml=report.xml pour obtenir un rapport XML à la place. Jenkins peut utiliser ce fichier pour afficher de meilleurs rapports pour vos tests.
pytest test_suite.py --junit-xml=report.xmlpynose Rapports : L'option --report vous donne un rapport sophistiqué une fois votre suite de tests terminée.
pynose test_suite.py --report (REMARQUE : vous pouvez ajouter --show-report pour afficher immédiatement les rapports pynose une fois la suite de tests terminée. Utilisez uniquement --show-report lors de l'exécution de tests localement, car cela met l'exécution du test en pause.)
behave le tableau de bord et les rapports :(Le dossier behavior_bdd/ se trouve dans le dossier examples/.)
behave behave_bdd/features/ -D dashboard -D headless Vous pouvez également utiliser --junit pour obtenir des rapports .xml pour chaque fonctionnalité behave . Jenkins peut utiliser ces fichiers pour afficher de meilleurs rapports pour vos tests.
behave behave_bdd/features/ --junit -D rs -D headlessVoir : https://allurereport.org/docs/pytest/
SeleniumBase n'inclut plus allure-pytest dans les dépendances installées. Si vous souhaitez l'utiliser, installez-le d'abord :
pip install allure-pytestVos tests peuvent désormais créer des fichiers de résultats Allure, qui peuvent être traités par Allure Reports.
pytest test_suite.py --alluredir=allure_results Si vous souhaitez utiliser un serveur proxy pour les tests de votre navigateur (Chromium ou Firefox), vous pouvez ajouter --proxy=IP_ADDRESS:PORT comme argument sur la ligne de commande.
pytest proxy_test.py --proxy=IP_ADDRESS:PORTSi le serveur proxy que vous souhaitez utiliser nécessite une authentification, vous pouvez procéder comme suit (Chromium uniquement) :
pytest proxy_test.py --proxy=USERNAME:PASSWORD@IP_ADDRESS:PORTSeleniumBase prend également en charge les proxys SOCKS4 et SOCKS5 :
pytest proxy_test.py --proxy= " socks4://IP_ADDRESS:PORT "
pytest proxy_test.py --proxy= " socks5://IP_ADDRESS:PORT " Pour faciliter les choses, vous pouvez ajouter vos proxys fréquemment utilisés à PROXY_LIST dans proxy_list.py, puis utiliser --proxy=KEY_FROM_PROXY_LIST pour utiliser l'IP_ADDRESS:PORT de cette clé.
pytest proxy_test.py --proxy=proxy1 ? Si vous souhaitez modifier le User-Agent pour les tests de votre navigateur (Chromium et Firefox uniquement), vous pouvez ajouter --agent="USER AGENT STRING" comme argument sur la ligne de commande.
pytest user_agent_test.py --agent= " Mozilla/5.0 (Nintendo 3DS; U; ; en) Version/1.7412.EU " ? self.accept_alert() attend et accepte automatiquement les fenêtres contextuelles d'alerte. self.dismiss_alert() attend et rejette automatiquement les fenêtres contextuelles d'alerte. Parfois, certaines méthodes comme self.click(SELECTOR) peuvent rejeter une fenêtre contextuelle d'elles-mêmes car elles appellent JavaScript pour s'assurer que l' readyState de la page est complete avant de continuer. Si vous essayez d'accepter une fenêtre contextuelle qui a été rejetée de cette façon, utilisez cette solution de contournement : appelez plutôt self.find_element(SELECTOR).click() (ce qui permettra à la fenêtre contextuelle de rester à l'écran), puis utilisez self.accept_alert() pour accepter la fenêtre contextuelle (plus d'informations à ce sujet ici). Si les fenêtres contextuelles sont intermittentes, enveloppez le code dans un bloc try/sauf.
? Découvrez les procédures pas à pas interactives de SeleniumBase (dans le dossier examples/tour_examples/ ). C'est idéal pour prototyper une expérience d'intégration de site Web.
--with-s3-logging sur la ligne de commande lors de l'exécution de vos tests.Voici un exemple d'exécution de tests avec quelques fonctionnalités supplémentaires activées :
pytest [YOUR_TEST_FILE.py] --with-db-reporting --with-s3-logging? Navigation vers une page Web : (et commandes associées)
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™ : vous pouvez utiliser la méthode self.get_page_source() avec la commande find() de Python pour analyser le code HTML afin de trouver quelque chose de spécifique. (Pour une analyse plus avancée, voir l'exemple 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 ]? En cliquant :
Pour cliquer sur un élément de la page :
self . click ( "div#my_id" ) ProTip™ : dans la plupart des navigateurs Web, vous pouvez cliquer avec le bouton droit sur une page et sélectionner Inspect Element pour voir les détails du sélecteur CSS dont vous aurez besoin pour créer vos propres scripts.
? Saisie de texte :
self.type(selector, text) # met à jour le texte de l'élément spécifié avec la valeur spécifiée. Une exception est levée si l'élément est manquant ou si le champ de texte n'est pas modifiable. Exemple:
self . type ( "input#id_value" , "2012" ) Vous pouvez également utiliser self.add_text() ou la commande WebDriver .send_keys() , mais celles-ci n'effaceront pas d'abord la zone de texte s'il y a déjà du texte à l'intérieur.
? Récupérer le texte d'un élément sur une page :
text = self . get_text ( "header h2" )? Obtenir la valeur de l'attribut d'un élément sur une page :
attribute = self . get_attribute ( "#comic img" , "title" )? Affirmation de l'existence d'un élément sur une page en un certain nombre de secondes :
self . wait_for_element_present ( "div.my_class" , timeout = 10 ) (REMARQUE : vous pouvez également utiliser : self.assert_element_present(ELEMENT) )
? Affirmation de la visibilité d'un élément sur une page en un certain nombre de secondes :
self . wait_for_element_visible ( "a.my_class" , timeout = 5 ) (REMARQUE : les versions courtes sont self.find_element(ELEMENT) et self.assert_element(ELEMENT) . La version find_element() renvoie l'élément.)
Puisque la ligne ci-dessus renvoie l'élément, vous pouvez le combiner avec .click() comme indiqué ci-dessous :
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™ : Vous pouvez utiliser des points pour signifier les noms de classe (Ex : div.class_name ) comme version simplifiée de div[class="class_name"] dans un sélecteur CSS.
Vous pouvez également utiliser *= pour rechercher n'importe quelle valeur partielle dans un sélecteur CSS, comme indiqué ci-dessous :
self . click ( 'a[name*="partial_name"]' )? Affirmation de la visibilité du texte à l'intérieur d'un élément sur une page en un certain nombre de secondes :
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 ) (REMARQUE : self.find_text(TEXT, ELEMENT) et self.wait_for_text(TEXT, ELEMENT) font également cela. Pour des raisons de compatibilité ascendante, les anciens noms de méthodes ont été conservés, mais le délai d'expiration par défaut peut être différent.)
? Affirmer quoi que ce soit :
self . assert_true ( var1 == var2 )
self . assert_false ( var1 == var2 )
self . assert_equal ( var1 , var2 )? Déclarations conditionnelles utiles : (avec des exemples créatifs)
❓ is_element_visible(selector): (visible sur la page)
if self . is_element_visible ( 'div#warning' ):
print ( "Red Alert: Something bad might be happening!" ) ❓ is_element_present(selector): (présent dans le 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): (texte visible sur l'élément)
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 votre test ouvre un nouvel onglet/une nouvelle fenêtre, vous pouvez y accéder. (SeleniumBase bascule automatiquement vers de nouveaux onglets qui ne s'ouvrent pas sur les URL about:blank .)
self . switch_to_window ( 1 ) # This switches to the new tab (0 is the first one)? Les iframes suivent le même principe que les nouvelles fenêtres : Vous devez d'abord basculer vers l'iframe si vous souhaitez y effectuer des actions :
self . switch_to_frame ( "iframe" )
# ... Now perform actions inside the iframe
self . switch_to_parent_frame () # Exit the current iframe Pour quitter plusieurs iframes, utilisez self.switch_to_default_content() . (Si vous êtes à l'intérieur d'une seule iframe, cela a le même effet 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? Vous pouvez également utiliser un gestionnaire de contexte pour agir à l'intérieur des iframes :
with self . frame_switch ( "iframe" ):
# ... Now perform actions while inside the code block
# You have left the iframeCela fonctionne également avec les iframes imbriquées :
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 est une puissante bibliothèque JavaScript qui vous permet d'effectuer des actions avancées dans un navigateur Web. Si jQuery est déjà chargé sur la page Web sur laquelle vous vous trouvez, vous pouvez commencer à exécuter des scripts jQuery immédiatement. Vous le sauriez car la page Web contiendrait quelque chose comme ce qui suit dans le code HTML :
< script src =" https://ajax.googleapis.com/ajax/libs/jquery/3.6.3/jquery.min.js " > </ script >? Ce n'est pas grave si vous souhaitez utiliser jQuery sur une page qui ne l'a pas encore chargée. Pour ce faire, exécutez d'abord la commande suivante :
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 plupart des commandes ci-dessus peuvent être effectuées directement avec les méthodes SeleniumBase intégrées.)
❗ Certains sites Web ont une politique de sécurité du contenu restrictive pour empêcher les utilisateurs de charger jQuery et d'autres bibliothèques externes sur leurs sites Web. Si vous devez utiliser jQuery ou une autre bibliothèque JS sur ces sites Web, ajoutez --disable-csp comme option de ligne de commande pytest pour charger une extension Chromium qui contourne le 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 (En raison de la demande générale, cet exemple de génération de trafic a été inclus dans SeleniumBase avec les méthodes self.generate_referral(start_page, end_page) et self.generate_traffic(start_page, end_page, loops) .)
Supposons que vous souhaitiez vérifier plusieurs éléments différents sur une page Web en un seul test, mais que vous ne vouliez pas que le test échoue tant que vous n'aurez pas vérifié plusieurs éléments à la fois afin de ne pas avoir à réexécuter le test pour trouver d'autres éléments manquants. éléments sur la même page. C'est là qu'interviennent les assertions différées. Voici un exemple :
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() et deferred_assert_text() enregistreront toutes les exceptions qui seraient déclenchées. Pour éliminer toutes les assertions différées ayant échoué en une seule exception, assurez-vous d'appeler self.process_deferred_asserts() à la fin de votre méthode de test. Si votre test atteint plusieurs pages, vous pouvez appeler self.process_deferred_asserts() avant de naviguer vers une nouvelle page afin que la capture d'écran de vos fichiers journaux corresponde à l'URL où les assertions différées ont été effectuées.
Si vous avez besoin d'accéder à des commandes fournies avec WebDriver standard, vous pouvez les appeler directement comme ceci :
self . driver . delete_all_cookies ()
capabilities = self . driver . capabilities
self . driver . find_elements ( "partial link text" , "GitHub" )(En général, vous souhaiterez utiliser les versions des méthodes SeleniumBase lorsqu'elles sont disponibles.)
Vous pouvez utiliser pytest --reruns=NUM pour réessayer les tests ayant échoué autant de fois. Ajoutez --reruns-delay=SECONDS pour attendre autant de secondes entre les tentatives. Exemple:
pytest --reruns=1 --reruns-delay=1 Vous pouvez utiliser le décorateur @retry_on_exception() pour réessayer les méthodes défaillantes. (Première importation : from seleniumbase import decorators ). Pour en savoir plus sur les décorateurs SeleniumBase, cliquez ici.
"Détectez les bugs dans le contrôle qualité avant de déployer le code en production !"
