Comment construire un framework Selenium / BDD avec Python ?

La liaison de Selenium avec Python fournit une API simple pour écrire des tests fonctionnels / d’acceptation à l’aide de Selenium WebDriver. Grâce à l’API Selenium Python, vous pouvez accéder à toutes les fonctionnalités de Selenium WebDriver de manière intuitive. Les liaisons de Python avec Selenium fournissent également une API pratique pour accéder aux Selenium WebDriver tels que Firefox, IE, Chrome, etc.

1. Qu’est-ce que Python ?

Python est un langage de programmation interprété, orienté objet et de haut niveau avec une sémantique dynamique. Sa structure de données intégrée de haut niveau, combinée à une frappe et une liaison dynamiques, le rend très attrayant pour le développement rapide d’applications, ainsi que pour une utilisation en tant que langage de script ou de collage pour connecter les composants existants entre eux. La syntaxe simple et facile à apprendre de Python met l’accent sur la lisibilité et, par conséquent, réduit le coût de la maintenance du programme. Python prend en charge les modules et les packages, ce qui encourage la modularité du programme et la réutilisation du code.

1.1 Pourquoi Python est-il utile pour les tests d’automatisation ?

• Python est très utile pour les tests d’automatisation car il prend en charge plusieurs modèles de programmation. Il est notamment largement utilisé pour réaliser des tests Selenium avec Python.
• Python possède de nombreux frameworks de test intégrés tels que Pytest et Robot , qui couvrent le débogage et un flux de travail plus rapide.
• Il s’agit d’un langage interprété signifie que l’interpréteur implémente le code ligne par ligne à un moment qui facilite le débogage.
• Python est un langage multiplateforme; c’est pourquoi il peut fonctionner sur différentes plateformes comme Windows, Linux, UNIX et Macintosh,
• Python peut être facilement implémenté avec d’autres langages de programmation tels que C, C ++, JAVA , etc.

2. Qu’est-ce que Selenium ?

Selenium est un outil d’automatisation open source pour tester votre application web. Vous pouvez le faire de différentes manières. Par exemple :

• Selenium prend en charge plusieurs langages tels que Java, C #, Python, Ruby etc.
• Selenium a des composants comme, IDE, WebDriver.

2.1 Pourquoi nous utilisons Selenium pour les tests d’automatisation ?

Selenium est l’un des outils de test d’automatisation les plus populaires. Les tests automatiques sont un processus de conversion de n’importe quel scénario de test manuel en scripts de test à l’aide d’outils d’automatisation tels que Selenium.

Voici quelques aspects qui, pourquoi nous préférons Selenium pour les tests d’automatisation :

• Les scripts de test Selenium peuvent être écrits dans n’importe quel langage de programmation comme Java, Python, C #, Ruby, Perl , etc.;
• Les scripts de test Selenium peuvent être exécutés sur des nombreuses plates-formes de système d’exploitation telles que Windows, Mac, Linux , etc;
• Et les scripts de test peuvent être implémentés sur différents navigateurs comme Google Chrome, Mozilla Firefox, Internet Explorer , Safari , etc;
• L’outil de test Selenium peut être associé à d’autres outils de test tels que TestNG, Junit pour gérer les cas de test et générer des rapports de test;
• Pour réaliser des tests en continu, Selenium est intégré aux outils de test Maven, Jenkins et Docker.

3. Qu’est-ce que Behavior driven development ?

3.1 Behavior-driven development (BDD)

Behave est un framework de test construit sur les liaisons du langage Selenium avec Python qui prend en charge le cadre de développement basé sur le comportement (BDD). Il définit le comportement de l’application à l’aide d’un texte anglais simple, défini par une langue appelée Gherkin. Pour savoir plus sur le BDD vous pouvez consulter cet article.

3.2 Gherkin

