TestNG Handledning: Vad är anteckningar och ramar i Selenium

Vad är TestNG?

TestNG är ett ramverk för automationstestning där NG står för "Next Generation". TestNG är inspirerad av JUnit som använder anteckningarna (@). TestNG övervinner nackdelarna med JUnit och är designad för att göra test från slut till slut lätt.

Använda TestNG, kan du skapa en ordentlig rapport och du kan enkelt få reda på hur många testfall som är godkända, underkända och hoppade över. Du kan utföra de misslyckade testfallen separat.

Till exempel:

Anta att du har fem testfall, en metod skrivs för varje testfall (Anta att programmet är skrivet med huvudmetoden utan att använda testNG). När du kör det här programmet först, exekveras tre metoder framgångsrikt, och den fjärde metoden misslyckades. Korrigera sedan felen som finns i den fjärde metoden, nu vill du bara köra den fjärde metoden eftersom de tre första metoderna ändå exekveras framgångsrikt. Detta är inte möjligt utan att använda TestNG.
Smakämnen TestNG in Selenium tillhandahåller ett alternativ, dvs testng-failed.xml-filen i test-output-mappen. Om du bara vill köra misslyckade testfall betyder det att du kör den här XML-filen. Den kommer endast att köra misslyckade testfall.

Förutom ovanstående koncept kommer du att lära dig mer om TestNG, som vad är fördelarna med TestNG, hur man skapar testmetoder med hjälp av @test-kommentarer, hur man konverterar dessa klasser till en testsvitsfil och exekverar genom eclipse såväl som från kommandoraden.

Varför använda TestNG med Selenium?

Standard Selenium tester genererar inte ett korrekt format för testresultaten. Använder sig av TestNG in Selenium, kan vi generera testresultat.

bro Selenium användare använder detta mer än junit på grund av dess fördelar. Det finns så många funktioner i TestNG, men vi kommer bara att fokusera på de viktigaste som vi kan använda i Selenium. Följande är de viktigaste funktionerna i Selenium TestNG:

Generera rapporten i ett korrekt format inklusive ett antal testfall som körs, antalet testfall som godkänts, antalet testfall som misslyckades och antalet testfall som hoppades över.
Flera testfall kan grupperas lättare genom att konvertera dem till filen testng.xml. Där du kan göra prioriteringar vilket testfall som ska köras först.
Samma testfall kan köras flera gånger utan loopar bara genom att använda nyckelordet "anropsräkning".
Med testng kan du köra flera testfall på flera webbläsare, dvs cross webbläsartestning.
Smakämnen TestNG ramverk kan enkelt integreras med verktyg som TestNG Maven, Jenkins, etc.
Anteckningar som används i testningen är mycket lätta att förstå ex: @BeforeMethod, @AfterMethod, @BeforeTest, @AfterTest
WebDriver har ingen inbyggd mekanism för att generera rapporter. TestNG kan generera rapporten i ett läsbart format som det som visas nedan.

TestNG förenklar hur testerna kodas. Det finns inte längre behov av en statisk huvudmetod i våra tester. Handlingssekvensen regleras av lättbegripliga anteckningar som inte kräver att metoderna är statiska.

Ofångade undantag hanteras automatiskt av TestNG utan att avsluta testet i förtid. Dessa undantag rapporteras som misslyckade steg i rapporten.

Fördelar med TestNG över JUnit

Det finns tre stora fördelar med TestNG över JUnit:

Anteckningar är lättare att förstå
Testfall kan enklare grupperas
Parallelltestning är möjlig

Vad är anteckning i TestNG?

Anteckningar i TestNG är kodrader som kan styra hur metoden under dem kommer att exekveras. De föregås alltid av @-symbolen. En mycket tidig och snabb TestNG Exempel är det som visas nedan.

Anteckningar kommer att diskuteras senare i avsnittet "Annoteringar som används i TestNG”så det är helt ok om du inte förstår ovanstående TestNG Exempel ännu. Det är bara viktigt att notera för nu att anteckningar finns TestNG är lättare att koda och förstå än i JUnit.

Möjligheten att köra tester parallellt finns i TestNG men inte i JUnit, Så TestNG ramverk är mer föredraget för testare som använder Selenium Rutnät.

Hur man skriver testfall i TestNG?

Steg 1) Skriv din affärslogik och infoga TestNG anteckningar i din kod.
Steg 2) Lägg till mer information som klassnamn, gruppnamn, paketnamn, etc
Steg 3) Kör TestNG.

Skapa testfall med hjälp av TestNG Anteckningar

Nu kommer vi att lära oss hur vi skapar vårt första testfall med hjälp av TestNG Anteckningar i Selenium:

Innan vi skapar ett testfall bör vi först ställa in ett nytt TestNG Projekt in Eclipse och namnge det som "FörstTestNGProjekt".

Sätter upp en ny TestNG Projekt

Steg 1: Klicka på Arkiv > Ny > Java Projekt

Steg 2: Skriv "FörstTestNGProjekt” som projektnamn och klicka sedan på Nästa.

Steg 3: Vi kommer nu att börja importera TestNG Bibliotek till vårt projekt. Klicka på fliken "Bibliotek" och sedan på "Lägg till bibliotek..."

Steg 4: I dialogrutan Lägg till bibliotek väljer du "TestNG”Och klicka på Nästa.

Steg 5: Klicka på Slutför.

Det borde du märka TestNG finns med på bibliotekslistan.

Steg 6: Vi kommer nu att lägga till JAR-filerna som innehåller Selenium API. Dessa filer finns i Java klientdrivrutinen som vi laddade ner från https://www.selenium.dev/downloads/ när vi installerade Selenium och Eclipse i de föregående kapitlen.

Navigera sedan till där du har placerat Selenium JAR-filer.

När du har lagt till de externa JAR:erna bör din skärm se ut så här.

Steg 7: Klicka på Slutför och verifiera att vår förstaTestNGProjektet syns på Eclipses Package Explorer-fönster.

Hur man skapar en ny TestNG Testfil

Nu när vi är klara med att sätta upp vårt projekt i detta TestNG tutorial, låt oss skapa en ny TestNG fil.

Steg 1: Klicka på 'src' och välj annat.
Högerklicka på paketmappen "src" och välj sedan Ny > Annat...

Steg 2: Välja TestNG klass.
Klicka på TestNG mappen och välj "TestNG klass” alternativet. Klicka på Nästa.

Steg 3: Skriv in värdena.
Skriv in värdena som anges nedan i lämpliga inmatningsrutor och klicka på Slutför. Lägg märke till att vi har döpt vår Java fil som "FörstTestNGFil".

Steg 4: Mall skapad.
Eclipse ska automatiskt skapa mallen för vår TestNG filen som visas nedan.

Kodning av vår första TestNG Exempel på testfall

Låt oss nu skapa vår första Testfall som kommer att kontrollera om Mercury Tours hemsida är korrekt. Skriv din kod enligt nedan TestNG Exempelvis:

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

Lägg märke till följande.

TestNG kräver inte att du har en main()-metod.
Metoderna behöver inte vara statiska.
Vi använde @Test-kommentaren. @Test används för att tala om att metoden under den är ett testfall. I det här fallet har vi ställt in metoden verifyHomepageTitle() som vårt testfall, så vi placerade en '@Test'-anteckning ovanför den.
Eftersom vi använder anteckningar i TestNG, behövde vi importera paketet org.testng.annotations.*.
Vi använde Assert-klassen. Assert-klassen används för att utföra verifieringsoperationer i TestNG. För att använda det måste vi importera paketet org.testng.Assert.

Du kan ha flera testfall (därför flera @Test-kommentarer) i en enda TestNG fil. Detta kommer att behandlas mer i detalj senare i avsnittet "Anteckningar som används i TestNG. "

Kör testet

För att köra testet, kör helt enkelt in filen Eclipse som du normalt gör. Eclipse kommer att tillhandahålla två utgångar – en i konsolfönstret och den andra på TestNG Resultatfönster.

Kontrollera rapporter skapade av TestNG

Konsolfönstret in Eclipse ger en textbaserad rapport av våra testfallsresultat medan TestNG Resultatfönstret ger oss ett grafiskt.

Generera HTML-rapporter

TestNG har möjlighet att generera rapporter i HTML-format.

Steg 1: Efter att ha kört vår FirstTestNGFil som vi skapade i föregående avsnitt, högerklicka på projektnamnet (FörstTestNGProject) i Project Explorer-fönstret och klicka sedan på alternativet "Uppdatera".

Steg 2: Observera att en "test-output"-mapp skapades. Expandera den och leta efter en index.html-fil. Denna HTML-fil är en rapport över resultaten av den senaste testkörningen.

Steg 3: Double-klicka på filen index.html för att öppna den Eclipses inbyggda webbläsare. Du kan uppdatera den här sidan när som helst efter att du kört ditt test igen genom att helt enkelt trycka på F5 precis som i vanliga webbläsare.

Anteckningar som används i TestNG

I föregående avsnitt har du blivit introducerad till @Test-kommentaren. Nu ska vi studera mer avancerade kommentarer och deras användningsområden.

Flera testfall

Vi kan använda flera @Test-kommentarer i en enda TestNG fil. Som standard exekveras metoder som kommenteras av @Test alfabetiskt. Se koden nedan. Även om metoderna c_test, a_test och b_test inte är ordnade alfabetiskt i koden, kommer de att exekveras som sådana.

Kör den här koden och klicka på "Kronologisk vy" på den genererade sidan index.html.

parametrar

Om du vill att metoderna ska exekveras i en annan ordning, använd parametern "prioritet". Parametrar är nyckelord som ändrar anteckningens funktion.

Parametrar kräver att du tilldelar dem ett värde. Du gör detta genom att placera ett "=" bredvid dem och sedan följt av värdet.
Parametrar är inneslutna i ett par parenteser som placeras direkt efter anteckningen som kodavsnittet som visas nedan.

TestNG kommer att köra @Test-kommentaren med det lägsta prioritetsvärdet upp till det största. Det finns inget behov av att dina prioriterade värden är konsekutiva.

Smakämnen TestNG HTML-rapporten kommer att bekräfta att metoderna kördes baserat på det stigande prioritetsvärdet.

Flera parametrar

Bortsett från "prioritet" har @Test en annan parameter som heter "alwaysRun" som bara kan ställas in på antingen "true" eller "false". Om du vill använda två eller flera parametrar i en enda anteckning, separera dem med ett kommatecken som den som visas nedan.

@Test(priority = 0, alwaysRun = true)

@BeforeTest och @AfterTest

@BeforeTest	metoder under denna anteckning kommer att exekveras före det första testfallet i TestNG fil.
@AfterTest	metoder under denna anteckning kommer att exekveras efter alla testfall i TestNG filen körs.

Tänk på koden nedan.

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

Genom att tillämpa logiken som presenteras av tabellen och koden ovan kan vi förutsäga att sekvensen med vilken metoder kommer att exekveras är:

1^st – launchBrowser()
2^nd – verifyHomepageTitle()
3^rd – terminateBrowser()

Placeringen av anteckningsblocken kan bytas ut utan att påverka den kronologiska ordningen med vilken de kommer att exekveras. Låt oss förstå med en TestNG Exempel och försök att ordna om anteckningsblocken så att din kod skulle se ut som den nedan.

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

Kör koden ovan och lägg märke till det

@BeforeMethod och @AfterMethod

@BeforeMethod	metoder under denna anteckning kommer att exekveras före varje metod i varje testfall.
@AfterMethod	metoder under denna anteckning kommer att exekveras efter varje metod i varje testfall.

In Mercury Turer, anta att vi vill verifiera titlarna på målsidorna för de två länkarna nedan.

Flödet av vårt test skulle vara:

Gå till hemsidan och verifiera dess titel.
Klicka på REGISTRERA och verifiera titeln på dess målsida.
Gå tillbaka till startsidan och kontrollera om den fortfarande har rätt titel.
Klicka på SUPPORT och verifiera titeln på dess målsida.
Gå tillbaka till startsidan och kontrollera om den fortfarande har rätt titel.

Koden nedan illustrerar hur @BeforeMethod och @AfterMethod används för att effektivt exekvera scenariot som nämns ovan.

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

Efter att ha utfört detta test, din TestNG ska rapportera följande sekvens.

Enkelt uttryckt borde @BeforeMethod innehålla metoder som du behöver för att köra innan varje testfall medan @AfterMethod bör innehålla metoder som du behöver köra efter varje testfall.

Sammanfattning av TestNG Anteckningar

@BeforeSuite: Den kommenterade metoden kommer att köras innan alla tester i den här sviten har körts.

@AfterSuite: Den kommenterade metoden kommer att köras efter att alla tester i den här sviten har körts.

@BeforeTest: Den kommenterade metoden kommer att köras innan någon testmetod som tillhör klasserna inuti taggen körs.

@AfterTest: Den kommenterade metoden kommer att köras efter att alla testmetoder som tillhör klasserna inuti taggen har körts.

@BeforeGroups: Listan över grupper som den här konfigurationsmetoden kommer att köras tidigare. Denna metod kommer garanterat att köras kort innan den första testmetoden som tillhör någon av dessa grupper anropas.

@AfterGroups: Listan över grupper som den här konfigurationsmetoden kommer att köras efter. Denna metod kommer garanterat att köras kort efter att den sista testmetoden som tillhör någon av dessa grupper anropas.

@Innan lektionen: Den kommenterade metoden kommer att köras innan den första testmetoden i den aktuella klassen anropas.

@Efter lektionen: Den kommenterade metoden kommer att köras efter att alla testmetoder i den aktuella klassen har körts.

@BeforeMethod: Den kommenterade metoden kommer att köras före varje testmetod.

@AfterMethod: Den kommenterade metoden kommer att köras efter varje testmetod.

@Testa: Den kommenterade metoden är en del av ett testfall

Slutsats

TestNG är en testning ram som är kapabel att göra Selenium tester lättare att förstå och att generera rapporter som är lätta att förstå.
De största fördelarna med TestNG över JUnit är följande.
- Anteckningar är lättare att använda och förstå.
- Testfall kan enklare grupperas.
- TestNG låter oss skapa parallella tester.
Konsolfönstret in Eclipse genererar ett textbaserat resultat medan TestNG fönstret är mer användbart eftersom det ger oss en grafisk utdata av testresultatet plus andra meningsfulla detaljer som:
- Körtider för varje metod.
- Den kronologiska ordning efter vilken metoderna utfördes
TestNG kan generera HTML-baserade rapporter.
Anteckningar kan använda parametrar precis som de vanliga Java TestNG metoder.
TestNG Dataprovider är ett sätt att skicka parametrar till testfunktionen som skickar olika värden i testfall i en enda exekvering.

Du kanske gillar: