TestNG-zelfstudie: wat is, annotaties & Framework in selenium

Inhoudsopgave:

Anonim

Wat is TestNG?

TestNG is een automatiseringstestraamwerk waarin NG staat voor "Next Generation". TestNG is geïnspireerd op JUnit dat de annotaties (@) gebruikt. TestNG overwint de nadelen van JUnit en is ontworpen om end-to-end testen gemakkelijk te maken.

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

Bijvoorbeeld:

  • Stel dat u vijf testcases heeft, dan wordt voor elke testcase één methode geschreven (neem aan dat het programma is geschreven volgens de hoofdmethode zonder testNG te gebruiken). Als u dit programma eerst uitvoert, worden drie methoden met succes uitgevoerd en de vierde methode is mislukt. 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 met succes worden uitgevoerd. Dit is niet mogelijk zonder TestNG te gebruiken.
  • De TestNG in Selenium biedt een optie, dwz het bestand testng-failed.xml in de map test-output. Als u alleen mislukte testgevallen wilt uitvoeren, betekent dit dat u dit XML-bestand uitvoert. Het voert alleen mislukte testgevallen uit.

Naast het bovenstaande concept, leert u meer over TestNG, zoals wat zijn de voordelen van TestNG, hoe u testmethoden kunt maken met @test-annotaties, hoe u deze klassen kunt converteren naar een testsuite-bestand en deze kunt uitvoeren via de eclips en vanaf de opdrachtregel. .

In deze TestNG-zelfstudie leert u

  • Waarom TestNG gebruiken met selenium?
  • Voordelen van TestNG ten opzichte van JUnit
  • Maak een testcase met behulp van TestNG-annotaties
  • Hoe u een nieuw TestNG-testbestand maakt
    • Codering van ons eerste TestNG-testcasevoorbeeld
    • De test uitvoeren
  • Controleren van rapporten die zijn gemaakt door TestNG
  • Annotaties die worden gebruikt in TestNG
  • Meerdere testcases
  • Parameters
    • Meerdere parameters
    • Samenvatting van TestNG-annotaties

Waarom TestNG gebruiken met selenium?

Standaard seleniumtests genereren geen correct formaat voor de testresultaten. Met TestNG in Selenium kunnen we testresultaten genereren.

De meeste Selenium-gebruikers gebruiken dit vanwege de voordelen meer dan Junit. Er zijn zoveel functies van TestNG, maar we zullen ons alleen concentreren op de belangrijkste die we in Selenium kunnen gebruiken. Hieronder volgen de belangrijkste kenmerken van Selenium TestNG:

  • Genereer het rapport in een correct formaat, inclusief een aantal testcases-runs, het aantal testcases dat is geslaagd, het aantal testcases dat is mislukt en het aantal testcases dat is overgeslagen.
  • Meerdere testgevallen kunnen gemakkelijker worden gegroepeerd door ze te converteren naar het testng.xml-bestand. Waarin je prioriteiten kunt stellen welke testcase als eerste uitgevoerd moet worden.
  • Hetzelfde testgeval kan meerdere keren zonder lussen worden uitgevoerd door het trefwoord 'aanroepaantal' te gebruiken.
  • Door testng te gebruiken, kunt u meerdere testgevallen op meerdere browsers uitvoeren, dwz cross-browser testen.
  • Het TestNG-framework kan eenvoudig worden geïntegreerd met tools zoals TestNG Maven, Jenkins, enz.
  • Annotaties die bij het testen worden gebruikt, zijn heel 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 waarvoor geen statische methoden nodig zijn.
  • Niet-afgevangen uitzonderingen worden automatisch door TestNG afgehandeld zonder de test voortijdig te beëindigen. Deze uitzonderingen worden in het rapport gerapporteerd als mislukte stappen.

Voordelen van TestNG ten opzichte van JUnit

Er zijn drie belangrijke voordelen van TestNG ten opzichte van JUnit:

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

Annotaties in TestNG zijn coderegels die kunnen bepalen hoe de onderstaande methode wordt uitgevoerd . Ze worden altijd voorafgegaan door het @ -symbool. Een zeer vroeg en snel TestNG-voorbeeld is het onderstaande.

Annotaties zullen later worden besproken in de sectie met de naam "Annotaties gebruikt in TestNG", dus het is prima als je het bovenstaande TestNG-voorbeeld nog niet begrijpt. Het is alleen belangrijk om op te merken dat annotaties in TestNG gemakkelijker te coderen en te begrijpen zijn dan in JUnit.

De mogelijkheid om tests parallel uit te voeren is beschikbaar in TestNG maar niet in JUnit, dus het TestNG-framework heeft meer de voorkeur van testers die Selenium Grid gebruiken.

Maak een testcase met behulp van TestNG-annotaties

Nu zullen we leren hoe we onze eerste testcase kunnen maken met behulp van TestNG-annotaties in Selenium:

Voordat we een testcase maken, moeten we eerst een nieuw TestNG-project in Eclipse opzetten en het de naam "FirstTestNGProject" geven.

Een nieuw TestNG-project opzetten

Stap 1: Klik op Bestand> Nieuw> Java-project

Stap 2: Typ "FirstTestNGProject" als de projectnaam en klik op Volgende.

Stap 3: We gaan nu beginnen met het importeren van de TestNG-bibliotheken in ons project. Klik op het tabblad "Bibliotheken" en vervolgens op "Bibliotheek toevoegen

​

Stap 4: Kies "TestNG" in het dialoogvenster Bibliotheek toevoegen en klik op Volgende.

Stap 5: Klik op Voltooien.

U zou moeten opmerken dat TestNG is opgenomen in de lijst met bibliotheken.

Stap 6: We zullen nu de JAR-bestanden toevoegen die de Selenium API bevatten. Deze bestanden zijn te vinden in het Java-clientstuurprogramma dat we hebben gedownload van http://docs.seleniumhq.org/download/ toen we Selenium en Eclipse installeerden in de vorige hoofdstukken.

Navigeer vervolgens naar waar u de Selenium JAR-bestanden hebt geplaatst.

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 ons FirstTestNGProject zichtbaar is in het venster Pakketverkenner van Eclipse.

Hoe u een nieuw TestNG-testbestand maakt

Nu we klaar zijn met het opzetten van ons project in deze TestNG-zelfstudie, kunnen we een nieuw TestNG-bestand maken.

Stap 1: Klik met de rechtermuisknop op de pakketmap "src" en kies Nieuw> Overig

​

Stap 2: Klik op de map TestNG en selecteer de optie "TestNG class". Klik volgende.

Stap 3: Typ de onderstaande waarden in de juiste invoervakken en klik op Voltooien. Merk op dat we ons Java-bestand de naam "FirstTestNGFile" hebben gegeven.

Eclipse zou automatisch de sjabloon moeten maken voor ons TestNG-bestand dat hieronder wordt weergegeven.

Codering van ons eerste TestNG-testcasevoorbeeld

Laten we nu onze eerste testcase maken die zal controleren of de startpagina van Mercury Tours correct is. Typ uw code zoals weergegeven in het onderstaande TestNG-voorbeeld:

pakket firsttestngpackage;importeer org.openqa.selenium. *;importeer org.openqa.selenium.firefox.FirefoxDriver;importeer org.testng.Assert;importeer org.testng.annotaties. *;openbare klasse firsttestngfile {public String baseUrl = "http://demo.guru99.com/test/newtours/";String driverPath = "C: \\ geckodriver.exe";openbare WebDriver-driver;@Testopenbare ongeldige verificatieHomepageTitle () {System.out.println ("firefox-browser wordt gestart");System.setProperty ("webdriver.gecko.driver", driverPath);driver = nieuwe FirefoxDriver ();driver.get (baseUrl);String verwachteTitle = "Welkom: Mercury Tours";String actualTitle = driver.getTitle ();Assert.assertEquals (actualTitle, verwachteTitle);driver.close ();​​

Let op het volgende.

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

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

De test uitvoeren

Om de test uit te voeren, voert u het bestand gewoon in Eclipse uit zoals u normaal doet. Eclipse biedt twee uitgangen: een in het consolevenster en de andere in het venster TestNG-resultaten.

Controleren van rapporten die zijn gemaakt door TestNG

Het consolevenster in Eclipse geeft een op tekst gebaseerd rapport van de resultaten van onze testcase, terwijl het venster TestNG-resultaten ons een grafisch rapport geeft.

HTML-rapporten genereren

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

Stap 1: Na het uitvoeren van onze FirstTestNGFile die we in de vorige sectie hebben gemaakt, klikt u met de rechtermuisknop op de projectnaam (FirstTestNGProject) in het venster Projectverkenner en klikt u 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: Dubbelklik op dat index.html-bestand om het te openen in de ingebouwde webbrowser van Eclipse. U kunt deze pagina op elk moment vernieuwen nadat u uw test opnieuw hebt uitgevoerd door simpelweg op F5 te drukken, net als in gewone webbrowsers.

Annotaties die worden gebruikt in TestNG

In het vorige gedeelte heb je kennis gemaakt met de @Test-annotatie. Nu zullen we meer geavanceerde annotaties en hun gebruik bestuderen.

Meerdere testcases

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

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

Parameters

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

  • Parameters vereisen dat u er een waarde aan toewijst. U doet dit door een ernaast te plaatsen, gevolgd door de waarde.
  • Parameters staan ​​tussen haakjes die direct na de annotatie worden geplaatst, zoals het onderstaande codefragment.

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

Het TestNG HTML-rapport bevestigt dat de methoden zijn uitgevoerd op basis van de oplopende prioriteitswaarde.

Meerdere parameters

Behalve "prioriteit" heeft @Test nog een parameter genaamd "alwaysRun" die alleen kan worden ingesteld op "true" of "false". Om twee of meer parameters in een enkele annotatie te gebruiken, scheidt u ze met een komma , zoals hieronder wordt weergegeven.

@Test (prioriteit = 0, alwaysRun = true)

@BeforeTest en @AfterTest

@BeforeTest

methoden onder deze annotatie worden uitgevoerd voorafgaand aan de eerste testcase in het TestNG-bestand .

@AfterTest

methoden onder deze annotatie worden uitgevoerd nadat alle testgevallen in het TestNG-bestand zijn uitgevoerd .

Beschouw de onderstaande code.

pakket firsttestngpackage;importeer org.openqa.selenium. *;importeer org.openqa.selenium.firefox.FirefoxDriver;importeer org.testng.Assert;importeer org.testng.annotaties. *;openbare klasse firsttestngfile {public String baseUrl = "http://demo.guru99.com/test/newtours/";String driverPath = "C: \\ geckodriver.exe";openbare WebDriver-driver;@BeforeTestopenbare leegte launchBrowser () {System.out.println ("firefox-browser wordt gestart");System.setProperty ("webdriver.gecko.driver", driverPath);driver = nieuwe FirefoxDriver ();driver.get (baseUrl);​@Testopenbare ongeldige verificatieHomepageTitle () {String verwachteTitle = "Welkom: Mercury Tours";String actualTitle = driver.getTitle ();Assert.assertEquals (actualTitle, verwachteTitle);​@AfterTestpublic void terminateBrowser () {driver.close ();​​

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

  • 1 e - launchBrowser ()
  • 2 nd - verifyHomepageTitle ()
  • 3 rd - terminateBrowser ()

De plaatsing van de annotatieblokken kan worden uitgewisseld zonder dat dit invloed heeft op de chronologische volgorde waarin ze worden uitgevoerd . Laten we het begrijpen met een TestNG-voorbeeld en proberen de annotatieblokken opnieuw te rangschikken zodat uw code er ongeveer zo uitziet als hieronder.

pakket firsttestngpackage;importeer org.openqa.selenium. *;importeer org.openqa.selenium.firefox.FirefoxDriver;importeer org.testng.Assert;importeer org.testng.annotaties. *;openbare klasse firsttestngfile {public String baseUrl = "http://demo.guru99.com/test/newtours/";String driverPath = "C: \\ geckodriver.exe";openbare WebDriver-driver;@AfterTest // Door elkaar gegooidpublic void terminateBrowser () {driver.close ();​@BeforeTest // Door elkaar gegooidopenbare leegte launchBrowser () {System.out.println ("firefox-browser wordt gestart");System.setProperty ("webdriver.gecko.driver", driverPath);driver = nieuwe FirefoxDriver ();driver.get (baseUrl);​@Test // Door elkaar gegooidopenbare ongeldige verificatieHomepageTitle () {String verwachteTitle = "Welkom: Mercury Tours";String actualTitle = driver.getTitle ();Assert.assertEquals (actualTitle, verwachteTitle);​​

Voer de bovenstaande code uit en merk dat op

@BeforeMethod en @AfterMethod

@WillemII

methoden onder deze annotatie zullen voorafgaand aan elke methode in elk testgeval worden uitgevoerd .

@AfterMethod

methoden onder deze annotatie worden in elk testgeval na elke methode uitgevoerd .

Stel dat we bij Mercury Tours graag de titels van de doelpagina's van de twee onderstaande links willen verifiëren.

De stroom van onze test zou zijn:

  • Ga naar de homepagina en controleer de titel.
  • Klik op REGISTREREN en verifieer de titel van de doelpagina.
  • Ga terug naar de homepagina en controleer of deze nog steeds de juiste titel heeft.
  • Klik op ONDERSTEUNING en verifieer de titel van de doelpagina.
  • Ga terug naar de homepagina 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.

pakket firsttestngpackage;importeer org.openqa.selenium. *;importeer org.openqa.selenium.firefox.FirefoxDriver;importeer org.testng.Assert;importeer org.testng.annotaties. *;@Testopenbare klasse firsttestngfile {public String baseUrl = "http://demo.guru99.com/test/newtours/";String driverPath = "C: \\ geckodriver.exe";openbare WebDriver-driver;public String verwacht = null;public String actual = null;@BeforeTestopenbare leegte launchBrowser () {System.out.println ("firefox-browser wordt gestart");System.setProperty ("webdriver.gecko.driver", driverPath);driver = nieuwe FirefoxDriver ();driver.get (baseUrl);​@WillemIIopenbare ongeldige verificatieHomepageTitle () {String verwachteTitle = "Welkom: Mercury Tours";String actualTitle = driver.getTitle ();Assert.assertEquals (actualTitle, verwachteTitle);​@Test (prioriteit = 0)openbaar ongeldig register () {driver.findElement (By.linkText ("REGISTER")). klik ();verwacht = "Registreren: Mercury Tours";actual = driver.getTitle ();Assert.assertEquals (actueel, verwacht);​@Test (prioriteit = 1)openbare ongeldige ondersteuning () {driver.findElement (By.linkText ("SUPPORT")). klik ();verwacht = "Under Construction: Mercury Tours";actual = driver.getTitle ();Assert.assertEquals (actueel, verwacht);​@AfterMethodopenbare ongeldige goBackToHomepage () {driver.findElement (By.linkText ("Home")). klik ();​@AfterTestpublic void terminateBrowser () {driver.close ();​​

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

Simpel gezegd, @BeforeMethod moet methoden bevatten die u vóór elke testcase moet uitvoeren, terwijl @AfterMethod methoden moet bevatten die u na elke testcase moet uitvoeren .

Samenvatting van 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.

@BeforeTest : 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.

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

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

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

@AfterClass : De geannoteerde methode wordt uitgevoerd nadat alle testmethoden in de huidige klasse zijn uitgevoerd.

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

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

@Test : de geannoteerde methode maakt deel uit van een testcase

Gevolgtrekking

  • TestNG is een testraamwerk dat in staat is om Selenium-tests begrijpelijker te maken en rapporten te genereren die gemakkelijk te begrijpen zijn.
  • De belangrijkste voordelen van TestNG ten opzichte van JUnit zijn de volgende.
    • Annotaties zijn gemakkelijker te gebruiken en te begrijpen.
    • Testgevallen kunnen gemakkelijker worden gegroepeerd.
    • Met TestNG kunnen we parallelle tests maken.
  • Het consolevenster in Eclipse genereert een op tekst gebaseerd resultaat, terwijl het TestNG-venster nuttiger is omdat het ons een grafische uitvoer van het testresultaat geeft plus andere zinvolle details, zoals:
    • Looptijden van elke methode.
    • De chronologische volgorde waarin de methoden zijn uitgevoerd
  • TestNG kan op HTML gebaseerde rapporten genereren.
  • Annotaties kunnen parameters gebruiken, net als de gebruikelijke Java TestNG-methoden.
  • TestNG Dataprovider is een manier om parameters door te geven aan de testfunctie die verschillende waarden doorgeeft in testgevallen in een enkele uitvoering.