Top 50 TestNG Questions et réponses d'entretien (2026)
Krishna Rungta
Se préparer à un TestNG Un entretien ? Il est temps de réfléchir aux questions qui mettent en valeur vos points forts. Une solide TestNG La qualité de l'entretien révèle la profondeur, la confiance et la préparation recherchées par les équipes de recrutement.
Ce domaine offre de nombreuses opportunités, notamment dans les secteurs de l'automatisation, des frameworks en constante évolution et des applications de test pratiques nécessitant une expérience technique et professionnelle. Travailler dans ce domaine exige une expertise métier, des compétences analytiques et une grande polyvalence permettant aux débutants, aux professionnels de niveau intermédiaire et aux seniors de répondre aux questions les plus fréquentes, qu'elles soient techniques, fondamentales ou avancées. Lire la suite...
👉 Téléchargement PDF gratuit : TestNG Questions et réponses d'entretien
Top TestNG Questions et réponses d'entrevue
1) Qu'est-ce que TestNG Et pourquoi est-il utilisé dans les tests automatisés ?
TestNG (Test Next Generation) est un framework de test inspiré par JUnit Il s'agit d'un outil basé sur NUnit, mais enrichi de fonctionnalités avancées telles que le regroupement, le séquençage, la paramétrisation et la gestion des dépendances. Il est principalement utilisé dans les tests automatisés pour rationaliser l'exécution des tests, améliorer leur organisation et générer des rapports HTML et XML détaillés.
Principaux avantages de TestNG consistent à
- accompagne exécution de tests parallèles, réduisant ainsi la durée totale d'exécution.
- permet annotations qui contrôlent efficacement le déroulement des tests.
- offre tests basés sur les données dans le cadre du
@DataProviderannotation. - Génère rapports personnalisables pour un meilleur débogage.
Par exemple, TestNG permet d'exécuter indépendamment des groupes de tests de fumée, de régression et d'intégration sans modifier le code de test, offrant ainsi flexibilité et évolutivité dans les grandes suites d'automatisation.
2) Expliquez le TestNG Cycle de vie avec annotations et leur ordre d'exécution.
Le TestNG Le cycle de vie définit comment les tests sont initialisés, exécutés et terminés. Il est contrôlé par des annotations qui structurent et clarifient le flux de tests.
| Annotation | Description | Ordre d'exécution |
|---|---|---|
@BeforeSuite |
S'exécute avant tous les tests de la suite | 1 |
@BeforeTest |
S'exécute avant <test> balise en XML |
2 |
@BeforeClass |
S'exécute avant la première méthode de la classe actuelle | 3 |
@BeforeMethod |
S'exécute avant chaque méthode de test | 4 |
@Test |
Contient la logique de test réelle | 5 |
@AfterMethod |
S'exécute après chaque méthode de test | 6 |
@AfterClass |
S'exécute après toutes les méthodes de la classe | 7 |
@AfterTest |
Courit après <test> balise en XML |
8 |
@AfterSuite |
S'exécute après tous les tests de la suite | 9 |
Cet ordre structuré garantit une configuration et un démontage des tests prévisibles, ce qui est crucial pour maintenir l'indépendance des tests.
3) Comment est TestNG différent de JUnit?
Bien que les deux frameworks soient utilisés pour les tests unitaires, TestNG offre des capacités de configuration et d'exécution parallèle plus robustes.
| Fonctionnalité | JUnit | TestNG |
|---|---|---|
| Exécution parallèle | Support limité | Plein soutien |
| Annotations | Moins (@Before, @After) |
Riche (@BeforeSuite, @DataProvider) |
| Gestion des dépendances | Indisponible | Disponible via dependsOnMethods |
| regroupement | Non pris en charge | Prise en charge par groups |
| Paramétrage | Par l'intermédiaire de coursiers externes | Intégré via XML ou @DataProvider |
En résumé, les TestNG est préféré pour tests d'automatisation au niveau de l'entreprise et l'intégration avec des outils comme Selenium, tandis que JUnit est idéal pour les tests unitaires plus simples.
4) Que sont TestNG Les annotations et en quoi sont-elles utiles ?
Annotations dans TestNG Vous permet de définir la structure et le comportement des méthodes d'essaiIls éliminent le besoin d'une configuration XML complexe en fournissant un contrôle déclaratif des tests directement dans le code.
Les annotations couramment utilisées comprennent :
@BeforeSuite,@BeforeTest,@BeforeClass,@BeforeMethod@Test@AfterMethod,@AfterClass,@AfterTest,@AfterSuite
Exemple :
@BeforeMethod
public void setup() {
System.out.println("Initializing browser...");
}
@Test
public void verifyLogin() {
System.out.println("Executing login test...");
}
Cela aide les développeurs à organiser l'exécution des tests de manière logique, en veillant à ce que la configuration, l'exécution des tests et la suppression se déroulent dans un ordre défini.
5) Expliquez le concept de groupement dans TestNG.
Regroupement dans TestNG permet une catégorisation logique des tests en ensembles plus petits et plus faciles à gérer, tels que « Fumée », « Régression » ou « Correction ».
Exemple :
@Test(groups = {"Smoke"})
public void loginTest() { ... }
@Test(groups = {"Regression"})
public void paymentTest() { ... }
Vous pouvez configurer votre suite XML pour exécuter des groupes spécifiques :
<groups>
<run>
<include name="Smoke"/>
</run>
</groups>
Avantages :
- Facilite l'exécution sélective des cas de test.
- Améliore la flexibilité des pipelines CI/CD.
- Permet de gagner du temps d'exécution lors des compilations incrémentales.
6) Comment la paramétrisation peut-elle être réalisée dans TestNG?
La paramétrisation permet des tests basés sur les données, autorisant l'exécution de tests avec plusieurs ensembles de données d'entrée. TestNG prend en charge deux méthodes principales :
- L'utilisation de
@Parametersannotation avec XML : - L'utilisation de
@DataProvider:
<parameter name="browser" value="chrome"/>
@Test
@Parameters("browser")
public void launchBrowser(String browser) { ... }
@DataProvider(name="loginData")
public Object[][] getData() {
return new Object[][] {{"user1","pass1"}, {"user2","pass2"}};
}
@Test(dataProvider="loginData")
public void loginTest(String user, String pass) { ... }
Cette flexibilité facilite la maintenance et l'exécution de grands ensembles de tests dans différents environnements ou configurations.
7) Que sont les dépendances dans TestNG et comment sont-ils gérés ?
Dépendances dans TestNG contrôler l'ordre d'exécution des tests en fonction des résultats d'autres tests à l'aide de dependsOnMethods or dependsOnGroups attributs.
Exemple :
@Test
public void loginTest() { ... }
@Test(dependsOnMethods = {"loginTest"})
public void verifyDashboard() { ... }
Si la méthode dépendante échoue, le test suivant est automatiquement ignoré.
Ce mécanisme empêche l'exécution de tests invalides et contribue à la maintenance intégrité des tests logiquesIl est particulièrement utile pour les flux fonctionnels à plusieurs étapes, comme connexion → effectuer une action → vérifier le résultat.
8) Quelles sont les différentes manières d'exécuter TestNG des examens ?
TestNG Les tests peuvent être exécutés de plusieurs manières flexibles en fonction de la configuration de test :
- Depuis l'IDE (Eclipse/IntelliJ): Faites un clic droit sur la classe ou
XML file→Run as→TestNG Test. - Depuis la ligne de commande :
java -cp "path\testng.jar;bin" org.testng.TestNG testng.xml - Utilisation des outils de construction :
- Maven : Configurez
surefire-plugininpom.xml. - Gradle: Utilisez le
testngConfiguration des dépendances et des tâches.
- Maven : Configurez
- Via les pipelines CI/CD : Intégration avec Jenkins ou GitHub Actions pour une exécution automatisée.
Cette variété garantit la compatibilité entre les environnements de développement, de test et de production.
9) Que sont TestNG Les auditeurs et pourquoi sont-ils importants ?
Auditeurs dans TestNG Fournir des points d'extension pour personnaliser le comportement des tests en surveillant les événements d'exécution des tests tels que le démarrage, le succès, l'échec ou le saut.
Auditeurs habituels :
ITestListener: Suit les événements au niveau de la méthode de test.ISuiteListener: Observe les événements au niveau de la suite.IReporterGénère des rapports personnalisés.
Exemple :
public class CustomListener implements ITestListener {
public void onTestFailure(ITestResult result) {
System.out.println("Test Failed: " + result.getName());
}
}
Les écouteurs sont souvent utilisés pour prendre captures d'écran en cas d'échec, générant journaux personnalisés, ou intégration avec les outils de reporting comme Allure ou ExtentReports.
10) Quels sont les avantages et les inconvénients de l'utilisation TestNG?
| Aspect | Avantages | Désavantages |
|---|---|---|
| Souplesse | Prend en charge le regroupement, la dépendance et l'exécution parallèle | Configuration XML complexe pour les grandes suites |
| Reporting | Fournit des rapports HTML et XML détaillés | Personnalisation limitée sans écouteurs |
| Intégration : | Fonctionne parfaitement avec Selenium et outils CI/CD | Courbe d'apprentissage légèrement plus élevée |
| Paramétrage | Prise en charge intégrée des tests basés sur les données | Nécessite une maintenance pour les grands ensembles de données |
Dans l'ensemble, TestNG est un framework robuste et flexible, adapté aux environnements de tests d'automatisation modernes malgré sa faible surcharge de configuration.
11) Comment prioriser les cas de test dans TestNG?
TestNG Fournit le priority attribut dans la @Test Annotation permettant de définir l'ordre d'exécution des méthodes de test. Les tests ayant une priorité plus faible s'exécutent en premier.
Exemple :
@Test(priority = 1)
public void loginTest() { ... }
@Test(priority = 2)
public void dashboardTest() { ... }
Si aucune priorité n'est spécifiée, la valeur par défaut est 0et les méthodes s'exécutent par ordre alphabétique.
Meilleure pratique : Utilisez les valeurs de priorité avec parcimonie. Leur utilisation excessive peut rendre l'ordre des tests rigide. Pour les flux complexes, la gestion des dépendances (dependsOnMethods) est plus facile à maintenir qu'une priorisation stricte.
12) Expliquez le concept et l'utilisation de l'exécution parallèle dans TestNG.
Exécution parallèle dans TestNG permet d'exécuter simultanément plusieurs tests, classes ou méthodes, réduisant ainsi considérablement le temps d'exécution global.
Vous pouvez activer cette fonctionnalité dans le testng.xml fichier:
<suite name="ParallelSuite" parallel="tests" thread-count="3"> <test name="Test1">...</test> <test name="Test2">...</test> </suite>
Modes parallèles pris en charge :
testsclassesmethodsinstances
Avantages :
- Cycle de rétroaction plus rapide.
- Utilisation efficace des processeurs multicœurs.
- Évolutivité pour les grandes suites d'automatisation.
Toutefois, assurez-vous sécurité du fil lors de l'utilisation de ressources partagées telles que WebDriver ou des connexions à une base de données.
13) Que sont les fournisseurs de données dans TestNGEn quoi diffèrent-ils des paramètres ?
@DataProvider permet tests basés sur les données en fournissant aux méthodes de test plusieurs ensembles de données.
Exemple :
@DataProvider(name="credentials")
public Object[][] data() {
return new Object[][] {{"user1", "pass1"}, {"user2", "pass2"}};
}
@Test(dataProvider="credentials")
public void login(String username, String password) { ... }
Différence entre @Parameters et @DataProvider :
| Fonctionnalité | @Parameters |
@DataProvider |
|---|---|---|
| La source de données | Fichier XML | Java méthode |
| Type de données | Ensemble de données unique | Plusieurs ensembles de données |
| Souplesse | Less | Haute |
| Case Study | Variables d'environnement | Tests répétés basés sur les données |
Par conséquent, @DataProvider est préférable lors de l'exécution d'un test unique avec plusieurs ensembles de données, comme la vérification de la connexion avec plusieurs identifiants.
14) Comment désactiver ou ignorer un test dans TestNG?
Vous pouvez désactiver un test dans TestNG en utilisant la fonction enabled attribut ou en l'ignorant par programmation.
1. Utilisation enabled = false:
@Test(enabled = false)
public void skipTest() {
System.out.println("This test will not run.");
}
2. Ignorer pendant l'exécution en utilisant SkipException:
@Test
public void conditionalSkip() {
throw new SkipException("Skipping this test due to condition.");
}
La désactivation est utile pour désactivation temporaire ignorer les tests instables ou incomplets sans les supprimer. L'ignorance est utile pour conditions d'exécution, comme par exemple ignorer les tests pour les navigateurs non pris en charge.
15) Quel est le rôle du fichier testng.xml et quels sont ses principaux composants ?
Le testng.xml Le fichier constitue la base de la configuration de TestNGIl définit les suites de tests, les groupes de tests, les paramètres et la configuration d'exécution parallèle.
Exemple de structure :
<suite name="AutomationSuite">
<parameter name="browser" value="chrome"/>
<test name="RegressionTests">
<classes>
<class name="com.test.LoginTest"/>
<class name="com.test.PaymentTest"/>
</classes>
</test>
</suite>
Composants majeurs:
<suite>– Définit l'ensemble de la suite.<test>– Représente un bloc de test.<classes>– Liste les classes de test.<methods>– Filtre les méthodes de test spécifiques.<parameter>– Fournit des paramètres globaux ou au niveau du test.
Le fichier XML fournit contrôle centralisé Exécution excessive sans modification du code.
16) Comment générer des rapports dans TestNG?
TestNG génère automatiquement deux types de rapports:
- Rapport HTML (
test-output/index.html) – Résume les tests réussis, échoués et ignorés. - Rapport XML – Utilisé pour l'intégration avec les outils CI/CD.
Pour les rapports avancés, TestNG s'intègre avec:
- Rapports d'étendue – Propose des tableaux de bord graphiques et des journaux détaillés.
- Allure Reports – Fournit des analyses visuelles avec des étapes de test, des captures d'écran et des journaux.
Exemple d'intégration :
ExtentReports extent = new ExtentReports();
ExtentTest test = extent.createTest("Login Test");
test.pass("Test Passed Successfully");
extent.flush();
Ces rapports sont essentiels pour suivre les tendances et identifier les points faibles en matière de couverture des tests.
17) Que sont les usines dans TestNG, et comment fonctionnent-ils ?
Usines à TestNG servent à créer instances dynamiques de classes de testIls permettent l'instanciation paramétrée des classes avant l'exécution des tests.
Exemple :
public class FactoryExample {
private String browser;
public FactoryExample(String browser) {
this.browser = browser;
}
@Factory
public static Object[] factoryMethod() {
return new Object[] { new FactoryExample("Chrome"), new FactoryExample("Firefox") };
}
@Test
public void testBrowser() {
System.out.println("Running test on: " + browser);
}
}
Avantages :
- Permet création d'objet paramétrée.
- Idéale pour tests multi-navigateurs et exécution multi-environnement.
Les fabriques complètent les fournisseurs de données lorsque vous avez besoin de configurations d'objets différentes plutôt que d'une simple variation des données au niveau des méthodes.
18) Comment utiliser les assertions dans TestNG?
Les assertions servent à valider les résultats attendus par rapport aux résultats réels dans les méthodes de test.
Types d'assertions :
- Assertions strictes (classe Assert) :
Interrompt immédiatement l'exécution du test en cas d'échec. - Assertions souples (classe SoftAssert) :
L'exécution se poursuit même après un échec, en signalant tous les problèmes à la fin. - Quand utiliser:
- Utilisez des assertions strictes pour validation critique comme une connexion réussie.
- Utilisez des assertions souples pour vérifications multiples au sein d'une seule méthode de test.
Assert.assertEquals(actual, expected); Assert.assertTrue(condition);
SoftAssert soft = new SoftAssert();
soft.assertEquals(actual, expected);
soft.assertAll();
19) Expliquez la différence entre @BeforeMethod et @BeforeClass dans TestNG.
| Aspect | @BeforeMethod |
@BeforeClass |
|---|---|---|
| Internationaux | Fonctionne avant chaque méthode d'essai | Fonctionne une fois avant toute méthode de la classe |
| Domaine | Par méthode d'essai | Par classe de test |
| Usage commun | Initialisation du navigateur avant chaque test | Chargement de la configuration ou du paramétrage du navigateur une fois |
Exemple :
@BeforeClass
public void setupClass() {
System.out.println("Executed once per class");
}
@BeforeMethod
public void setupMethod() {
System.out.println("Executed before each method");
}
Utilisez le @BeforeMethod lorsque chaque test nécessite un environnement propre, et @BeforeClass pour les tâches d'initialisation lourdes qui peuvent être réutilisées.
20) Comment TestNG La prise en charge de l'injection de dépendances et ses cas d'utilisation ?
TestNG supports injection de dépendance grâce à l'injection intégrée d'objets de contexte et de configuration tels que ITestContext, XmlTest, ou Method.
Exemple :
@Test
public void testContextExample(ITestContext context) {
System.out.println("Suite Name: " + context.getSuite().getName());
}
Cas d'utilisation:
- Récupération dynamique des paramètres de test.
- Accéder aux informations de configuration telles que les noms des suites ou les paramètres d'exécution parallèle.
- Améliorer la flexibilité des tests sans coder en dur les dépendances.
L'injection de dépendances permet aux développeurs de rédiger des tests modulaires et contextuels qui s'adaptent dynamiquement aux changements environnementaux.
21) Quelle est la différence entre @Factory et @DataProvider dans TestNG?
Le @Factory et @DataProvider ils aident à la paramétrisation, mais ils fonctionnent à différents niveaux dans l'architecture de test.
| Fonctionnalité | @Factory |
@DataProvider |
|---|---|---|
| Domaine | Niveau de classe | Niveau de méthode |
| Interet | Crée plusieurs instances d'une classe avec des données différentes | Fournit des données à une seule méthode de test |
| Internationaux | Exécute la classe entière pour chaque instance | Exécute une méthode plusieurs fois |
| Cas d'utilisation idéal | Tests multi-navigateurs ou multi-environnements | Tests fonctionnels basés sur les données |
Exemple :
- usine: Exécute la classe entière pour chaque type de navigateur.
- Fournisseur de données : Exécute une méthode de test avec plusieurs ensembles de données.
Utilisez le @Factory lorsque l'instanciation de l'objet elle-même varie, et @DataProvider pour la variation des entrées fonctionnelles au sein d'une même instance d'objet.
22) Comment peut-on relancer automatiquement les cas de test ayant échoué ? TestNG?
TestNG fournit un mécanisme pour relancer les cas de test ayant échoué en utilisant la fonction IRetryAnalyzer interface.
Exemple d'implémentation :
public class RetryAnalyzer implements IRetryAnalyzer {
int count = 0;
int maxTry = 2;
public boolean retry(ITestResult result) {
if (count < maxTry) {
count++;
return true;
}
return false;
}
}
Usage:
@Test(retryAnalyzer = RetryAnalyzer.class)
public void testLogin() {
Assert.fail("Intentional Failure");
}
Avantages :
- Réduit l'instabilité des pipelines CI.
- Gère les problèmes transitoires de réseau ou d'environnement.
Meilleure pratique : Combinez une logique de nouvelle tentative avec une journalisation appropriée et des captures d'écran pour le débogage des pannes intermittentes.
23) À quoi sert ITestContext dans TestNG?
ITestContext offre aux information contextuelle concernant l'exécution du test, y compris le nom de la suite, le nom du test, le répertoire de sortie et les paramètres.
Exemple :
@Test
public void contextExample(ITestContext context) {
System.out.println("Suite: " + context.getSuite().getName());
}
Méthodes clés :
getSuite()– Récupère les informations au niveau de la suite.getName()– Renvoie le nom du test.setAttribute()/getAttribute()– Partager les données entre les tests.
Il permet partage de données entre méthodes ou classes de test et facilite la création de rapports et l'enregistrement dynamiques.
24) Comment créer une dépendance entre les groupes de tests dans TestNG?
Vous pouvez définir les dépendances intergroupes à l'aide de dependsOnGroups attribut dans la @Test annotation.
Exemple :
@Test(groups = "Login")
public void login() { ... }
@Test(dependsOnGroups = "Login")
public void verifyProfile() { ... }
Cela garantit que le verifyProfile Le groupe ne s'exécute que si tous les tests du groupe sont exécutés. Login Le groupe a réussi.
Il est particulièrement utile dans test d'intégration, où les modules dépendent de l'exécution réussie des autres (par exemple, flux connexion → profil → déconnexion).
25) Comment peut-on ignorer certaines méthodes de test dans un TestNG Fichier XML ?
Vous pouvez explicitement exclure les méthodes dans une classe du fichier XML suite utilisant <exclude> Mots clés.
Exemple :
<class name="com.test.LoginTests">
<methods>
<exclude name="verifyLogout"/>
</methods>
</class>
Cela permet aux testeurs de désactiver temporairement certaines méthodes sans modifier le Java code source — utile dans les grandes suites logicielles où l'inclusion ou l'exclusion dynamique est nécessaire en fonction des cycles de publication ou des priorités des sprints.
26) Comment peut-on TestNG être intégré à Selenium Pilote Web ?
TestNG et Selenium forment une combinaison puissante pour l'automatisation de l'interface utilisateur.
Une configuration d'intégration typique implique l'organisation des tests à l'aide d'annotations, la gestion de la configuration/désinstallation et l'exécution des tests via XML ou des outils CI.
Exemple :
@BeforeMethod
public void setup() {
driver = new ChromeDriver();
}
@Test
public void verifyTitle() {
driver.get("https://example.com");
Assert.assertEquals(driver.getTitle(), "Example Domain");
}
@AfterMethod
public void teardown() {
driver.quit();
}
Avantages de l'intégration :
- Permet tests parallèles du navigateur.
- Simplifie regroupement et rapport des tests.
- Fonctionne parfaitement avec Pipelines CI / CD comme Jenkins ou GitHub Actions.
27) Quelles sont les meilleures pratiques à adopter lors de l'utilisation TestNG dans les grands frameworks d'automatisation ?
Meilleures pratiques :
- Utilisez le DescriptNommage ive : Nommez les tests en fonction du comportement, et non de l'implémentation.
- Groupement d'effet de levier : Créer des groupes de tests logiques (Fumée, Régression).
- Évitez le codage en dur : Utilisez des fichiers de paramètres ou de propriétés pour les données de test.
- Minimiser les dépendances : Veillez à ce que les cas de test restent indépendants autant que possible.
- Centraliser la configuration : Utilisez le
testng.xmlpour la configuration de la suite. - Intégrer les rapports : Utilisez des écouteurs ou des outils tiers comme ExtentReports.
- Utilisez la logique de nouvelle tentative avec prudence : Évitez de masquer les défauts réels.
Le respect de ces garanties évolutivité, maintenabilité et lisibilité dans l'automatisation au niveau de l'entreprise.
28) Quelle est la différence entre @BeforeTest et @BeforeSuite dans TestNG?
| Fonctionnalité | @BeforeTest |
@BeforeSuite |
|---|---|---|
| Domaine | S'exécute avant chaque <test> balise en XML |
S'exécute une fois avant la suite entière |
| Fréquence | Plusieurs fois (si plusieurs <test> blocs) |
Une seule fois par suite |
| Usage commun | Initialiser la configuration au niveau du test | Mettre en place des ressources mondiales |
Exemple :
@BeforeSuite
public void setupSuite() {
System.out.println("Global setup for suite.");
}
@BeforeTest
public void setupTest() {
System.out.println("Setup for each <test> tag.");
}
Utilisez le @BeforeSuite pour configurations globales (par exemple, connexion à une base de données) et @BeforeTest pour Initialisations spécifiques aux tests.
29) peut TestNG Peut-on l'utiliser pour des tests d'API ? Comment ?
Oui. TestNG peut être utilisé efficacement pour Test d'API en s'intégrant à des bibliothèques clientes HTTP comme Rassurez-vous or Client HTTP.
Exemple :
@Test
public void verifyApiResponse() {
Response response = RestAssured.get("https://api.example.com/users");
Assert.assertEquals(response.getStatusCode(), 200);
}
Avantages :
- Permet validation basée sur des assertions des réponses.
- accompagne paramétrage et tests basés sur les données pour plusieurs points de terminaison.
- Génère rapports structurés pour les validations d'API REST.
En combinant TestNG Avec RestAssured, les testeurs peuvent maintenir un cadre d'automatisation unifié pour les tests d'interface utilisateur et d'API.
30) Comment transmettre des paramètres depuis la ligne de commande ? TestNG?
Vous pouvez remplacer les paramètres XML lors de l'exécution en transmettant des propriétés système à l'aide de -D drapeau.
Exemple de commande :
mvn test -Dbrowser=chrome -Denv=staging
Exemple de code:
@Parameters("browser")
@Test
public void launch(@Optional("firefox") String browser) {
System.out.println("Running on: " + browser);
}
Cela permet sélection dynamique de l'environnement dans les pipelines CI/CD sans modifier les fichiers de configuration, ce qui améliore la flexibilité des tests.
31) Comment contrôler l'ordre d'exécution des tests dans TestNG sans utiliser de priorités ?
À la place d'utiliser priority, TestNG permet le contrôle par dépendances et ordre de méthode XML.
Méthodologie:
- L'utilisation de
dependsOnMethods: - Utilisation de la séquence de méthodes XML :
@Test
public void login() { ... }
@Test(dependsOnMethods = "login")
public void verifyDashboard() { ... }
<classes>
<class name="com.test.LoginTests">
<methods>
<include name="login"/>
<include name="verifyDashboard"/>
</methods>
</class>
</classes>
Meilleure pratique : Privilégiez les dépendances logiques pour les flux complexes plutôt que les priorités statiques, afin de garantir des suites de tests robustes et maintenables.
32) Comment exécuter des méthodes de test spécifiques à partir de la ligne de commande dans TestNG?
TestNG permet exécution de tests au niveau de la méthode directement depuis la ligne de commande en utilisant des configurations XML ou Maven Surefire.
Option 1 : Utilisation d’un fichier XML
<class name="com.test.LoginTests">
<methods>
<include name="verifyLogin"/>
</methods>
</class>
Option 2 : Commande Maven
mvn test -Dtest=com.test.LoginTests#verifyLogin
Cette approche permet exécution sélective, utile pour déboguer des méthodes individuelles ou valider des fonctionnalités critiques lors de compilations rapides.
33) Comment paramétrer des tests à l'aide d'un fichier Excel externe dans TestNG?
La paramétrisation via Excel est courante dans les frameworks basés sur les données où les données de test changent fréquemment.
Étapes de mise en œuvre :
- Utilisez le POI Apache or JExcel lire les données Excel.
- Introduisez-le dans un
@DataProviderméthode.
Exemple :
@DataProvider(name = "excelData")
public Object[][] readExcel() throws Exception {
FileInputStream fis = new FileInputStream("data.xlsx");
XSSFWorkbook wb = new XSSFWorkbook(fis);
XSSFSheet sheet = wb.getSheetAt(0);
Object[][] data = new Object[sheet.getLastRowNum()][2];
for (int i = 0; i < sheet.getLastRowNum(); i++) {
data[i][0] = sheet.getRow(i + 1).getCell(0).getStringCellValue();
data[i][1] = sheet.getRow(i + 1).getCell(1).getStringCellValue();
}
return data;
}
Cela permet d'exécuter la même méthode de test avec plusieurs ensembles de données réelles provenant d'Excel, ce qui accroît la flexibilité et la couverture.
34) Comment pouvez-vous courir TestNG tests dans Jenkins ou pipelines CI/CD ?
TestNG s'intègre parfaitement avec Jenkins, CI GitLab, ou Actions GitHub via Maven ou Gradle construit.
Étapes dans Jenkins :
- Installer Plugin d'intégration Maven.
- Créer un Travail freestyle ou pipeline.
- Ajouter
mvn clean testcomme étape de construction. - Après la compilation, configurez les rapports HTML :
- Répertoire des rapports :
test-output - Fichier index :
index.html
- Répertoire des rapports :
Avantages :
- Permet d'automatiser les tests de régression.
- Assure la planification des tests et le suivi des tendances.
- Garantit une exécution cohérente des tests dans tous les environnements.
35) Quel est le but de @Parameters et en quoi est-il différent de @Optional ?
Ces deux annotations concernent la paramétrisation, mais servent des objectifs distincts.
| Fonctionnalité | @Parameters |
@Optional |
|---|---|---|
| Interet | Transmet les paramètres depuis un fichier XML | Fournit une valeur par défaut si le paramètre est manquant. |
| Déclaration | Utilisé avec XML <parameter> |
Utilisé dans la méthode de test |
| Comportement | Lève une erreur si la valeur est manquante. | Utilise la valeur de repli |
Exemple :
@Test
@Parameters("browser")
public void runTest(@Optional("chrome") String browser) {
System.out.println("Running on: " + browser);
}
L'utilisation de @Optional Assure tester la stabilité lorsque les configurations XML sont incomplètes.
36) Comment gérez-vous les dépendances de test entre différentes classes dans TestNG?
Pour créer des dépendances entre classes, TestNG permet d'utiliser le dependsOnGroups attribuer.
Exemple :
@Test(groups = "Login")
public void loginTest() { ... }
@Test(groups = "Dashboard", dependsOnGroups = "Login")
public void dashboardTest() { ... }
Cette approche permet de gérer dépendances multi-modules où chaque classe représente un module (Connexion, Tableau de bord, Paiement, etc.).
Cela garantit que les modules dépendants ne s'exécutent que si les tests préalables réussissent, préservant ainsi l'intégrité des tests.
37) Que sont les échecs de configuration dans TestNG, et comment peut-on les gérer ?
Des échecs de configuration se produisent lorsque les méthodes d'installation ou de nettoyage sont annotées avec @Before* or @After* échouer.
Ils peuvent causer tests dépendants à ignorer, même si ces tests sont corrects.
Causes communes
- Initialisation incorrecte du pilote Web.
- Problèmes de configuration de la base de données ou de l'environnement.
- Configuration incorrecte des paramètres.
Solutions:
- Utilisez le essayer-attraper blocs dans les méthodes de configuration.
- Appliquer
alwaysRun = truepour garantir le bon déroulement du nettoyage malgré les échecs.
Exemple :
@BeforeMethod(alwaysRun = true)
public void setup() {
// Setup logic
}
Cela garantit que vos méthodes de démontage continuent de s'exécuter, maintenant ainsi la stabilité de l'environnement de test.
38) À quoi servent les attributs invocationCount et threadPoolSize dans TestNG?
Ces attributs permettent exécution de tests répétée et parallèle de la même méthode.
Exemple :
@Test(invocationCount = 5, threadPoolSize = 2)
public void loadTest() {
System.out.println("Running load test...");
}
| Attribut | Description |
|---|---|
invocationCount |
Nombre de fois où une méthode est exécutée |
threadPoolSize |
Nombre de threads simultanés |
Cas d'utilisation: Tests de performance, vérification de la stabilité ou reproduction d'un comportement instable lors de plusieurs exécutions.
39) Comment exécuter uniquement les cas de test ayant échoué dans TestNG?
Après une course en suite, TestNG génère un fichier nommé testng-failed.xml dans le test-output répertoire.
Vous pouvez relancer uniquement les tests ayant échoué en exécutant :
java -cp testng.jar org.testng.TestNG test-output/testng-failed.xml
Avantages :
- Permet de gagner du temps en ignorant les tests réussis.
- Facilite le débogage dans les grandes suites logicielles.
- Couramment utilisé dans les pipelines CI pour des tests de validation rapides.
Vous pouvez également intégrer cela à Jenkins en utilisant un script post-compilation pour les réexécutions.
40) Quelles sont certaines limitations de TestNG et comment peut-on les atténuer ?
Malgré sa robustesse, TestNG présente quelques limitations.
| Limitation | Stratégie d'atténuation |
|---|---|
| Complexité de la configuration XML | Utilisez la configuration et les générateurs basés sur les annotations |
| Reportages limités des natifs | Intégrez ExtentReports ou Allure |
| Aucun contrôle de nouvelle tentative intégré | Mettre en œuvre le IRetryAnalyzer |
| Problèmes de sécurité liés aux threads dans les exécutions parallèles | Utilisez des instances WebDriver locales au thread |
| Courbe d'apprentissage pour les débutants | Maintenir des structures de projet basées sur des modèles |
Grâce à une conception de cadre appropriée et à des pratiques exemplaires, ces limitations peuvent être minimisées, garantissant ainsi des solutions d'automatisation stables et maintenables.
41) Comment utiliser les écouteurs pour la journalisation et la capture d'écran dans Selenium-TestNG?
Auditeurs dans TestNG aider à surveiller l'exécution des tests et à effectuer des actions telles que la journalisation, la prise de captures d'écran ou la génération de rapports de résultats de manière dynamique.
Exemple d'implémentation :
public class ScreenshotListener implements ITestListener {
@Override
public void onTestFailure(ITestResult result) {
WebDriver driver = ((BaseTest) result.getInstance()).getDriver();
File src = ((TakesScreenshot) driver).getScreenshotAs(OutputType.FILE);
FileUtils.copyFile(src, new File("screenshots/" + result.getName() + ".png"));
}
}
Usage:
@Listeners(ScreenshotListener.class)
public class LoginTests extends BaseTest { ... }
Avantages :
- Capture automatiquement les défaillances.
- Améliore le débogage grâce à des preuves visuelles.
- Réduit les efforts manuels liés à la tenue des registres.
Cette technique est cruciale dans les pipelines d'automatisation CI/CD, notamment pour le diagnostic à distance des échecs de compilation.
42) Quelle est la différence entre IReporter et ITestListener dans TestNG?
| Fonctionnalité | IReporter |
ITestListener |
|---|---|---|
| Interet | Génère des rapports personnalisés après l'exécution des tests. | Suit et réagit aux événements de test d'exécution |
| Invocation | Une fois tous les tests terminés | Durant le cycle de vie du test (démarrage, succès, échec) |
| Sortie | Rapports HTML/XML/JSON | Fichiers journaux, captures d'écran, tableaux de bord en direct |
| Usage commun | Intégration d'ExtentReports et d'Allure | Journalisation, gestion des défaillances, mécanismes de nouvelle tentative |
Exemple :
- Utilisez le
IReporterpour la construction des rapports complets après la fin du test. - Utilisez le
ITestListenerpour journalisation en temps réel ou captures d'écran.
Ils peuvent également être combinées construire des systèmes d'analyse d'automatisation de bout en bout.
43) Comment effectuer des tests multi-navigateurs en utilisant TestNG Configuration XML ?
Les tests multi-navigateurs garantissent que les mêmes fonctionnalités fonctionnent sur différents navigateurs.
Exemple de configuration :
<suite name="CrossBrowserSuite" parallel="tests">
<test name="ChromeTest">
<parameter name="browser" value="chrome"/>
<classes><class name="com.test.LoginTest"/></classes>
</test>
<test name="FirefoxTest">
<parameter name="browser" value="firefox"/>
<classes><class name="com.test.LoginTest"/></classes>
</test>
</suite>
Java Code:
@Parameters("browser")
@BeforeClass
public void setup(String browser) {
if(browser.equalsIgnoreCase("chrome"))
driver = new ChromeDriver();
else if(browser.equalsIgnoreCase("firefox"))
driver = new FirefoxDriver();
}
Cette approche permet exécution parallèle et multi-navigateurs, accélérant la couverture des tests sur toutes les plateformes.
44) Comment intégrez-vous TestNG avec Docker ou Selenium Grille?
TestNG s'intègre parfaitement avec Dockerisé Selenium Grille pour permettre les tests parallèles distribués.
Étape:
- Mettre en place Selenium Grille dans Docker en utilisant le fonctionnaire Selenium image:
docker run -d -p 4444:4444 --name selenium-grid selenium/standalone-chrome
- Mises à jour TestNG configuration:
- Exécutez votre suite via Jenkins ou un pipeline CI.
DesiredCapabilities caps = new DesiredCapabilities();
caps.setBrowserName("chrome");
driver = new RemoteWebDriver(new URL("http://localhost:4444/wd/hub"), caps);
Avantages :
- Permet tests parallèles évolutifs.
- Réduit les coûts liés à la configuration de l'environnement.
- permet exécution de tests cohérente à travers des conteneurs distribués.
45) Quelle est la différence entre l'exécution parallèle au niveau de la suite, des tests et des méthodes ? TestNG?
| LEVEL | Attribut parallèle | Comportement d'exécution |
|---|---|---|
| Suite | parallel="suites" |
Exécute plusieurs suites simultanément |
| Test | parallel="tests" |
Fonctionne <test> blocs simultanément |
| Classe | parallel="classes" |
Exécute les classes de test en parallèle |
| Méthode | parallel="methods" |
Exécute les méthodes de test individuelles en parallèle |
Exemple :
<suite name="ParallelTests" parallel="methods" thread-count="3">
<test name="SampleTest">
<classes><class name="com.test.ParallelExample"/></classes>
</test>
</suite>
Meilleure pratique :Utilisez le parallel="classes" pour la stabilité dans Selenium tests pour éviter les conflits de pilotes partagés.
46) Comment partager des données entre les tests sans utiliser de variables globales ? TestNG?
TestNG offre aux ITestContext et injection de dépendance partager des données de manière dynamique.
Exemple :
@Test
public void storeData(ITestContext context) {
context.setAttribute("token", "abc123");
}
@Test(dependsOnMethods = "storeData")
public void useData(ITestContext context) {
String token = (String) context.getAttribute("token");
System.out.println("Using token: " + token);
}
Cela évite les variables statiques, préserve la sécurité des threads et garantit isolation des données dans les tests.
47) Comment capturez-vous et enregistrez-vous les tests ignorés dans TestNG?
Vous pouvez capturer les tests ignorés en utilisant onTestSkipped() dans le ITestListener interface.
Exemple :
@Override
public void onTestSkipped(ITestResult result) {
System.out.println("Skipped Test: " + result.getName());
}
Raisons de l'absence :
- Échec du test dépendant.
- Saut conditionnel via
SkipException. - Indisponibilité de l'environnement.
Meilleure pratique :
Consignez les raisons des sauts de journal et les traces de pile pour la traçabilité dans les rapports ou tableaux de bord d'intégration continue.
48) Expliquez comment paramétrer les tests d'API REST en utilisant TestNG et RestAssuré.
TestNG's @DataProvider s'intègre élégamment avec Rassurez-vous pour la paramétrisation de l'API.
Exemple :
@DataProvider(name = "apiData")
public Object[][] apiData() {
return new Object[][] {
{"https://api.example.com/users/1"},
{"https://api.example.com/users/2"}
};
}
@Test(dataProvider = "apiData")
public void testApi(String url) {
Response response = RestAssured.get(url);
Assert.assertEquals(response.getStatusCode(), 200);
}
Avantages :
- Exécute le même appel API pour plusieurs points de terminaison ou charges utiles.
- Simplifie les tests de régression pour les API avec des ensembles d'entrées variables.
- S'intègre parfaitement aux outils et rapports d'intégration continue.
49) Comment créer des annotations personnalisées dans TestNG pour des modèles de test réutilisables ?
Les annotations personnalisées permettent de standardiser les configurations ou les validations de tests répétitifs.
Exemple :
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface SmokeTest {
String description() default "Smoke Test";
}
Usage:
@SmokeTest(description="Validating Login Functionality")
@Test
public void loginTest() { ... }
Combinées à la réflexion, ces annotations peuvent être lues dynamiquement pour regrouper les tests ou piloter une exécution conditionnelle.
Cette technique est largement utilisée dans métaprogrammation de cadre pour créer des tests auto-documentés.
50) Comment pouvez-vous combiner Cucumber et TestNG pour les frameworks de tests hybrides ?
TestNG peut agir comme le testeur pour Cucumber Scénarios BDD offrant des fonctionnalités puissantes de reporting et de parallélisation.
Exemple de coureur :
@CucumberOptions(
features = "src/test/resources/features",
glue = "stepDefinitions",
plugin = {"pretty", "html:target/cucumber-report.html"}
)
public class RunCucumberTest extends AbstractTestNGCucumberTests { }
Avantages :
- Des effets de levier TestNG's annotations, auditeurs et rapports.
- accompagne Exécution parallèle des fonctionnalités.
- S'intègre avec Allure et Rapports d'étendue facilement.
Cette approche hybride fusionne Lisibilité du BDD avec finition TestNG la flexibilité, idéal pour les frameworks d'entreprise.
🔍 Haut TestNG Questions d'entretien avec des scénarios réels et des réponses stratégiques
Vous trouverez ci-dessous 10 exemples réalistes et pertinents pour le domaine. TestNG Questions d'entretien accompagnées d'attentes claires et d'exemples de réponses pertinents.
1) Pouvez-vous expliquer les principaux avantages de l'utilisation TestNG par rapport à JUnit?
Attendu du candidat : Démontrer sa compréhension de TestNGSes fonctionnalités améliorées et les raisons pour lesquelles il est souvent privilégié pour l'automatisation en entreprise.
Exemple de réponse: "TestNG offre plusieurs avantages tels que la configuration flexible des tests, la prise en charge de l'exécution parallèle, les méthodes de test dépendantes, les tests pilotés par les données avec les fournisseurs de données et la génération de rapports intégrés. Ces fonctionnalités rendent TestNG « Plus performant pour les frameworks d'automatisation complexes qui nécessitent une évolutivité. »
2) Comment utilisez-vous TestNG Des annotations pour contrôler le flux d'exécution des tests ?
Attendu du candidat : Connaissance de l'objectif et de l'ordre des annotations.
Exemple de réponse: "TestNG Il propose des annotations telles que `@BeforeSuite`, `@BeforeClass`, `@BeforeMethod`, `@Test` et leurs annotations de nettoyage correspondantes. Celles-ci permettent une organisation structurée de la configuration et du nettoyage des tests. Par exemple, `@BeforeMethod` s'exécute avant chaque méthode de test, ce qui est utile pour initialiser l'état du navigateur.
3) Décrivez un projet d'automatisation complexe où TestNG a joué un rôle clé.
Attendu du candidat : Expérience concrète de projets et capacité à expliquer les solutions aux problèmes.
Exemple de réponse: « Dans mon poste précédent, j'ai travaillé sur un projet qui nécessitait des tests de régression approfondis dans plusieurs environnements. » TestNGLes fonctionnalités d'exécution parallèle et de regroupement de [nom de la plateforme] ont permis à l'équipe d'exécuter simultanément des suites critiques, réduisant considérablement le temps d'exécution tout en maintenant la fiabilité. »
4) Comment faire TestNG Les groupes aident-ils à organiser et à exécuter efficacement les tests ?
Attendu du candidat : Compréhension du regroupement, y compris des mécanismes d'inclusion/exclusion.
Exemple de réponse: « Groupes dans TestNG Cela permet de catégoriser les cas de test (tests de fumée, de régression et d'intégration, par exemple). Grâce à testng.xml, je peux exécuter des groupes de tests de manière sélective, exclure les tests instables et gérer différentes suites de tests sans modifier le code source.
5) Décrivez une situation où vous avez dû déboguer un problème. TestNG tests. Quelle a été votre approche ?
Attendu du candidat : Esprit critique et compétences en résolution de problèmes.
Exemple de réponse: « À un poste précédent, j'ai rencontré un ensemble de défaillances TestNG Des tests semblaient réussir en local mais échouaient en intégration continue. J'ai activé la journalisation détaillée, examiné l'ordre d'exécution et découvert qu'une ressource partagée n'était pas réinitialisée entre les tests. J'ai ensuite mis en place une procédure de nettoyage appropriée à l'aide de @AfterMethod pour garantir l'isolation des tests.
6) Comment mettre en œuvre des tests pilotés par les données en utilisant TestNG?
Attendu du candidat : Compréhension des fournisseurs de données et de leurs cas d'utilisation.
Exemple de réponse: « Je crée une méthode annotée avec @DataProvider qui renvoie des données sous forme de tableaux d'objets, puis je la lie à une méthode annotée avec @Test à l'aide de l'attribut dataProvider. Cela permet d'exécuter plusieurs itérations du même test avec différents ensembles d'entrées, ce qui est utile pour valider les soumissions de formulaires ou les variations de charge utile d'une API. »
7) Comment gérez-vous les dépendances de test dans TestNG?
Attendu du candidat : Utilisation correcte de dependsOnMethods ou dependsOnGroups.
Exemple de réponse: "TestNG Cela permet de définir des dépendances de test grâce aux attributs `dependsOnMethods` et `dependsOnGroups`. J'utilise les dépendances lorsqu'un test ne doit s'exécuter qu'une fois un autre terminé avec succès, par exemple pour vérifier une commande uniquement après sa création.
8) Décrivez comment vous avez utilisé TestNG avec des outils d'intégration continue.
Attendu du candidat : Expérience concrète en matière de pipelines d'automatisation.
Exemple de réponse: « À mon précédent emploi, j'ai intégré TestNG avec Jenkins en configurant la compilation Maven pour générer TestNG Jenkins a ensuite archivé les rapports HTML et XML et affiché les résultats après chaque cycle de compilation. Cette intégration a permis à l'équipe de détecter rapidement les défaillances et de garantir la stabilité des versions.
9) Parlez-moi d'une situation où vous avez dû travailler dans des délais très serrés tout en gérant plusieurs tâches d'automatisation.
Attendu du candidat : Gestion du temps et capacité à prioriser.
Exemple de réponse: « Dans mon dernier poste, j'ai dû mettre à jour des documents existants. » TestNG J'ai effectué des tests unitaires tout en en créant de nouveaux pour une prochaine version. J'ai priorisé les tâches en fonction de leur impact sur l'activité, automatisé en premier les zones à haut risque et utilisé… TestNG Le regroupement permettait d'isoler les sections terminées pour un examen anticipé. Cela garantissait une livraison dans les délais sans compromettre la qualité.
10) Comment concevriez-vous un système évolutif ? TestNG Un cadre pour une application de grande envergure ?
Attendu du candidat : ArchiCompréhension de la structure, des modèles et des meilleures pratiques.
Exemple de réponse: « Je concevrais un framework modulaire utilisant le Page Object Model, et j'intégrerais… » TestNG Pour la gestion de l'exécution, j'utiliserais des fournisseurs de données pour les scénarios axés sur les données. Je configurerais également l'exécution parallèle, centraliserais les utilitaires et externaliserais les paramètres de configuration afin que le framework reste évolutif et maintenable à mesure que l'application se développe.
