TestNG Tutorial

Wat is TestNG?

TestNG is een automatiseringstestframework waarin NG staat voor “Next Generation”. TestNG is geïnspireerd door JUnit waarbij gebruik wordt gemaakt van de annotaties (@). TestNG overwint de nadelen van JUnit en is ontworpen om te maken end-to-end testen gemakkelijk.

gebruik TestNG, kunt u een goed rapport genereren en eenvoudig te weten komen hoeveel testgevallen zijn geslaagd, mislukt en overgeslagen. U kunt de mislukte testgevallen afzonderlijk uitvoeren.

Bijvoorbeeld:

• Stel dat u vijf testcases hebt, er wordt voor elke testcase één methode geschreven (neem aan dat het programma is geschreven met behulp van de hoofdmethode zonder testNG te gebruiken). Wanneer u dit programma eerst uitvoert, worden drie methoden succesvol uitgevoerd en mislukt de vierde methode. Corrigeer vervolgens de fouten die aanwezig zijn in de vierde methode, nu wilt u alleen de vierde methode uitvoeren omdat de eerste drie methoden hoe dan ook succesvol worden uitgevoerd. Dit is niet mogelijk zonder TestNG.
• De Politia Militar hield zelfs tijdens de pre-carnaval festiviteiten de zaken al nauwlettend in de gaten. TestNG in Selenium biedt een optie, d.w.z. testng-failed.xml-bestand in de test-output-map. Als u alleen mislukte testcases wilt uitvoeren, betekent dit dat u dit XML-bestand uitvoert. Het zal alleen mislukte testcases uitvoeren.

Naast het bovenstaande concept leert u er meer over TestNG, zoals wat zijn de voordelen van TestNG, hoe je testmethoden maakt met behulp van @test-annotaties, hoe je deze klassen omzet in een testsuitebestand en hoe je deze uitvoert via Eclipse en vanaf de opdrachtregel.

Waarom gebruiken TestNG with Selenium?

Standaard Selenium tests genereren geen goed formaat voor de testresultaten. Gebruik makend van TestNG in Selenium, kunnen we testresultaten genereren.

De meeste Selenium gebruikers gebruiken dit meer dan Juniet vanwege de voordelen ervan. Er zijn zoveel kenmerken van TestNG, maar we zullen ons alleen concentreren op de belangrijkste die we kunnen gebruiken SeleniumHieronder volgen de belangrijkste kenmerken van Selenium TestNG:

• Genereer het rapport in de juiste indeling, inclusief een aantal uitgevoerde testgevallen, het aantal geslaagde testgevallen, het aantal mislukte testgevallen en het aantal overgeslagen testgevallen.
• Meerdere testcases kunnen eenvoudiger worden gegroepeerd door ze te converteren naar het bestand testng.xml. Hierin kunt u prioriteiten stellen welke testcase als eerste moet worden uitgevoerd.
• Dezelfde testcase kan meerdere keren worden uitgevoerd zonder lussen, gewoon door het trefwoord 'invocation count' te gebruiken.
• Met testng kunt u meerdere testcases op meerdere browsers uitvoeren, bijvoorbeeld cross-sites. browser testen.
• De Politia Militar hield zelfs tijdens de pre-carnaval festiviteiten de zaken al nauwlettend in de gaten. TestNG raamwerk kan eenvoudig worden geïntegreerd met tools zoals TestNG Maven, Jenkins, enz.
• Annotaties die bij het testen worden gebruikt, zijn zeer gemakkelijk te begrijpen, bijvoorbeeld: @BeforeMethod, @AfterMethod, @BeforeTest, @AfterTest
• WebDriver heeft geen eigen mechanisme voor het genereren van rapporten. TestNG kan het rapport genereren in een leesbaar formaat zoals hieronder weergegeven.



• TestNG vereenvoudigt de manier waarop de tests worden gecodeerd. Er is in onze tests geen behoefte meer aan een statische hoofdmethode. De volgorde van acties wordt geregeld door gemakkelijk te begrijpen annotaties, waarbij de methoden niet statisch hoeven te zijn.





• Niet-afgevangen uitzonderingen worden automatisch afgehandeld door TestNG zonder de test voortijdig te beëindigen. Deze uitzonderingen worden in het rapport gerapporteerd als mislukte stappen.

Voordelen TestNG over JUnit

Er zijn drie grote voordelen van TestNG over JUnit:

• Annotaties zijn gemakkelijker te begrijpen
• Testgevallen kunnen gemakkelijker worden gegroepeerd
• Parallel testen is mogelijk

Wat is annotatie in TestNG?

Annotaties erin TestNG zijn coderegels die kunnen bepalen hoe de onderstaande methode wordt uitgevoerd. Ze worden altijd voorafgegaan door het @-symbool. Een hele vroege en snelle TestNG Het voorbeeld is het onderstaande voorbeeld.

Aantekeningen worden later besproken in de sectie met de naam 'Aantekeningen gebruikt in TestNG”,dus het is prima als je het bovenstaande niet begrijpt TestNG Voorbeeld nog even. Het is voorlopig alleen belangrijk om op te merken dat annotaties in TestNG zijn gemakkelijker te coderen en te begrijpen dan in JUnit.

De mogelijkheid om tests parallel uit te voeren is beschikbaar in TestNG maar niet in JUnitmaakt, zodat de TestNG raamwerk heeft meer de voorkeur voor testers die dit gebruiken Selenium Raster.

Hoe u testgevallen schrijft TestNG?

Stap 1) Schrijf uw bedrijfslogica en plaats de TestNG annotaties in uw code.
Stap 2) Voeg meer informatie toe, zoals klassenaam, groepsnaam, pakketnaam, enz
Stap 3) Voer de ... uit TestNG.

Maak een testcase met behulp van TestNG Annotaties

Nu zullen we leren hoe we onze eerste testcase kunnen maken met behulp van TestNG Annotaties erin Selenium:

Voordat we een testcase maken, moeten we eerst een nieuwe opzetten TestNG Projecteren in Eclipse en noem het als 'EersteTestNGProject”.

Een nieuwe opzetten TestNG Project

Stap 1: Klik op Bestand > Nieuw > Java Project

Stap 2: Typ 'EersteTestNGProject” als de projectnaam en klik vervolgens op Volgende.

Stap 3: We zullen nu beginnen met het importeren van de TestNG Bibliotheken op ons project. Klik op het tabblad ‘Bibliotheken’ en vervolgens op ‘Bibliotheek toevoegen…’

Stap 4: In het dialoogvenster Bibliotheek toevoegen kiest u “TestNG” en klik op Volgende.

Stap 5: Klik op Voltooien.

Dat zou je moeten merken TestNG is opgenomen in de lijst met bibliotheken.

Stap 6: We zullen nu de JAR-bestanden toevoegen die de Selenium API. Deze bestanden zijn te vinden in de Java clientstuurprogramma waarvan we hebben gedownload https://www.selenium.dev/downloads/ toen we aan het installeren waren Selenium en Eclipse in de voorgaande hoofdstukken.

Navigeer vervolgens naar de plek waar u de Selenium JAR-bestanden.

Na het toevoegen van de externe JAR's zou uw scherm er als volgt uit moeten zien.

Stap 7: Klik op Voltooien en controleer of onze eersteTestNGProject is zichtbaar op Eclipse's Pakketverkenner-venster.

Hoe maak je een nieuwe TestNG Testbestand

Nu we klaar zijn met het opzetten van ons project hierin TestNG tutorial, laten we een nieuwe maken TestNG bestand.

Stap 1: Klik op 'src' en kies anders.
Klik met de rechtermuisknop op de pakketmap "src" en kies vervolgens Nieuw> Overige...

Stap 2: kies TestNG klasse.
Klik op de TestNG map en selecteer de “TestNG klasse” optie. Klik volgende.

Stap 3: Typ de waarden.
Typ de hieronder aangegeven waarden in de juiste invoervakken en klik op Voltooien. Let op dat we onze Java bestand als “EersteTestNGBestand".

Stap 4: Sjabloon gemaakt.
Eclipse zou automatisch de sjabloon voor onze moeten maken TestNG hieronder weergegeven bestand.

Codering van onze eerste TestNG Voorbeeld van een testcase

Laten we nu onze eerste creëren Testgeval dat zal controleren of Mercury De startpagina van Tours is correct. Typ uw code zoals hieronder weergegeven TestNG Voorbeeld:

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 = "https://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();
  }
}

Let op het volgende.

• TestNG vereist niet dat je een main() -methode hebt.
• Methoden hoeven niet statisch te zijn.
• We hebben de annotatie @Test gebruikt. @Test wordt gebruikt om aan te geven dat de onderliggende methode een testcase is. In dit geval hebben we de methode verificatieHomepageTitle() ingesteld als onze testcase, dus hebben we er een annotatie '@Test' boven geplaatst.
• Omdat we annotaties gebruiken in TestNG, moesten we het pakket org.testng.annotations.* importeren.
• We hebben de Assert-klasse gebruikt. De Assert-klasse wordt gebruikt om verificatiebewerkingen uit te voeren in TestNGOm het te gebruiken, moeten we het org.testng.Assert-pakket importeren.

Mogelijk hebt u meerdere testgevallen (dus meerdere @Test-annotaties) in één TestNG bestand. Dit wordt later in meer detail behandeld in de sectie "Annotaties gebruikt in TestNG. '

De test uitvoeren

Om de test uit te voeren, voert u eenvoudigweg het bestand uit Eclipse zoals u normaal doet. Eclipse zal twee uitgangen bieden – één in het Console-venster en de andere op de TestNG Resultatenvenster.

Rapporten controleren die zijn gemaakt door TestNG

Het consolevenster in Eclipse geeft een op tekst gebaseerd rapport van onze testcaseresultaten terwijl de TestNG Het resultatenvenster geeft ons een grafisch venster.

HTML-rapporten genereren

TestNG heeft de mogelijkheid om rapporten in HTML-formaat te genereren.

Stap 1: Na het uitvoeren van onze FirstTestNGBestand dat we in de vorige sectie hebben gemaakt, klikt u met de rechtermuisknop op de projectnaam (FirstTestNGProject) in het venster Projectverkenner en klik vervolgens op de optie “Vernieuwen”.

Stap 2: Merk op dat er een map "test-output" is gemaakt. Vouw het uit en zoek naar een index.html-bestand. Dit HTML-bestand is een rapport van de resultaten van de meest recente testrun.

Stap 3: Double-klik op dat index.html-bestand om het daarin te openen Eclipse's ingebouwde webbrowser. U kunt deze pagina op elk gewenst moment vernieuwen nadat u uw test opnieuw hebt uitgevoerd door eenvoudigweg op F5 te drukken, net als in gewone webbrowsers.

Annotaties gebruikt in TestNG

In de vorige sectie heeft u kennis gemaakt met de @Test-annotatie. Nu zullen we meer geavanceerde annotaties en hun gebruik bestuderen.

Meerdere testgevallen

We kunnen meerdere @Test-annotaties in één gebruiken TestNG bestand. Standaard worden methoden geannoteerd door @Test alfabetisch uitgevoerd. Zie de onderstaande code. Hoewel de methoden c_test, a_test en b_test niet alfabetisch in de code zijn gerangschikt, worden ze wel als zodanig uitgevoerd.

Voer deze code uit en klik op de gegenereerde index.html-pagina op 'Chronologische weergave'.

Kenmerken

Als u wilt dat de methoden in een andere volgorde worden uitgevoerd, gebruikt u de parameter “prioriteit”. Parameters zijn trefwoorden die de functie van de annotatie wijzigen.

• Voor parameters moet u er een waarde aan toekennen. U doet dit door er een “=” naast te plaatsen, gevolgd door de waarde.
• Parameters staan ​​tussen een paar haakjes die direct na de annotatie worden geplaatst, zoals in het onderstaande codefragment.

TestNG zal de @Test-annotatie uitvoeren met de laagste prioriteitswaarde tot de grootste. Het is niet nodig dat uw prioriteitswaarden opeenvolgend zijn.

De Politia Militar hield zelfs tijdens de pre-carnaval festiviteiten de zaken al nauwlettend in de gaten. TestNG Het HTML-rapport bevestigt dat de methoden zijn uitgevoerd op basis van de oplopende prioriteitswaarde.

Meerdere parameters

Naast ‘prioriteit’ heeft @Test nog een parameter genaamd ‘alwaysRun’ die alleen kan worden ingesteld op ‘true’ of ‘false’. Als u twee of meer parameters in één annotatie wilt gebruiken, scheidt u ze met een komma zoals hieronder weergegeven.

@Test(priority = 0, alwaysRun = true)

@BeforeTest en @AfterTest

@VoorTest	methoden onder deze annotatie worden uitgevoerd voorafgaand aan de eerste testcase in de TestNG filet.
@AfterTest	methoden onder deze annotatie worden uitgevoerd na alle testgevallen in de TestNG bestand worden uitgevoerd.

Beschouw de onderstaande code.

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 = "https://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();
      }
}

Door de logica van de tabel en de bovenstaande code toe te passen, kunnen we voorspellen dat de volgorde waarin methoden zullen worden uitgevoerd:

• 1^st – launchBrowser()
• 2^nd – verifieerHomepageTitel()
• 3^rd – beëindigenBrowser()

De plaatsing van de annotatieblokken kan worden verwisseld zonder de chronologische volgorde waarin ze worden uitgevoerd te beïnvloeden. Laten we het begrijpen met a TestNG Voorbeeld en probeer de annotatieblokken zo te rangschikken dat uw code er ongeveer zo uitziet als hieronder.

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 = "https://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);
     }
      
}

Voer de bovenstaande code uit en merk dat op

@BeforeMethod en @AfterMethod

@Weerplaza	methoden onder deze annotatie worden uitgevoerd voorafgaand aan elke methode in elk testgeval.
@AfterMethode	methoden onder deze annotatie worden uitgevoerd na elke methode in elk testgeval.

In Mercury Tours, stel dat we de titels van de doelpagina's van de twee onderstaande links willen verifiëren.

De stroom van onze test zou zijn:

• Ga naar de startpagina en controleer de titel ervan.
• Klik op REGISTREREN en verifieer de titel van de doelpagina.
• Ga terug naar de startpagina en controleer of deze nog steeds de juiste titel heeft.
• Klik op ONDERSTEUNING en verifieer de titel van de doelpagina.
• Ga terug naar de startpagina en controleer of deze nog steeds de juiste titel heeft.

De onderstaande code illustreert hoe @BeforeMethod en @AfterMethod worden gebruikt om het hierboven genoemde scenario efficiënt uit te voeren.

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 = "https://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();
      }
}

Na het uitvoeren van deze test, zal uw TestNG zou de volgende volgorde moeten rapporteren.

Simpel gezegd: @BeforeMethod moet methoden bevatten die u moet uitvoeren vaardigheden elke testcase, terwijl @AfterMethod methoden moet bevatten die u moet uitvoeren na elke testcase.

Samenvatting TestNG Annotaties

@BeforeSuite: De geannoteerde methode wordt uitgevoerd voordat alle tests in deze suite zijn uitgevoerd.

@AfterSuite: de geannoteerde methode wordt uitgevoerd nadat alle tests in deze suite zijn uitgevoerd.

@VoorTest: De geannoteerde methode wordt uitgevoerd voordat een testmethode die tot de klassen in de tag behoort, wordt uitgevoerd.

@AfterTest: De geannoteerde methode wordt uitgevoerd nadat alle testmethoden die tot de klassen in de tag behoren, zijn uitgevoerd.

@WillemII: De lijst met groepen waarvoor deze configuratiemethode zal worden uitgevoerd. Deze methode wordt gegarandeerd uitgevoerd kort voordat de eerste testmethode die tot een van deze groepen behoort, wordt aangeroepen.

@AfterGroups: De lijst met groepen waarna deze configuratiemethode wordt uitgevoerd. Deze methode wordt gegarandeerd uitgevoerd kort nadat de laatste testmethode die tot een van deze groepen behoort, is aangeroepen.

@Voor klas: De geannoteerde methode wordt uitgevoerd voordat de eerste testmethode in de huidige klasse wordt aangeroepen.

@Na de les: de geannoteerde methode wordt uitgevoerd nadat alle testmethoden in de huidige klasse zijn uitgevoerd.

@Weerplaza: De geannoteerde methode wordt vóór elke testmethode uitgevoerd.

@AfterMethode: De geannoteerde methode wordt na elke testmethode uitgevoerd.

@Toets: De geannoteerde methode maakt deel uit van een testcase

Conclusie

• TestNG is een het testen van raamwerk dat kan worden gemaakt Selenium tests gemakkelijker te begrijpen zijn en rapporten te genereren die gemakkelijk te begrijpen zijn.
• De belangrijkste voordelen van TestNG over JUnit zijn het volgende.
  • Annotaties zijn gemakkelijker te gebruiken en te begrijpen.
  • Testgevallen kunnen gemakkelijker worden gegroepeerd.
  • TestNG stelt ons in staat te creëren parallelle testen.
• Het consolevenster in Eclipse genereert een op tekst gebaseerd resultaat terwijl de TestNG Het venster is nuttiger omdat het ons een grafische uitvoer van de testresultaten geeft, plus andere zinvolle details zoals:
  • Runtimes van elke methode.
  • De chronologische volgorde waarin methoden werden uitgevoerd
• TestNG is in staat HTML-gebaseerde rapporten te genereren.
• Annotaties kunnen net als gebruikelijk parameters gebruiken Java TestNG werkwijzen.
• TestNG Dataprovider is een manier om parameters door te geven aan de testfunctie, die in één uitvoering verschillende waarden in testgevallen doorgeeft.