Menu

Annotazioni e listener di TestNG

testng annotations listeners

Prova Il Nostro Strumento Per Eliminare I Problemi

Questo tutorial spiega i diversi tipi di annotazioni e listener di TestNG. Imparerai anche come utilizzare le annotazioni e gli ascoltatori di TestNG con esempi:

Qui, eseguiremo un programma TestNG di base utilizzando le annotazioni TestNG e vedremo anche il ruolo degli ascoltatori TestNG e come usarli nei test.

=> Leggere attraverso la serie di formazione Easy TestNG.

Annotazioni e listener di TestNG

Cosa imparerai:

Cosa sono le annotazioni TestNG?

Questi sono il programma o la logica aziendale utilizzati per controllare il flusso dei metodi. Svolgono un ruolo molto importante in TestNG. Queste annotazioni differiscono in ogni progetto secondo i requisiti. Il flusso di annotazioni rimane lo stesso in ogni programma nonostante i diversi requisiti.

Esistono diversi tipi di annotazioni TestNG che rendono TestNG più semplice e migliore di JUnit. Ciascuna di queste annotazioni verrà eseguita in un evento specifico in TestNG.

Tipi di annotazioni in TestNG

Di seguito sono riportati gli elenchi di annotazioni e dei relativi attributi utilizzati in TestNG. Esploriamoli e i loro usi in dettaglio.

Prima

  • @BeforeSuite: Questo metodo verrà eseguito prima di eseguire tutti i test nella suite.
  • @BeforeTest: Questo metodo verrà eseguito prima che ogni sezione di test venga dichiarata nella suite.
  • @Prima della lezione: Questo metodo verrà eseguito prima del primo metodo di test nella classe corrente.
  • @BeforeMethod: Questo metodo verrà eseguito prima di ogni metodo di prova.
  • @BeforeGroups: Questo metodo verrà eseguito prima che venga menzionato qualsiasi metodo di test del gruppo specificato.
  • @Test : Contrassegna una classe o un metodo come parte del test. Oppure possiamo dire che fa un metodo come metodo di prova.

Dopo

  • @AfterSuite: Questo metodo verrà eseguito dopo che tutti i test nella suite saranno stati eseguiti.
  • @AfterTest: Questo metodo verrà eseguito dopo che ogni sezione di test è stata dichiarata nella suite.
  • @Dopo la lezione: Questo metodo verrà eseguito dopo l'ultimo metodo di test della classe.
  • @AfterMethod: Questo metodo verrà eseguito dopo l'esecuzione di ogni metodo di prova.
  • @AfterGroups: Questo metodo verrà eseguito dopo l'esecuzione dell'ultimo metodo di test del gruppo specificato.

Flusso di lavoro delle annotazioni

Quando eseguiamo il file TestNG.xml, le annotazioni TestNG verranno eseguite nella seguente sequenza:

Before Suite-> Before Test-> Before Class-> Before Method-> @Test -> After Method-> After Class-> After Test-> After Suite

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

@Test ha molti altri attributi che ci aiutano a eseguire i nostri casi di test in modo più efficace.

Di seguito sono riportati i tipi di attributi e le loro descrizioni con esempi.

# 1) alwaysRun: Se impostato su true, questo metodo verrà eseguito anche se dipende da un metodo che non è riuscito.

Esempio: Test (alwaysRun = true)

# 2) dataProvider : Mostra il nome del fornitore di dati per questo metodo. Ha solo attributi, ad esempio nome. Possiamo usarlo quando testiamo il nostro software con più set di dati in fase di input o run time. Questo è anche noto come test basato sui dati. Possiamo eseguire test basati sui dati utilizzando questo attributo.

Esempio: @dataProvider (name = 'TestData')

# 3) dataProviderClass : Questo attributo ti consentirà di specificare la classe del fornitore di dati che conterrà il fornitore di dati che verrà utilizzato dal metodo @Test.

Esempio: @Test (dataProvider = 'Client Data Test', dataProviderClass = ClientDetailsTest.class)

# 4) dipende da gruppi : Questo attributo dipende dall'elenco dei gruppi, ovvero il metodo di test inizierà l'esecuzione solo dopo che i gruppi dipendenti sono stati eseguiti.

Nota : Se uno qualsiasi dei test nei gruppi che dipendono da fallisce, salterà quel test.

Di seguito è riportato l'esempio:

@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 : Questa annotazione dipende dall'elenco dei metodi. Ciò significa che il metodo di test inizierà l'esecuzione solo dopo l'esecuzione dei metodi dipendenti.

Nota : Se uno qualsiasi dei test nei metodi dipendenti non riesce, salterà quel test.

Esempio:

@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: Possiamo impostare gli attributi su un metodo di test su true e questo forzerà l'esecuzione del test anche se alcuni dei test nel gruppo dipendono dal fallimento.

Per esempio:

@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) descrizione : Fornisce la descrizione del metodo. Generalmente, contiene un riepilogo di una riga.

Esempio:

@Test(description = “Regression Test Summary”)

# 8) abilitato : Questo attributo aiuta a specificare se si desidera eseguire / eseguire il particolare metodo di test nella suite / classe corrente o meno. A volte non vogliamo eseguire alcuni test a causa di alcuni motivi come il requisito / la funzione cambia frequentemente e non vogliamo disturbare l'esecuzione corrente per quella particolare funzione.

In questi casi, possiamo semplicemente ignorare / disabilitare quel particolare test impostando questa funzione come @Test (enabled = false).

Esempio:

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

# 9) eccezioni previste : Questo attributo mostra l'elenco delle eccezioni che il metodo di test genererà durante il runtime. Se non vengono generate eccezioni o altre eccezioni per il metodo, il test viene contrassegnato come errore.

Esempio:

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

# 10) gruppi : Questo attributo viene utilizzato per specificare i gruppi a cui appartiene il metodo di prova.

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

# 11) priorità : Questo aiuta a dare la priorità ai metodi di test, mentre la priorità predefinita inizia con 0 ei test vengono eseguiti in ordine crescente.

Esempio:

@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”); }

Risultati: Di seguito sono riportati i risultati in base alla priorità, anche se al primo test non è stato assegnato alcun numero, ha preso la priorità di default come 0 e l'esecuzione è stata eseguita in ordine crescente.

Superato: launchApp
Superato: loginApp
Superato: checkTrans

# 12) timeout : Questo attributo aiuta a specificare un valore di timeout per il test (generalmente utilizzato come millisecondi). Se il test richiede più del valore di timeout specificato, il test viene contrassegnato come non riuscito. Possiamo utilizzare questo timeout per eseguire un test delle prestazioni, per assicurarci che il metodo venga restituito entro un tempo ragionevole.

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

# 13) invocationCount : Questo attributo aiuta a determinare il numero di volte in cui un metodo di prova deve essere invocato.

@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();

Produzione:

Il titolo della pagina è Google
Il titolo della pagina è Google
Il titolo della pagina è Google
Il titolo della pagina è Google
Il titolo della pagina è Google

# 14) invocationTimeOut: Questo è il tempo massimo (numero di millisecondi) che questo test dovrebbe impiegare per tutti i conteggi delle chiamate. Questo metodo deve essere utilizzato insieme al metodo di conteggio delle chiamate, altrimenti verrebbe ignorato.

Esempio:

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

L'esempio sopra mostra che questo test richiederà un totale di 4 secondi per essere eseguito e ogni volta che il test viene richiamato / eseguito, ci vorrebbe 1 secondo per essere eseguito.

# 15) @DataProvider : Questo metodo aiuta a fornire i dati per un metodo di prova. Innanzitutto, dobbiamo dichiarare un metodo annotato da @DataProvider e quindi utilizzare questo metodo nel metodo di test richiesto utilizzando l'attributo 'DataProvider' nell'annotazione @Test.

Un fornitore di dati restituisce una matrice di oggetti, in particolare una matrice di oggetti bidimensionale () (). Il primo array rappresenta un set di dati e il secondo array contiene i parametri.

@DataProvider (name = 'Test'): qui, il nome rappresenta il nome del fornitore di dati. Se il nome non viene fornito, il nome del DataProvider verrà impostato automaticamente sul nome del metodo.

Esempio:

@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 : Viene utilizzato per specificare un metodo come factory per fornire oggetti che devono essere utilizzati da TestNG per le sue classi di test. Usando @Factory, possiamo creare test dinamici in fase di esecuzione e dovrebbe restituire un oggetto array.

Esempio:

Facciamo un esempio per capirlo meglio. Creeremo due classi, ovvero FactorySample.Java e 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; } }

Produzione : Google è stato lanciato con successo

Gmail ha effettuato l'accesso con successo

Differenza tra le annotazioni @Factory e @DataProvider

C'è una differenza fondamentale tra le due annotazioni. C'è molta confusione riguardo a queste due annotazioni come dove usarle e perché?

Troviamo le risposte.

@DataProvider: Questa annotazione parametrizzerà il particolare metodo di prova ed eseguirà il test in uno specifico n. volte sulla base dei dati forniti con tale modalità.

Per esempio, se sono presenti due parametri, il metodo di test verrà eseguito due volte. Ad esempio, se vogliamo accedere a un sito con diversi set di nomi utente e password ogni volta, questo è utile in quanto dobbiamo fornire i parametri da testare.

@Fabbrica : Questo eseguirà tutti i metodi di test presenti nel file della classe di test mentre si utilizza un'istanza separata di quella classe. Ciò è utile se vogliamo eseguire la classe di test un numero qualsiasi di volte.

Per esempio , se dobbiamo testare la funzione di accesso di qualsiasi applicazione o sito web e poiché dobbiamo eseguire questo test più volte, è meglio utilizzare @Factory dove possiamo creare più istanze di test ed eseguire i test.

Diamo un'occhiata a questi esempi per conoscere la differenza.

@DataProvider Esempio :

@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); }

Nota : Nel programma sopra abbiamo fornito due dati e il risultato del programma sarebbe:

I nomi sono: Mihir 145632
I nomi sono: Kumar 28242

Ciò mostra che se aumentiamo il numero di dati nel metodo del messaggio, il metodo di stampa verrà eseguito lo stesso numero di volte.

@ Esempio di fabbrica :

TestNG Factory è molto utile quando dobbiamo eseguire più classi di test utilizzando una singola classe di test.

Vediamo un esempio.

Per questo, dobbiamo creare due classi di test con pochi metodi di test al loro interno.

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'); } }

Ora dobbiamo definire il metodo @Factory che restituisce un array di oggetti delle classi sopra definite.

Programma di fabbrica:

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; } }

Produzione:

Metodo di prova Test1
Metodo di prova Test2
SUPERATO: test1
SUPERATO: test2

Listener TestNG con tipi

In termini semplici, gli ascoltatori ascoltano l'evento definito nello script Selenium e si comportano di conseguenza. Lo scopo principale è creare log e personalizzare i report TestNG.

Ci sono molti tipi di listener disponibili in TestNG.

Per esempio , IAnnotationTransformer, IAnnotationTransformer2, IConfigurable, IConfigurationListener, IConfigurationListener2, IExecutionListener, IHookable, IInvokedMethodListener, IInvokedMethodListener2, IMethodInterceptor, IReporter, ISuiteListener

Tuttavia, quando si tratta di test, ne usiamo solo alcuni come discusso di seguito:

# 1) ISuiteListener

Questo è un ascoltatore per suite di test. Consiste di due metodi, ad es. onStart () e onFinish () .

Ogni volta che implementiamo questo listener, garantirà che l'utente finale invocherà i metodi onStart () e onFinish () prima e dopo l'esecuzione di una suite TestNG.

Dettagli del metodo:

void onStart (suite ISuite) : Questo metodo viene richiamato prima dell'avvio di Suite Runner.

void onFinish (suite ISuite) : Questo metodo viene richiamato dopo che Suite Runner ha eseguito tutte le suite di test.

Esempio:

@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

Questo listener funziona proprio come ISuiteListener. Tuttavia, l'unica differenza è che effettua la chiamata prima e dopo il Test e non la Suite. È un listener per l'esecuzione di test e questo listener contiene sette metodi.

(i) onStart () :Questo metodo viene richiamato dopo l'istanza della classe di test e prima che venga chiamato qualsiasi metodo di configurazione.

Esempio:

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

(ii) onFinish () :Questo metodo viene richiamato dopo che tutti i test sono stati eseguiti e tutti i metodi di configurazione sono stati chiamati.

Esempio:

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

(iii) onTestStart () :Questo metodo viene richiamato ogni volta prima che venga richiamato un test. ITestResult è solo parzialmente riempito con i riferimenti a classe, metodo, start millis e status.

Metodo: void onTestStart (risultato ITestResult)

Esempio:

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

(iv) onTestSuccess () :Questo metodo viene richiamato ogni volta che un test ha esito positivo.

Metodo: void onTestSuccess (risultato ITestResult)

Esempio:

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

(v) onTestFailure () :Questo metodo viene richiamato ogni volta che un test fallisce.

Metodo: void onTestFailure (risultato ITestResult)

Esempio:

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

(vi) onTestSkipped () :Questo metodo viene richiamato ogni volta che viene saltato un test.

Metodo: void onTestSkipped (risultato ITestResult)

Esempio:

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

(vii) onTestFailedButWithinSuccessPercentage :Questo metodo viene richiamato ogni volta che un metodo fallisce ma è stato annotato con percentuale di successo e l'errore lo mantiene all'interno della percentuale di successo.

Metodo: void onTestFailedButWithinSuccessPercentage (risultato ITestResult)

Esempio:

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

# 3) IExecutionListener

È un listener che monitora l'inizio e la fine di un'esecuzione di TestNG. Ha due metodi, ad es. onExecutionStart () e onExecutionFinish () .

Il metodo onExecutionStart () viene chiamato prima che TestNG inizi a eseguire le suite e il metodo onExecutionFinish () viene chiamato dopo che TestNG è terminato con l'esecuzione di tutte le suite di test.

Metodo:

void onExecutionStart ()

void onExecutionFinish ()

Esempio:

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

# 4) IInvokedMethodListener

È un listener che viene richiamato prima e dopo che un metodo viene richiamato da TestNG. Questo listener viene richiamato solo per configurazioni e metodi di test. Ha solo due metodi, ovvero afterInvocation e beforeInvocation.

  1. prima dell'invito: Invoca prima di ogni metodo.
  2. afterInvocation: Invoca dopo ogni metodo.

Metodo:

void beforeInvocation (metodo IInvokedMethod, ITestResult testResult)

void afterInvocation (metodo IInvokedMethod, ITestResult testResult)

Esempio:

@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

Questa classe viene utilizzata per modificare l'elenco dei metodi di test che TestNG eseguirà. Utilizzando questo metodo possiamo riordinare l'elenco dei metodi di test.

È applicabile solo a quei metodi che non hanno dipendenze e quei metodi che non dipendono da altri metodi di test verranno passati nei parametri. Questa interfaccia restituirà un elenco di metodi di test che devono essere eseguiti ma in un modo ordinato diverso.

Metodo:

software per copiare dvd su pc

java.util.List intercetta (metodi java.util.List, contesto ITestContext)

Esempio:

@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

Questo viene implementato dai client per generare un report. Questo metodo verrà richiamato una volta che tutta la suite sarà stata eseguita e i parametri forniranno tutti i risultati del test verificatosi durante tale esecuzione.

Metodo:

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

Esempio:

@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(); }

Conclusione

In questo articolo, abbiamo visto come le annotazioni TestNG possono essere utili per semplificare la logica del nostro programma. Le annotazioni vengono utilizzate secondo necessità.

È possibile passare i parametri alle annotazioni e anche eseguire test basati sui dati. Puoi eseguire i test case in gruppi e risparmiare tempo. Con i listener puoi persino generare i rapporti. Non pensi che sia meraviglioso?

TestNG.xml sarà spiegato in dettaglio nel nostro prossimo tutorial. Questo file XML è la spina dorsale del framework TestNG e ci aiuterà nell'esecuzione dei nostri casi di test.

=> Dai un'occhiata alla guida di formazione Perfect TestNG qui.

Lettura consigliata

^