Gherkin utilise un ensemble de mots-clés spéciaux pour donner une structure et un sens aux spécifications exécutables. Gherkin permet d’écrire des scénarios de test compréhensibles par des individus non techniques. Cette approche sert deux objectifs : documenter les fonctionnalités à développer d’une part, et permettre l’automatisation des tests d’autre part.

La plupart des lignes d’un document Gherkin commencent par l’un des mots-clés:

• Le “Given” mot-clé précède le texte définissant le contexte; l’état connu du système (ou condition préalable).
• Le “When” mot-clé précède le texte définissant une action.
• Le “Then” mot-clé précède le texte définissant le résultat de l’action sur le contexte (ou résultat attendu).

4. Avantages de Python avec Selenium

• Par rapport à d’autres langages, Python Selenium prend moins de temps pour exécuter le script et terminer l’exécution.
• Python Selenium utilise l’indentation, pas les accolades ({}), ce qui facilite la compréhension du flux de code.
• Selenium Python est plus simple et plus compact.

5. Pourquoi Selenium avec Python ?

Tout comme la combinaison Selenium et JAVA, la combinaison Selenium et Python offre de nombreuses variétés de tests :

• Vous pouvez automatiser les applications Web / UI / Mobile ;
• Vous pouvez automatiser le remplissage de formulaires ou de données sur n’importe quel site Web ;
• Vous pouvez planifier un système de messagerie électronique automatisé pour diffuser le contenu de votre blog ou un publipostage personnalisé ;
• Vous pouvez tester les services Web / les tests de l’API REST ;
• Vous pouvez automatiser les tests de test au niveau BDD / TDD pour faire la démonstration du nouveau produit / fonction développé.

6. Fonctionnement de Selenium avec Python

La première étape consiste à écrire vos tests fonctionnels à l’aide du Selenium Web Driver, après cela, vous devez envoyer une demande au serveur Selenium, puis les scénarios de test sont exécutés sur différents navigateurs. Il peut s’agir de Google Chrome, Internet Explorer ou Mozilla Firefox.

7. Localisation des éléments Web à l’aide de Python et Selenium

Le langage de programmation Python offre divers cadres comme Django, flask etc. Vous pouvez le personnaliser avec des thèmes et des plugins et il vous permet également d’améliorer la productivité tout en codant en fournissant certaines fonctionnalités comme des suggestions, VCS local, etc. Vous pouvez écrire des scripts Selenium en Python en utilisant n’importe quel des outils comme Jupyter Notebook, Anaconda et PyCharm.

Le localisateur est une adresse qui identifie un élément Web de manière unique dans la page Web. Les localisateurs sont les propriétés HTML d’un élément Web qui indiquent à Selenium l’élément dont il a besoin pour effectuer l’action. Selenium utilise des localisateurs pour interagir avec les éléments de la page Web.

Chaque commande Selenium nécessite des localisateurs pour trouver des éléments Web. Ainsi, pour identifier ces éléments web avec précision et précision, nous avons différents types de localisateurs, à savoir:

• Identifiant
• Nom
• linkText
• Sélecteur CSS
• partiallinkText et
• XPath

8. Configurer Selenium à l’aide de Python

Les étapes suivantes permettent de configurer Selenium à l’aide de Python:

• Téléchargez et installez Python sur Windows;
• Installer les bibliothèques Selenium en Python à l’aide de la commande;

pip install -U selenium

• Téléchargez et installez PyCharm;
• Créez un nouveau projet et écrivez le script de test Selenium;
• Exécutez et validez les scripts de test.

9. Installer Behave

Exécuter la commande suivante pour installer behave

pip install behave

Pour mettre à jour une version Behave déjà installée, utilisez :

pip install -U behave

9.1 Utiliser une distribution source

Après avoir déballé la distribution source de Behave, entrez dans le répertoire nouvellement créé «behave- » et exécutez :

python setup.py install

# OR:

pip install

9.2 Utilisation du Github repository

Exécutez la commande suivante pour installer la dernière version à partir du Github repository :

pip install git+https://github.com/behave/behave

