TestNG : questions d’entretien
MIN
07 Juin 2024
TestNG est l’un des cadres de test les plus utilisés pour les tests unitaires et automatisés. Dans ce guide, nous avons rassemblé les questions les plus fréquemment posées et les réponses aux entretiens, tant pour les nouveaux venus que pour les plus expérimentés.
Question 1. Qu’est-ce que TestNG ?
Réponse : TestNG (NG comme Next Generation) est un cadre de test qui peut être intégré à Selenium ou à tout autre outil d’automatisation afin de fournir de multiples fonctionnalités telles que des assertions, des rapports, l’exécution de tests en parallèle, etc.
Question 2. Quels sont les avantages de TestNG ?
R : Les avantages de TestNG sont les suivants :
- TestNG fournit diverses assertions qui permettent de vérifier les résultats attendus et réels.
- Permet l’exécution en parallèle des méthodes d’essai.
- Dans TestNG, nous pouvons définir la dépendance d’une méthode de test par rapport aux autres.
- Nous pouvons attribuer une priorité aux méthodes de test dans Selenium.
- Permet de regrouper les méthodes d’essai en groupes d’essai.
- Permet des tests basés sur les données en utilisant l’annotation @DataProvider.
- Il dispose d’un support de reporting inhérent.
- Il permet de paramétrer les cas de test à l’aide de l’annotation @Parameters.
Question 3. En quoi TestNG est-il différent de Selenium WebDriver ?
R : Selenium est un outil d’automatisation que nous pouvons utiliser pour automatiser les applications web. Afin d’ajouter des capacités de test aux suites d’automatisation des tests, Selenium est interfacé avec TestNG. En utilisant TestNG, nous pouvons avoir différentes fonctionnalités dans notre suite d’automatisation telles que différents types d’assertions, le reporting, l’exécution parallèle, la paramétrisation, etc.
En bref, pour effectuer des tests d’automatisation, Selenium aide à l' »automatisation » et TestNG aide aux capacités de « test ».
Question 4. À quoi sert le fichier testng.xml ?
R : Le fichier testng.xml est utilisé pour configurer l’ensemble de la suite de tests. Dans le fichier testng.xml, nous pouvons créer une suite de tests, créer des groupes de tests, marquer des tests pour une exécution parallèle, ajouter des auditeurs et passer des paramètres aux scripts de test. Nous pouvons également utiliser ce fichier testng.xml pour exécuter la suite de tests à partir de la ligne de commande/terminal ou de Jenkins.
Question 5. Comment pouvons-nous regrouper les cas de test en tant que cas de test distincts pour la suite de sécurité, la suite de régression, etc.
R : En utilisant l’attribut groups dans TestNG, nous pouvons assigner des méthodes de test à différents groupes.
//Testovacia metóda patriaca len do sanity suite
@Test(groups = {"sanitySuite"})
public void testMethod1() {
//Testovacia logika
}
//Testovacia metóda patriaca do sady sanity aj regresnej sady
@Test(groups = {"sanitySuite", "regressionSuite"})
public void testMethod2() {
//Testovacia logika
}Questions 6. Comment exclure une méthode de test de l’exécution via le fichier testng.xml ?
R : En utilisant la balise exclude dans le fichier testng.xml, nous pouvons exclure une méthode de test particulière de l’exécution.
<suite name="Test Suite" verbose="1">
<test name="TestName">
<classes>
<class name="TestClassName">
<methods>
<exclude name="testMethodToBeExcluded"/>
</methods>
</class>
</classes>
</test>
</suite>Questions 7. Quelles sont les annotations TestNG couramment utilisées ?
Réponse : Les annotations TestNG couramment utilisées sont les suivantes :
- @Test – l’annotation @Test identifie la méthode comme une méthode de test.
- @BeforeSuite – La méthode d’annotation n’est exécutée qu’une seule fois avant l’exécution de tous les tests de cette suite.
- @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.
- @BeforeClass – La méthode annotée n’est exécutée qu’une seule fois avant d’appeler la première méthode de test de la classe actuelle.
- @AfterClass – La méthode annotée n’est exécutée qu’une seule fois après l’exécution de toutes les méthodes de test de la classe actuelle.
@BeforeTest – La méthode annotée est exécutée avant toute méthode de test appartenant aux classes contenues dans la balise. @AfterTest – La méthode annotée est exécutée après l’exécution de toutes les méthodes de test appartenant aux classes contenues dans la balise. - @BeforeMethod – La méthode annotée est exécutée avant chaque méthode de test annotée avec @Test.
- @AfterMethod – La méthode annotée est exécutée après chaque méthode de test annotée avec @Test.
- @DataProvider – L’annotation @DataProvider est utilisée pour transmettre des données de test à la méthode de test. La méthode de test est déclenchée par le nombre de lignes de données transmises par la méthode du fournisseur de données.
Question 8. Quel est l’ordre d’exécution de la méthode de test en fonction des différentes annotations ?
Réponse : Les méthodes de test dans TestNG sont exécutées dans l’ordre Suite->Test->Classe->Méthode combiné à l’ordre Avant les annotations->Test les annotations->Après les annotations. L’ordre d’exécution est donc le suivant :
@BeforeSuite
@BeforeTest
@BeforeClass
@BeforeMethod
@Test
@AfterMethod
@AfterClass
@AfterTest
@AfterSuite
Question 9. Quelles sont les assertions courantes fournies par TestNG ?
Réponse Voici quelques-unes des affirmations courantes de TestNG :
- assertEquals(String actual, String expected, String message) et d’autres types de données surchargées dans le paramètre
- assertNotEquals(double data1, double data2, String message) et d’autres types de données surchargés dans le paramètre
- assertFalse(boolean condition, String message)
- assertTrue(boolean condition, String message)
- assertNotNull(Object object)
- fail(boolean condition, String message)
- true(String message)
Question 10. Comment désactiver ou empêcher l’exécution d’un scénario de test ?
Réponse : En définissant l’attribut « enabled » sur false, nous pouvons empêcher l’exécution de la méthode de test.
//V prípade testovacej metódy
@Test(enabled = false)
public void testMethod1() {
//Testovacia logika
}
//V prípade testovacej metódy patriacej do skupiny
@Test(groups = {"NegativeTests"}, enabled = false)
public void testMethod2() {
//Testovacia logika
}Question 11. Comment utiliser TestNG pour rendre une méthode de test dépendante des autres ?
R : En utilisant le paramètre dependsOnMethods dans l’annotation @Test de TestNG, nous pouvons faire en sorte qu’une méthode de test ne soit exécutée que lorsque la méthode de test dépendante a été exécutée avec succès.
@Test(dependsOnMethods = { « preTests » })
Question 12. Comment définir la priorité des cas de test dans TestNG ?
R : Nous pouvons définir la priorité des cas de test en utilisant le paramètre « priority » dans l’annotation @Test. Les essais dont les valeurs de priorité sont les plus faibles sont effectués en premier. Exemple :
@Test(priority=1)
Question 13. Quelle est la priorité par défaut des cas de test dans TestNG ?
R : La priorité de test par défaut, si elle n’est pas spécifiée, est une valeur entière de 0. Ainsi, si nous avons un cas de test avec une priorité de 1 et un autre sans priorité, le test sans aucune valeur de priorité sera exécuté en premier (puisque la valeur par défaut sera 0 et que les tests avec une priorité inférieure seront exécutés en premier).
Question 14. Comment exécuter une méthode de test plusieurs fois dans un cycle (sans utiliser de fournisseur de données) ?
R : En utilisant le paramètre invocationCount et en lui attribuant une valeur entière, la méthode de test sera exécutée n fois par cycle.
@Test(invocationCount = 10)
public void invocationCountTest(){
//Testovacia logika
}Questions 15. Qu’est-ce que le threadPoolSize ? Comment l’utiliser ?
Réponse : L’attribut threadPoolSize spécifie le nombre de threads à affecter à la méthode de test. Il est utilisé conjointement avec l’attribut invocationCount. Le nombre de threads est divisé par le nombre d’itérations de la méthode de test spécifié dans l’attribut invocationCount.
@Test(threadPoolSize = 5, invocationCount = 10)
public void threadPoolTest(){
//Testovacia logika
}Question 16. Quelle est la différence entre les assertions douces et les assertions dures dans TestNG ?
Réponse : C’est l’une des questions les plus fréquemment posées lors d’un entretien avec TestNG. Les assertions douces (SoftAssert) nous permettent d’avoir plusieurs assertions dans une méthode de test, même si une assertion échoue, la méthode de test continue d’exécuter le reste du test. Le résultat de toutes les assertions peut être résumé à la fin à l’aide de la méthode softAssert.assertAll().
@Test
public void softAssertionTest(){
SoftAssert softAssert= new SoftAssert();
//Assertion failing
softAssert.fail();
System.out.println("Failing");
//Assertion passing
softAssert.assertEquals(1, 1);
System.out.println("Passing");
//Collates test results and marks them pass or fail
softAssert.assertAll();
}Ici, même si la première assertion échoue, le test continuera son exécution et imprimera un message sous la deuxième assertion.
Les assertions dures, quant à elles, sont les assertions habituelles fournies par TestNG. Dans le cas d’une assertion dure, en cas d’échec, l’exécution de l’essai est interrompue, ce qui empêche toute autre étape de la méthode d’essai.
Question 17. Comment faire échouer un testNG s’il n’est pas effectué dans le temps imparti ?
Réponse : Nous pouvons utiliser l’attribut timeOut de l’annotation @Test. La valeur attribuée à cet attribut timeOut servira de limite supérieure. Si le test n’est pas exécuté dans ce délai, il échouera, à l’exception d’un délai d’attente.
@Test(timeOut = 1000)
public void timeOutTest() throws InterruptedException {
//Sleep for 2sec so that test will fail
Thread.sleep(2000);
System.out.println("Will throw Timeout exception!");
}Question 18. Comment pouvons-nous ignorer un scénario de test de manière conditionnelle ?
R : Nous pouvons ignorer un scénario de test de manière conditionnelle à l’aide de la fonction SkipException. Lorsqu’une exception de type skipException est déclenchée, la méthode de test est marquée comme étant ignorée dans le rapport d’exécution du test et aucune instruction n’est exécutée après le déclenchement de l’exception.
@Test
public void testMethod(){
if(conditionToCheckForSkippingTest)
throw new SkipException("Skipping the test");
//test logic
}Question 19. Comment s’assurer qu’une méthode de test sera exécutée même si les méthodes de test ou les groupes dont elle dépend échouent ou sont ignorés ?
R : En utilisant l’attribut « alwaysRun » de l’annotation @Test, nous pouvons nous assurer que la méthode de test est exécutée même si les méthodes de test ou les groupes dont elle dépend échouent ou sont ignorés.
@Test
public void parentTest() {
Assert.fail("Failed test");
}
@Test(dependsOnMethods={"parentTest"}, alwaysRun=true)
public void dependentTest() {
System.out.println("Running even if parent test failed");
}Ici, même si parentTest a échoué, dependentTest ne sera pas ignoré, mais sera exécuté en raison de « alwaysRun=true ». Si nous supprimons l’attribut « alwaysRun=true » de @Test, le rapport indiquera un échec et un test ignoré sans tenter d’exécuter la méthode dependentTest.
Question 20. Comment passer un paramètre de test à un script en utilisant TestNG ?
R : En utilisant l’annotation @Parameter et la balise « parameter » dans testng.xml, nous pouvons passer des paramètres aux scripts de test.
Exemple de testng.xml :
<suite name="sampleTestSuite">
<test name="sampleTest">
<parameter name="sampleParamName" value="sampleParamValue"/>
<classes>
<class name="TestFile" />
</classes>
</test>
</suite>
Ukážka testovacieho skriptu –
public class TestFile {
@Test
@Parameters("sampleParamName")
public void parameterTest(String paramValue) {
System.out.println("Value of sampleParamName is - " + sampleParamName);
}Question 21. Comment créer un cadre de travail basé sur les données à l’aide de TestNG ?
R : En utilisant @DataProvider, nous pouvons créer un cadre axé sur les données dans lequel les données sont transmises à la méthode de test appropriée et plusieurs itérations du test sont exécutées pour différentes valeurs des données de test transmises par la méthode @DataProvider. La méthode annotée par @DataProvider renvoie un tableau 2D de l’objet.
//Data provider returning 2D array of 3*2 matrix
@DataProvider(name = "dataProvider1")
public Object[][] dataProviderMethod1() {
return new Object[][] {{"kuldeep","rana"}, {"k1","r1"},{"k2","r2"}};
}
//This method is bound to the above data provider returning 2D array of 3*2 matrix
//The test case will run 3 times with different set of values
@Test(dataProvider = "dataProvider1")
public void sampleTest(String s1, String s2) {
System.out.println(s1 + " " + s2);
}Question 22. Quelle est l’utilité de l’annotation @Listener dans TestNG ?
Réponse : TestNG nous fournit différents types d’écouteurs qui nous permettent d’effectuer une action lorsqu’un événement est déclenché. En général, les auditeurs TestNG sont utilisés pour configurer les rapports et la journalisation. L’interface ITestListener est l’un des listeners les plus utilisés dans TestNG. Il possède des méthodes telles que onTestSuccess, onTestFailure, onTestSkipped, etc. Nous devons mettre en œuvre cette interface en créant notre propre classe d’auditeurs. Ensuite, en utilisant l’annotation @Listener, nous pouvons spécifier que notre classe d’écoute personnalisée doit être utilisée pour une classe de test particulière.
@Listeners(PackageName.CustomizedListenerClassName.class)
public class TestClass {
WebDriver driver= new FirefoxDriver();@Test
public void testMethod(){
//testovacia logika
}
}Question 23. Quelle est l’utilité de l’annotation @Factory dans TestNG ?
Réponse : L’annotation @Factory contribue à l’exécution dynamique des cas de test. En utilisant l’annotation @Factory, nous pouvons passer des paramètres à l’ensemble de la classe de test au moment de l’exécution. Les paramètres transmis peuvent être utilisés par une ou plusieurs méthodes de test de cette classe.
Par exemple, il existe deux classes : TestClass et TestFactory. Grâce à l’annotation @Factory, les méthodes de test de la classe TestClass sont exécutées deux fois avec les données « k1 » et « k2 »
public class TestClass{
private String str;
//Constructor
public TestClass(String str) {
this.str = str;
}
@Test
public void TestMethod() {
System.out.println(str);
}
}
public class TestFactory{
//The test methods in class TestClass will run twice with data "k1" and "k2"
@Factory
public Object[] factoryMethod() {
return new Object[] { new TestClass("K1"), new TestClass("k2") };
}
}Question 24. Quelle est la différence entre les annotations @Factory et @DataProvider ?
Réponse : La méthode @Factory crée une instance d’une classe de test et exécute toutes les méthodes de test de cette classe avec un ensemble de données différent.
Alors que @DataProvider se lie à des méthodes de test individuelles et exécute des méthodes spécifiques plusieurs fois.
Question 25. Comment pouvons-nous utiliser TestNG pour exécuter des cas de test en parallèle ?
Réponse : Pour exécuter des tests en parallèle, il suffit d’ajouter ces deux paires clé-valeur à la balise suite dans le fichier testng.xml-.
- parallel= »{methods/tests/classes} »
- thread-count= »{nombre de threads que vous voulez exécuter en même temps} ».
<suite name= »ITtester » parallel= »methods » thread-count= »5″>
Ceci conclut notre liste complète de questions d’entretien avec TestNG. Si vous souhaitez en savoir plus sur TestNG, vous pouvez également consulter notre tutoriel complet sur TestNG.
