Tutoriel Selenium - Apprenez l'automatisation du navigateur avec Selenium WebDriver

Selenium est un ensemble de bibliothèques utilisées pour émuler les interactions d'un utilisateur avec un navigateur.

Les utilisateurs écrivent des scripts à l'aide de bibliothèques de sélénium pour simuler les interactions courantes du navigateur utilisateur, telles que la navigation vers une page, le clic sur un bouton et le remplissage d'un formulaire.

Le sélénium est couramment utilisé dans les projets qui créent des applications Web front-end (UI). Il est utilisé pour automatiser des scénarios qui imitent l'interaction d'un utilisateur avec l'application Web.




Installez Selenium

Pour utiliser Selenium WebDriver dans un projet, nous devons d'abord installer Selenium Core et WebDriver Binaries.

Nous devons également définir le chemin de chaque exécutable du pilote.


Si vous souhaitez utiliser Selenium avec Java, le moyen le plus simple d'installer Selenium est via une dépendance Maven dans votre projet pom.xml déposer:


org.seleniumhq.selenium
selenium-java
3.141.59

Pour exécuter des tests Selenium sur Google Chrome ou navigateur Firefox, vous devez ajouter la dépendance appropriée dans votre pom.xml déposer:

Navigateur Google Chrome


org.seleniumhq.selenium
selenium-chrome-driver
3.141.59

Navigateur Firefox


org.seleniumhq.selenium
selenium-firefox-driver
3.141.59

Installer les binaires WebDriver et définir le chemin

Pour exécuter des tests Selenium sur un navigateur particulier, vous devez disposer des binaires WebDriver spécifiques au navigateur et du chemin d'accès correct.

Chrome Pour définir le chemin d'accès à l'exécutable chrome sur un système MacOS, vous pouvez utiliser:


$ export PATH='$PATH:/path/to/chromedriver'

Vous pouvez également définir le chemin par programme, directement dans le code:

System.setProperty('webdriver.chrome.driver', '/path/to/chromedriver');

Firefox - Geckodriver:

System.setProperty('webdriver.gecko.driver', '/path/to/geckodriver');

Bord:

System.setProperty('webdriver.edge.driver', 'C:/path/to/MicrosoftWebDriver.exe');

Internet Explorer:


System.setProperty('webdriver.ie.driver', 'C:/path/to/IEDriver.exe');

Instancier le pilote du navigateur

Après avoir installé Selenium, instanciez ensuite un pilote de navigateur spécifique afin d'exécuter les tests d'interface utilisateur.

Les tests Selenium sont exécutés sur l'interface utilisateur d'une application et nécessitent un navigateur pour fonctionner. Nous pouvons spécifier le navigateur sur lequel nous voulons exécuter nos tests, puis instancier le pilote approprié.

Noter:Les tests de sélénium ne sont utilisés que pour Automatisation de l'interface utilisateur et les tests s'exécutent sur un navigateur.

Chrome

import org.openqa.selenium.WebDriver; import org.openqa.selenium.chrome.ChromeDriver; WebDriver driver = new ChromeDriver();

Firefox

import org.openqa.selenium.WebDriver; import org.openqa.selenium.Firefox.FirefoxDriver; WebDriver driver = new FirefoxDriver();

Bord

import org.openqa.selenium.WebDriver; import org.openqa.selenium.edge.EdgeDriver; WebDriver driver = new EdgeDriver();

Internet Explorer

import org.openqa.selenium.WebDriver; import org.openqa.selenium.ie.InternetExplorerDriver; WebDriver driver = new InternetExplorerDriver();

Navigation dans le navigateur

Une fois que nous avons une session WebDriver active et que nous avons lancé un navigateur, la prochaine chose que nous voulons faire est de naviguer vers une page et d'exécuter des tests.

Selenium WebDriver fournit un certain nombre de méthodes utiles pour interagir avec le navigateur. Nous pouvons effectuer la navigation et obtenir des informations sur la page en cours.


Pour accéder à une URL, nous avons deux options:

//The short form driver.get('https://devqa.io'); //The long form driver.navigate().to('https://devqa.io');

Retourner

Le sélénium back() La méthode simule un clic sur le bouton de retour du navigateur:

driver.navigate().back();

