Tutorial TestNG: cos'è, annotazioni e Quadro in Selenio

Cos'è TestNG?

TestNG è un framework di test di automazione in cui NG sta per "Next Generation". TestNG si ispira a JUnit che utilizza le annotazioni (@). TestNG supera gli svantaggi di JUnit ed è progettato per semplificare i test end-to-end.

Utilizzando TestNG, puoi generare un report appropriato e puoi facilmente sapere quanti casi di test sono stati superati, falliti e ignorati. È possibile eseguire separatamente i casi di test non riusciti.

Per esempio:

• Supponiamo di avere cinque casi di test, un metodo viene scritto per ogni caso di test (supponiamo che il programma sia scritto utilizzando il metodo principale senza utilizzare testNG). Quando si esegue per primo questo programma, tre metodi vengono eseguiti correttamente e il quarto metodo non è riuscito. Quindi correggi gli errori presenti nel quarto metodo, ora vuoi eseguire solo il quarto metodo perché i primi tre metodi vengono comunque eseguiti con successo. Ciò non è possibile senza utilizzare TestNG.
• Il TestNG in Selenium fornisce un'opzione, cioè il file testng-failed.xml nella cartella test-output. Se desideri eseguire solo casi di test non riusciti, significa che esegui questo file XML. Eseguirà solo casi di test falliti.

Oltre al concetto di cui sopra, imparerai di più su TestNG, come quali sono i vantaggi di TestNG, come creare metodi di test utilizzando le annotazioni @test, come convertire queste classi in file di suite di test ed eseguirle tramite eclipse e dalla riga di comando .

In questo tutorial di TestNG imparerai

• Perché usare TestNG con selenio?
• Vantaggi di TestNG rispetto a JUnit
• Crea scenario di test utilizzando le annotazioni TestNG
• Come creare un nuovo file di test TestNG
• Codifica del nostro primo esempio di test case TestNG
• Esecuzione del test
• Verifica dei rapporti creati da TestNG
• Annotazioni utilizzate in TestNG
• Casi di test multipli
• Parametri
• Parametri multipli
• Riepilogo delle annotazioni TestNG

Perché usare TestNG con selenio?

I test di selenio predefiniti non generano un formato appropriato per i risultati del test. Usando TestNG in Selenium, possiamo generare i risultati dei test.

La maggior parte degli utenti di selenio lo usa più di Junit per i suoi vantaggi. Ci sono così tante funzionalità di TestNG, ma ci concentreremo solo su quelle più importanti che possiamo usare in Selenium. Di seguito sono riportate le caratteristiche principali di Selenium TestNG:

• Genera il report in un formato appropriato, includendo un numero di esecuzioni di test case, il numero di test case superati, il numero di test case non riusciti e il numero di test case ignorati.
• Più casi di test possono essere raggruppati più facilmente convertendoli nel file testng.xml. In cui puoi stabilire le priorità quale test case dovrebbe essere eseguito per primo.
• Lo stesso test case può essere eseguito più volte senza loop semplicemente utilizzando la parola chiave chiamata "conteggio chiamate".
• Utilizzando testng, è possibile eseguire più casi di test su più browser, ovvero test su più browser.
• Il framework TestNG può essere facilmente integrato con strumenti come TestNG Maven, Jenkins, ecc.
• Le annotazioni utilizzate nei test sono molto facili da capire, ad esempio: @BeforeMethod, @AfterMethod, @BeforeTest, @AfterTest
• WebDriver non dispone di un meccanismo nativo per la generazione di report. TestNG può generare il report in un formato leggibile come quello mostrato di seguito.
• TestNG semplifica il modo in cui i test sono codificati. Non è più necessario un metodo principale statico nei nostri test. La sequenza di azioni è regolata da annotazioni di facile comprensione che non richiedono che i metodi siano statici.
• Le eccezioni non rilevate vengono gestite automaticamente da TestNG senza terminare prematuramente il test. Queste eccezioni vengono segnalate come passaggi non riusciti nel rapporto.

Vantaggi di TestNG rispetto a JUnit

Ci sono tre principali vantaggi di TestNG rispetto a JUnit:

• Le annotazioni sono più facili da capire
• I casi di test possono essere raggruppati più facilmente
• È possibile eseguire test paralleli

Le annotazioni in TestNG sono righe di codice che possono controllare come verrà eseguito il metodo sottostante . Sono sempre preceduti dal simbolo @. Un esempio di TestNG molto precoce e veloce è quello mostrato di seguito.

Le annotazioni verranno discusse più avanti nella sezione denominata "Annotazioni usate in TestNG", quindi è perfettamente corretto se non si comprende ancora l'esempio di TestNG sopra. È solo importante notare per ora che le annotazioni in TestNG sono più facili da codificare e comprendere rispetto a JUnit.

La possibilità di eseguire test in parallelo è disponibile in TestNG ma non in JUnit, quindi il framework TestNG è più preferito dei tester che utilizzano Selenium Grid.

Crea scenario di test utilizzando le annotazioni TestNG

Ora impareremo come creare il nostro primo caso di test utilizzando le annotazioni TestNG in Selenium:

Prima di creare un test case, dobbiamo prima impostare un nuovo progetto TestNG in Eclipse e chiamarlo "FirstTestNGProject".

Impostazione di un nuovo progetto TestNG

Passaggio 1: fare clic su File> Nuovo> Progetto Java

Passaggio 2: digitare "FirstTestNGProject" come nome del progetto, quindi fare clic su Avanti.

Passaggio 3: ora inizieremo a importare le librerie TestNG nel nostro progetto. Fare clic sulla scheda "Librerie", quindi su "Aggiungi libreria

... "

Passaggio 4: nella finestra di dialogo Aggiungi libreria, selezionare "TestNG" e fare clic su Avanti.

Passaggio 5: fare clic su Fine.

Dovresti notare che TestNG è incluso nell'elenco delle librerie.

Passaggio 6: ora aggiungeremo i file JAR che contengono l'API Selenium. Questi file si trovano nel driver client Java che abbiamo scaricato da http://docs.seleniumhq.org/download/ quando stavamo installando Selenium ed Eclipse nei capitoli precedenti.

Quindi, vai al punto in cui hai posizionato i file JAR Selenium.

Dopo aver aggiunto i JAR esterni, lo schermo dovrebbe apparire così.

Passaggio 7: fare clic su Fine e verificare che il nostro FirstTestNGProject sia visibile nella finestra Package Explorer di Eclipse.

Come creare un nuovo file di test TestNG

Ora che abbiamo finito di impostare il nostro progetto in questo tutorial TestNG, creiamo un nuovo file TestNG.

Passaggio 1: fare clic con il pulsante destro del mouse sulla cartella del pacchetto "src", quindi scegliere Nuovo> Altro

...

Passaggio 2: fare clic sulla cartella TestNG e selezionare l'opzione "Classe TestNG". Fare clic su Avanti.

Passaggio 3: digitare i valori indicati di seguito nelle caselle di input appropriate e fare clic su Fine. Notare che abbiamo denominato il nostro file Java come "FirstTestNGFile".

Eclipse dovrebbe creare automaticamente il modello per il nostro file TestNG mostrato di seguito.

Codifica del nostro primo esempio di test case TestNG

Creiamo ora il nostro primo caso di test che controllerà se la home page di Mercury Tours è corretta. Digita il tuo codice come mostrato nell'esempio TestNG di seguito:

pacchetto firsttestngpackage;import org.openqa.selenium. *;import org.openqa.selenium.firefox.FirefoxDriver;import org.testng.Assert;import org.testng.annotations. *;public class firsttestngfile {public String baseUrl = "http://demo.guru99.com/test/newtours/";String driverPath = "C: \\ geckodriver.exe";driver WebDriver pubblico;@Testpublic void verifyHomepageTitle () {System.out.println ("avvio del browser Firefox");System.setProperty ("webdriver.gecko.driver", driverPath);driver = nuovo FirefoxDriver ();driver.get (baseUrl);String expectedTitle = "Benvenuto: Mercury Tours";String actualTitle = driver.getTitle ();Assert.assertEquals (actualTitle, expectedTitle);driver.close ();}}

Notare quanto segue.

• TestNG non richiede di avere un metodo main ().
• I metodi non devono essere statici.
• Abbiamo usato l'annotazione @Test. @Test è usato per dire che il metodo sotto di esso è un caso di prova . In questo caso, abbiamo impostato il metodo verifyHomepageTitle () come nostro test case, quindi abbiamo inserito un'annotazione '@Test' sopra di esso.
• Dato che usiamo le annotazioni in TestNG, dovevamo importare il pacchetto org.testng.annotations. *.
• Abbiamo usato la classe Assert. La classe Assert viene utilizzata per condurre operazioni di verifica in TestNG . Per usarlo, dobbiamo importare il pacchetto org.testng.Assert.

Potresti avere più casi di test (quindi, più annotazioni @Test) in un singolo file TestNG. Questo verrà affrontato in modo più dettagliato più avanti nella sezione "Annotazioni utilizzate in TestNG".

Esecuzione del test

Per eseguire il test, esegui semplicemente il file in Eclipse come fai normalmente. Eclipse fornirà due output: uno nella finestra della console e l'altro nella finestra dei risultati di TestNG.

Verifica dei rapporti creati da TestNG

La finestra Console in Eclipse fornisce un rapporto basato su testo dei risultati del nostro caso di test mentre la finestra Risultati TestNG ce ne fornisce uno grafico.

Generazione di report HTML

TestNG ha la capacità di generare report in formato HTML.

Passaggio 1: dopo aver eseguito il nostro FirstTestNGFile che abbiamo creato nella sezione precedente, fare clic con il pulsante destro del mouse sul nome del progetto (FirstTestNGProject) nella finestra Esplora progetti, quindi fare clic sull'opzione "Aggiorna".

Passaggio 2: notare che è stata creata una cartella "test-output". Espandilo e cerca un file index.html. Questo file HTML è un report dei risultati dell'ultimo test eseguito.

Passaggio 3: fare doppio clic su quel file index.html per aprirlo nel browser Web integrato di Eclipse. Puoi aggiornare questa pagina in qualsiasi momento dopo aver rieseguito il test semplicemente premendo F5 come nei normali browser web.

Annotazioni utilizzate in TestNG

Nella sezione precedente, sei stato introdotto all'annotazione @Test. Ora studieremo annotazioni più avanzate e il loro utilizzo.

Casi di test multipli

Possiamo usare più annotazioni @Test in un singolo file TestNG. Per impostazione predefinita, i metodi annotati da @Test vengono eseguiti in ordine alfabetico. Vedi il codice qui sotto. Sebbene i metodi c_test, a_test e b_test non siano disposti alfabeticamente nel codice, verranno eseguiti come tali.

Esegui questo codice e nella pagina index.html generata, fai clic su "Visualizzazione cronologica".

Parametri

Se si desidera che i metodi vengano eseguiti in un ordine diverso, utilizzare il parametro "priorità". I parametri sono parole chiave che modificano la funzione dell'annotazione .

• I parametri richiedono di assegnare loro un valore. Puoi farlo inserendo un accanto a loro e quindi seguito dal valore.
• I parametri sono racchiusi tra una coppia di parentesi che vengono posizionate subito dopo l'annotazione come lo snippet di codice mostrato di seguito.

TestNG eseguirà l'annotazione @Test con il valore di priorità più basso fino al più grande. Non è necessario che i valori di priorità siano consecutivi.

Il report HTML di TestNG confermerà che i metodi sono stati eseguiti in base al valore di priorità crescente.

Parametri multipli

Oltre a "priority", @Test ha un altro parametro chiamato "alwaysRun" che può essere impostato solo su "true" o "false". Per utilizzare due o più parametri in una singola annotazione, separarli con una virgola come quella mostrata di seguito.

@Test (priorità = 0, alwaysRun = true)

@BeforeTest e @AfterTest

@BeforeTest	i metodi sotto questa annotazione verranno eseguiti prima del primo caso di test nel file TestNG .
@AfterTest	i metodi sotto questa annotazione verranno eseguiti dopo che tutti i casi di test nel file TestNG saranno stati eseguiti .

Considera il codice di seguito.

pacchetto firsttestngpackage;import org.openqa.selenium. *;import org.openqa.selenium.firefox.FirefoxDriver;import org.testng.Assert;import org.testng.annotations. *;public class firsttestngfile {public String baseUrl = "http://demo.guru99.com/test/newtours/";String driverPath = "C: \\ geckodriver.exe";driver WebDriver pubblico;@BeforeTestpublic void launchBrowser () {System.out.println ("avvio del browser Firefox");System.setProperty ("webdriver.gecko.driver", driverPath);driver = nuovo FirefoxDriver ();driver.get (baseUrl);}@Testpublic void verifyHomepageTitle () {String expectedTitle = "Benvenuto: Mercury Tours";String actualTitle = driver.getTitle ();Assert.assertEquals (actualTitle, expectedTitle);}@AfterTestpublic void terminateBrowser () {driver.close ();}}

Applicando la logica presentata dalla tabella e dal codice sopra, possiamo prevedere che la sequenza con cui verranno eseguiti i metodi è:

• 1 ^° - launchBrowser ()
• 2 ^° - verificaHomepageTitle ()
• 3 ^° - terminateBrowser ()

Il posizionamento dei blocchi di annotazione può essere scambiato senza influire sull'ordine cronologico in base al quale verranno eseguiti . Comprendiamo con un esempio TestNG e proviamo a riorganizzare i blocchi di annotazione in modo che il tuo codice sia simile a quello qui sotto.

pacchetto firsttestngpackage;import org.openqa.selenium. *;import org.openqa.selenium.firefox.FirefoxDriver;import org.testng.Assert;import org.testng.annotations. *;public class firsttestngfile {public String baseUrl = "http://demo.guru99.com/test/newtours/";String driverPath = "C: \\ geckodriver.exe";driver WebDriver pubblico;@AfterTest // Jumbledpublic void terminateBrowser () {driver.close ();}@BeforeTest // Jumbledpublic void launchBrowser () {System.out.println ("avvio del browser Firefox");System.setProperty ("webdriver.gecko.driver", driverPath);driver = nuovo FirefoxDriver ();driver.get (baseUrl);}@Test // Jumbledpublic void verifyHomepageTitle () {String expectedTitle = "Benvenuto: Mercury Tours";String actualTitle = driver.getTitle ();Assert.assertEquals (actualTitle, expectedTitle);}}

Esegui il codice sopra e notalo

@BeforeMethod e @AfterMethod

@BeforeMethod	i metodi sotto questa annotazione verranno eseguiti prima di ogni metodo in ogni caso di test .
@AfterMethod	i metodi sotto questa annotazione verranno eseguiti dopo ogni metodo in ogni caso di test.

In Mercury Tours, supponiamo di voler verificare i titoli delle pagine di destinazione dei due link sottostanti.

Il flusso del nostro test sarebbe:

• Vai alla home page e verifica il titolo.
• Fare clic su REGISTRA e verificare il titolo della pagina di destinazione.
• Torna alla home page e verifica se ha ancora il titolo corretto.
• Fare clic su SUPPORTO e verificare il titolo della pagina di destinazione.
• Torna alla home page e verifica se ha ancora il titolo corretto.

Il codice seguente illustra come vengono utilizzati @BeforeMethod e @AfterMethod per eseguire in modo efficiente lo scenario menzionato in precedenza.

pacchetto firsttestngpackage;import org.openqa.selenium. *;import org.openqa.selenium.firefox.FirefoxDriver;import org.testng.Assert;import org.testng.annotations. *;@Testpublic class firsttestngfile {public String baseUrl = "http://demo.guru99.com/test/newtours/";String driverPath = "C: \\ geckodriver.exe";driver WebDriver pubblico;stringa pubblica prevista = null;public String effettivo = null;@BeforeTestpublic void launchBrowser () {System.out.println ("avvio del browser Firefox");System.setProperty ("webdriver.gecko.driver", driverPath);driver = nuovo FirefoxDriver ();driver.get (baseUrl);}@BeforeMethodpublic void verifyHomepageTitle () {String expectedTitle = "Benvenuto: Mercury Tours";String actualTitle = driver.getTitle ();Assert.assertEquals (actualTitle, expectedTitle);}@Test (priorità = 0)public void register () {driver.findElement (By.linkText ("REGISTER")). click ();previsto = "Registrati: Mercury Tours";effettivo = driver.getTitle ();Assert.assertEquals (effettivo, previsto);}@Test (priorità = 1)public void support () {driver.findElement (By.linkText ("SUPPORT")). click ();previsto = "In costruzione: Mercury Tours";effettivo = driver.getTitle ();Assert.assertEquals (effettivo, previsto);}@AfterMethodpublic void goBackToHomepage () {driver.findElement (By.linkText ("Home")). clic ();}@AfterTestpublic void terminateBrowser () {driver.close ();}}

Dopo aver eseguito questo test, il tuo TestNG dovrebbe riportare la seguente sequenza.

In poche parole, @BeforeMethod dovrebbe contenere metodi che è necessario eseguire prima di ogni caso di test mentre @AfterMethod dovrebbe contenere metodi che è necessario eseguire dopo ogni caso di test.

Riepilogo delle annotazioni TestNG

@BeforeSuite : il metodo annotato verrà eseguito prima che tutti i test in questa suite siano stati eseguiti.

@AfterSuite : il metodo annotato verrà eseguito dopo che tutti i test in questa suite saranno stati eseguiti.

@BeforeTest : il metodo annotato verrà eseguito prima di eseguire qualsiasi metodo di test appartenente alle classi all'interno del tag.

@AfterTest : il metodo annotato verrà eseguito dopo che tutti i metodi di test appartenenti alle classi all'interno del tag sono stati eseguiti.

@BeforeGroups : l'elenco dei gruppi che questo metodo di configurazione eseguirà prima. È garantito che questo metodo venga eseguito poco prima che venga richiamato il primo metodo di prova che appartiene a uno di questi gruppi.

@AfterGroups : l'elenco dei gruppi in base ai quali verrà eseguito questo metodo di configurazione. È garantito che questo metodo venga eseguito subito dopo che è stato richiamato l'ultimo metodo di test che appartiene a uno di questi gruppi.

@BeforeClass : il metodo annotato verrà eseguito prima che venga richiamato il primo metodo di test nella classe corrente.

@AfterClass : il metodo annotato verrà eseguito dopo che tutti i metodi di test nella classe corrente saranno stati eseguiti.

@BeforeMethod : il metodo annotato verrà eseguito prima di ogni metodo di test.

@AfterMethod : il metodo annotato verrà eseguito dopo ogni metodo di test.

@Test : il metodo annotato fa parte di un test case

Conclusione

• TestNG è un framework di test in grado di rendere i test Selenium più facili da capire e di generare report di facile comprensione.
• I principali vantaggi di TestNG rispetto a JUnit sono i seguenti.
  • Le annotazioni sono più facili da usare e da capire.
  • I casi di test possono essere raggruppati più facilmente.
  • TestNG ci permette di creare test paralleli.
• La finestra Console in Eclipse genera un risultato basato su testo mentre la finestra TestNG è più utile perché ci fornisce un output grafico del risultato del test più altri dettagli significativi come:
  • Autonomia di ogni metodo.
  • L'ordine cronologico con cui sono stati eseguiti i metodi
• TestNG è in grado di generare report basati su HTML.
• Le annotazioni possono utilizzare parametri proprio come i normali metodi Java TestNG.
• TestNG Dataprovider è un modo per passare parametri alla funzione di test che passa valori diversi nei casi di test in una singola esecuzione.