Quand il s’agit d’automatiser les tests frontaux, le choix du langage de programmation idéal devient extrêmement crucial. Python est l’un de ces langages qui figure en tête de liste, en raison de sa facilité d’utilisation et du soutien de sa communauté étendue.
De plus, les tests d’automatisation en Python vous permettent de tirer parti des capacités offertes par des bibliothèques et des cadres populaires tels que Selenium, pytest et Robot, entre autres. L’utilisation de Selenium avec Python aide à tirer le meilleur parti des puissantes capacités d’automatisation du navigateur de Selenium et de la simplicité et de l’extensibilité de Python. Globalement, les tests d’automatisation en Python sont largement utilisés par les AQ partout, en particulier avec Selenium WebDriver.
Dans ce blog, nous plongerons profondément dans les subtilités de Python d’un point de vue front-end. Les enseignements de ce blog seront utiles pour exploiter les capacités de Python afin d’automatiser des scénarios frontaux simples ainsi que complexes.
Qu’est-ce que les tests d’automatisation en Python?
Comme son nom l’indique, les tests d’automatisation en Python sont le processus d’utilisation de scripts Python pour automatiser des tests. C’est l’un des langages de programmation les plus recherchés pour l’automatisation des tâches manuelles et répétitives.
Un exemple simple de test d’automatisation en Python implique l’utilisation du framework pytest avec Selenium pour automatiser des tests frontaux sur une plateforme de commerce électronique. Vous pouvez vérifier la fonctionnalité d’inscription d’un site web de commerce électronique et utiliser la même session pour naviguer sur le site et ajouter les articles nécessaires au panier. À la fin de ce test, vous aurez vérifié les fonctionnalités d’inscription, de connexion et de panier du site de commerce électronique.
Enfin, vous pouvez également exploiter Python pour automatiser l’administration système, l’envoi d’e-mails et les tâches de traitement des données. Comme Python est un prérequis pour les tests automatisés, veuillez vous référer à la vidéo ci-dessous, qui plonge profondément dans l’installation de Python.
Pourquoi Python pour les tests automatisés ?
Maintenant que nous savons pourquoi les testeurs préfèrent Selenium avec Python, examinons quelques-unes des raisons essentielles de choisir Python pour les tests d’automatisation :
1. Large gamme de bibliothèques et de frameworks
PyUnit (ou unittest) est le framework de test par défaut pour effectuer des tests unitaires en Python. Bien que PyUnit soit disponible en standard, Python prend en charge d’autres frameworks populaires comme pytest, Behave, Robot, Lettuce et Nose2.
Tous peuvent être utilisés de manière exhaustive avec les frameworks Selenium et Playwright pour automatiser les tests de navigateur web.
2. Exécution de tests parallèles super facile
Les tests parallèles dans Selenium et Python peuvent être largement utilisés pour effectuer des tests d’automatisation de navigateur web sur différentes combinaisons de navigateurs et de plates-formes. Bien que tous les langages supportés par Selenium prennent en charge l’exécution de tests parallèles, c’est très facile à utiliser avec Python.
3. Langage de programmation multi-paradigme
Python est un langage de programmation multi-paradigme. Par conséquent, il offre un support complet pour la programmation orientée objet et la programmation structurée. La majorité des fonctionnalités de Python prennent en charge la programmation fonctionnelle et la programmation orientée aspect. Python, associé à Selenium, peut également être utilisé pour tester des sites web et des applications web de manière fonctionnelle.
4. Typage dynamique
Le langage Python utilise un typage dynamique et une liaison tardive (ou résolution dynamique des noms) qui lie les méthodes et les noms de variables pendant l’exécution. Cette fonctionnalité est très pratique pour l’automatisation des tests en Python.
Python offre également des options telles que Pyre (un vérificateur de type performant pour Python 3) et Mypy, qui sont des vérificateurs de type statique populaires. Avec ces vérificateurs, Python vous permet de combiner la puissance du typage dynamique et statique.
5. Extraction de données web
L’extraction de données web avec Python est le processus d’extraction d’informations/données significatives et utiles à partir de sites web. Elle est principalement utilisée pour la recherche académique, l’analyse concurrentielle, l’agrégation de contenu, et plus encore.
Python propose un certain nombre de bibliothèques et de frameworks, notamment BeautifulSoup (bs4), Selenium, Puppeteer et Pyppeteer, qui facilitent la tâche d’extraire du contenu des sites web.
6. Rapports puissants et sans tracas
La génération de rapports dans l’automatisation des tests offre une meilleure visibilité sur les nuances de l’exécution des tests (c’est-à-dire le pourcentage de tests réussis/échoués, l’environnement de test, les captures d’écran, etc.). Des rapports puissants qui fournissent les bonnes informations de manière concise et compréhensible peuvent être envoyés aux parties prenantes nécessaires (dans l’équipe) afin qu’elles soient informées des progrès réalisés dans le domaine des tests.
Comment réaliser des tests d’automatisation en Python?
Maintenant que nous avons examiné l’importance des tests d’automatisation en Python, mettons-nous au travail en exécutant quelques tests. Notre discussion portera principalement sur les tests automatisés de l’interface utilisateur avec Python.
Avant de commencer les tests, configurons l’environnement virtuel (venv), qui aide à gérer l’environnement et les dépendances de manière plus efficace. venv joue un rôle essentiel en offrant une isolation par rapport aux packages installés dans l’environnement de base.
Exécutez les commandes virtualenv venv et source venv/bin/activate dans le terminal pour créer l’environnement virtuel. Toutes les dépendances (ou packages Python), comme pytest, selenium, etc., nécessaires à l’exécution du projet sont disponibles dans le fichier requirements.txt.
pytest-selenium
pytest-xdist
selenium>=4.6.0
urllib3==1.26.12
requests
py
Dépendances
Les dépendances peuvent être installées en déclenchant pip install -r requirements.txt dans le terminal. Selenium v4.6.0 (ou version ultérieure) est installé dans le cadre de la procédure d’installation.
Pour la démonstration, nous exécuterions des tests Selenium Python simples avec les frameworks pytest et PyUnit (ou unittest). Si vous maîtrisez l’un de ces frameworks, il est recommandé d’utiliser les fixtures en Python et le modèle Page Object en Selenium Python pour une meilleure maintenance des tests. Le package Selenium lui-même ne fournit pas d’outil ou de framework de test. Par conséquent, nous utiliserions Selenium avec pytest et PyUnit pour automatiser les interactions avec les éléments de la page web.
Scénario de test
- Accéder au terrain de jeu LambdaTest Selenium.
- Trouver le lien Soumettre le formulaire d’entrée sur la page.
- Entrer les informations requises sur la page.
- Envoyer les détails et vérifier si les informations n’ont pas été soumises avec succès.
Mise en œuvre (Framework pytest)
Voici le script de test pour le scénario de test ci-dessus :
import os
import pytest
from os import environ
import time
from selenium.webdriver import ChromeOptions
from selenium.webdriver.support.ui import WebDriverWait
from selenium import webdriver
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.ui import Select
from selenium.webdriver.common.by import By
exec_platform = os.getenv('EXEC_PLATFORM')
time_sleep = 2
########################## Locators #########################
xSubmitForm = "//a[.='Input Form Submit']"
xInpName = "//input[@id='name']"
cInpName = "#name"
xInpEmail = "//form[@id='seleniumform']//input[@name='email']"
xInpPassword = "//input[@name='password']"
cssCompany = "#company"
cWebName = "#websitename"
xInpCountry = "//select[@name='country']"
xInpCity = "//input[@id='inputCity']"
cssAddress1 = "[placeholder='Address 1']"
cssAddress2 = "[placeholder='Address 2']"
cssInpState = "#inputState"
cssInpZip = "#inputZip"
cssInpButton = ".bg-lambda-900"
nameSearchBox = "search"
class TestFormInput:
def setup_method(self):
if exec_platform == 'cloud':
username = environ.get('LT_USERNAME', None)
access_key = environ.get('LT_ACCESS_KEY', None)
ch_options = webdriver.ChromeOptions()
lt_options = {}
lt_options["build"] = "Build: Getting Started with Selenium PyTest"
lt_options["project"] = "Project: Getting Started with Selenium PyTest"
lt_options["name"] = "Test: Getting Started with Selenium PyTest"
lt_options["browserName"] = "Chrome"
lt_options["browserVersion"] = "latest"
lt_options["platformName"] = "macOS Sonoma"
lt_options["geoLocation"] = "US"
lt_options["console"] = "error"
lt_options["w3c"] = True
lt_options["headless"] = False
ch_options.set_capability('LT:Options', lt_options)
gridURL = "https://{}:{}@hub.lambdatest.com/wd/hub".format(username, access_key)
self.driver = webdriver.Remote(
command_executor = gridURL,
options = ch_options
)
elif exec_platform == 'local':
ch_options = ChromeOptions()
self.driver = webdriver.Chrome(options=ch_options)
def test_enter_form_details(self):
resultant_str = "Thanks for contacting us, we will get back to you shortly."
driver = self.driver
driver.get("https://www.lambdatest.com/selenium-playground/")
# Commented once the tests are executed in non-headless mode
driver.maximize_window()
wait = WebDriverWait(driver, 5)
try:
element = driver.find_element(By.XPATH, xSubmitForm)
element.click()
elem_name = driver.find_element(By.XPATH, xInpName)
elem_name.send_keys("Testing")
time.sleep(time_sleep)
elem_email = driver.find_element(By.XPATH, xInpEmail)
elem_email.send_keys("[email protected]")
time.sleep(time_sleep)
elem_pass = driver.find_element(By.XPATH, xInpPassword)
elem_pass.send_keys("password")
time.sleep(time_sleep)
elem_comp = driver.find_element(By.CSS_SELECTOR, cssCompany)
elem_comp.send_keys("LambdaTest")
elem = driver.find_element(By.CSS_SELECTOR, cWebName)
elem.send_keys("https://wwww.lambdatest.com")
country_dropdown = Select(driver.find_element(By.XPATH, xInpCountry))
country_dropdown.select_by_visible_text("United States")
time.sleep(time_sleep)
elem = driver.find_element(By.XPATH, xInpCity)
elem.send_keys("San Jose")
time.sleep(time_sleep)
elem = driver.find_element(By.CSS_SELECTOR, cssAddress1)
elem.send_keys("Googleplex, 1600 Amphitheatre Pkwy")
time.sleep(time_sleep)
elem = driver.find_element(By.CSS_SELECTOR, cssAddress2)
elem.send_keys("Mountain View, CA 94043")
time.sleep(time_sleep)
elem = driver.find_element(By.CSS_SELECTOR, cssInpState)
elem.send_keys("California")
time.sleep(time_sleep)
elem = driver.find_element(By.CSS_SELECTOR, cssInpZip)
elem.send_keys("94088")
time.sleep(time_sleep)
# Click on the Submit button
submit_button = driver.find_element(By.CSS_SELECTOR, cssInpButton)
submit_button.click()
time.sleep(2)
try:
element = wait.until(
EC.presence_of_element_located((By.CSS_SELECTOR, ".success-msg"))
)
assert resultant_str in element.text, f"'{resultant_str}' not found in the specified element."
except Exception as e:
if exec_platform == 'cloud':
driver.execute_script("lambda-status=failed")
pytest.fail(f"Text '{resultant_str}' not found: {str(e)}")
time.sleep(2)
except Exception as e:
# Catch other exceptions
print(f"Failed: Input Form Demo, generic exception - {e}")
if exec_platform == 'cloud':
driver.execute_script("lambda-status=failed")
if exec_platform == 'cloud':
driver.execute_script("lambda-status=passed")
print(f"PyTest Demo: Test Passed")
def teardown_method(self):
if (self.driver != None):
# self.driver.close()
self.driver.quit()
if __name__ == "__main__":
pytest.main()
Parcours du code
Pour commencer, nous importons d’abord les modules nécessaires pour l’implémentation des tests. Comme nous utilisons pytest, le module pytest est également importé dans le code.
La classe WebDriverWait du module selenium.webdriver.support.ui est importée afin que nous puissions utiliser des attentes explicites pour les scénarios où les WebElements sont situés de manière dynamique. Le module expected_conditions fournit un ensemble de ExpectedConditions prédéfinis dans Selenium qui peuvent être utilisés avec des attentes explicites.
Comme les éléments doivent être localisés avant d’effectuer une action, nous définissons d’abord les localisateurs d’éléments requis. L’ID, le Nom, le XPath, le Texte du Lien, le Texte de Lien Partiel, etc., sont quelques-uns des localisateurs web largement utilisés qui vous aident à trouver des éléments dans le Modèle d’Objet de Document (DOM).
Vous pouvez utiliser les outils d’inspection disponibles nativement dans le navigateur web ou un plugin (ou module complémentaire) comme POM Builder qui facilite la recherche du XPath/Sélecteur CSS des WebElements.
Une fois le localisateur web identifié, le ou les WebElement(s) respectifs sont localisés en combinant le localisateur avec la méthode find_element() ou find_elements() de Selenium Python. La méthode find_element() renvoie un seul WebElement, tandis que find_elements() renvoie une liste de WebElements correspondant aux critères de localisation.
Comme mentionné précédemment, la méthode setup_method() est un fixture pytest qui fait partie de l’initialisation. La méthode est appelée avant que chaque fonction de test ne soit implémentée sous ladite classe de test.
Les tests en cours d’implémentation peuvent être exécutés sur Selenium installé sur la machine locale ainsi que sur la grille Selenium en ligne offerte par le test cloud. LambdaTest est une plateforme d’exécution de tests alimentée par l’IA qui vous permet d’exécuter des tests automatisés en Python à grande échelle sur différents navigateurs et systèmes d’exploitation. Elle offre de nombreux avantages, les principaux étant une maintenance réduite, des coûts inférieurs et une exécution de tests accélérée.
En ce qui concerne la mise en œuvre, le seul changement concerne Selenium WebDriver, où Remote WebDriver de Selenium est instancié lors de l’exécution des tests sur une grille cloud. Le générateur de capacités d’automatisation aide à générer des capacités pour la combinaison de tests destinée à être utilisée dans les tests.
Dans Selenium 4, les options de navigateur sont utilisées à la place des capacités désirées. Vous pouvez consulter le blog des différences entre Selenium 3 et Selenium 4 pour en savoir plus sur ce qui est obsolète et ce qui est obsolète dans Selenium 4.
Les variables d’environnement LT_USERNAME et LT_ACCESS_KEY peuvent être obtenues à partir des paramètres de votre compte LambdaTest > Mot de passe et sécurité. La combinaison, lorsqu’elle est transmise avec l’URL de la grille LambdaTest, aide à exécuter des tests sur la grille cloud. Dans la méthode test_enter_form_details(), nous naviguons d’abord vers l’URL du test en invoquant la méthode driver.get().
Ensuite, la fenêtre du navigateur instanciée est maximisée car il est considéré comme l’une des meilleures pratiques de Selenium.
Ensuite, l’élément de soumission de formulaire d’entrée est localisé en utilisant la méthode find_element() avec le localisateur XPath dans Selenium. Une fois localisé, le clic sur le bouton dans Selenium est invoqué pour simuler l’action de clic sur l’élément de bouton localisé à l’étape précédente.
Puisque toutes les étapes de test impliquent la localisation des éléments et l’exécution d’actions, nous nous concentrons sur seulement quelques méthodes. L’approche utilisée pour localiser l’élément de l’entreprise via le sélecteur CSS dans Selenium est présentée ci-dessous. Le send_keys() dans Selenium WebDriver aide à envoyer une entrée de texte dans l’élément localisé.
Les dropdowns sont largement utilisés sur les sites web ; par conséquent, automatiser les interactions avec les dropdowns en utilisant Selenium devient absolument indispensable pour vos cas de test. La classe Select du module selenium.webdriver.support.ui fournit des méthodes qui vous permettent de manipuler les dropdowns avec Selenium.
Ici, un objet (c’est-à-dire country_dropdown) de la classe Select est créé avec l’entrée définie sur l’élément dropdown localisé avec XPath. La méthode select_by_visible_text() de la classe Select permet de sélectionner des éléments avec un texte visible correspondant à la chaîne donnée (c’est-à-dire, États-Unis).
Une fois que toutes les informations dans le formulaire sont entrées et que le bouton Submit est cliqué, nous attendons jusqu’à ce que la chaîne du message de réussite (par défaut : cachée) soit visible sur la page. Une attente explicite avec l’ExpectedCondition (c’est-à-dire, la présence de l’élément localisé) est effectuée jusqu’à ce que le message de réussite ne soit pas sur la page.
Une assertion est déclenchée si la chaîne résultante n’est pas présente sur la page. Pour l’exécution sur le cloud, la variable lambda-status est marquée comme passed/failed en fonction de l’état de l’exécution.
La fixture teardown_method() contient une implémentation pour nettoyer les ressources ou l’état après l’exécution des tests dans la classe. La construction if __name__ == "__main__": assure que le code est exécuté uniquement lorsque le script est exécuté directement. L’appel à pytest.main() appelle le framework pytest qui découvre et exécute tous les tests activés (c’est-à-dire, non marqués comme skipped) dans le script.
Exécution des tests (framework pytest)
Après avoir défini EXEC_PLATFORM sur cloud, invoquez la commande suivante dans le terminal pour exécuter les tests pytest sur la grille cloud de LambdaTest :
pytest --verbose --capture=no tests/pytest/pytest_selenium_demo.py
Ci-dessous se trouve la capture d’écran du tableau de bord d’automatisation Web de LambdaTest qui indique que l’exécution du test a réussi :
Implémentation (framework PyUnit)
Le script de test pour le scénario de test mentionné ci-dessus en utilisant le framework PyUnit se trouve dans le fichier tests/pyunit/pyunit_selenium_demo.py.
La logique centrale du test reste inchangée lors de la migration de pytest vers le framework PyUnit (ou unittest). Au lieu du module pytest, le module unittest est importé dans le code. La classe de cas de test hérite de unittest.TestCase informe le module unittest qu’il s’agit d’un cas de test.
Les fixtures pytest setup_method()/teardown() sont similaires aux méthodes setUp()/tearDown() du framework PyUnit. Les méthodes setUp() et tearDown() consistent en une implémentation dont la responsabilité est l’initialisation et la désinitialisation, respectivement.
Voici le code de base pour exécuter la suite de tests :
if __name__ == "__main__":
unittest.main()
Exécution des tests (Cadre PyUnit)
Après avoir défini EXEC_PLATFORM sur cloud, invoquez la commande suivante dans le terminal pour exécuter les tests PyUnit sur le cloud grid:
python tests/pyunit/pyunit_selenium_demo.py
Voici ci-dessous une capture d’écran du tableau de bord d’automatisation Web LambdaTest qui indique que l’exécution du test a été réussie:
Si vous souhaitez exécuter les tests ci-dessus sur Selenium installé sur la machine locale, définissez simplement EXEC_PLATFORM sur local, et vous êtes prêt pour l’exécution locale.
Meilleurs cadres de test Python
Puisque Python prend en charge plusieurs cadres d’automatisation de test, choisir le bon cadre devient extrêmement crucial pour votre projet. Le choix pose en fait les bases d’un test efficace. En plus des capacités du cadre, vous devez également tenir compte de l’expertise interne avec ledit cadre. Voici quelques-uns des meilleurs cadres de test Python:
PyUnit (unittest)
C’est le cadre par défaut disponible en Python. Comme son nom l’indique, il est principalement utilisé pour les tests unitaires. PyUnit s’inspire du cadre JUnit pour Java et partage une structure et une fonctionnalité similaires.
Le cadre unittest prend également en charge l’automatisation des tests, le partage du code de configuration et d’arrêt pour les tests, l’indépendance des tests par rapport au cadre de reporting, et plus encore. Il prend également en charge les suites de tests et les cas de tests de manière orientée objet. Il dispose également d’un exécuteur de tests qui est un composant responsable de l’orchestration de l’exécution des tests.
pytest
C’est l’un des cadres d’automatisation des tests les plus populaires pour Python. Il utilise une syntaxe moins verbeuse et plus conviviale pour implémenter des tests. pytest peut être utilisé pour mettre en œuvre des tests unitaires ainsi que des tests fonctionnels complexes pour tester des sites Web et des applications Web.
Les tests écrits avec pytest sont beaucoup plus compacts, car le cadre ne nécessite pas de code répétitif. pytest dispose de fonctionnalités intégrées qui aident à la découverte automatique des modules et des fonctions de test.
Robot
C’est un cadre Python open-source basé sur des mots-clés, qui est principalement utilisé pour l’automatisation des processus robotisés (RPA) et l’automatisation des tests. Tout comme le cadre pytest, Robot est également extensible. L’utilisation d’une syntaxe/mots-clés lisibles par l’homme minimise la courbe d’apprentissage impliquée dans l’apprentissage de Robot.
Les tests écrits dans Robot sont sauvegardés avec une extension .robot. Si vous prévoyez d’utiliser Robot pour des tests front-end, vous pouvez le faire avec la SeleniumLibrary, qui est une bibliothèque de tests Web pour Robot Framework. La bibliothèque prend en charge une gamme exhaustive de mots-clés (Cliquez sur le bouton, Cliquez sur l’image, Ouvrir le navigateur, Glisser-déposer, entre autres).
Nose2
C’est le successeur de Nose et c’est un framework de test Python qui étend les capacités du framework PyUnit (ou unittest). Il est relativement facile de commencer avec Nose2 si vous avez déjà une expérience de travail avec unittest.
L’avantage majeur de Nose2 par rapport à PyUnit est la disponibilité d’un grand nombre de plugins Nose intégrés qui rendent les tests plus faciles et plus rapides. Les plugins dans Nose2 aident à la paramétrisation des tests, à une meilleure organisation des tests, au support des fixtures, à la découverte des tests, et plus encore.
Behave
C’est un framework Python utilisé pour le Développement Piloté par le Comportement (BDD). Les tests sont basés sur la syntaxe Gherkin, qui suit le format Given-When-Then.
Étant donné que les tests sont mis en œuvre dans des fichiers de scénarios et de fonctionnalités, même le personnel non technique peut participer au processus de QA. SpecFlow (C#) et Cucumber (Java, JS, Ruby) sont d’autres frameworks BDD populaires.
Conclusion
Comme nous l’avons vu jusqu’à présent, Python est de loin le meilleur langage de script pour l’automatisation des tests. Il est relativement facile de commencer avec les tests d’automatisation en Python. Sa large gamme de frameworks de test peut être utilisée pour les tests unitaires, les tests multi-navigateurs, et plus encore. Faites-nous savoir ci-dessous votre langage de programmation préféré pour les tests Selenium et comment vous le comparez à Python, le roi incontesté des tests d’automatisation. Joyeux tests!
Source:
https://dzone.com/articles/python-automation-testing-with-examples