Aller de l'avant

Le sélénium forward() La méthode simule un clic sur le bouton Suivant du navigateur:

driver.navigate().forward();

Rafraîchir la page

Le sélénium refresh() La méthode simule un clic sur le bouton d’actualisation du navigateur:


driver.navigate().refresh();

Obtenir des informations sur la page actuelle

Selenium fournit également des méthodes pour obtenir l'URL actuelle, le titre de la page et la source de la page.

Obtenir l'URL actuelle

Nous pouvons obtenir l'URL de la page actuelle:

driver.getCurrentUrl();

Obtenir le titre de la page

Nous pouvons obtenir le titre de la page actuelle:

driver.getTitle();

Obtenir la source de la page

Nous pouvons obtenir la source de la page actuelle:

driver.getPageSource();

Fermer et quitter la session du navigateur

Pour fermer la fenêtre actuelle du navigateur:

driver.close(); Noter:Fermer la fenêtre du navigateur ne fait pas mettre fin à la session WebDriver.

Pour quitter la session WebDriver à la fin du test, utilisez:

driver.quit();

La méthode d'abandon:

  • Fermez toutes les fenêtres associées à cette session WebDriver
  • Tuez le processus du navigateur
  • Tuez le processus de pilote


Localisateurs de sélénium - Comment localiser des éléments Web

Avant de pouvoir interagir avec un élément Web, nous devons localiser l'élément sur la page html.

L'une des compétences les plus importantes d'un ingénieur en automatisation de test travaillant avec Selenium WebDriver est de pouvoir utiliser des méthodes appropriées pour localiser des éléments sur une page.

Par exemple, si nous voulons cliquer sur un lien, vérifier qu'un message est affiché ou cliquer sur un bouton, nous devons d'abord localiser l'élément.

Selenium WebDriver fournit différentes méthodes pour localiser des éléments sur une page.

Un localisateur décrit ce que vous recherchez sur une page. En Java, nous créons un localisateur en utilisant le By classer.

Par exemple, si nous voulions trouver un h1 élément de titre sur une page, nous écririons

WebElement h1Element = driver.findElement(By.tagName('h1'));

Ou, si nous voulions trouver tous les éléments de paragraphe sur une page, nous utiliserions

List pElements = driver.findElements(By.tagName('p'));

Par texte du lien

Cette méthode localise les éléments par le texte exact qu'ils affichent. Cette méthode est normalement le localisateur préféré pour les liens sur une page.

Par exemple, supposons que nous ayons ce lien sur une page:

Forgotten Password

Ensuite, le lien peut être localisé en utilisant:

driver.findElement(By.linkText('Forgotten Password'));

Par texte de lien partiel

Lorsque nous ne sommes pas sûrs de la formulation exacte du texte du lien, mais que nous voulons trouver un lien ou des liens qui contient un texte donné, on peut utiliser

driver.findElement(By.partialLinkText('Forgotten '));

ou alors

driver.findElement(By.partialLinkText('Password'));

Vous devez être prudent lorsque vous utilisez findElement avec ce localisateur car il pourrait y avoir d'autres éléments qui contiennent le même texte partiel, il ne doit donc pas être utilisé pour localiser un seul élément seul. Il est préférable de l'utiliser pour localiser un groupe d'éléments à l'aide de la méthode findElements.

Par attribut de classe

Cela localise les éléments par la valeur de l'attribut de classe. Cela ne peut être utilisé que pour les éléments ayant un attribut de classe, mais ce n'est pas un bon sélecteur à utiliser avec findElement méthode.

En utilisant le même exemple ci-dessus avec le lien, le lien «Mot de passe oublié» a une classe CSS: btn qui peut être utilisé pour le localiser

Forgotten Password

Ensuite, le lien peut être localisé en utilisant:

driver.findElement(By.className('btn')); Noter:L'attribut class est utilisé pour styliser les pages, et il y a donc de fortes chances que de nombreux éléments aient la même classe.

Par identifiant

Par id, localise les éléments par la valeur de leur attribut id. Le lien dans l'exemple ci-dessus a un identifiant que nous pouvons utiliser:

Forgotten Password

Ensuite, le lien peut être localisé en utilisant:

driver.findElement(By.id('change-password'));

Si l'attribut id est disponible, il doit être utilisé comme premier choix préféré.

De nom

Localise les éléments par la valeur de leur attribut de nom. Normalement, il ne peut être utilisé que pour localiser des éléments de formulaire construits en utilisant: , , , et .

Sur une page de connexion typique, vous avez des champs de saisie qui pourraient être comme:

Nous pouvons ensuite localiser le champ email par l'attribut de nom d'entrée

driver.findElement(By.name('email'));

Par nom de balise

Ce localisateur trouve les éléments par leur nom de balise HTML. Puisqu'il y a souvent de nombreuses utilisations répétées de la plupart des balises, ce n'est pas une bonne idée d'utiliser cette méthode pour localiser un seul élément.

Une utilisation typique de la localisation d'un élément par nom de balise consiste à localiser l'en-tête de la page, car il n'y en a qu'un:



Welcome to DevQA!

Nous pouvons ensuite localiser le champ d'en-tête par nom de balise:

driver.findElement(By.tagName('h1'));

Par les sélecteurs Css

Localise les éléments via le moteur de sélection CSS W3 sous-jacent du pilote. Le localisateur de sélecteur CSS est puissant car il peut être utilisé pour localiser n'importe quel élément d'une page.

Forgotten Password

Nous pouvons ensuite localiser le champ email par l'attribut de nom d'entrée

driver.findElement(By.cssSelector('#change-password'));

Ici, # représente l'identifiant de l'élément. Et le . la notation représente l'attribut de classe d'un élément.

Par example:

driver.findElement(By.cssSelector('.btn'));

En rapport:

Par XPath

Les localisateurs XPath sont les sélecteurs les plus complexes à utiliser. Il nécessite des connaissances en langage de requête XPath, donc si vous ne maîtrisez pas ce langage de requête, vous aurez du mal à trouver des éléments à l'aide de requêtes XPath.

Examinons un exemple d'utilisation d'un XPath pour ce code HTML:

Change Password

Nous pouvons ensuite localiser le champ email par l'attribut de nom d'entrée

driver.findElement(By.xpath('//a[@id='change-password']'));

Interagir avec les éléments Web

Une fois que nous avons localisé un élément sur la page, nous pouvons interagir avec lui en utilisant une variété de méthodes fournies par le sélénium.

Selenium WebDriver fournit un certain nombre de façons d'interagir avec les éléments Web, comme cliquer sur les boutons d'envoi et saisir du texte dans les champs de saisie.

Le WebElement class a un certain nombre de méthodes que nous pouvons utiliser pour interagir avec les éléments de la page. Les plus courants sont:

  • click()
  • clear()
  • sendKeys()
  • submit()

Cliquez sur

Le click() est utilisée pour cliquer sur un élément Web tel qu'un lien ou un bouton.

Exemple:

Menu WebElement mToggle = driver.findElement(By.id('menu-toggle')); mToggle.click();

Dégager

Le clear() La méthode efface la valeur d’un champ d’entrée.

Conseil:Il est recommandé d'utiliser le .dégager() méthode avant de saisir du texte dans un champ de saisie.

Exemple:

WebElement username = driver.findElement(By.id('username')); username.clear();

SendKeys

Nous utilisons le sendKeys() méthode pour saisir des caractères dans une zone de champ de saisie.

Exemple:

WebElement username = driver.findElement(By.id('username')); username.sendKeys('jondoe');

Exemple - Remplir un formulaire

Vous trouverez ci-dessous un exemple d'utilisation de Selenium pour remplir un formulaire

username:

Last name:


WebElement username = driver.findElement(By.id('username'));
username.sendKeys('jondoe');
WebElement password = driver.findElement(By.id('password'));
password.sendKeys('secret');
WebElement submit = driver.findElement(By.cssSelector('input[type='submit']'));
submit.click();

Maintenant que nous avons couvert les bases de Selenium WebDriver, il est temps de créer un framework.



Créer un framework Selenium

Apprenez à créer un framework de sélénium à partir de zéro.

La première partie du didacticiel explique étape par étape comment créer un framework Selenium WebDriver à l'aide de Java, Maven et TestNG.

La deuxième partie se concentre sur la structuration des tests de sélénium à partir du célèbre modèle d'objet de page.