Gruppi in TestNG

By: Krishna rungta Krishna rungta
Hours aggiornato

⚡ Riepilogo intelligente

Gruppi in TestNG Consente di etichettare i metodi di test con etichette logiche, per poi includerli o escluderli tramite una suite XML. Questo approccio semplifica i test di smoke test, di regressione e di dipendenza senza riscrivere Java codice.

  • 🏷️ Sintassi dell'annotazione: Usa il @Test(groups = {"smoke","regression"}) per etichettare qualsiasi metodo con uno o più nomi di gruppo logici.
  • 📜 Controllo XML: Migliori <groups><run><include> and <exclude> I tag all'interno di testng.xml determinano quali metodi contrassegnati da tag vengono effettivamente eseguiti.
  • 🔗 dipendenze: Migliori dependsOnGroups L'attributo impone un ordine tale che i gruppi di prerequisiti terminino sempre prima dell'inizio dei test dipendenti.
  • 🤖 Selezione tramite IA: Gli strumenti di test basati sull'intelligenza artificiale associano le modifiche al codice ai gruppi pertinenti, in modo che ad ogni commit vengano eseguite solo le suite di test interessate.
  • 🧪 TestNG 7.x: Le versioni più recenti mantengono i gruppi pienamente compatibili con l'esecuzione parallela, i listener e le pipeline di Maven Surefire.
Scopri di più

Gruppi in TestNG

TestNG è un framework di test che copre test unitari, funzionali, end-to-end, dell'interfaccia utente e di integrazione per Java

È possibile eseguire un singolo pacchetto o più pacchetti (un pacchetto incapsula classi correlate in una struttura di directory definita) creando una suite XML e attivandola tramite Maven.

TestNG Gruppi con esempio

Si utilizzano i gruppi in TestNG quando:

  • Non si desidera disperdere i metodi di test in molte classi esclusivamente in base all'area funzionale e
  • Si desidera saltare (non eseguire) i casi di test selezionati come se fossero assenti dal codice sorgente.
  • Per raggiungere entrambi gli obiettivi, si raggruppano i metodi in categorie logiche. TestNG quindi rispetta i filtri “includi” ed “escludi” dichiarati nella suite XML.

Il frammento di codice seguente mostra la sintassi di raggruppamento dei tag utilizzata in un metodo di test.

@Test (gruppi = { “legame”, “legami forti” })

Qui vengono utilizzati due nomi di gruppo, vale a dire bonding and strong_tiesSi tratta di etichette logiche che puoi rinominare in base alle esigenze del tuo progetto.

Migliori <groups> Il tag indica l'inizio dei filtri di gruppo all'interno della suite XML.

Successivamente, si personalizza il file XML per selezionare un gruppo specifico tra le classi contrassegnate. L'esempio seguente mostra la sintassi per la dichiarazione del gruppo.

<gruppi>
<eseguire il>
<includere Nome=“legame” />
</eseguire il>
</gruppi>

Supponiamo che una singola classe contenga 10 metodi di test.

Tra questi metodi:

  • 6 metodi portano il bonding gruppo e
  • 4 metodi portano il strong_ties gruppo.

Successivamente, si configura Maven e Java percorsi e utilizzare il Eclipse IDE per dimostrare l'utilizzo del gruppo tramite file XML all'interno di un Java- progetto Maven.

ARTICOLI CORRELATI

Crea XML per TestNG con le etichette

  • Il file XML (Extensible Markup Language) nel framework Maven memorizza la configurazione per uno o più test, dichiarati all'interno del etichetta.
  • Ogni voce del test è avvolta in un etichetta e può contenerne uno o più TestNG classi.
  • A Java classe con uno o più @Test le annotazioni sui suoi metodi sono trattate come un TestNG classe.

Per costruire un file testng.xml funzionante, vengono visualizzati in sequenza più tag, vale a dire: , , E .

  • Migliori il tag contiene il nome a livello di suite utilizzato in TestNG report per i riepiloghi di esecuzione.
  • Migliori <test name=”Guru 99 Test di fumo dimostrativo”> Il tag contiene un nome logico per il test; il report lo utilizza per il conteggio dei test superati, falliti e saltati, oltre al tempo totale di esecuzione e ai metadati di gruppo.
  • Migliori Il tag punta alla classe di test, dove com.group.guru99 è il pacchetto e TC_Class1 è il nome della classe.

<!DOCTYPE suite SISTEMA “http://testng.org/testng-1.0.dtd”>
<suite Nome="Suite">
<test Nome="Guru 99 Test di fumo dimostrativo”>
<gruppi>
<eseguire il>
<includere Nome=“legami forti” />
</eseguire il>
</gruppi>
<classi>
<classe Nome=“com.group.guru99.TC_Class1” />
</classi>
</test>
</suite>

Questa configurazione XML viene illustrata nei video tutorial nelle sezioni successive.

"escludere" o "includere" nell'XML di prova

Se il meccanismo di raggruppamento risulta troppo complesso per un filtro di piccole dimensioni, la suite testng.xml consente anche di escludere o includere singoli metodi di test specificandone il nome.

Escludi tag: Sintassi per il tag di esclusioneescludere Nome=“${TEST_CASE_NAME}” />
Includi tag: Sintassi per il tag includeincludere Nome=“${TEST_CASE_NAME}” />

Nota: È possibile includere o escludere molti casi di test in una singola esecuzione, e la stessa sintassi si applica ai filtri di gruppo.

Utilizzo di dependsOnGroups per l'esecuzione ordinata

Al di là della semplice inclusione, TestNG consente a un gruppo di dipendere da un altro utilizzando il dependsOnGroups attributo. Il runner garantisce che ogni metodo nel gruppo padre termini prima che inizi qualsiasi metodo dipendente, il che mantiene affidabili le precondizioni.

  • Prima effettua il login, poi le transazioni: Tagga i metodi di accesso con group = "auth"e test di trasferimento tag con dependsOnGroups = {"auth"}I test di trasferimento vengono eseguiti solo dopo che l'accesso è andato a buon fine.
  • Salta in caso di errore: Se un metodo nel gruppo padre fallisce, TestNG contrassegna i metodi dipendenti come ignorati anziché come fallimenti diretti, garantendo così l'accuratezza dei report.
  • Da abbinare ad alwaysRun: I metodi di pulizia dovrebbero essere impostati alwaysRun = true quindi la procedura di pulizia continua a essere eseguita anche quando un gruppo a monte fallisce.

Questo schema è comune per le suite end-to-end in cui la configurazione delle API deve essere completata prima che inizino le asserzioni dell'interfaccia utente.

Correre TestNG Raggruppa, includi, escludi codice (video demo)

Di seguito è riportata una guida dettagliata Java codice e la suite XML che guidano il raggruppare, escludere e includere comportamento.

Scenario di prova: Avviare il Guru99 sito demo di banking, verifica alcuni elementi nella pagina di accesso, inserisci le credenziali e riverifica alcuni elementi nella dashboard dopo l'accesso.

Correre TestNG Gruppo, Includi, Escludi Code

Nota: Ogni passaggio risiede in un metodo separato, ma in fase di esecuzione l'ordine dipende dalle voci presenti nella suite XML.

  • Metodo 1: Inizializza il browser e avvia il URL (tc01LaunchURL()).
  • Metodo 2: Verificare l'intestazione della pagina di accesso (tc02VerifyLaunchPage()).
  • Metodo 3: Inserisci nome utente e password nel modulo di accesso (tc03EnterCredentials()).
  • Metodo 4: Verificare la presenza dell'ID Manager nella dashboard utente (tc04VerifyLoggedInPage()).
  • Metodo 5: Verificare i collegamenti aggiuntivi nella dashboard utente (tc05VerifyHyperlinks()).

Code per lo scenario:

pacchetto com.group.guru99;

importare java.util.concurrent.TimeUnit;

importare org.openqa.selenium.By;
importare org.openqa.selenium.WebDriver;
importare org.openqa.selenium.firefox.FirefoxAutista;
importare org.testng.Assert;
importare org.testng.annotations.Test;

classe pubblica TC_Class1 {
finale statica pubblica webdriver webDriver = new FirefoxGuidatore();

Corda launchPageHeading = “//h3[text()='Guru99 Bank']”;
finale Corda elemento_nomeutente = “//input[@name='uid']”, elemento_password = “//input[@name='password']”,
elemento_di_accesso = “//input[@name='btnLogin']”;
finale Corda userName_value = “mngr28642”, valore_password = “ydAnate”;
finale Corda managerID = “//td[contains(text(),'ID del responsabile')]”;
finale Corda nuovoCliente = “//a[@href='addcustomerpage.php']”, trasferimento fondi = “//a[@href='FundTransInput.php']”;

/** Questo caso di test inizializza il webDriver */
@Test(gruppi = { “legame”, “legami forti” })
vuoto pubblico tc01LaunchURL() {
webDriver.manage().window().maximize();
webDriver.manage().timeouts().implicitlyWait(20, Unità di tempo SECONDI);
webDriver.get(“https://www.demo.guru99.com/V4/”);
}

/** Verifica la presenza dell'intestazione nella pagina di accesso */
@Test(gruppi = { “legame” })
vuoto pubblico tc02VerifyLaunchPage() {
Assert.assertTrue(webDriver.findElement(By.xpath(launchPageHeading)).isDisplayed(),
L'intestazione della pagina iniziale non viene visualizzata.);
System.out.println("Viene visualizzata l'intestazione della pagina iniziale");
}

/** Inserisce nome utente e password, quindi fa clic su Accedi */
@Test(gruppi = { “legame”, “legami forti” })
vuoto pubblico tc03EnterCredentials() {
webDriver.findElement(By.xpath(userName_element)).sendKeys(userName_value);
webDriver.findElement(By.xpath(password_element)).sendKeys(password_value);
webDriver.findElement(By.xpath(signIn_element)).click();
}

/** Verifica l'ID del responsabile sulla dashboard */
@Test(gruppi = { “legami forti” })
vuoto pubblico tc04VerifyLoggedInPage() {
Assert.assertTrue(webDriver.findElement(By.xpath(managerID)).isDisplayed(),
"L'etichetta ID responsabile non viene visualizzata");
System.out.println("Viene visualizzata l'etichetta ID responsabile");
}

/** Verifica il link "Nuovo cliente" e il link "Trasferimento fondi" nella dashboard */
@Test(gruppi = { “legame” })
vuoto pubblico tc05VerifyHyperlinks() {
Assert.assertTrue(webDriver.findElement(By.xpath(newCustomer)).isEnabled(),
Il collegamento ipertestuale per i nuovi clienti non viene visualizzato.);
System.out.println("Viene visualizzato il collegamento ipertestuale per i nuovi clienti");

Assert.assertTrue(webDriver.findElement(By.xpath(fundTransfer)).isEnabled(),
Il collegamento ipertestuale per il trasferimento fondi non viene visualizzato.);
System.out.println("Viene visualizzato il collegamento ipertestuale per il trasferimento fondi");
}
}

Nota bene: le credenziali di accesso alla demo bancaria rimangono valide per circa 20 giorni, pertanto, una volta scaduto tale periodo, un'esecuzione in locale potrebbe visualizzare un errore di credenziali non valide.

Spiegazione del codice:

Cinque metodi di prova, uno per azione, ciascuno dei quali comporta un groups attributo sul @Test annotazione.

Le due etichette di gruppo logico sono strong_ties and bonding.

  • Il primo e il terzo metodo comportano entrambi bonding and strong_ties, quindi vengono eseguiti ogni volta che uno dei due gruppi è incluso nella suite. Questo è uno schema comune per la condivisione caso di prova gradini.
  • Il secondo metodo è contrassegnato solo con bonding, quindi viene eseguito solo quando bonding il gruppo è incluso.
  • Il quarto metodo è etichettato solo con strong_ties, quindi viene eseguito solo quando quel gruppo è incluso.
  • Il quinto metodo è etichettato solo con bonding, quindi viene eseguito solo quando bonding il gruppo è incluso.

Seguono quattro scenari di esecuzione:

Scenario 1: Eseguire ogni metodo di test indipendentemente dal gruppo. Rimuovere il <groups> blocco dal file XML in esecuzione.

Scenario 2: Eseguire solo i metodi legati al gruppo scelto, vale a dire strong_ties or bondingSi prega di fare riferimento al video qui sotto.

  • Nella prima parte del video, il <groups> Il blocco è commentato, quindi tutti i metodi di test vengono eseguiti.
  • Nella seconda parte, il filtro di gruppo viene ripristinato e vengono eseguiti solo i metodi corrispondenti.

Scenario 3: Applica il filtro di esclusione per saltare i casi di test selezionati. Fai riferimento al video.

  • La demo esclude tc02 per nome nell'XML in esecuzione e il report dei risultati conferma che il metodo escluso non viene eseguito.

Scenario 4: Applica il filtro di inclusione per eseguire solo tc01LaunchURL, tc03EnterCredentialse tc05VerifyHyperlinksSi prega di fare riferimento al video.

In questa esecuzione, vengono eseguiti solo i metodi elencati nel filtro di inclusione, esattamente come configurato.

Scarica il progetto di esempio dal link sottostante.

Scarica il file sopra Code

Conclusione

Gruppi in TestNG portare struttura a grandi Selenium e suite di unità sostituendo le suddivisioni di classe una tantum con filtri XML dichiarativi.

Etichetta i tuoi metodi con @Test(groups = {...}), quindi utilizzare <include>, <exclude>e dependsOnGroups per condurre test di fumo, regressione e test end-to-end dallo stesso progetto Maven su TestNG 7.x.

DOMANDE FREQUENTI

Un gruppo è un'etichetta logica collegata a un metodo di test tramite il groups attributo su @TestLa suite XML seleziona quindi i gruppi utilizzando filtri di inclusione ed esclusione, consentendoti di decidere in fase di esecuzione quali metodi con tag eseguire.

Dentro <groups><run>, il <include name="..."> tag whitelist gruppi per l'esecuzione e <exclude name="..."> li blocca. TestNG Applica le esclusioni dopo le inclusioni, quindi un gruppo escluso viene sempre saltato, anche se è presente anche nell'elenco delle inclusioni.

Migliori dependsOnGroups attributo su @Test forze TestNG per eseguire ogni metodo nel gruppo elencato prima dell'avvio del metodo dipendente. Se un qualsiasi metodo prerequisito fallisce, TestNG contrassegna il metodo dipendente come saltato anziché come fallito.

Sì. Il groups l'attributo accetta un array, quindi @Test(groups = {"smoke", "regression"}) colloca un metodo in entrambi i gruppi. TestNG esegue tale metodo ogni volta che uno dei due gruppi è incluso nella suite, il che mantiene i passaggi condivisi DRY (Don't Repeat Yourself).

TestNG 7.x è la linea mantenuta, con rilasci sotto il org.testng:testng Maven coordinate. Mantiene gruppi, esecuzione parallela e listener pienamente compatibili con le tecnologie moderne. Selenium Progetti 4 e JDK 17.

Gli strumenti di test di impatto dell'IA analizzano le differenze del codice, quindi mappano le classi modificate ai gruppi che le coprono. La pipeline esegue solo i gruppi contrassegnati su ogni pull request, riducendo i tempi di feedback e mantenendoping Percorsi rischiosi messi alla prova.

Sì. Gli algoritmi di clustering AI leggono i registri storici degli errori, segnalano i test instabili e propongono un sottoinsieme stabile etichettato come regressionGli ingegneri approvano l'elenco, quindi TestNG quel gruppo gestisce quel gruppo ogni notte, il che mantiene la suite compatta senza perdere la copertura.

Riassumi questo post con: