TestNG Tutorial: cosa sono le annotazioni e il framework Selenium

Che cos'è la TestNG?

TestNG è un framework di test di automazione in cui NG sta per "Next Generation". TestNG è ispirato da JUnit che utilizza le annotazioni (@). TestNG supera gli svantaggi di JUnit ed è progettato per realizzare test end-to-end Easy.

utilizzando TestNG, puoi generare un report adeguato e puoi facilmente sapere quanti casi di test sono stati superati, falliti e saltati. È possibile eseguire separatamente i casi di test falliti.

Per esempio:

Supponiamo di avere cinque casi di test, un metodo è scritto per ogni caso di test (si supponga che il programma sia scritto usando il metodo principale senza usare testNG). Quando si esegue questo programma per primo, tre metodi vengono eseguiti con successo e il quarto metodo fallisce. Quindi si correggono gli errori presenti nel quarto metodo, ora si desidera eseguire solo il quarto metodo perché i primi tre metodi vengono comunque eseguiti con successo. Ciò non è possibile senza usare TestNG.
TestNG in Selenium fornisce un'opzione, ovvero il file testng-failed.xml nella cartella test-output. Se vuoi eseguire solo casi di test falliti 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 un file di suite di test ed eseguirle tramite Eclipse e dalla riga di comando.

Perché usare TestNG con Selenium?

Predefinito Selenium i test non generano un formato corretto per i risultati del test. Utilizzando TestNG in Selenium, possiamo generare i risultati dei test.

ponte Selenium gli utenti lo usano più di giunzione a causa dei suoi vantaggi. Ci sono così tante caratteristiche di TestNG, ma ci concentreremo solo su quelli più importanti che possiamo utilizzare SeleniumDi seguito sono riportate le caratteristiche principali di Selenium TestNG:

Generare il report in un formato appropriato includendo il numero di esecuzioni di casi di test, il numero di casi di test superati, il numero di casi di test falliti e il numero di casi di test saltati.
Più casi di test possono essere raggruppati più facilmente convertendoli nel file testng.xml. In cui puoi stabilire le priorità su quale caso di test deve essere eseguito per primo.
Lo stesso caso di test può essere eseguito più volte senza cicli semplicemente utilizzando la parola chiave chiamata "conteggio invocazioni".
Usando testng, puoi eseguire più casi di test su più browser, ad esempio cross test del browser.
TestNG framework può essere facilmente integrato con strumenti come TestNG Maven, Jenkins, ecc.
Le annotazioni utilizzate nei test sono molto facili da comprendere, 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 main statico nei nostri test. La sequenza delle 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 interrompere anticipatamente la prova. Queste eccezioni vengono segnalate come passaggi non riusciti nel report.

Vantaggi di TestNG ancora JUnit

Ci sono tre principali vantaggi di TestNG ancora JUnit:

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

Che cos'è l'annotazione TestNG?

Annotazioni in TestNG sono righe di codice che possono controllare come verrà eseguito il metodo sottostante. Sono sempre preceduti dal simbolo @. Molto presto e veloce TestNG L'esempio è quello mostrato di seguito.

Le annotazioni saranno discusse più avanti nella sezione denominata “Annotazioni utilizzate in TestNG", quindi è perfettamente ok se non capisci quanto sopra TestNG Esempio per ora. È solo importante notare per ora che le annotazioni in TestNG sono più facili da codificare e comprendere che in JUnit.

La possibilità di eseguire test in parallelo è disponibile in TestNG ma non in JUnit, Quindi la TestNG framework è più preferito per i tester che utilizzano Selenium Griglia.

Come scrivere casi di test in TestNG?

Passo 1) Scrivi la logica del tuo business e inserisci il file TestNG annotazioni nel codice.
Passo 2) Aggiungi ulteriori informazioni come nome della classe, nome del gruppo, nome del pacchetto, ecc
Passo 3) Corri il TestNG.

Crea caso di test utilizzando TestNG Annotazioni

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

Prima di creare un caso di test, dovremmo prima impostarne uno nuovo TestNG Proietta dentro Eclipse e chiamarlo "Primo".TestNGProgetto".

Impostare un nuovo TestNG Progetto

Passo 1: Fare clic su File > Nuovo > Java Progetto

Passo 2: Digita "Primo".TestNGProject" come nome del progetto, quindi fare clic su Avanti.

Passo 3: Inizieremo ora a importare il file TestNG Biblioteche sul nostro progetto. Fare clic sulla scheda “Librerie”, quindi su “Aggiungi libreria…”

Passo 4: Nella finestra di dialogo Aggiungi libreria, seleziona "TestNG" e fare clic su Avanti.

Passo 5: Fai clic su Fine.

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

Passo 6: Aggiungeremo ora i file JAR che contengono il file Selenium API. Questi file si trovano in Java driver client da cui abbiamo scaricato https://www.selenium.dev/downloads/ durante l'installazione Selenium e dell' Eclipse nei capitoli precedenti.

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

Dopo aver aggiunto i JAR esterni, il tuo schermo dovrebbe assomigliare a questo.

Passo 7: Fare clic su Fine e verificare che il nostro PrimoTestNGIl progetto è visibile su Eclipsela finestra Esplora pacchetti di.

Come crearne uno nuovo TestNG File di prova

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

Passo 1: Fare clic su "src" e scegliere altro.
Fare clic con il tasto destro sulla cartella del pacchetto "src", quindi scegliere Nuovo > Altro...

Passo 2: Seleziona TestNG classe.
Clicca sul TestNG cartella e seleziona "TestNG opzione “classe”. Fare clic su Avanti.

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

Passo 4: Modello creato.
Eclipse dovrebbe creare automaticamente il modello per il nostro TestNG file mostrato di seguito.

Codificazione del nostro primo TestNG Esempio di caso di prova

Creiamo ora il nostro primo Test Case questo controllerà se Mercury La home page di Tours è corretta. Digita il tuo codice come mostrato di seguito TestNG Esempio:

package 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";
    public WebDriver driver ; 
     
  @Test
  public void verifyHomepageTitle() {
       
      System.out.println("launching firefox browser"); 
      System.setProperty("webdriver.gecko.driver", driverPath);
      driver = new FirefoxDriver();
      driver.get(baseUrl);
      String expectedTitle = "Welcome: Mercury Tours";
      String actualTitle = driver.getTitle();
      Assert.assertEquals(actualTitle, expectedTitle);
      driver.close();
  }
}

Si noti quanto segue.

TestNG non richiede la presenza di un metodo main().
I metodi non devono essere statici.
Abbiamo utilizzato l'annotazione @Test. @Test viene utilizzato per indicare che il metodo sottostante è un caso di test. In questo caso, abbiamo impostato il metodo verifyHomepageTitle() come nostro caso di test, quindi abbiamo inserito un'annotazione '@Test' sopra di esso.
Poiché utilizziamo le annotazioni in TestNG, abbiamo dovuto importare il pacchetto org.testng.annotations.*.
Abbiamo utilizzato 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 uno solo TestNG file. Questo sarà affrontato più in dettaglio più avanti nella sezione "Annotazioni utilizzate in TestNG. "

Esecuzione del test

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

Controllo dei report creati da TestNG

La finestra della console in Eclipse fornisce un rapporto testuale dei risultati del nostro caso di test mentre il TestNG La finestra dei risultati ce ne fornisce una grafica.

Generazione di report HTML

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

Passo 1: Dopo aver eseguito il nostro primoTestNGFile che abbiamo creato nella sezione precedente, fare clic con il pulsante destro del mouse sul nome del progetto (FirstTestNGProgetto) nella finestra Esplora progetto, quindi fare clic sull'opzione "Aggiorna".

Passo 2: Si noti che è stata creata una cartella "test-output". Espandilo e cerca un file index.html. Questo file HTML è un report dei risultati dell'esecuzione del test più recente.

Passo 3: Double-fai clic sul file index.html per aprirlo all'interno Eclipseil browser web integrato. Puoi aggiornare questa pagina in qualsiasi momento dopo aver eseguito nuovamente il test semplicemente premendo F5 proprio come nei normali browser web.

Annotazioni utilizzate in TestNG

Nella sezione precedente ti è stata presentata l'annotazione @Test. Ora studieremo le annotazioni più avanzate e il loro utilizzo.

Casi di test multipli

Possiamo utilizzare più annotazioni @Test in una singola TestNG file. 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 in ordine alfabetico 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 che tu assegni loro un valore. Puoi farlo posizionando un "=" accanto a loro, quindi seguito dal valore.
I parametri sono racchiusi tra una coppia di parentesi 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 a quello più grande. Non è necessario che i valori di priorità siano consecutivi.

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

Parametri multipli

Oltre a "priorità", @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 quello mostrato di seguito.

@Test(priority = 0, alwaysRun = true)

@BeforeTest e @AfterTest

@Prima del test	verranno eseguiti i metodi sotto questa annotazione prima del primo caso di prova nel TestNG filetto.
@DopoTest	verranno eseguiti i metodi sotto questa annotazione dopo tutti i casi di test in TestNG vengono eseguiti.

Considera il codice qui sotto.

package 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";
    public WebDriver driver ; 
     
     @BeforeTest
      public void launchBrowser() {
          System.out.println("launching firefox browser"); 
          System.setProperty("webdriver.gecko.driver", driverPath);
          driver = new FirefoxDriver();
          driver.get(baseUrl);
      }
      @Test
      public void verifyHomepageTitle() {
          String expectedTitle = "Welcome: Mercury Tours";
          String actualTitle = driver.getTitle();
          Assert.assertEquals(actualTitle, expectedTitle);
     }
      @AfterTest
      public 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^st – avviaBrowser()
2^nd – verificareHomepageTitolo()
3^rd – terminaBrowser()

Il posizionamento dei blocchi di annotazione può essere scambiato senza influenzare l'ordine cronologico in cui verranno eseguiti. Capiamo con a TestNG Esempio e prova a riorganizzare i blocchi di annotazione in modo tale che il tuo codice sia simile a quello seguente.

