Sélénium - Guide rapide

introduction

Selenium est un outil de test logiciel open-source et portable pour tester les applications Web. Il a des capacités pour fonctionner sur différents navigateurs et systèmes d'exploitation. Selenium n'est pas seulement un outil unique, mais un ensemble d'outils qui aide les testeurs à automatiser plus efficacement les applications Web.

Voyons maintenant chacun des outils disponibles dans la suite Selenium et leur utilisation.

N ° Sr.	Outil et description
1	Selenium IDE Sélénium Inintégré Ddéveloppement Environment (IDE) est un plugin Firefox qui permet aux testeurs d'enregistrer leurs actions tout en suivant le flux de travail dont ils ont besoin pour tester.
2	Selenium RC Sélénium Remote Control (RC) était le cadre de test phare qui permettait plus que de simples actions de navigateur et une exécution linéaire. Il utilise toute la puissance des langages de programmation tels que Java, C #, PHP, Python, Ruby et PERL pour créer des tests plus complexes.
3	Selenium WebDriver Selenium WebDriver est le successeur de Selenium RC qui envoie des commandes directement au navigateur et récupère les résultats.
4	Selenium Grid Selenium Grid est un outil utilisé pour exécuter des tests parallèles sur différentes machines et différents navigateurs simultanément, ce qui réduit le temps d'exécution.

Avantages du sélénium

QTP et Selenium sont les outils les plus utilisés sur le marché pour les tests d'automatisation logicielle. Il est donc logique de comparer les avantages de Selenium par rapport à QTP.

Sélénium	QTP
Selenium est un outil open source.	QTP est un outil commercial et il y a un coût impliqué dans chacune des licences.
Peut être étendu pour diverses technologies qui exposent DOM.	Modules complémentaires limités et nécessite des modules complémentaires pour chacune des technologies.
Possède des capacités pour exécuter des scripts sur différents navigateurs.	Peut exécuter des tests dans des versions spécifiques de Firefox, IE et Chrome.
Peut exécuter des scripts sur divers systèmes d'exploitation.	Fonctionne uniquement avec Windows.
Prend en charge les appareils mobiles.	Prend en charge les appareils mobiles à l'aide d'outils tiers.
Exécute les tests dans le navigateur, donc le focus n'est PAS nécessaire pendant l'exécution du script.	Besoin de se concentrer pendant l'exécution du script, car l'outil agit sur le navigateur (imite les actions de l'utilisateur).
Peut exécuter des tests en parallèle avec l'utilisation de Selenium Grids.	QTP ne peut pas exécuter de tests en parallèle, mais l'intégration de QTP avec QC permet aux testeurs de s'exécuter en parallèle. Le QC est également un outil commercial.

Inconvénients du sélénium

Parlons maintenant des pièges de Selenium sur QTP.

Sélénium	QTP
Prend en charge uniquement les applications Web.	Peut tester les applications Web et de bureau.
Aucune fonctionnalité telle que le référentiel d'objets / scénario de récupération	QTP a des référentiels d'objets et des scénarios de récupération intégrés.
Pas d'IDE, donc le développement du script ne sera pas aussi rapide que QTP.	IDE plus intuitif; l'automatisation peut être réalisée plus rapidement.
Impossible d'accéder aux contrôles dans le navigateur.	Peut accéder aux commandes du navigateur telles que la barre des favoris, les boutons arrière et suivant.
Aucune génération de rapport de test par défaut.	Génération de résultats de test par défaut dans l'outil.
Pour le paramétrage, les utilisateurs doivent s'appuyer sur le langage de programmation.	Le paramétrage est intégré et facile à mettre en œuvre.

Le Selenium-IDE (Integrated Development Environment) est un plug-in Firefox facile à utiliser pour développer des cas de test Selenium. Il fournit une interface utilisateur graphique pour enregistrer les actions des utilisateurs à l'aide de Firefox qui est utilisée pour apprendre et utiliser Selenium, mais elle ne peut être utilisée qu'avec le navigateur Firefox car les autres navigateurs ne sont pas pris en charge.

Cependant, les scripts enregistrés peuvent être convertis en divers langages de programmation pris en charge par Selenium et les scripts peuvent également être exécutés sur d'autres navigateurs.

Le tableau suivant répertorie les sections que nous allons couvrir dans ce chapitre.

N ° Sr.	Description du titre
1	Télécharger Selenium IDE Cette section explique comment télécharger et configurer Selenium IDE.
2	Fonctionnalités de Selenium IDE Cette section traite des fonctionnalités disponibles dans Selenium IDE.
3	Création de tests Selenium IDE Cette section explique comment créer des tests IDE à l'aide de la fonction d'enregistrement.
4	Débogage de script Selenium IDE Cette section traite du débogage du script Selenium IDE.
5	Insertion de points de vérification Cette section décrit comment insérer des points de vérification dans Selenium IDE.
6	Correspondance des motifs de sélénium Cette section explique comment travailler avec des expressions régulières à l'aide de l'EDI.
sept	Extensions utilisateur Selenium Le script Java qui permet aux utilisateurs de personnaliser ou d'ajouter de nouvelles fonctionnalités.
8	Exécution différente du navigateur Cette section explique comment exécuter des scripts Selenium IDE sur différents navigateurs.

Afin de développer des scripts Selenium RC ou WebDriver, les utilisateurs doivent s'assurer qu'ils ont effectué la configuration initiale. La configuration de l'environnement implique les étapes suivantes.

• Téléchargez et installez Java
• Téléchargez et configurez Eclipse
• Configurer FireBug et FirePath
• Configurer Selenium RC
• Configurer Selenium WebDriver

Téléchargez et installez Java

Nous devons avoir JDK (Java Development Kit) installé afin de travailler avec Selenium WebDriver / Selenium. Voyons comment télécharger et installer Java.

Step 1 - Accédez à l'UR.

https://www.oracle.com/technetwork/java/javase/downloads/index.html

Step 2 - Allez dans la section "Téléchargements" et sélectionnez "Télécharger JDK".

Step 3 - Sélectionnez le bouton radio "Accepter le contrat de licence".

Step 4- Sélectionnez l'installation appropriée. Dans ce cas, il s'agit du bit «Windows 7-64». Cliquez sur le lien approprié et enregistrez le fichier .exe sur votre disque.

Step 5- Exécutez le fichier exe téléchargé pour lancer l'assistant d'installation. Cliquer sur Suivant pour continuer.

Step 6 - Sélectionnez les fonctionnalités et cliquez sur «Suivant».

Step 7 - Le programme d'installation est extrait et sa progression est affichée dans l'assistant.

Step 8 - L'utilisateur peut choisir l'emplacement d'installation et cliquer sur «Suivant».

Step 9 - Le programme d'installation installe le JDK et les nouveaux fichiers sont copiés.

Step 10 - Le programme d'installation s'installe avec succès et affiche la même chose à l'utilisateur.

Step 11- Pour vérifier si l'installation a réussi, accédez à l'invite de commande et tapez simplement «java» comme commande. La sortie de la commande est indiquée ci-dessous. Si l'installation de Java échoue ou si elle n'a PAS été installée, une erreur "commande inconnue" sera générée.

Téléchargez et configurez Eclipse

Step 1 - Accédez à l'URL: https://www.eclipse.org/downloads/ et téléchargez le fichier approprié en fonction de l'architecture de votre système d'exploitation.

Step 2 - Cliquez sur le bouton «Télécharger».

Step 3- Le téléchargement serait au format zippé. Décompressez le contenu.

Step 4 - Localisez Eclipse.exe et double-cliquez sur le fichier.

Step 5 - Pour configurer l'espace de travail, sélectionnez l'emplacement où le développement doit avoir lieu.

Step 6 - La fenêtre Eclipse s'ouvre comme illustré ci-dessous.

Configurer FireBug et FirePath

Pour travailler avec Selenium RC ou WebDriver, nous devons localiser les éléments en fonction de leur XPath ou ID ou nom, etc. Afin de localiser un élément, nous avons besoin d'outils / plugins.

Step 1 - Accédez à l'URL: https://addons.mozilla.org/en-US/firefox/addon/firebug/ et téléchargez le plugin.

Step 2 - Le programme d'installation du module complémentaire est présenté à l'utilisateur et il est installé en cliquant sur le bouton «Installer».

Step 3 - Après l'installation, nous pouvons lancer le plugin en accédant à "Web Developer" >> "Firebug".

Step 4- FirePath, un plugin qui fonctionne avec Firebug, aide les utilisateurs à saisir le «XPath» d'un élément. Installez FirePath en accédant à "https://addons.mozilla.org/en-US/firefox/addon/firepath/"

Step 5 - Le programme d'installation du module complémentaire est présenté à l'utilisateur et il est installé en cliquant sur le bouton «Installer».

Step 6 - Lancez maintenant "Firebug" en accédant à "Outils" >> "Webdeveloper" >> "Firebug".

Exemple

Voyons maintenant comment utiliser FireBug et FirePath avec un exemple. Pour une démonstration, nous utiliserons www.google.com et capturerons les propriétés de la zone de texte "google.com".

Step 1- Cliquez d'abord sur l'icône de flèche comme surligné dans la capture d'écran suivante et faites-la glisser vers l'objet dont nous souhaitons capturer les propriétés. Le HTML / DOM de l'objet serait affiché comme indiqué ci-dessous. Nous sommes capables de capturer l'ID de la zone de texte d'entrée avec laquelle nous pouvons interagir.

Step 2 - Pour récupérer le XPath de l'objet, allez dans l'onglet 'firepath' et effectuez les étapes suivantes.

• Cliquez sur l'icône Espion.
• Sélectionnez le contrôle pour lequel nous souhaitons capturer le XPath.
• XPath du contrôle sélectionné serait généré.

Configurer Selenium RC

Voyons maintenant comment configurer la télécommande Selenium. Nous comprendrons comment développer des scripts avec Selenium RC dans les chapitres suivants, mais pour l'instant, nous ne comprendrons que la partie configuration de celui-ci.

Step 1 - Accédez à la section des téléchargements de Selenium http://www.seleniumhq.org/download/ et téléchargez Selenium Server en cliquant sur son numéro de version comme indiqué ci-dessous.

Step 2- Après le téléchargement, nous devons démarrer le serveur Selenium. Pour ce faire, ouvrez l'invite de commande et accédez au dossier dans lequel le fichier JAR téléchargé est conservé, comme indiqué ci-dessous.

Step 3- Pour démarrer le serveur, utilisez la commande 'java -jar << nom du fichier téléchargé >> et si java JDK est correctement installé, vous obtiendrez un message de réussite comme indiqué ci-dessous. Nous pouvons maintenant commencer à écrire des scripts Selenium RC.

Configurer Selenium WebDriver

Voyons maintenant comment configurer Selenium WebDriver. Nous comprendrons comment développer des scripts avec Selenium WebDriver dans les chapitres suivants, mais pour l'instant, nous ne comprendrons que la partie configuration.

Step 1 - Accédez à la section des téléchargements de sélénium http://www.seleniumhq.org/download/ et téléchargez Selenium WebDriver en cliquant sur son numéro de version comme indiqué ci-dessous.

Step 2 - Le fichier téléchargé est au format zippé et il faut décompresser le contenu pour le mapper au dossier du projet.

Step 3- Le contenu décompressé serait affiché comme indiqué ci-dessous. Comment le mapper au dossier du projet et comment démarrer le script sera traité dans le chapitre webDriver.

Qu'est-ce que Selenium RC?

Selenium Remote Control (RC) était le principal projet Selenium qui a duré longtemps avant la naissance de Selenium WebDriver (Selenium 2.0). Maintenant Selenium RC est à peine utilisé, car WebDriver offre des fonctionnalités plus puissantes, mais les utilisateurs peuvent toujours continuer à développer des scripts à l'aide de RC.

Il nous permet d'écrire des tests d'interface utilisateur d'applications Web automatisés à l'aide de toute la puissance de langages de programmation tels que Java, C #, Perl, Python et PHP pour créer des tests plus complexes tels que la lecture et l'écriture de fichiers, l'interrogation d'une base de données et l'envoi par courrier électronique des résultats des tests. .

Architecture sélénium RC

Selenium RC fonctionne de telle manière que les bibliothèques clientes puissent communiquer avec le serveur Selenium RC en passant chaque commande Selenium pour exécution. Ensuite, le serveur transmet la commande Selenium au navigateur à l'aide des commandes JavaScript Selenium-Core.

Le navigateur exécute la commande Selenium à l'aide de son interpréteur JavaScript.

Selenium RC est disponible en deux parties.

• Le serveur Selenium lance et tue les navigateurs. En plus de cela, il interprète et exécute les commandes Selenese. Il agit également comme un proxy HTTP en interceptant et en vérifiant les messages HTTP passés entre le navigateur et l'application testée.

• Bibliothèques clientes qui fournissent une interface entre chacun des langages de programmation (Java, C #, Perl, Python et PHP) et le serveur Selenium-RC.

Script RC

Maintenant, écrivons un exemple de script à l'aide de Selenium Remote Control. Laissez-nous utiliserhttp://www.calculator.net/pour comprendre Selenium RC. Nous effectuerons un calcul de pourcentage à l'aide de la «Calculatrice de pourcentage» qui est présente dans le module «Calculatrices mathématiques».

Step 1 - Démarrez Selenium Remote Control (à l'aide de l'invite de commande).

Step 2 - Après avoir lancé Selenium RC, ouvrez Eclipse et créez un "Nouveau projet" comme indiqué ci-dessous.

Step 3 - Entrez le nom du projet et cliquez sur le bouton «Suivant».

Step 4 - Vérifiez le dossier Source, Projets, Bibliothèques et Sortie et cliquez sur «Terminer».

Step 5 - Faites un clic droit sur le conteneur 'projet' et choisissez 'Configurer le chemin de construction'.

Step 6- Les propriétés de 'selrcdemo' s'ouvrent. Accédez à l'onglet "Bibliothèques" et sélectionnez "Ajouter des fichiers JAR externes". Choisissez le fichier jar Selenium RC que nous avons téléchargé et il apparaîtra comme indiqué ci-dessous.

Step 7 - Les bibliothèques référencées sont affichées comme ci-dessous.

Step 8 - Créez un nouveau fichier de classe en effectuant un clic droit sur le dossier 'src' et sélectionnez 'New' >> 'class'.

Step 9 - Entrez un nom de fichier de classe et activez 'public static void main' comme indiqué ci-dessous.

Step 10 - La classe créée est créée sous la structure de dossiers comme indiqué ci-dessous.

Step 11- Il est maintenant temps de coder. Le code suivant contient des commentaires pour que les lecteurs comprennent ce qui a été proposé.

package selrcdemo;

import com.thoughtworks.selenium.DefaultSelenium;
import com.thoughtworks.selenium.Selenium;

public class rcdemo {
   public static void main(String[] args) throws InterruptedException {

      // Instatiate the RC Server
      Selenium selenium = new DefaultSelenium("localhost", 4444 , "firefox", "http://www.calculator.net");
      selenium.start();   // Start
      selenium.open("/");  // Open the URL
      selenium.windowMaximize();

      // Click on Link Math Calculator
      selenium.click("xpath = .//*[@id = 'menu']/div[3]/a");
      Thread.sleep(2500); // Wait for page load

      // Click on Link Percent Calculator
      selenium.click("xpath = .//*[@id = 'menu']/div[4]/div[3]/a");
      Thread.sleep(4000); // Wait for page load

      // Focus on text Box
      selenium.focus("name = cpar1");
      
      // enter a value in Text box 1
      selenium.type("css=input[name = \"cpar1\"]", "10");
      
      // enter a value in Text box 2
      selenium.focus("name = cpar2");
      selenium.type("css = input[name = \"cpar2\"]", "50");

      // Click Calculate button
      selenium.click("xpath = .//*[@id = 'content']/table/tbody/tr/td[2]/input");

      // verify if the result is 5
      String result = selenium.getText(".//*[@id = 'content']/p[2]");

      if (result == "5") {
         System.out.println("Pass");
      } else {
         System.out.println("Fail");
      }
   }
}

Step 12 - Maintenant, exécutons le script en cliquant sur le bouton «Exécuter».

Step 13 - Le script commencerait à s'exécuter et l'utilisateur pourrait voir l'historique des commandes sous l'onglet «Historique des commandes».

Step 14- L'état final de l'application est indiqué ci-dessous. Le pourcentage est calculé et il affiche le résultat à l'écran comme indiqué ci-dessous.

Step 15- La sortie du test est imprimée sur la console Eclipse comme indiqué ci-dessous, car nous avons imprimé la sortie sur la console. En temps réel, la sortie est écrite dans un fichier HTML ou dans un simple fichier texte.

Une commande fait référence à ce que Selenium doit faire et les commandes dans le sélénium sont de trois types. Cliquez sur chacun d'eux pour en savoir plus sur les commandes.

• Actions

• Accessors

• Assertions

Localisateurs

Les localisateurs d'élément aident Selenium à identifier l'élément HTML auquel la commande fait référence. Tous ces localisateurs peuvent être identifiés à l'aide du plugin FirePath et FireBug de Mozilla. Veuillez consulter le chapitre Configuration de l'environnement pour plus de détails.

• identifier = id Sélectionnez l'élément avec l'attribut "id" spécifié et s'il n'y a pas de correspondance, sélectionnez le premier élément dont l'attribut @name est id.

• id = id Sélectionnez l'élément avec l'attribut "id" spécifié.

• name = name Sélectionnez le premier élément avec l'attribut "nom" spécifié

• dom = javascriptExpressionSelenium trouve un élément en évaluant la chaîne spécifiée qui nous permet de parcourir le modèle d'objet de document HTML à l'aide de JavaScript. Les utilisateurs ne peuvent pas renvoyer une valeur mais peuvent évaluer comme une expression dans le bloc.

• xpath = xpathExpression Recherchez un élément à l'aide d'une expression XPath.

• link = textPattern Sélectionnez l'élément de lien (dans les balises d'ancrage) qui contient le texte correspondant au modèle spécifié.

• css = cssSelectorSyntax Sélectionnez l'élément à l'aide du sélecteur css.

WebDriver est un outil permettant d'automatiser les tests d'applications Web. Il est populairement connu sous le nom de Selenium 2.0. WebDriver utilise un cadre sous-jacent différent, tandis que Selenium RC utilise JavaScript Selenium-Core intégré dans le navigateur qui présente certaines limitations. WebDriver interagit directement avec le navigateur sans aucun intermédiaire, contrairement à Selenium RC qui dépend d'un serveur. Il est utilisé dans le contexte suivant -

• Tests multi-navigateurs comprenant une fonctionnalité améliorée pour les navigateurs qui n'est pas bien prise en charge par Selenium RC (Selenium 1.0).

• Gestion de plusieurs cadres, de plusieurs fenêtres de navigateur, de fenêtres contextuelles et d'alertes.

• Navigation de page complexe.

• Navigation utilisateur avancée telle que le glisser-déposer.

• Éléments d'interface utilisateur basés sur AJAX.

Architecture

WebDriver est mieux expliqué avec un schéma d'architecture simple comme indiqué ci-dessous.

Selenium RC contre WebDriver

Sélénium RC	Selenium WebDriver
L'architecture de Selenium RC est compliquée, car le serveur doit être opérationnel avant de démarrer un test.	L'architecture de WebDriver est plus simple que Selenium RC, car elle contrôle le navigateur à partir du niveau du système d'exploitation.
Le serveur Selenium agit comme un intermédiaire entre le navigateur et les commandes Selenese.	WebDriver interagit directement avec le navigateur et utilise le moteur du navigateur pour le contrôler.
L'exécution du script Selenium RC est plus lente, car il utilise un Javascript pour interagir avec RC.	WebDriver est plus rapide, car il interagit directement avec le navigateur.
Selenium RC ne peut pas prendre en charge l'exécution sans tête car il a besoin d'un vrai navigateur pour fonctionner.	WebDriver peut prendre en charge l'exécution sans tête.
C'est une API simple et petite.	API complexe et un peu grande par rapport à RC.
API moins orientée objet.	API purement orientée objet.
Impossible de tester les applications mobiles.	Peut tester les applications iPhone / Android.

Script à l'aide de WebDriver

Laissez-nous comprendre comment travailler avec WebDriver. Pour la démonstration, nous utiliserionshttps://www.calculator.net/. Nous allons effectuer une "Calculatrice de pourcentage" qui se trouve sous "Calculatrice mathématique". Nous avons déjà téléchargé les fichiers JAR WebDriver requis. Reportez-vous au chapitre "Configuration de l'environnement" pour plus de détails.

Step 1 - Lancez "Eclipse" à partir du dossier Eclipse extrait.

Step 2 - Sélectionnez l'espace de travail en cliquant sur le bouton «Parcourir».

Step 3 - Créez maintenant un «Nouveau projet» dans le menu «Fichier».

Step 4 - Entrez le nom du projet et cliquez sur «Suivant».

Step 5- Allez dans l'onglet Bibliothèques et sélectionnez tous les JAR que nous avons téléchargés. Ajoutez une référence à tous les JAR du dossier Selenium WebDriver Library ainsi qu'à selenium-java-2.42.2.jar et selenium-java-2.42.2-srcs.jar.

Step 6 - Le package est créé comme indiqué ci-dessous.

Step 7 - Cliquez maintenant avec le bouton droit sur le package et sélectionnez «Nouveau» >> «Classe» pour créer une «classe».

Step 8 - Nommez maintenant la classe et faites-en la fonction principale.

Step 9 - Le plan de classe est présenté ci-dessous.

Step 10- Il est maintenant temps de coder. Le script suivant est plus facile à comprendre, car il contient des commentaires pour expliquer clairement les étapes. Veuillez consulter le chapitre «Localisateurs» pour comprendre comment capturer les propriétés des objets.

import java.util.concurrent.TimeUnit;

import org.openqa.selenium.*;
import org.openqa.selenium.firefox.FirefoxDriver;

public class webdriverdemo {
   public static void main(String[] args) {
   
      WebDriver driver = new FirefoxDriver();
      //Puts an Implicit wait, Will wait for 10 seconds before throwing exception
      driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
      
      //Launch website
      driver.navigate().to("http://www.calculator.net/");
      
      //Maximize the browser
      driver.manage().window().maximize();
      
      // Click on Math Calculators
      driver.findElement(By.xpath(".//*[@id = 'menu']/div[3]/a")).click();
      
      // Click on Percent Calculators
      driver.findElement(By.xpath(".//*[@id = 'menu']/div[4]/div[3]/a")).click();
      
      // Enter value 10 in the first number of the percent Calculator
      driver.findElement(By.id("cpar1")).sendKeys("10");
      
      // Enter value 50 in the second number of the percent Calculator
      driver.findElement(By.id("cpar2")).sendKeys("50");
      
      // Click Calculate Button
      driver.findElement(By.xpath(".//*[@id = 'content']/table/tbody/tr[2]/td/input[2]")).click();

      
      // Get the Result Text based on its xpath
      String result =
         driver.findElement(By.xpath(".//*[@id = 'content']/p[2]/font/b")).getText();

      
      // Print a Log In message to the screen
      System.out.println(" The Result is " + result);
      
      //Close the Browser.
      driver.close();
   }
}

Step 11 - La sortie du script ci-dessus serait imprimée dans la console.

Commandes les plus utilisées

Le tableau suivant répertorie certaines des commandes les plus fréquemment utilisées dans WebDriver ainsi que leur syntaxe.

N ° Sr.	Commande et description
1	driver.get("URL") Pour accéder à une application.
2	element.sendKeys("inputtext") Entrez du texte dans une zone de saisie.
3	element.clear() Effacez le contenu de la zone de saisie.
4	select.deselectAll() Désélectionnez toutes les OPTIONS du premier SELECT sur la page.
5	select.selectByVisibleText("some text") Sélectionnez l'OPTION avec l'entrée spécifiée par l'utilisateur.
6	driver.switchTo().window("windowName") Déplacez le focus d'une fenêtre à une autre.
sept	driver.switchTo().frame("frameName") Passez d'une image à l'autre.
8	driver.switchTo().alert() Aide à gérer les alertes.
9	driver.navigate().to("URL") Accédez à l'URL.
dix	driver.navigate().forward() Pour avancer.
11	driver.navigate().back() Pour revenir en arrière.
12	driver.close() Ferme le navigateur actuel associé au pilote.
13	driver.quit() Quitte le pilote et ferme toute la fenêtre associée à ce pilote.
14	driver.refresh() Actualise la page actuelle.

La localisation des éléments dans Selenium WebDriver est effectuée à l'aide des méthodes findElement () et findElements () fournies par WebDriver et la classe WebElement.

• findElement () renvoie un objet WebElement basé sur un critère de recherche spécifié ou finit par lever une exception s'il ne trouve aucun élément correspondant aux critères de recherche.

• findElements () renvoie une liste de WebElements correspondant aux critères de recherche. Si aucun élément n'est trouvé, il renvoie une liste vide.

Le tableau suivant répertorie toute la syntaxe Java pour localiser les éléments dans Selenium WebDriver.

Méthode	Syntaxe	La description
Par ID	driver.findElement (By.id (<ID d'élément>))	Localise un élément à l'aide de l'attribut ID
De nom	driver.findElement (By.name (<nom de l'élément>))	Localise un élément à l'aide de l'attribut Name
Par nom de classe	driver.findElement (By.className (<classe d'élément>))	Localise un élément à l'aide de l'attribut Classe
Par nom de balise	driver.findElement (By.tagName (<htmltagname>))	Localise un élément à l'aide de la balise HTML
Par texte du lien	driver.findElement (Par.linkText (<linktext>))	Localise un lien à l'aide du texte du lien
Par texte de lien partiel	driver.findElement (Par.partialLinkText (<linktext>))	Localise un lien à l'aide du texte partiel du lien
Par CSS	driver.findElement (By.cssSelector (<sélecteur css>))	Localise un élément à l'aide du sélecteur CSS
Par XPath	driver.findElement (Par.xpath (<xpath>))	Localise un élément à l'aide de la requête XPath

Utilisation des localisateurs

Maintenant, comprenons l'utilisation pratique de chacune des méthodes de localisation à l'aide de https://www.calculator.net

Par ID

Ici, un objet est accessible à l'aide d'identifiants. Dans ce cas, il s'agit de l'ID de la zone de texte. Les valeurs sont saisies dans la zone de texte à l'aide de la méthode sendkeys à l'aide de l'ID (cdensity).

driver.findElement(By.id("cdensity")).sendKeys("10");

De nom

Ici, un objet est accessible à l'aide de noms. Dans ce cas, il s'agit du nom de la zone de texte. Les valeurs sont saisies dans la zone de texte à l'aide de la méthode sendkeys à l'aide de l'ID (cdensity).

driver.findElement(By.name("cdensity")).sendKeys("10");

Par nom de classe

Ici, un objet est accessible à l'aide des noms de classe. Dans ce cas, il s'agit du nom de classe du WebElement. La valeur est accessible à l'aide de la méthode gettext.

List<WebElement> byclass = driver.findElements(By.className("smalltext smtb"));

Par nom de tag

Le nom de balise DOM d'un élément peut être utilisé pour localiser cet élément particulier dans le WebDriver. Il est très facile de gérer les tableaux à l'aide de cette méthode. Jetez un œil au code suivant.

WebElement table = driver.findElement(By.id("calctable"));
List<WebElement> row = table.findElements(By.tagName("tr"));
int rowcount = row.size();

Par texte du lien

Cette méthode permet de localiser un élément de lien avec le texte visible correspondant.

driver.findElements(By.linkText("Volume")).click();

Par texte de lien partiel

Cette méthode permet de localiser un élément de lien avec un texte visible partiellement correspondant.

driver.findElement(By.partialLinkText("Volume")).click();

Par CSS

Le CSS est utilisé comme méthode pour identifier l'objet Web, mais tous les navigateurs ne prennent PAS en charge l'identification CSS.

WebElement loginButton = driver.findElement(By.cssSelector("input.login"));

Par XPath

XPath signifie langage de chemin XML. C'est un langage de requête pour sélectionner des nœuds à partir d'un document XML. XPath est basé sur la représentation arborescente des documents XML et offre la possibilité de naviguer dans l'arborescence en sélectionnant des nœuds à l'aide de divers critères.

driver.findElement(By.xpath(".//*[@id = 'content']/table[1]/tbody/tr/td/table/tbody/tr[2]/td[1]/input")).sendkeys("100");

Selenium WebDriver est l'outil le plus fréquemment utilisé parmi tous les outils disponibles dans l'ensemble d'outils Selenium. Par conséquent, il est important de comprendre comment utiliser Selenium pour interagir avec les applications Web. Dans ce module, expliquons comment interagir avec les objets GUI à l'aide de Selenium webDriver.

Nous devons interagir avec l'application à l'aide de certaines actions de base ou même d'une action utilisateur avancée en développant des fonctions définies par l'utilisateur pour lesquelles il n'y a pas de commandes prédéfinies.

Vous trouverez ci-dessous les différents types d'actions contre ces objets GUI -

• Interaction de la zone de texte

• Sélection du bouton radio

• Sélection de la case à cocher

• Sélection d'éléments déroulants

• Synchronization

• Glisser-déposer

• Actions du clavier

• Actions de la souris

• Sélection multiple

• Trouver tous les liens

Il existe différents composants impliqués dans la conception des tests. Laissez-nous comprendre certains des composants importants impliqués dans la conception d'un cadre. Nous apprendrons les sujets suivants dans ce chapitre -

• Modèle d'objet de page

• Paramétrage à l'aide d'Excel

• Journalisation Log4j

• Gestion des exceptions

• Test multi-navigateurs

• Capturez des captures d'écran

• Capturer des vidéos

TestNG est un puissant framework de test, une version améliorée de JUnit qui était utilisée pendant longtemps avant que TestNG ne soit créé. NG signifie «Next Generation».

Le framework TestNG fournit les fonctionnalités suivantes -

• Les annotations nous aident à organiser les tests facilement.
• Configuration de test flexible.
• Les cas de test peuvent être regroupés plus facilement.
• La parallélisation des tests peut être réalisée à l'aide de TestNG.
• Prise en charge des tests basés sur les données.
• Rapports intégrés.

Installation de TestNG pour Eclipse

Step 1 - Lancez Eclipse et sélectionnez «Installer un nouveau logiciel».

Step 2 - Entrez l'URL comme "http://beust.com/eclipse" et cliquez sur "Ajouter".

Step 3- La boîte de dialogue «Ajouter un référentiel» s'ouvre. Entrez le nom comme 'TestNG' et cliquez sur 'OK'

Step 4 - Cliquez sur «Sélectionner tout» et «TestNG» sera sélectionné comme indiqué sur la figure.

Step 5 - Cliquez sur «Suivant» pour continuer.

Step 6 - Passez en revue les éléments sélectionnés et cliquez sur «Suivant».

Step 7 - «Acceptez le contrat de licence» et cliquez sur «Terminer».

Step 8 - TestNG commence l'installation et la progression est indiquée ci-dessous.

Step 9- Un avertissement de sécurité apparaît car la validité du logiciel ne peut pas être établie. Cliquez sur OK'.

Step 10- Le programme d'installation vous invite à redémarrer Eclipse pour que les modifications prennent effet. Cliquez sur «Oui».

Annotations dans TestNG

Des annotations ont été officiellement ajoutées au langage Java dans JDK 5 et TestNG a fait le choix d'utiliser des annotations pour annoter les classes de test. Voici quelques-uns des avantages de l'utilisation des annotations. Plus d'informations sur TestNG peuvent être trouvéeshere

• TestNG identifie les méthodes qui l'intéressent en recherchant des annotations. Par conséquent, les noms de méthode ne sont limités à aucun modèle ou format.

• Nous pouvons passer des paramètres supplémentaires aux annotations.

• Les annotations sont fortement typées, de sorte que le compilateur signalera immédiatement toute erreur.

• Les classes de test n'ont plus besoin d'étendre quoi que ce soit (comme TestCase, pour JUnit 3).

N ° Sr.	Annotation et description
1	@BeforeSuite La méthode annotée ne sera exécutée qu'une seule fois avant que tous les tests de cette suite ne soient exécutés.
2	@AfterSuite La méthode annotée ne sera exécutée qu'une seule fois après l'exécution de tous les tests de cette suite.
3	@BeforeClass La méthode annotée ne sera exécutée qu'une seule fois avant que la première méthode de test de la classe actuelle ne soit appelée.
4	@AfterClass La méthode annotée ne sera exécutée qu'une seule fois après l'exécution de toutes les méthodes de test de la classe actuelle.
5	@BeforeTest La méthode annotée sera exécutée avant l'exécution de toute méthode de test appartenant aux classes à l'intérieur de la balise <test>.
6	@AfterTest La méthode annotée sera exécutée après l'exécution de toutes les méthodes de test appartenant aux classes à l'intérieur de la balise <test>.
sept	@BeforeGroups La liste des groupes que cette méthode de configuration exécutera avant. Il est garanti que cette méthode s'exécutera peu de temps avant que la première méthode de test appartenant à l'un de ces groupes ne soit appelée.
8	@AfterGroups La liste des groupes après lesquels cette méthode de configuration s'exécutera. Cette méthode est garantie de s'exécuter peu de temps après que la dernière méthode de test appartenant à l'un de ces groupes a été appelée.
9	@BeforeMethod La méthode annotée sera exécutée avant chaque méthode de test.
dix	@AfterMethod La méthode annotée sera exécutée après chaque méthode de test.
11	@DataProvider Marque une méthode comme fournissant des données pour une méthode d'essai. La méthode annotée doit renvoyer un objet [] [] où chaque objet [] peut se voir attribuer la liste des paramètres de la méthode de test. La méthode @Test qui souhaite recevoir des données de ce DataProvider doit utiliser un nom dataProvider égal au nom de cette annotation.
12	@Factory Marque une méthode comme une fabrique qui renvoie des objets qui seront utilisés par TestNG comme classes de test. La méthode doit renvoyer Object [].
13	@Listeners Définit les écouteurs sur une classe de test.
14	@Parameters Décrit comment passer des paramètres à une méthode @Test.
15	@Test Marque une classe ou une méthode comme faisant partie du test.

Configuration de TestNG-Eclipse

Step 1 - Lancez Eclipse et créez un «Nouveau projet Java» comme indiqué ci-dessous.

Step 2 - Entrez le nom du projet et cliquez sur «Suivant».

Step 3 - Accédez à l'onglet "Bibliothèques" et ajoutez le fichier JAR du serveur de contrôle à distance Selenium en cliquant sur "Ajouter des fichiers JAR externes" comme indiqué ci-dessous.

Step 4- Le fichier JAR ajouté est affiché ici. Cliquez sur «Ajouter une bibliothèque».

Step 5- La boîte de dialogue «Ajouter une bibliothèque» s'ouvre. Sélectionnez «TestNG» et cliquez sur «Suivant» dans la boîte de dialogue «Ajouter une bibliothèque».

Step 6 - La bibliothèque 'TestNG' ajoutée est ajoutée et s'affiche comme indiqué ci-dessous.

Step 7 - Lors de la création du projet, la structure du projet serait comme indiqué ci-dessous.

Step 8 - Faites un clic droit sur le dossier 'src' et sélectionnez Nouveau >> Autre.

Step 9 - Sélectionnez «TestNG» et cliquez sur «Suivant».

Step 10 - Sélectionnez le nom du «dossier source» et cliquez sur «OK».

Step 11 - Sélectionnez le 'Nom du package', le 'nom de la classe' et cliquez sur 'Terminer'.

Step 12 - L'explorateur de packages et la classe créée seraient affichés.

Premier test dans TestNG

Maintenant, commençons à créer des scripts avec TestNG. Écrivons le même exemple que celui utilisé pour comprendre le WebDriver. Nous utiliserons l'application de démonstration, www.calculator.net , et effectuerons un calculateur de pourcentage.

Dans le test suivant, vous remarquerez qu'il n'y a AUCUNE méthode principale, car testNG pilotera le flux d'exécution du programme. Après avoir initialisé le pilote, il exécutera la méthode '@BeforeTest' suivie de '@Test' puis de '@AfterTest'. Veuillez noter qu'il peut y avoir n'importe quel nombre d'annotations «@Test» dans une classe, mais «@BeforeTest» et «@AfterTest» ne peuvent apparaître qu'une seule fois.

package TestNG;

import java.util.concurrent.TimeUnit;

import org.openqa.selenium.*;
import org.openqa.selenium.firefox.FirefoxDriver;

import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Test;

public class TestNGClass {
   WebDriver driver = new FirefoxDriver();
   
   @BeforeTest
   public void launchapp() {
      // Puts an Implicit wait, Will wait for 10 seconds before throwing exception
      driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
      
      // Launch website
      driver.navigate().to("http://www.calculator.net");
      driver.manage().window().maximize();
   }
   
   @Test
   public void calculatepercent() {
      // Click on Math Calculators
      driver.findElement(By.xpath(".//*[@id='menu']/div[3]/a")).click();
      
      // Click on Percent Calculators
      driver.findElement(By.xpath(".//*[@id='menu']/div[4]/div[3]/a")).click();
      
      // Enter value 10 in the first number of the percent Calculator
      driver.findElement(By.id("cpar1")).sendKeys("10");
      
      // Enter value 50 in the second number of the percent Calculator
      driver.findElement(By.id("cpar2")).sendKeys("50");
      
      // Click Calculate Button
      driver.findElement(By.xpath(".//*[@id='content']/table/tbody/tr/td[2]/input")).click();
      
      // Get the Result Text based on its xpath
      String result =
         driver.findElement(By.xpath(".//*[@id='content']/p[2]/span/font/b")).getText();
      
      // Print a Log In message to the screen
      System.out.println(" The Result is " + result);
      
      if(result.equals("5")) {
         System.out.println(" The Result is Pass");
      } else {
         System.out.println(" The Result is Fail");
      }
   }
   
   @AfterTest
   public void terminatetest() {
      driver.close();
   }
}

Exécution

Pour l'exécuter, faites un clic droit sur le XML créé et sélectionnez "Exécuter en tant que" >> "TestNG Suite"

Analyse des résultats

La sortie est envoyée à la console et elle apparaîtra comme indiqué ci-dessous. La sortie de la console a également un résumé de l'exécution.

Le résultat de TestNG peut également être vu dans un autre onglet. Cliquez sur le bouton "Affichage du rapport HTML" comme indiqué ci-dessous.

Le résultat HTML serait affiché comme indiqué ci-dessous.

Selenium Grid est un outil qui distribue les tests sur plusieurs machines physiques ou virtuelles afin que nous puissions exécuter des scripts en parallèle (simultanément). Il accélère considérablement le processus de test sur les navigateurs et sur toutes les plates-formes en nous donnant des commentaires rapides et précis.

Selenium Grid nous permet d'exécuter plusieurs instances de tests WebDriver ou Selenium Remote Control en parallèle qui utilisent la même base de code, par conséquent le code n'a PAS besoin d'être présent sur le système qu'ils exécutent. Le package selenium-server-standalone inclut Hub, WebDriver et Selenium RC pour exécuter les scripts dans la grille.

Selenium Grid a un Hub et un Node.

• Hub- Le hub peut également être compris comme un serveur qui agit comme le point central où les tests seraient déclenchés. Un Selenium Grid n'a qu'un seul Hub et il est lancé une fois sur une seule machine.

• Node- Les nœuds sont les instances Selenium qui sont attachées au Hub qui exécutent les tests. Il peut y avoir un ou plusieurs nœuds dans une grille qui peuvent être de n'importe quel système d'exploitation et peuvent contenir n'importe lequel des navigateurs pris en charge par Selenium.

Architecture

Le diagramme suivant montre l'architecture de Selenium Grid.

Travailler avec Grid

Afin de travailler avec le Grid, nous devons suivre certains protocoles. Écoutez ci-dessous les principales étapes de ce processus -

• Configuration du concentrateur
• Configuration des nœuds
• Développer le script et préparer le fichier XML
• Exécution des tests
• Analyse des résultats

Laissez-nous discuter de chacune de ces étapes en détail.

Configuration du concentrateur

Step 1 - Téléchargez le dernier fichier JAR autonome de Selenium Server à partir de http://docs.seleniumhq.org/download/. Téléchargez-le en cliquant sur la version ci-dessous.

Step 2- Démarrez le Hub en lançant le serveur Selenium à l'aide de la commande suivante. Nous allons maintenant utiliser le port '4444' pour démarrer le hub.

Note - Assurez-vous qu'aucune autre application n'est en cours d'exécution sur le port # 4444.

java -jar selenium-server-standalone-2.25.0.jar -port 4444 -role hub -nodeTimeout 1000

Step 3 - Ouvrez maintenant le navigateur et accédez à l'URL http // localhost: 4444 à partir du Hub (le système sur lequel vous avez exécuté l'étape 2).

Step 4- Cliquez maintenant sur le lien 'console' et cliquez sur 'view config'. La configuration du hub serait affichée comme suit. Pour l'instant, nous n'avons pas de nœuds, nous ne pourrons donc pas voir les détails.

Configuration des nœuds

Step 1- Connectez-vous au nœud (sur lequel vous souhaitez exécuter les scripts) et placez le 'selenium-server-standalone-2.42.2' dans un dossier. Nous devons pointer vers le JAR selenium-server-standalone lors du lancement des nœuds.

Step 2 - Lancez FireFox Node à l'aide de la commande ci-dessous.

java -jar D:\JAR\selenium-server-standalone-2.42.2.jar
   -role node -hub http://10.30.217.157:4444/grid/register
   -browser browserName = firefox -port 5555

Où,

D: \ JAR \ selenium-server-standalone-2.42.2.jar = Emplacement du fichier Jar autonome du serveur Selenium (sur la machine Node)

http://10.30.217.157:4444 = Adresse IP du Hub et 4444 est le port du Hub

browserName = firefox (Paramètre pour spécifier le nom du navigateur sur les nœuds)

5555 = Port sur lequel Firefox Node serait opérationnel.

Step 3- Après avoir exécuté la commande, revenez au Hub. Accédez à l'URL - http://10.30.217.157:4444 et le hub afficherait maintenant le nœud qui lui est attaché.

Step 4- Lançons maintenant le nœud Internet Explorer. Pour lancer le nœud IE, nous devons avoir le pilote Internet Explorer téléchargé sur la machine du nœud.

Step 5 - Pour télécharger le pilote Internet Explorer, accédez à http://docs.seleniumhq.org/download/et téléchargez le fichier approprié en fonction de l'architecture de votre système d'exploitation. Après avoir téléchargé, décompressez le fichier exe et placez-y un dossier qui doit être référencé lors du lancement des nœuds IE.

Step 6 - Lancez IE à l'aide de la commande suivante.

C:\>java -Dwebdriver.ie.driver = D:\IEDriverServer.exe
   -jar D:\JAR\selenium-server-standalone-2.42.2.jar
   -role webdriver -hub http://10.30.217.157:4444/grid/register
   -browser browserName = ie,platform = WINDOWS -port 5558

Où,

D: \ IEDriverServer.exe = L'emplacement du pilote IE téléchargé (sur la machine Node)

D: \ JAR \ selenium-server-standalone-2.42.2.jar = Emplacement du fichier Jar autonome du serveur Selenium (sur la machine Node)

http://10.30.217.157:4444 = Adresse IP du Hub et 4444 est le port du Hub

browserName = ie (Paramètre pour spécifier le nom du navigateur sur les nœuds)

5558 = Port sur lequel le nœud IE serait opérationnel.

Step 7- Après avoir exécuté la commande, revenez au Hub. Accédez à l'URL - http://10.30.217.157:4444 et le hub afficherait maintenant le nœud IE qui lui est attaché.

Step 8- Lançons maintenant Chrome Node. Pour lancer le nœud Chrome, nous devons télécharger le pilote Chrome sur la machine du nœud.

Step 9 - Pour télécharger le pilote Chrome, accédez à http://docs.seleniumhq.org/download/ puis accédez à la zone Pilotes de navigateur tiers et cliquez sur le numéro de version «2.10» comme indiqué ci-dessous.

Step 10- Téléchargez le pilote en fonction du type de votre système d'exploitation. Nous l'exécuterons sur l'environnement Windows, par conséquent, nous téléchargerons le pilote Windows Chrome. Après avoir téléchargé, décompressez le fichier exe et placez-le dans un dossier qui doit être référencé lors du lancement des nœuds chrome.

Step 11 - Lancez Chrome à l'aide de la commande suivante.

C:\>java -Dwebdriver.chrome.driver = D:\chromedriver.exe 
   -jar D:\JAR\selenium-server-standalone-2.42.2.jar 
   -role webdriver -hub  http://10.30.217.157:4444/grid/register 
   -browser browserName = chrome, platform = WINDOWS -port 5557

Où,

D: \ chromedriver.exe = L'emplacement du pilote Chrome téléchargé (sur la machine Node)

D: \ JAR \ selenium-server-standalone-2.42.2.jar = Emplacement du fichier Jar autonome du serveur Selenium (sur la machine Node)

http://10.30.217.157:4444 = Adresse IP du Hub et 4444 est le port du Hub

browserName = chrome (Paramètre pour spécifier le nom du navigateur sur les nœuds)

5557 = Port sur lequel Chrome Node serait opérationnel.

Step 12- Après avoir exécuté la commande, revenez au Hub. Accédez à l'URL - http://10.30.217.157:4444 et le hub afficherait maintenant le nœud chrome qui lui est attaché.

Développer le script et préparer le fichier XML

Step 1- Nous développerons un test en utilisant TestNG. Dans l'exemple suivant, nous allons lancer chacun de ces navigateurs à l'aide de webDriver distant. Il peut transmettre leurs capacités au pilote afin que le pilote dispose de toutes les informations à exécuter sur les nœuds.

Le paramètre de navigateur serait passé du fichier "XML".

package TestNG;

import org.openqa.selenium.*;
import org.openqa.selenium.remote.RemoteWebDriver;
import org.openqa.selenium.remote.DesiredCapabilities;

import org.testng.annotations.AfterTest;
import org.testng.annotations.BeforeTest;
import org.testng.annotations.Parameters;
import org.testng.annotations.Test;

import java.net.URL;
import java.util.concurrent.TimeUnit;
import java.net.MalformedURLException;

public class TestNGClass {
   public WebDriver driver;
   public String URL, Node;
   protected ThreadLocal<RemoteWebDriver> threadDriver = null;
   
   @Parameters("browser")
   @BeforeTest
   public void launchapp(String browser) throws MalformedURLException {
      String URL = "http://www.calculator.net";
      
      if (browser.equalsIgnoreCase("firefox")) {
         System.out.println(" Executing on FireFox");
         String Node = "http://10.112.66.52:5555/wd/hub";
         DesiredCapabilities cap = DesiredCapabilities.firefox();
         cap.setBrowserName("firefox");
         
         driver = new RemoteWebDriver(new URL(Node), cap);
         // Puts an Implicit wait, Will wait for 10 seconds before throwing exception
         driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
         
         // Launch website
         driver.navigate().to(URL);
         driver.manage().window().maximize();
      } else if (browser.equalsIgnoreCase("chrome")) {
         System.out.println(" Executing on CHROME");
         DesiredCapabilities cap = DesiredCapabilities.chrome();
         cap.setBrowserName("chrome");
         String Node = "http://10.112.66.52:5557/wd/hub";
         driver = new RemoteWebDriver(new URL(Node), cap);
         driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
         
         // Launch website
         driver.navigate().to(URL);
         driver.manage().window().maximize();
      } else if (browser.equalsIgnoreCase("ie")) {
         System.out.println(" Executing on IE");
         DesiredCapabilities cap = DesiredCapabilities.chrome();
         cap.setBrowserName("ie");
         String Node = "http://10.112.66.52:5558/wd/hub";
         driver = new RemoteWebDriver(new URL(Node), cap);
         driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
         
         // Launch website
         driver.navigate().to(URL);
         driver.manage().window().maximize();
      } else {
         throw new IllegalArgumentException("The Browser Type is Undefined");
      }
   }
   
   @Test
   public void calculatepercent() {
      // Click on Math Calculators
      driver.findElement(By.xpath(".//*[@id = 'menu']/div[3]/a")).click();     	
      
      // Click on Percent Calculators
      driver.findElement(By.xpath(".//*[@id = 'menu']/div[4]/div[3]/a")).click();
      
      // Enter value 10 in the first number of the percent Calculator
      driver.findElement(By.id("cpar1")).sendKeys("10");
      
      // Enter value 50 in the second number of the percent Calculator
      driver.findElement(By.id("cpar2")).sendKeys("50");
      
      // Click Calculate Button
      // driver.findElement(By.xpath(".//*[@id = 'content']/table/tbody/tr/td[2]/input")).click();
      // Get the Result Text based on its xpath
      String result =
         driver.findElement(By.xpath(".//*[@id = 'content']/p[2]/span/font/b")).getText();
      
      // Print a Log In message to the screen
      System.out.println(" The Result is " + result);
      
      if(result.equals("5")) {
         System.out.println(" The Result is Pass");
      } else {
         System.out.println(" The Result is Fail");
      }
   }
   
   @AfterTest
   public void closeBrowser() {
      driver.quit();
   }
}

Step 2- Le paramètre Browser sera transmis en utilisant XML. Créez un XML sous le dossier du projet.

Step 3 - Sélectionnez «Fichier» dans «Général» et cliquez sur «Suivant».

Step 4 - Entrez le nom du fichier et cliquez sur «Terminer».

Step 5 - TestNg.XML est créé dans le dossier du projet comme indiqué ci-dessous.

Step 6- Le contenu du fichier XML est indiqué ci-dessous. Nous créons 3 tests et les mettons dans une suite et mentionnons parallel = "tests" pour que tous les tests soient exécutés en parallèle.

<?xml version = "1.0" encoding = "UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">
<suite name = "Suite" parallel = "tests">

   <test name = "FirefoxTest">
   <parameter name = "browser" value = "firefox" />
      <classes>
         <class name = "TestNG.TestNGClass" />
      </classes>
   </test>

   <test name = "ChromeTest">
   <parameter name = "browser" value = "chrome" />
      <classes>
         <class name = "TestNG.TestNGClass" />
      </classes>
   </test>

   <test name = "IETest">
   <parameter name = "browser" value = "ie" />
      <classes>
         <class name = "TestNG.TestNGClass" />
      </classes>
   </test>
   
</suite>

Exécution des tests

Step 1- Sélectionnez le XML créé; cliquez avec le bouton droit de la souris et choisissez «Exécuter en tant que» >> «TestNG Suite».

Step 2- Ouvrez maintenant le nœud, où nous avons lancé tous les nœuds du navigateur. Vous verrez les trois navigateurs en exécution simultanément.

Analyse des résultats

Step 1- Une fois l'exécution terminée, nous pouvons analyser le résultat comme toute autre exécution. Le résumé des résultats est imprimé dans la console comme indiqué dans l'instantané suivant.

Step 2 - Accédez à l'onglet «Résultats de la suite d'exécution» et TestNG affichera le résumé des résultats comme indiqué ci-dessous.

Step 3 - Lors de la génération du HTML, nous pourrons voir les résultats des tests au format HTML.