Menu

Annotations et auditeurs TestNG

testng annotations listeners

Essayez Notre Instrument Pour Éliminer Les Problèmes

Ce didacticiel explique les différents types d'annotations et d'écouteurs TestNG. Vous apprendrez également à utiliser les annotations et écouteurs TestNG avec des exemples:

Ici, nous allons exécuter un programme TestNG de base en utilisant les annotations TestNG et voir également le rôle des écouteurs TestNG et comment les utiliser dans les tests.

=> Lisez la série de formations Easy TestNG.

Annotations et auditeurs TestNG

Ce que vous apprendrez:

Que sont les annotations TestNG?

Il s'agit du programme ou de la logique métier utilisé pour contrôler le flux des méthodes. Ils jouent un rôle très important dans TestNG. Ces annotations diffèrent dans chaque projet selon les exigences. Le flux d'annotations reste le même dans chaque programme malgré les différentes exigences.

Il existe différents types d'annotations TestNG qui rendent TestNG plus facile et meilleur que JUnit. Chacune de ces annotations s'exécutera lors d'un événement spécifique dans TestNG.

Types d'annotations dans TestNG

Vous trouverez ci-dessous les listes d'annotations et leurs attributs utilisés dans TestNG. Explorons-les et leurs usages en détail.

Avant que

  • @BeforeSuite: Cette méthode sera exécutée avant que tous les tests de la suite ne soient exécutés.
  • @BeforeTest: Cette méthode sera exécutée avant que chaque section de test ne soit déclarée dans la suite.
  • @Avant les cours: Cette méthode sera exécutée avant la première méthode de test de la classe actuelle.
  • @BeforeMethod: Cette méthode sera exécutée avant chaque méthode de test.
  • @BeforeGroups: Cette méthode sera exécutée avant que toute méthode de test du groupe spécifié ne soit mentionnée.
  • @Test : Marque une classe ou une méthode comme faisant partie du test. Ou nous pouvons dire qu'il fait une méthode comme méthode de test.

Après

  • @AfterSuite: Cette méthode sera exécutée après l'exécution de tous les tests de la suite.
  • @AfterTest: Cette méthode sera exécutée après la déclaration de chaque section de test dans la suite.
  • @Après les cours: Cette méthode sera exécutée après la dernière méthode de test de la classe.
  • @AfterMethod: Cette méthode sera exécutée après l'exécution de chaque méthode de test.
  • @AfterGroups: Cette méthode sera exécutée après l'exécution de la dernière méthode de test du groupe spécifié.

Flux de travail des annotations

Lorsque nous exécutons le fichier TestNG.xml, les annotations TestNG seront exécutées dans l'ordre suivant:

Avant la suite-> Avant le test-> Avant la classe-> Avant la méthode-> @Test -> Après la méthode-> Après la classe-> Après le test-> Après la suite

@BeforeSuite @BeforeTest @BeforeClass @BeforeMethod @Test @AfterMethod @AfterClass @AfterTest @AfterSuite

@Test a beaucoup d'autres attributs qui nous aident à exécuter nos cas de test plus efficacement.

Voici les types d'attributs et leurs descriptions avec des exemples.

# 1) AlwaysRun: Lorsqu'elle est définie sur true, cette méthode s'exécute même si elle dépend d'une méthode qui a échoué.

Exemple: Test (alwaysRun = true)

# 2) fournisseur de données : Ceci montre le nom du fournisseur de données pour cette méthode. Il n'a que des attributs, c'est-à-dire le nom. Nous pouvons l'utiliser lorsque nous testons notre logiciel avec plusieurs ensembles de données au moment de l'entrée ou de l'exécution. Ceci est également connu sous le nom de test piloté par les données. Nous pouvons faire des tests basés sur les données en utilisant cet attribut.

Exemple: @dataProvider (nom = 'TestData')

# 3) dataProviderClass : Cet attribut vous permettra de spécifier la classe du fournisseur de données qui contiendra le fournisseur de données que la méthode @Test utilisera.

Exemple: @Test (dataProvider = «Client Data Test», dataProviderClass = ClientDetailsTest.class)

# 4) dependOnGroups : Cet attribut dépend de la liste des groupes, c'est-à-dire que la méthode de test ne commencera l'exécution qu'après l'exécution des groupes dépendants.

Remarque : Si l'un des tests dans les groupes qui dépendent de échoue, alors il ignorera ce test.

Voici l'exemple:

@Test(groups= “homepage”) public void homepageTest(){ System.out.println('Home Page displayed successfully'); } @Test(groups= “transactionspage”) Public void transactionpageTest(){ System.out.println(“Transaction Page displayed successfully”); } @Test(dependsOnGroups={“homepage”, “transactionspage”}) public void dependOnGroupTest1(){ System.out.println(“dependency tested successful”);

# 5) dependOnMethods : Cette annotation dépend de la liste des méthodes. Cela signifie que la méthode de test ne commencera l'exécution qu'après l'exécution des méthodes dépendantes.

Remarque : Si l'un des tests des méthodes dépendantes échoue, il ignorera ce test.

Exemple:

@Test public void loginTest() { System.out.println(“Login Tested Successfully”); } @Test public void homepageTest() { System.out.println(“Home Page Tested Successfully”); } @Test(dependsOnMethods={“ loginTest”, “homepageTest”}) public void smokeTest() { System.out.println(“Smoke Tests were done successfully”);

# 6) alwaysRun = true: Nous pouvons définir les attributs d'une méthode de test sur true, ce qui forcera l'exécution du test même si certains des tests du groupe dépendent d'un échec.

Par exemple:

@Test public void launchAppTest() { System.out.println(“Application launched Successfully”); } @Test public void loginAppTest() { System.out.println(“Application logged in Successfully”); } @Test(dependsOnMethods={“launchAppTest”, “loginAppTest”}, alwaysRun=true) public void smokeTest() { System.out.println(“Smoke Test were done successfully”); }

# 7) description : Ceci fournit la description de la méthode. Généralement, il contient un résumé sur une ligne.

Exemple:

@Test(description = “Regression Test Summary”)

# 8) activé : Cet attribut aide à spécifier si nous voulons exécuter / exécuter la méthode de test particulière dans la suite / classe actuelle ou non. Parfois, nous ne voulons pas exécuter quelques tests pour des raisons telles que l'exigence / la fonction change fréquemment et nous ne voulons pas perturber l'exécution en cours pour cette fonction particulière.

Dans ces cas, nous pouvons simplement ignorer / désactiver ce test particulier en définissant cette fonctionnalité sur @Test (enabled = false).

Exemple:

@Test(enabled = false) public void imageTest() {//We have disabled this test by giving enabled=false System.out.println(“Image was tested successfully()”); }

# 9) Exceptions attendues : Cet attribut affiche la liste des exceptions que la méthode de test va lancer lors de l'exécution. Si aucune exception ou aucune autre exception n'est levée pour la méthode, le test est marqué comme un échec.

Exemple:

@Test(expectedExceptions = ArithmeticException.class) public void numericTest() { int i = 1 / 0; }

# 10) groupes : Cet attribut est utilisé pour spécifier les groupes auxquels appartient la méthode de test.

@Test(groups = {“Regression”}) Public void runRegressionTest(){ System.out.println(“test runs were successful”); }

# 11) priorité : Cela aide à hiérarchiser les méthodes de test, tandis que la priorité par défaut commence par 0 et les tests sont exécutés dans l'ordre croissant.

Exemple:

@Test Public void launchApp(){ System.out.println(“Application was launched successfully”): } @Test (priority = 1) Public void loginApp(){ System.out.println(“Application logged in successfully”); } @Test (priority = 2) Public void checkTrans(){s System.out.println(“Checked Transactions successfully”); }

Résultats: Vous trouverez ci-dessous les résultats selon la priorité, même si aucun numéro n'a été attribué au premier test, il a pris sa priorité par défaut à 0 et l'exécution a été effectuée dans l'ordre croissant.

Passé: launchApp
Réussi: loginApp
Réussi: checkTrans

# 12) Délai d'expiration : Cet attribut aide à spécifier une valeur de délai d'expiration pour le test (généralement utilisé en millisecondes). Si le test prend plus que la valeur de délai d'attente spécifiée, le test est marqué comme échec. Nous pouvons utiliser ce délai pour effectuer un test de performance, pour nous assurer que la méthode revient dans un délai raisonnable.

@Test(timeOut = 500) public void timeTest() throws InterruptedException { Thread.sleep(400); System.out.println(“Time test method successfully tested”); }

# 13) invocationCount : Cet attribut aide à déterminer le nombre de fois qu'une méthode de test doit être invoquée.

@Test(invocationCount = 5) public void loginTest() { WebDriver driver = new FirefoxDriver(); driver.get('http://www.google.com'); System.out.println('Page Title is ' + driver.getTitle()); driver.quit();

Production:

Le titre de la page est Google
Le titre de la page est Google
Le titre de la page est Google
Le titre de la page est Google
Le titre de la page est Google

# 14) invocationTimeOut: Il s'agit du temps maximum (nombre de millisecondes) que ce test doit prendre pour tous les décomptes d'appels. Cette méthode doit être utilisée avec la méthode de comptage des appels, sinon elle serait ignorée.

Exemple:

@Test(invocationCount=4, invocationTimeOut=4000) public void loginTest(){ Thread.sleep(1000); System.Out.println(“login Test”); }

L'exemple ci-dessus montre que ce test prendra un total de 4 secondes pour s'exécuter et que chaque fois que le test est appelé / exécuté, il prendrait 1 seconde pour s'exécuter.

# 15) @DataProvider : Cette méthode aide à fournir des données pour une méthode d'essai. Tout d'abord, nous devons déclarer une méthode annotée par @DataProvider, puis utiliser cette méthode dans la méthode de test requise en utilisant l'attribut «DataProvider» dans l'annotation @Test.

Un fournisseur de données renvoie un tableau d'objets, en particulier un tableau d'objets à deux dimensions () (). Le premier tableau représente un ensemble de données et le deuxième tableau contient les paramètres.

@DataProvider (name = 'Test') - Ici, le nom représente le nom du fournisseur de données. Si le nom n’est pas donné, le nom du fournisseur de données sera automatiquement défini sur le nom de la méthode.

Exemple:

@DataProvider(name = “Name”) public object()() credentials(){ return new object ()() { { “Mohan”, “23”}, { “Shikhar”, “30”} }; } //Now we are calling the Data Provider object by its name @Test(DataProvider = “Name”) Public void testData(String sName, int age) { System.out.println(“Data is: (Name, age)”); }

# 16) @Factory : Ceci est utilisé pour spécifier une méthode en tant que fabrique pour fournir des objets qui doivent être utilisés par TestNG pour ses classes de test. En utilisant @Factory, nous pouvons créer des tests dynamiques au moment de l'exécution et cela devrait renvoyer un objet tableau.

Exemple:

Prenons un exemple pour mieux le comprendre. Nous allons créer deux classes à savoir FactorySample.Java et FactoryTest.Java

FactorySample.Java

public class FactorySample { @Test public void googleTest() { System.out.println(“Google was launched successfully”); } @Test public void gmailLogin() { System.out.println(“Gmail logged in successfully”); }

FactoryTest.Java

public class FactoryTest { @Factory() public Object() testFact() { FactorySample fs = new FactorySample(2); fs(0) = new googleTest(); fs(1) = new gmailLogin(); return fs; } }

Production : Google a été lancé avec succès

Gmail s'est connecté avec succès

Différence entre les annotations @Factory et @DataProvider

Il existe une différence fondamentale entre les deux annotations. Il y a beaucoup de confusion concernant ces deux annotations comme où les utiliser et pourquoi?

Trouvons les réponses.

@Fournisseur de données: Cette annotation paramétrera la méthode de test particulière et exécutera le test dans un no spécifique. de fois sur la base des données fournies par cette méthode.

Par exemple, s'il y a deux paramètres, la méthode de test sera exécutée deux fois. Par exemple, si nous voulons nous connecter à un site avec différents ensembles de noms d'utilisateur et de mots de passe à chaque fois, cela est utile car nous devons fournir les paramètres à tester.

@Usine : Cela exécutera toutes les méthodes de test présentes dans le fichier de classe de test tout en utilisant une instance distincte de cette classe. Ceci est utile si nous voulons exécuter la classe de test un certain nombre de fois.

Par exemple , si nous devons tester la fonction de connexion d'une application ou d'un site Web et que nous devons exécuter ce test plusieurs fois, il est préférable d'utiliser @Factory où nous pouvons créer plusieurs instances de test et exécuter les tests.

Jetons un œil à ces exemples pour connaître la différence.

Exemple de @DataProvider :

@DataProvider public Object()() message(){ return new Object ()(){{“Mihir” , new Integer (145632)}, {“Kumar”, new Integer (28242)}}; } @Test (dataProvider=”message”) public void PrintMsg(String name, Integer id){ System.out.println(“Names are: “+name+” “+id); }

Remarque : Dans le programme ci-dessus, nous avons fourni deux données et le résultat du programme serait:

Les noms sont: Mihir 145632
Les noms sont: Kumar 28242

Cela montre que si nous augmentons le nombre de données dans la méthode de message, la méthode d'impression exécutera le même nombre de fois.

Exemple @Factory :

TestNG Factory est très utile lorsque nous devons exécuter plusieurs classes de test en utilisant une seule classe de test.

Voyons un exemple.

Pour cela, nous devons créer deux classes de test avec peu de méthodes de test à l'intérieur.

TestData 1:

public class TestData1 { @Test public void testData1() { System.out.println('Test data 1 successfully tested'); } }

TestData 2:

public class TestData2 { @Test public void testData2() { System.out.println('Test data 2 successfully tested'); } }

Nous devons maintenant définir la méthode @Factory qui renvoie un tableau d'objets des classes définies ci-dessus.

Programme d'usine:

public class TestNGFactory { @Factory() public Object() getTestClass() { Object() tests = new Object(2); tests(0) = new Test Data 1(); tests(1) = new Test Data 2(); return tests; } }

Production:

Méthode d'essai Test1
Méthode d'essai Test2
RÉUSSI: test1
RÉUSSI: test2

Auditeurs TestNG avec types

En termes simples, les auditeurs écoutent l'événement défini dans le script Selenium et se comportent en conséquence. L'objectif principal est de créer des journaux et de personnaliser les rapports TestNG.

Il existe de nombreux types d'écouteurs disponibles dans TestNG.

Par exemple , IAnnotationTransformer, IAnnotationTransformer2, IConfigurable, IConfigurationListener, IConfigurationListener2, IExecutionListener, IHookable, IInvokedMethodListener, IInvokedMethodListener2, IMethodInterceptor, IReporter, ISuiteListener, ITest

Cependant, en ce qui concerne les tests, nous n'en utilisons que quelques-uns, comme indiqué ci-dessous:

# 1) ISuiteListener

Ceci est un écouteur pour les suites de tests. Il se compose de deux méthodes, à savoir onStart () et onFinish () .

Chaque fois que nous implémentons cet écouteur, il garantira que l'utilisateur final appellera les méthodes onStart () et onFinish () avant et après l'exécution d'une suite TestNG.

Détails de la méthode:

void onStart (suite ISuite) : Cette méthode est appelée avant le démarrage de Suite Runner.

void onFinish (suite ISuite) : Cette méthode est appelée après que Suite Runner a exécuté toutes les suites de tests.

Exemple:

@Override public void onStart(ISuite suite) { System.out.println(“TestNG Suite Starts”); } @Override public void onFinish(ISuite suite) { System.out.println(“TestNG Suite Finishes”); }

# 2) ITestListener

Cet écouteur fonctionne exactement comme ISuiteListener. Cependant, la seule différence est qu'il effectue l'appel avant et après le test et non la suite. C'est un écouteur pour l'exécution de test et cet écouteur contient sept méthodes.

(i) onStart () :Cette méthode est appelée après l'instanciation de la classe de test et avant l'appel d'une méthode de configuration.

Exemple:

@Override public void onStart(ITestContext context) { System.out.println(“Context Name = ” + context.getName()); }

(ii) onFinish () :Cette méthode est appelée après que tous les tests ont été exécutés et que toutes les méthodes de configuration sont appelées.

Exemple:

public void onFinish(ITestContext context) { System.out.println(context.getPassedTests()); }

(iii) onTestStart () :Cette méthode est invoquée à chaque fois avant qu'un test ne soit appelé. Le ITestResult n'est que partiellement rempli avec les références à la classe, la méthode, les millis de démarrage et l'état.

Méthode: void onTestStart (résultat ITestResult)

Exemple:

@Override public void onTestStart(ITestResult result) { System.out.println('Test Started…'+result.getStartMillis()); }

(iv) onTestSuccess () :Cette méthode est appelée à chaque fois qu'un test réussit.

Méthode: void onTestSuccess (résultat ITestResult)

Exemple:

@Override public void onTestSuccess(ITestResult result) { System.out.println('Test Success. '+result.getEndMillis()); }

(v) onTestFailure () :Cette méthode est invoquée chaque fois qu'un test échoue.

Méthode: void onTestFailure (résultat ITestResult)

Exemple:

@Override public void onTestFailure(ITestResult result) { System.out.println('Test Failed. '+result.getTestName()); }

(vi) onTestSkipped () :Cette méthode est invoquée à chaque fois qu'un test est ignoré.

Méthode: void onTestSkipped (résultat ITestResult)

Exemple:

@Override public void onTestSkipped(ITestResult result) { System.out.println('Test Skipped. '+result.getTestName()); }

(vii) onTestFailedButWithinSuccessPercentage :Cette méthode est appelée chaque fois qu'une méthode échoue mais a été annotée avec un pourcentage de réussite et l'échec la maintient dans le pourcentage de réussite.

Méthode: void onTestFailedButWithinSuccessPercentage (résultat ITestResult)

Exemple:

@Override public void onTestFailedButWithinSuccessPercentage(ITestResult iTestResult) { System.out.println('Test failed but it is in defined success ratio ' + getTestMethodName(iTestResult)); }

# 3) IExecutionListener

C'est un écouteur qui surveille le début et la fin d'une exécution de TestNG. Il a deux méthodes, à savoir onExecutionStart () et onExecutionFinish () .

La méthode onExecutionStart () est appelée avant que TestNG ne commence à exécuter les suites et la méthode onExecutionFinish () est appelée après que TestNG est terminé avec l'exécution de toutes les suites de tests.

Méthode:

void onExecutionStart ()

void onExecutionFinish ()

Exemple:

@Override public void onExecutionStart() { System.out.println('TestNG is going to start'); } @Override public void onExecutionFinish() { System.out.println('TestNG is finished'); }

# 4) IInvokedMethodListener

C'est un écouteur qui est appelé avant et après qu'une méthode est appelée par TestNG. Cet écouteur n'est appelé que pour les configurations et les méthodes de test. Il ne contient que deux méthodes, à savoir afterInvocation et beforeInvocation.

  1. avant l'invocation: Invoquez avant chaque méthode.
  2. afterInvocation: Invoquez après chaque méthode.

Méthode:

void beforeInvocation (méthode IInvokedMethod, ITestResult testResult)

void afterInvocation (méthode IInvokedMethod, ITestResult testResult)

Exemple:

@Override public void beforeInvocation(IInvokedMethod method, ITestResult testResult) { System.out.println('before invocation of ' + method.getTestMethod().getMethodName()); } @Override public void afterInvocation(IInvokedMethod method, ITestResult testResult) { System.out.println('after invocation of ' + method.getTestMethod().getMethodName()); }

# 5) IMethodInterceptor

Cette classe est utilisée pour modifier la liste des méthodes de test que TestNG va exécuter. En utilisant cette méthode, nous pouvons réorganiser la liste des méthodes de test.

Il s’applique uniquement aux méthodes qui n’ont pas de dépendants et les méthodes qui ne dépendent d’aucune autre méthode de test seront passées en paramètres. Cette interface renverra une liste de méthodes de test qui doivent être exécutées mais d'une manière triée différente.

Méthode:

quelle couche du modèle osi traite le cryptage des données?

java.util.List intercept (méthodes java.util.List, contexte ITestContext)

Exemple:

@Override public Listintercept(Listmethods, ITestContext context) { List result = new ArrayList(); for (IMethodInstance m : methods) { Test test = m.getMethod().getMethod().getAnnotation(Test.class); Setgroups = new HashSet(); for (String group : test.groups()) { groups.add(group); } if (groups.contains('sanity')) { result.add(m); } else { String testMethod = m.getMethod().getMethodName(); System.out.println(testMethod + ' not a SANITY test so not included'); } } return result; }

#6) IReporter

Ceci est mis en œuvre par les clients pour générer un rapport. Cette méthode sera appelée une fois que toute la suite aura été exécutée et que les paramètres donneront tous les résultats des tests qui se sont produits pendant cette exécution.

Méthode:

void generateReport (java.util.List xmlSuites, suites java.util.List, java.lang.String outputDirectory)

Exemple:

@Override public void generateReport(List xmlSuites, List suites, String outdir) { try { writer = createWriter(outdir); } catch (IOException e) { System.err.println('Unable to create output file'); e.printStackTrace(); return; } startHtml(writer); writeReportTitle(reportTitle); generateSuiteSummaryReport(suites); generateMethodSummaryReport(suites); generateMethodDetailReport(suites); endHtml(writer); writer.flush(); writer.close(); }

Conclusion

Dans cet article, nous avons vu comment les annotations TestNG peuvent être utiles pour faciliter la logique de notre programme. Les annotations sont utilisées selon les besoins.

Vous pouvez transmettre les paramètres aux annotations et effectuer également des tests basés sur les données. Vous pouvez exécuter les cas de test en groupes et gagner du temps. Avec les écouteurs, vous pouvez même générer les rapports. Ne pensez-vous pas que c'est merveilleux?

TestNG.xml sera expliqué en détail dans notre prochain tutoriel. Ce fichier XML est l'épine dorsale du framework TestNG et il nous aidera à exécuter nos cas de test.

=> Consultez le guide de formation Perfect TestNG ici.

lecture recommandée

^