package 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";
    public WebDriver driver ; 
     @AfterTest                            //Jumbled
      public void terminateBrowser(){
          driver.close();
      }
     @BeforeTest                            //Jumbled
      public void launchBrowser() {
          System.out.println("launching firefox browser"); 
          System.setProperty("webdriver.gecko.driver", driverPath);
          driver = new FirefoxDriver();
          driver.get(baseUrl);
      }
      @Test                                //Jumbled
      public void verifyHomepageTitle() {
          String expectedTitle = "Welcome: Mercury Tours";
          String actualTitle = driver.getTitle();
          Assert.assertEquals(actualTitle, expectedTitle);
     }
      
}

Esegui il codice sopra e notalo

@BeforeMethod e @AfterMethod

@PrimaMetodo	verranno eseguiti i metodi sotto questa annotazione prima di ciascun metodo in ciascun caso di test.
@DopoMetodo	verranno eseguiti i metodi sotto questa annotazione dopo ciascun metodo in ciascun caso di test.

In Mercury Tour, 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 verificane il titolo.
Fai clic su REGISTRATI e verifica il titolo della pagina di destinazione.
Torna alla homepage e verifica se ha ancora il titolo corretto.
Fai clic su SUPPORTO e verifica il titolo della pagina di destinazione.
Torna alla homepage 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 sopra menzionato.

package firsttestngpackage;
import org.openqa.selenium.*;
import org.openqa.selenium.firefox.FirefoxDriver;
import org.testng.Assert;
import org.testng.annotations.*;
@Test
public class firsttestngfile {
    public String baseUrl = "http://demo.guru99.com/test/newtours/";
    String driverPath = "C:\\geckodriver.exe";
    public WebDriver driver; 
    public String expected = null;
    public String actual = null;
        @BeforeTest
      public void launchBrowser() {
          System.out.println("launching firefox browser"); 
          System.setProperty("webdriver.gecko.driver", driverPath);
          driver= new FirefoxDriver();
          driver.get(baseUrl);
      }
      
      @BeforeMethod
      public void verifyHomepageTitle() {
          String expectedTitle = "Welcome: Mercury Tours";
          String actualTitle = driver.getTitle();
          Assert.assertEquals(actualTitle, expectedTitle);
      }
          @Test(priority = 0)
      public void register(){
          driver.findElement(By.linkText("REGISTER")).click() ;
          expected = "Register: Mercury Tours";
          actual = driver.getTitle();
          Assert.assertEquals(actual, expected);
      }
          @Test(priority = 1)
      public void support() {
            driver.findElement(By.linkText("SUPPORT")).click() ;
            expected = "Under Construction: Mercury Tours";
            actual = driver.getTitle();
            Assert.assertEquals(actual, expected);
      }
      @AfterMethod
      public void goBackToHomepage ( ) {
            driver.findElement(By.linkText("Home")).click() ;
      }
       
      @AfterTest
      public void terminateBrowser(){
          driver.close();
      }
}

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

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

Riepilogo delle TestNG Annotazioni

@Prima Suite: il metodo annotato verrà eseguito prima dell'esecuzione di tutti i test in questa suite.

@Aftersuite: il metodo annotato verrà eseguito dopo l'esecuzione di tutti i test in questa suite.

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

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

@PrimaGruppi: l'elenco dei gruppi che verranno eseguiti prima da questo metodo di configurazione. L'esecuzione di questo metodo è garantita poco prima che venga richiamato il primo metodo di test che appartiene a uno di questi gruppi.

@DopoGruppi: l'elenco dei gruppi dopo i quali verrà eseguito questo metodo di configurazione. L'esecuzione di questo metodo è garantita subito dopo il richiamo dell'ultimo metodo di test che appartiene a uno di questi gruppi.

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

@Dopo la lezione: il metodo annotato verrà eseguito dopo che sono stati eseguiti tutti i metodi di test nella classe corrente.

@PrimaMetodo: Il metodo annotato verrà eseguito prima di ciascun metodo di test.

@DopoMetodo: il metodo annotato verrà eseguito dopo ciascun metodo di test.

@Test: Il metodo annotato fa parte di un caso di test

Conclusione

TestNG è un analisi quadro che è in grado di creare Selenium test più facili da comprendere e di generare report di facile comprensione.
I principali vantaggi di TestNG ancora JUnit sono i seguenti.
- Le annotazioni sono più facili da usare e comprendere.
- I casi di test possono essere raggruppati più facilmente.
- TestNG ci permette di creare prove parallele.
La finestra della console in Eclipse genera un risultato basato su testo mentre il TestNG window è più utile perché ci fornisce un output grafico del risultato del test più altri dettagli significativi come:
- Tempi di esecuzione di ciascun metodo.
- L'ordine cronologico in base al quale i metodi sono stati eseguiti
TestNG è in grado di generare report basati su HTML.
Le annotazioni possono utilizzare parametri proprio come al solito Java TestNG metodi.
TestNG Il provider di dati è un modo per passare parametri alla funzione di test che trasmette valori diversi nei casi di test in un'unica esecuzione.

Potrebbe piacerti: