TestNG Tutoriel : Qu'est-ce que les annotations et le framework dans Selenium

Qu’est ce qu' TestNG?

TestNG est un cadre de test d'automatisation dans lequel NG signifie « Next Generation ». TestNG est inspiré par JUnit qui utilise les annotations (@). TestNG surmonte les inconvénients de JUnit et est conçu pour faire tests de bout en bout facile.

En utilisant TestNG, vous pouvez générer un rapport approprié et vous pouvez facilement savoir combien de cas de test ont réussi, échoué et ignorés. Vous pouvez exécuter les scénarios de test ayant échoué séparément.

Par exemple :

Supposons que vous ayez cinq cas de test, une méthode est écrite pour chaque cas de test (supposons que le programme soit écrit en utilisant la méthode principale sans utiliser testNG). Lorsque vous exécutez ce programme en premier, trois méthodes sont exécutées avec succès et la quatrième méthode échoue. Corrigez ensuite les erreurs présentes dans la quatrième méthode, vous ne voulez maintenant exécuter que la quatrième méthode car les trois premières méthodes sont de toute façon exécutées avec succès. Cela n'est pas possible sans utiliser TestNG.
Votre TestNG in Selenium fournit une option, c'est-à-dire le fichier testng-failed.xml dans le dossier test-output. Si vous souhaitez exécuter uniquement les cas de test ayant échoué, exécutez ce fichier XML. Il exécutera uniquement les cas de test ayant échoué.

Outre le concept ci-dessus, vous en apprendrez davantage sur TestNG, comme quels sont les avantages de TestNG, comment créer des méthodes de test à l'aide des annotations @test, comment convertir ces classes en fichier de suite de tests et les exécuter via Eclipse ainsi qu'à partir de la ligne de commande.

Pourquoi utiliser TestNG au Selenium?

Réglage par défaut Selenium les tests ne génèrent pas un format approprié pour les résultats des tests. En utilisant TestNG in Selenium, nous pouvons générer des résultats de tests.

pont Selenium les utilisateurs l'utilisent plus de Junite en raison de ses avantages. Il y a tellement de fonctionnalités de TestNG, mais nous nous concentrerons uniquement sur les plus importants que nous pouvons utiliser dans Selenium. Voici les principales caractéristiques de Selenium TestNG:

Générez le rapport dans un format approprié comprenant un certain nombre d'exécutions de scénarios de test, le nombre de scénarios de test réussis, le nombre de scénarios de test ayant échoué et le nombre de scénarios de test ignorés.
Plusieurs cas de test peuvent être regroupés plus facilement en les convertissant en fichier testng.xml. Dans lequel vous pouvez établir des priorités quel scénario de test doit être exécuté en premier.
Le même scénario de test peut être exécuté plusieurs fois sans boucles simplement en utilisant le mot-clé appelé « nombre d'appels ».
En utilisant testng, vous pouvez exécuter plusieurs cas de test sur plusieurs navigateurs, c'est-à-dire cross test du navigateur.
Votre TestNG le framework peut être facilement intégré à des outils tels que TestNG Maven, Jenkins, etc.
Les annotations utilisées dans les tests sont très faciles à comprendre, ex : @BeforeMethod, @AfterMethod, @BeforeTest, @AfterTest
WebDriver ne dispose d'aucun mécanisme natif pour générer des rapports. TestNG peut générer le rapport dans un format lisible comme celui présenté ci-dessous.

TestNG simplifie la façon dont les tests sont codés. Il n'y a plus besoin d'une méthode principale statique dans nos tests. La séquence d'actions est régulée par des annotations faciles à comprendre qui ne nécessitent pas que les méthodes soient statiques.

Les exceptions non interceptées sont automatiquement gérées par TestNG sans mettre fin prématurément au test. Ces exceptions sont signalées comme étapes ayant échoué dans le rapport.

Avantages de TestNG plus de JUnit

Il y a trois avantages majeurs à TestNG plus de JUnit:

Les annotations sont plus faciles à comprendre
Les cas de test peuvent être regroupés plus facilement
Des tests parallèles sont possibles

Qu'est-ce que l'annotation dans TestNG?

Annotations dans TestNG sont des lignes de code qui peuvent contrôler la manière dont la méthode située en dessous sera exécutée. Ils sont toujours précédés du symbole @. Un très tôt et rapide TestNG L’exemple est celui présenté ci-dessous.

Les annotations seront abordées plus tard dans la section intitulée « Annotations utilisées dans TestNG", donc ce n'est pas grave si vous ne comprenez pas ce qui précède TestNG Exemple pour l'instant. Il est juste important de noter pour l'instant que les annotations dans TestNG sont plus faciles à coder et à comprendre que dans JUnit.

La possibilité d'exécuter des tests en parallèle est disponible dans TestNG mais pas dans JUnit, alors le TestNG Le framework est plus préféré pour les testeurs utilisant Selenium Grille

Comment rédiger des cas de test dans TestNG?

Étape 1) Écrivez votre logique métier et insérez le TestNG annotations dans votre code.
Étape 2) Ajoutez plus d'informations telles que le nom de la classe, le nom du groupe, le nom du package, etc.
Étape 3) Exécutez le TestNG.

Créer un scénario de test à l'aide de TestNG Annotations

Maintenant, nous allons apprendre à créer notre premier cas de test en utilisant TestNG Annotations dans Selenium:

Avant de créer un scénario de test, nous devons d'abord configurer un nouveau TestNG Projet en Eclipse et nommez-le « PremierTestNGProjet".

Mettre en place un nouveau TestNG Projet

Étape 1: Cliquez sur Fichier > Nouveau > Java Projet

Étape 2: Tapez « PremierTestNGProjet » comme nom du projet, puis cliquez sur Suivant.

Étape 3: Nous allons maintenant commencer à importer le TestNG Bibliothèques sur notre projet. Cliquez sur l'onglet « Bibliothèques », puis « Ajouter une bibliothèque… »

Étape 4: Dans la boîte de dialogue Ajouter une bibliothèque, choisissez «TestNG" et cliquez sur Suivant.

Étape 5: Cliquez sur Terminer.

Vous devriez remarquer que TestNG est inclus dans la liste des bibliothèques.

Étape 6: Nous allons maintenant ajouter les fichiers JAR qui contiennent le Selenium API. Ces fichiers se trouvent dans le Java pilote client que nous avons téléchargé à partir de https://www.selenium.dev/downloads/ quand nous installions Selenium et le Eclipse dans les chapitres précédents.

Ensuite, accédez à l'endroit où vous avez placé le Selenium Fichiers JAR.

Après avoir ajouté les JAR externes, votre écran devrait ressembler à ceci.

Étape 7: Cliquez sur Terminer et vérifiez que notre premierTestNGLe projet est visible sur Eclipsela fenêtre de l'Explorateur de packages.

Comment créer un nouveau TestNG Fichier d'essai

Maintenant que nous avons fini de mettre en place notre projet dans ce TestNG tutoriel, créons un nouveau TestNG fichier.

Étape 1: Cliquez sur 'src' et choisissez autre.
Faites un clic droit sur le dossier du package « src » puis choisissez Nouveau > Autre…

Étape 2: Choisir TestNG classe.
Cliquez sur le TestNG dossier et sélectionnez le « TestNG classe ». Cliquez sur Suivant.

Étape 3: Tapez les valeurs.
Tapez les valeurs indiquées ci-dessous dans les zones de saisie appropriées et cliquez sur Terminer. Notez que nous avons nommé notre Java fichier comme « PremierTestNGDéposer".

Étape 4: Modèle créé.
Eclipse devrait créer automatiquement le modèle pour notre TestNG fichier présenté ci-dessous.

Codage de notre premier TestNG Exemple de cas de test

Créons maintenant notre premier Cas de test cela vérifiera si Mercury La page d'accueil de Tours est correcte. Tapez votre code comme indiqué ci-dessous TestNG Mise en situation :

package firsttestngpackage;
import org.openqa.selenium.*;
import org.openqa.selenium.firefox.FirefoxDriver;
import org.testng.Assert;
import org.testng.annotations.*;

public class firsttestngfile {
    public String baseUrl = "http://demo.guru99.com/test/newtours/";
    String driverPath = "C:\\geckodriver.exe";
    public WebDriver driver ; 
     
  @Test
  public void verifyHomepageTitle() {
       
      System.out.println("launching firefox browser"); 
      System.setProperty("webdriver.gecko.driver", driverPath);
      driver = new FirefoxDriver();
      driver.get(baseUrl);
      String expectedTitle = "Welcome: Mercury Tours";
      String actualTitle = driver.getTitle();
      Assert.assertEquals(actualTitle, expectedTitle);
      driver.close();
  }
}

Notez ce qui suit.

TestNG ne nécessite pas que vous ayez une méthode main().
Les méthodes ne doivent pas nécessairement être statiques.
Nous avons utilisé l'annotation @Test. @Test est utilisé pour indiquer que la méthode en dessous est un scénario de test. Dans ce cas, nous avons défini la méthode verifyHomepageTitle() comme notre scénario de test, nous avons donc placé une annotation « @Test » au-dessus.
Puisque nous utilisons des annotations dans TestNG, nous devions importer le package org.testng.annotations.*.
Nous avons utilisé la classe Assert. La classe Assert est utilisée pour effectuer des opérations de vérification dans TestNG. Pour l'utiliser, nous devons importer le package org.testng.Assert.

Vous pouvez avoir plusieurs cas de test (donc plusieurs annotations @Test) dans un seul TestNG fichier. Ceci sera abordé plus en détail plus tard dans la section « Annotations utilisées dans TestNG. »

Exécution du test

Pour exécuter le test, exécutez simplement le fichier dans Eclipse comme vous le faites normalement. Eclipse fournira deux sorties – une dans la fenêtre de la console et l'autre sur le TestNG Fenêtre de résultats.

Vérification des rapports créés par TestNG

La fenêtre Console dans Eclipse donne un rapport textuel des résultats de notre scénario de test tandis que le TestNG La fenêtre des résultats nous en donne une fenêtre graphique.

Génération de rapports HTML

TestNG a la capacité de générer des rapports au format HTML.

Étape 1: Après avoir exécuté notre premierTestNGFichier que nous avons créé dans la section précédente, cliquez avec le bouton droit sur le nom du projet (PremierTestNGProjet) dans la fenêtre Explorateur de projet puis cliquez sur l'option « Actualiser ».

Étape 2: Notez qu'un dossier « test-output » a été créé. Développez-le et recherchez un fichier index.html. Ce fichier HTML est un rapport des résultats du test le plus récent.

Étape 3: Double-cliquez sur ce fichier index.html pour l'ouvrir à l'intérieur EclipseLe navigateur Web intégré de. Vous pouvez actualiser cette page à tout moment après avoir réexécuté votre test en appuyant simplement sur F5, comme dans les navigateurs Web ordinaires.

Annotations utilisées dans TestNG

Dans la section précédente, vous avez découvert l'annotation @Test. Nous allons maintenant étudier les annotations plus avancées et leurs utilisations.

Plusieurs cas de test

Nous pouvons utiliser plusieurs annotations @Test en une seule TestNG déposer. Par défaut, les méthodes annotées par @Test sont exécutées par ordre alphabétique. Voir le code ci-dessous. Bien que les méthodes c_test, a_test et b_test ne soient pas classées par ordre alphabétique dans le code, elles seront exécutées telles quelles.

Exécutez ce code et sur la page index.html générée, cliquez sur « Vue chronologique ».

Paramètres

Si vous souhaitez que les méthodes soient exécutées dans un ordre différent, utilisez le paramètre « priorité ». Les paramètres sont des mots-clés qui modifient la fonction de l'annotation.

Les paramètres nécessitent que vous leur attribuiez une valeur. Pour ce faire, placez un « = » à côté d'eux, puis suivi de la valeur.
Les paramètres sont entourés d'une paire de parenthèses placées juste après l'annotation, comme l'extrait de code illustré ci-dessous.

TestNG exécutera l'annotation @Test avec la valeur de priorité la plus basse jusqu'à la plus grande. Il n'est pas nécessaire que vos valeurs de priorité soient consécutives.

Votre TestNG Le rapport HTML confirmera que les méthodes ont été exécutées en fonction de la valeur de priorité croissante.