9.3 Pour installer une version balisée à partir du Github repository, utilisez :

pip install git+https://github.com/behave/behave@

10. Création d’un cadre d’automatisation des tests à l’aide de Selenium avec Python

Il existe une infinité de façons de créer votre framework d’automatisation de test avec Selenium en Python. Dans cet article, nous allons voir comment utiliser le “Page Object Model” et la “Page Factory” pour créer un framework d’automatisation de test Selenium qui sera facile à maintenir et à développer.

10.1 Concepts

Objet Page:  Un objet Page est une représentation d’une «page» sur le site que nous testons. Cette «page» n’a pas besoin d’être exactement une page, mais il peut s’agir de tout ce que vous avez envie de résumer à un objet.

Page Factory:  Une Page Factory nous permet d’instancier un objet Page et de le «fabriquer» avec un ensemble de conditions. Son utilisation la plus courante consiste à rechercher tous les éléments d’un objet Page lorsque l’objet est instancié.

10.2 Conditions préalables

Pour ce projet, nous utiliserons les outils suivants:

• Python 2.7
• PyCharm
• Selenium
• ChromeDriver
• Allure

10.3 Conception du Framework

Avant d’écrire une seule ligne de code, nous devons décider comment notre cadre sera structuré. Notre objectif principal est de le garder simple, facile à lire et facile à entretenir.

11. Solution Selenium-Behave avec Python

L’image ci-dessous montre l’architecture de notre solution d’automatisation de test basée sur Selenium WebDriver avec Python.

11.1 Écriture de fonctionnalités

Nous écrivons des fichiers de fonctionnalités au format (Given, When & Then) décrivant le contexte du test.

Feature: AuthentificationFeature

# Enter feature description here

Scenario: Authentification

Given I go to the application

When I enter “Admin” in the username field

And I enter “admin123” in the password field

And I press the login button

Then The dashboard page is displayed

11.2 Rédaction de StepDefinitions

Nous écrivons le code typescript équivalent pour chacune des définitions d’étape qui nous aident à tester les scénarios de fonctionnalité.

from behave import *

from behave import given, when, then

import time

@given(“I go to the application”)

def step_impl(context):

context.authentification.load()

@when(‘I enter “{username}” in the username field’)

def step_impl(context, username):

time.sleep(5)

context.authentification.usernameSendKeys(username)

@step(‘I enter “{password}” in the password field’)

def step_impl(context, password):

time.sleep(5)

context.authentification.passwordSendKeys(password)

@step(“I press the login button”)

def step_impl(context):

time.sleep(5)

context.authentification.loginButtonClick()

@then(“The dashboard page is displayed”)

def step_impl(context):

time.sleep(5)

11.3 Écriture des objets de page

Les objets de page nous aident à écrire des tests plus propres en encapsulant des informations sur les éléments de notre page d’application.

from selenium.webdriver.common.by import By

from selenium.webdriver.support.wait import WebDriverWait

from selenium.webdriver.support import expected_conditions as EC

from selenium.webdriver.common.keys import Keys

class AuthentificationPageObject(object):

__TIMEOUT = 10

URL = ‘https://opensource-demo.orangehrmlive.com/index.php/auth/login’

 USERNAME_INPUT = (By.ID, ‘txtUsername’)

PASSWORD_INPUT = (By.ID, ‘txtPassword’)

LOGIN_BUTTON = (By.ID, ‘btnLogin’)

def __init__(self, web_driver):

self._web_driver_wait = WebDriverWait(web_driver, AuthentificationPageObject.__TIMEOUT)

self._web_driver = web_driver

def load(self):

self._web_driver.get(self.URL)

def usernameSendKeys(self, username):

username_input = self._web_driver.find_element(*self.USERNAME_INPUT)

username_input.send_keys(username)

def passwordSendKeys(self, password):

password_input = self._web_driver.find_element(*self.PASSWORD_INPUT)

password_input.send_keys(password)

def loginButtonClick(self):

button_click = self._web_driver.find_element(*self.LOGIN_BUTTON)

button_click.click()

11.4 Exécution du test

Pour l’exécution des tests nous avons utilisé la commande Behave.

• Exécution de la solution Selenium-Behave-Python avec Jenkins

Pour la partie reporting nous avons utilisé Allure report pour behave framework. L’installation d’allure est à travers de la commande suivante :

pip install allure-behave

L’exécution des tests se fait à travers la commande suivante:

behave -f allure_behave.formatter:AllureFormatter -o %allure_result_folder% ./features

La génération du rapport de test est à l’aide de la commande suivante

allure serve %allure_result_folder%

• Jenkins

Tout développeur de scripts d’automatisation voudrait exécuter ses scripts régulièrement et garder une trace des résultats et Il est très probable qu’il ajoute continuellement plus de scripts au projet et souhaite qu’ils soient également suivis.  Jenkins agit comme un outil de gestion de build qui gère chaque build de projet logiciel de manière continue. Facile à tester et à suivre les résultats de vos tests en un seul endroit.

Configuration avec jenkins :

Pour la configuration de notre solution d’automatisation avec jenkins nous avons commencé par l’ajout du plugin ShiningPanda Plugin qui permet d’ajouter le support Python à Jenkins

Puis nous avons construit un projet free-style et nous l’avons configuré comme suit :

11.5 Résultat de test (reporting)

Pour la partie reporting nous avons ajouté le plug-in Allure Jenkins Plugin et nous avons configuré notre projet comme suit :

Les images ci-dessous montrent le résultat de test :

12. Challenge – Exécuter des tests en parallèles avec Selenium Grid et Docker

La simulation de scénarios et l’exécution de tâches similaires sur des machines à différents emplacements peuvent être assez lourdes. Nous pouvons être amenés à tester une application à partir de différents sites ou à automatiser un processus qui doit s’exécuter à partir de différents navigateurs, systèmes d’exploitation et machines.

Posez-vous vous-même ces questions :

• Suis-je obligé d’exécuter des tests ou des tâches à partir de différents navigateurs ou de différents systèmes d’exploitation en même temps?
• Ai-je plusieurs tests ou tâches qui peuvent être exécutés en parallèle, donc je gagne du temps?

Si votre réponse est oui, vous pouvez alors utiliser Selenium Grid pour votre besoin.

12.1 Implémentation de Selenium Grid en Python

Dans cette section nous allons Configurer Selenium Grid avec de nombreux nœuds pour différents navigateurs et exécutez de nombreuses instances de notre exemple de manière distribuée et simultanée.

• Qu’est-ce que Selenium Grid ?

Selenium Grid est un projet créé pour exécuter des tests sur différents navigateurs et systèmes d’exploitation. Il a une architecture simple: un hub et un ou plusieurs nœuds. Vous exécutez votre test sur le concentrateur et le concentrateur distribue le test sur différents navigateurs.

12.2 Configurer l’environnement

Exécutez le standalone server en mode Hub (ouvrez d’abord un nouveau terminal):

$ cd ~/selenium

$ java -jar selenium-server-standalone-3.141.59.jar -role hub

Après cela, nous verrons où nos nœuds doivent s’enregistrer. Les nœuds doivent s’enregistrer sur https: // {{ip ou host}}: 4444 / grid / register /  Nous pouvons enregistrer maintenant deux nœuds (faites-le dans deux terminaux différents) :

java -jar selenium-server-standalone-2.49.0.jar -role node -hub https://{{ip or host}}:4444/grid/register/ -port 3456

java -jar selenium-server-standalone-2.49.0.jar -role node -hub https://{{ip or host}}:4444/grid/register/ -port 4567

Maintenant, nous avons deux nœuds enregistrés sur notre Grid.

12.3 Selenium server distant

Le serveur sélénium ne doit pas nécessairement être sur la même machine, nous avons donc besoin d’un moyen d’exécuter notre test à distance. La seule chose que nous devons changer est l’instanciation d’un pilote. Nous le changeons pour ressembler à ceci:

driver = webdriver.Remote(

command_executor=’https://{{ip or host}}:4444/wd/hub’,

desired_capabilities={‘browserName’: chrome, ‘javascriptEnabled’: True})

12.4 Exécuter plusieurs tests en utilisant le script bash

Créez le script bash grid.sh et modifiez-le pour qu’il contienne:

#!/bin/bash

python selenium_unittests.py &

python selenium_unittests.py &

python selenium_unittests.py &

python selenium_unittests.py &

python selenium_unittests.py &

13. Configurer Selenium Grid avec Docker

Avec Docker, vous pouvez rapidement, facilement installer, configurer et utiliser Selenium Grid. Dans cette section nous allons vous montrer les étapes dont vous avez besoin en tant que testeur de logiciel pour configurer Selenium Grid avec Docker.

13.1 Préparation des fichiers

$ mkdir -p ~/Project/NameProject && cd ~/Project/NameProject

# create docker-compose.yml (version 1)

$ vim v1-docker-compose.yml

# or create docker-compose.yml (version 2)

$ vim v2-docker-compose.yml

# create python example.py

$ vim example.py

• Docker-compose.yml file

version: ‘2’

services:

selenium_hub:

image: selenium/hub

ports:

– 4444:4444

node_1:

image: selenium/node-chrome

depends_on:

– selenium_hub

environment:

– HUB_PORT_4444_TCP_ADDR=selenium_hub

node_2:

image: selenium/node-firefox

environment:

– HUB_PORT_4444_TCP_ADDR=selenium_hub

depends_on:

– selenium_hub

• example.py file

class Example(unittest.TestCase):

def setUp(self):

self.driver = webdriver.Remote(         command_executor=’http://192.168.99.100:4444/wd/hub’,       desired_capabilities={ ‘browserName’: ‘firefox’,’javascriptEnabled’: True} )

self.driver.get(‘Application Site ‘)

def test_something(self):

dt_format = ‘%Y%m%d_%H%M%S’

cdt = datetime.datetime.fromtimestamp(time.time()).strftime(dt_format)

current_location = os.getcwd()

img_folder = current_location + ‘/images/’

if not os.path.exists(img_folder):

os.mkdir(img_folder)

picture = img_folder + cdt + ‘.png’ self.driver.save_screenshot(picture)

def tearDown(self):

self.driver.quit()

if __name__ == “__main__”:

unittest.main(verbosity=1)

13.2 Créer un environnement

# create new VM

$ docker-machine create -d virtualbox Grid

# pointing shell

$ eval $(docker-machine env Grid)

# show status (optional)

$ docker-machine ls

…

NAME   ACTIVE   DRIVER       STATE     URL                         SWARM   DOCKER    ERRORS

Grid   *        virtualbox   Running   tcp://192.168.99.100:2376           v1.11.1

# run docker-compose

$ docker-compose -f docker-compose.yml up -d

# show status

$ docker-compose -f docker-compose.yml ps

…

Name                         Command           State           Ports

——————————————————————————————

seleniumtutorial_node_1_1         /opt/bin/entry_point.sh   Up

seleniumtutorial_node_2_1         /opt/bin/entry_point.sh   Up

seleniumtutorial_selenium_hub_1   /opt/bin/entry_point.sh   Up      0.0.0.0:4444->4444/tcp

13.3 Lancer le script Python

# run python selenium script

$ python -B ~/Projects/Selenium/example.py

14. Pourquoi les testeurs préfèrent-ils Selenium avec Python?

Selenium est un ensemble d’outils solide qui soutient fermement le développement rapide de l’automatisation des tests des applications Web. Il offre un ensemble de fonctions de test spécialement conçues pour les exigences de test d’une application Web. Ces fonctions sont fiables, facilitant diverses options pour positionner les éléments de l’interface utilisateur et faire une comparaison des résultats attendus avec le comportement réel de l’application. Il utilise divers langages de script pour son automatisation des tests.

Python est un langage de script de haut niveau basé sur des objets conçu de manière conviviale. Il utilise des mots clés anglais simples qui nécessitent une interprétation très facile. Il a peu de complications de syntaxe par rapport aux autres langages de programmation.

• Facile à coder et facile à lire
• Fonctionne rapidement tout en comparant une autre programmation
• Offre une nature de frappe dynamique
• Un grand nombre de programmeurs sont habitués à Python en tant que langage
• L’API utilisée en python vous aide à vous connecter au navigateur via Selenium. La liaison de Python Selenium offre une API simple pour écrire des tests fonctionnels en utilisant Selenium WebDriver de manière perceptive.
• Le langage python a des poursuites très verbeuses et faciles par rapport à un autre langage de programmation. C’est à cause de l’API Python qui vous aide à vous connecter avec le navigateur complet Selenium. Selenium peut facilement envoyer des commandes standards de python à différents navigateurs, indépendamment de toutes les variations dans la conception du navigateur.
• Python étant un langage scripté, il n’y a pas à se soucier d’exécuter un compilateur pour convertir le code des lignes du code en tout ce qui peut être implémenté et utilisé.
• Python s’exécute très rapidement et utilise l’indentation pour initier et terminer les blocs. Il est très simple et compact par rapport à d’autres langages de programmation.
• Le langage Python est développé avec une grande communauté autour de lui pour laquelle il offre un très bon système de support. Ainsi, lors des tests automatisés utilisant Selenium avec python, la communauté est comme un chariot de bienvenue pour ceux qui sont complètement nouveaux dans le langage.
• Le langage de programmation est également gratuit et disponible en open source. Celui qui en a besoin peut facilement le télécharger et l’utiliser librement dans n’importe quel environnement. Toute la culture, ainsi que les communautés présentes autour de la langue, sont des fans de logiciels libres.
• Avec toutes les raisons ci-dessus qui prennent en charge l’utilisation de Selenium avec Python, une autre raison majeure d’utiliser le Selenium avec python est divers outils présents pour l’étendre. L’outil le plus important pour les interfaces utilisateur faciles qui est WebDriver a des liaisons solides pour Python.

15. Conclusion : Optimisation des tests d’automatisation avec Selenium et Python

Selenium WebDriver, en association avec Python, est l’un des outils les plus plébiscités pour l’automatisation de l’interface utilisateur Web. Python, en particulier, se révèle être un outil puissant pour automatiser une large gamme d’applications Web grâce à ses fonctionnalités de script avancées et sa simplicité.

Cet article a pour objectif de vous montrer comment mettre en place facilement une solution d’automatisation de test avec Selenium WebDriver, Behave (BDD) et le langage de programmation Python. Ce trio, Selenium, Python et BDD, offre une plateforme robuste et flexible pour construire un framework de test d’automatisation performant.

L’automatisation des tests avec Selenium et Python est une approche privilégiée par de nombreux professionnels du test, pour sa rapidité, son efficacité et sa facilité d’utilisation. De plus, l’extension de ces tests au niveau BDD / TDD permet de réaliser des démonstrations convaincantes des nouveaux produits ou fonctionnalités développés. L’ensemble de ces aspects fait de l’utilisation de Selenium avec Python une combinaison de choix pour les tests d’automatisation.

Dépôt GitHub

Voici la solution sur GitHub !

Rédacteurs :

Zied Hannachi / Consultant test automation / All4Test

Insaf Kssouri / SDET / All4Test

Formez-vous sur Selenium qui vous permettra de vous familiariser avec la rédaction de scripts Selenium pour l’automatisation du test des applications de navigateur. Notre partenaire UpSkill4IT vous propose cette formation Selenium – Automatisation des tests.