Paramètres multiples

Outre la « priorité », @Test a un autre paramètre appelé « alwaysRun » qui ne peut être défini que sur « true » ou « false ». Pour utiliser deux paramètres ou plus dans une seule annotation, séparez-les par une virgule comme celui présenté ci-dessous.

@Test(priority = 0, alwaysRun = true)

@BeforeTest et @AfterTest

@AvantTest	les méthodes sous cette annotation seront exécutées avant le premier cas de test dans le TestNG filet.
@AprèsTest	les méthodes sous cette annotation seront exécutées après tous les cas de test dans le TestNG le fichier est exécuté.

Considérez le code ci-dessous.

package firsttestngpackage;
import org.openqa.selenium.*;
import org.openqa.selenium.firefox.FirefoxDriver;
import org.testng.Assert;
import org.testng.annotations.*;
public class firsttestngfile {
    public String baseUrl = "http://demo.guru99.com/test/newtours/";
    String driverPath = "C:\\geckodriver.exe";
    public WebDriver driver ; 
     
     @BeforeTest
      public void launchBrowser() {
          System.out.println("launching firefox browser"); 
          System.setProperty("webdriver.gecko.driver", driverPath);
          driver = new FirefoxDriver();
          driver.get(baseUrl);
      }
      @Test
      public void verifyHomepageTitle() {
          String expectedTitle = "Welcome: Mercury Tours";
          String actualTitle = driver.getTitle();
          Assert.assertEquals(actualTitle, expectedTitle);
     }
      @AfterTest
      public void terminateBrowser(){
          driver.close();
      }
}

En appliquant la logique présentée par le tableau et le code ci-dessus, nous pouvons prédire que la séquence par laquelle les méthodes seront exécutées est :

1^st – lancerBrowser()
2^nd – verifyHomepageTitle()
3^rd – terminer le navigateur()

L'emplacement des blocs d'annotation peut être interchangé sans affecter l'ordre chronologique dans lequel ils seront exécutés. Comprenons avec un TestNG Exemple et essayez de réorganiser les blocs d'annotation de telle sorte que votre code ressemble à celui ci-dessous.

package firsttestngpackage;
import org.openqa.selenium.*;
import org.openqa.selenium.firefox.FirefoxDriver;
import org.testng.Assert;
import org.testng.annotations.*;
public class firsttestngfile {
    public String baseUrl = "http://demo.guru99.com/test/newtours/";
    String driverPath = "C:\\geckodriver.exe";
    public WebDriver driver ; 
     @AfterTest                            //Jumbled
      public void terminateBrowser(){
          driver.close();
      }
     @BeforeTest                            //Jumbled
      public void launchBrowser() {
          System.out.println("launching firefox browser"); 
          System.setProperty("webdriver.gecko.driver", driverPath);
          driver = new FirefoxDriver();
          driver.get(baseUrl);
      }
      @Test                                //Jumbled
      public void verifyHomepageTitle() {
          String expectedTitle = "Welcome: Mercury Tours";
          String actualTitle = driver.getTitle();
          Assert.assertEquals(actualTitle, expectedTitle);
     }
      
}

Exécutez le code ci-dessus et remarquez que

@BeforeMethod et @AfterMethod

@AvantMéthode	les méthodes sous cette annotation seront exécutées avant chaque méthode dans chaque cas de test.
@AprèsMéthode	les méthodes sous cette annotation seront exécutées après chaque méthode dans chaque cas de test.

In Mercury Tours, supposons que nous souhaitons vérifier les titres des pages cibles des deux liens ci-dessous.

Le déroulement de notre test serait :

Accédez à la page d'accueil et vérifiez son titre.
Cliquez sur S'INSCRIRE et vérifiez le titre de sa page cible.
Revenez à la page d'accueil et vérifiez si le titre est toujours correct.
Cliquez sur SUPPORT et vérifiez le titre de sa page cible.
Revenez à la page d'accueil et vérifiez si le titre est toujours correct.

Le code ci-dessous illustre comment @BeforeMethod et @AfterMethod sont utilisés pour exécuter efficacement le scénario mentionné ci-dessus.

package firsttestngpackage;
import org.openqa.selenium.*;
import org.openqa.selenium.firefox.FirefoxDriver;
import org.testng.Assert;
import org.testng.annotations.*;
@Test
public class firsttestngfile {
    public String baseUrl = "http://demo.guru99.com/test/newtours/";
    String driverPath = "C:\\geckodriver.exe";
    public WebDriver driver; 
    public String expected = null;
    public String actual = null;
        @BeforeTest
      public void launchBrowser() {
          System.out.println("launching firefox browser"); 
          System.setProperty("webdriver.gecko.driver", driverPath);
          driver= new FirefoxDriver();
          driver.get(baseUrl);
      }
      
      @BeforeMethod
      public void verifyHomepageTitle() {
          String expectedTitle = "Welcome: Mercury Tours";
          String actualTitle = driver.getTitle();
          Assert.assertEquals(actualTitle, expectedTitle);
      }
          @Test(priority = 0)
      public void register(){
          driver.findElement(By.linkText("REGISTER")).click() ;
          expected = "Register: Mercury Tours";
          actual = driver.getTitle();
          Assert.assertEquals(actual, expected);
      }
          @Test(priority = 1)
      public void support() {
            driver.findElement(By.linkText("SUPPORT")).click() ;
            expected = "Under Construction: Mercury Tours";
            actual = driver.getTitle();
            Assert.assertEquals(actual, expected);
      }
      @AfterMethod
      public void goBackToHomepage ( ) {
            driver.findElement(By.linkText("Home")).click() ;
      }
       
      @AfterTest
      public void terminateBrowser(){
          driver.close();
      }
}

Après avoir exécuté ce test, votre TestNG devrait signaler la séquence suivante.

En termes simples, @BeforeMethod doit contenir les méthodes que vous devez exécuter avant chaque scénario de test tandis que @AfterMethod doit contenir les méthodes que vous devez exécuter après chaque cas de test.

Résumé des TestNG Annotations

@AvantSuite: La méthode annotée sera exécutée avant que tous les tests de cette suite ne soient exécutés.

@AprèsSuite: La méthode annotée sera exécutée une fois tous les tests de cette suite exécutés.

@AvantTest: 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.

@AprèsTest: 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.

@AvantGroupes: La liste des groupes que cette méthode de configuration exécutera avant. L'exécution de cette méthode est garantie peu de temps avant l'appel de la première méthode de test appartenant à l'un de ces groupes.

@AfterGroups: La liste des groupes après lesquels cette méthode de configuration sera exécutée. Il est garanti que cette méthode s'exécutera peu de temps après l'appel de la dernière méthode de test appartenant à l'un de ces groupes.

@Avant les cours: La méthode annotée sera exécutée avant que la première méthode de test de la classe actuelle ne soit invoquée.

@Après les cours: La méthode annotée sera exécutée une fois que toutes les méthodes de test de la classe actuelle auront été exécutées.

@AvantMéthode: La méthode annotée sera exécutée avant chaque méthode de test.

@AprèsMéthode: La méthode annotée sera exécutée après chaque méthode de test.

@Tester: La méthode annotée fait partie d'un cas de test

Pour aller plus loin

TestNG est une vers les tests cadre capable de faire Selenium des tests plus faciles à comprendre et de générer des rapports faciles à comprendre.
Les principaux avantages de TestNG plus de JUnit sont les suivants.
- Les annotations sont plus faciles à utiliser et à comprendre.
- Les cas de test peuvent être regroupés plus facilement.
- TestNG nous permet de créer tests parallèles.
La fenêtre Console dans Eclipse génère un résultat textuel tandis que le TestNG La fenêtre est plus utile car elle nous donne une sortie graphique du résultat du test ainsi que d'autres détails significatifs tels que :
- Temps d'exécution de chaque méthode.
- L'ordre chronologique selon lequel les méthodes ont été exécutées
TestNG est capable de générer des rapports HTML.
Les annotations peuvent utiliser des paramètres comme d'habitude Java TestNG méthodes.
TestNG Dataprovider est un moyen de transmettre des paramètres à la fonction de test qui transmet différentes valeurs dans les cas de test en une seule exécution.

Tu pourrais aimer: