Meny

Påståenden i selen med Junit och TestNG Frameworks

  • Huvud
  • Övrig
  • Påståenden i selen med Junit och TestNG Frameworks

assertions selenium using junit

Prova Vårt Instrument För Att Eliminera Problem

Denna Selen-handledning om påståenden förklarar vad som är påståenden i selen och olika typer av påståenden och påståendemetoder med Junit- och TestNG-ramverk:

c ++ hur man använder stringstream

Påståenden används för att validera ett testfall och hjälper oss att förstå om ett testfall har passerat eller misslyckats. Påståendet anses vara uppfyllt om det faktiska resultatet av en ansökan överensstämmer med det för det förväntade resultatet.

När vi automatiserar webbapplikationer med Selen, måste vi validera våra tester för att verifiera om de fungerar som förväntat eller inte(det vill säga om ett testfallsslag är godkänt / misslyckas).

=> Ta en titt på Selenium Beginners Guide här.

Ett testfall anses endast godkänt om alla påståenden har uppfyllts. Påståenden i selen kan hanteras med fördefinierade metoder för Junit- och TestNG-ramar, vilket kommer att förklaras i detalj i den här artikeln.

Påståenden i selen

Vad du kommer att lära dig:

Påståenden i selen

Påståenden används för att utföra olika typer av valideringar i testfallet, vilket i sin tur hjälper oss att avgöra om testfallet har passerat eller misslyckats. Wanser ett test vara framgångsrikt om det körs utan något undantag.

Videohandledning om påståenden

Typer av påståenden i selen

Det finns två typer av påståenden i selen och kategoriseringen beror på hur påståendet beter sig efter att ett tillstånd är godkänt eller misslyckat.

Här skulle vi diskutera två typer av påståenden i Selen :

  • Svåra påståenden
  • Mjuka påståenden

Klicka här för prov testfall för att testa påståenden.

# 1) Hårda påståenden (eller helt enkelt påståenden)

Ett svårt påstående fortsätter inte med körningen förrän påståendevillkoret är uppfyllt.

Svåra påståenden ger vanligtvis ett påståendefel när ett påståendevillkor inte har uppfyllts. Testfallet kommer omedelbart att markeras som misslyckat när ett svårt påstående misslyckas.

Ett scenario för att använda denna typ av påstående är att när du vill verifiera om du har loggat in korrekt och misslyckas med testet om du inte har gjort en lyckad inloggning, eftersom det inte är någon mening att gå vidare om förutsättningen ( inloggning) i sig misslyckas.

Låt oss ta ett annat exempel som illustreras här:

Tänk på ett testfall för att hävda titeln på en webbsida.

public class LearnAssertions { WebDriver driver; //Store current project workspace location in a string variable ‘path’ String path = System.getProperty('user.dir”); @BeforeTest public void SetDriver(){ //Mention the location of ChromeDriver in localsystem System.setProperty('webdriver.chrome.driver',path+'\Drivers\chromedriver.exe'); driver = new ChromeDriver();// Object is created- Chrome browser is opened driver.manage().window().maximize(); } @Test public void verifyTitle() { driver.get(https://www.amazon.com); String ActualTitle = driver.getTitle(); String ExpectedTitle = “Amazon.com: Online Shopping for Electronics, Apparel, Computers, Books, DVDs & more”; Assert.assertEquals(ActualTitle, ExpectedTitle); System.out.println(“Assert passed”); } @AfterTest public void closedriver(){ //closes the browser instance driver.close(); }

Svåra påståenden

I exemplet kommer variabeln 'ActualTitle' att innehålla titeltexten från automatisering. 'ExpectedTitle' innehåller förväntade strängdata. Assert.assertEquals () verifierar om båda texterna är lika. Ovanstående testfall kommer att passera och fortsätta till nästa körningsrad eftersom den faktiska texten och den förväntade texten är desamma.

Konsol:
Assert passerade.
PASSAD: VerifyTitle

Resultat av hårda påståenden 1

Samma testfall när det misslyckades ger ett undantag och stoppar körningen vid den instansen.

Låt oss nu ändra den förväntade titeln till fel.

public class LearnAssertions { WebDriver driver; //Store current project workspace location in a string variable ‘path’ String path = System.getProperty('user.dir'); @BeforeTest public void SetDriver(){ //Mention the location of chromeDriver in localsystem System.setProperty('webdriver.chrome.driver',path+'\Drivers\chromedriver.exe'); driver = new ChromeDriver();// Object is created- Chrome browser is opened driver.manage().window().maximize(); } @Test public void verifyTitle() { driver.get(https://www.amazon.com); String ActualTitle = driver.getTitle(); String ExpectedTitle = “Welcome to Amazon”; Assert.assertEquals(ActualTitle, ExpectedTitle); System.out.println(“Assert passed”); } @AfterTest public void closedriver(){ //closes the browser instance driver.close(); }

Trösta:

java.lang.AssertionError:förväntat (Välkommen till Amazon)menhittades (Amazon.com: Online shopping för elektronik, kläder, datorer, böcker, DVD-skivor och mer)

Svåra påståenden Resultat 2

Från konsolen kan vi se att utskriftsuttalandet hoppades över (System.out.println) eftersom ett fel uppstod i Assert-uttalandet och det gav ett undantag.

# 2) Mjuka påståenden

Ett mjukt påstående fortsätter med nästa steg i testutförandet även om påståendebetingelsen inte är uppfyllt.

Mjuka påståenden är den typ av påståenden som inte ger ett undantag automatiskt när ett påstående misslyckas om det inte begärs. Detta är användbart om du gör flera valideringar i ett formulär, varav endast ett fåtal valideringar direkt påverkar avgörandet av testfallet.

Här använder vi en klass som heter SoftAssert och metoden assertAll () kallas för att kasta alla undantag som fångats under körningen. När softAssert används utför det påstående och om ett undantag hittas kastas det inte omedelbart, utan fortsätter tills vi kallar metoden assertAll () för att kasta alla fångade undantag.

Det är klokt att använda olika föremål av 'SoftAssert' -klassen för varje testfall.

Tänk på testfallet för att hävda sidans titel

I exemplet nedan skapas två objekt av klass 'SoftAssert' som ska användas i två olika testfall.

public class LearnAssertionsSoft { WebDriver driver; //Object of Class SoftAssert is created to use its methods SoftAssert softassert = new SoftAssert(); SoftAssert softassert2 = new SoftAssert(); //current project workspace String path = System.getProperty('user.dir'); @BeforeTest public void SetDriver(){ System.setProperty('webdriver.chrome.driver',path+'\Drivers\chromedriver.exe'); driver = new ChromeDriver();// Object is created - Chrome browser is opened driver.manage().window().maximize(); } //Soft Assertion example - with a failure test case example @Test public void verifyTitle(){ driver.get('https://amazon.in'); String ActualTitle = driver.getTitle(); System.out.println('Actual Title :'+ActualTitle); String ExpectedTitle = 'cameras, books, watches, apparel, shoes and e-Gift Cards. Free Shipping & Cash on Delivery Available.'; //Soft assert applied to verify title softassert.assertEquals(ActualTitle, ExpectedTitle); //If failed, this line gets printed and execution is not halted System.out.println('Assertion 1 is executed”); softassert.assertAll(); } //Soft Assertion example - with a positive flow test case example @Test public void verifyElement(){ WebElement AmazonIcon = driver.findElement(By.Xpath(“//div(contains(@id,’amazon_icon’))); softassert2.assertEquals (true, AmazonIcon.isDisplayed()); softassert2.assertAll(); System.out.println('Icon is displayed'); System.out.println('Assertion 2 is executed”); } @AfterTest public void closedriver(){ driver.close(); //Checks for failures if any and throws them at the end of execution } }

Trösta:

Faktisk titel: Amazon.com: Online shopping för elektronik, kläder, datorer, böcker, DVD och mer
Påstående 1 utförs
Ikonen visas
Påstående 2 utförs

Mjuka påståenden Resultat 1

java.lang.AssertionError: Följande påståenden misslyckades:

förväntat (Välkommen till Amazon) men hittat (Amazon.com: Online-shopping för elektronik, kläder, datorer, böcker, DVD-skivor och mer)

Mjuka påståenden Resultat 2

Från konsolen kan vi förstå att även om påståendet var ett misslyckande i det första testfallet (verifyTitle) fortsatte körningen till nästa rad där uttalandet - 'Assertion 1 exekveras' skrevs ut och först efter att softAssert anropades, undantaget kastades.

När ska jag använda hårda och mjuka påståenden?

Om du behöver utföra alla steg i ett testfall som ska utföras även efter att ett påstående misslyckas, och du också vill rapportera påståendeundantag, välj sedan att använda Soft Assertions. Att använda mjuka påståenden i dina testskript är en bra praxis och ett effektivt sätt att hantera ditt testutförande

Om du vill att ditt testfall ska genomföras först efter att ett påstående har godkänts ( Till exempel, För att verifiera giltig inloggning och först sedan utföra de andra stegen), använd sedan hårda påståenden.

Junit Assert Methods

De olika typerna av Junit Assert-metoder förklaras nedan i detalj.

# 1) assertEquals

assertequals-metoden jämför det förväntade resultatet med det faktiska resultatet. Det kastar en AssertionError om det förväntade resultatet inte överensstämmer med det för det faktiska resultatet och avslutar programkörningen vid metoden assert equals.

Syntax:

public static void assertEquals(String expected, String actual)

Exempel:

Sträng förväntad = “https://www.google.com”;

Sträng actualURL = “https://www.google.com”;

Assert.assertEquals (förväntad, actualURL);

# 2) assertTrue

asserttrue-metoden hävdar att ett angivet villkor är sant.

Det tar in två parametrar, dvs den ena är meddelandet och den andra är det villkor mot vilket påståendet måste tillämpas. Det kastar en AssertionError om villkoret som skickas till asserttrue-metoden inte är uppfyllt.

Syntax:

public static void assertTrue(java.lang.String message, boolean condition)

meddelande - Meddelande som ska visas i händelse av ett påståendefel.
villkor - Villkor som påståendet måste tillämpas mot.

Exempel:

Assert.assertTrue (“Assert True test message”, true);

# 3) assertFalse

assert false method hävdar att ett angivet tillstånd är falskt.

Det tar in två parametrar, dvs den ena är meddelandet och den andra är det tillstånd mot vilket påståendet måste tillämpas. Det kastar en AssertionError om villkoret som överförs till assertfalse-metoden inte är uppfyllt.

Syntax:

public static void assertFalse(java.lang.String message, boolean condition)

meddelande - Meddelande som ska visas i händelse av ett påståendefel.
villkor - Villkor som påståendet måste tillämpas mot.

Exempel:

Assert.assertFalse (”Assert false test message” false);

# 4) assertNull

assert null används för att verifiera om det angivna objektet innehåller ett null-värde. Det tar ett objekt som parameter och kastar en AssertionError om det angivna objektet inte har ett nullvärde.

Syntax:

public static void assertNull(Object object)

Exempel:

DemoClass demo = ny DemoClass ();
Assert.assertNull (demo);

# 5) assertNotNull

assert not null används för att verifiera att ett tillhandahållet objekt inte har ett nullvärde. Det tar ett objekt som parameter och kastar en AssertionError om det angivna objektet inte innehåller ett nullvärde.

Syntax:

public static void assertNotNull(Object object)

Exempel:

DemoClass demo = ny DemoClass ();
Assert.assertNotNull (demo);

# 6) assertSame

hävda samma metod kontrollerar om två objekt som tillhandahålls som parametrar hänvisar till samma objekt. Det kastar en AssertionError om de angivna objekten inte hänvisar till samma objekt med det meddelande som tillhandahålls.

Observera att Assert samma jämför endast referenserna för objekt, men inte de faktiska värdena.

Syntax:

public static void assertSame(String message, Object expected,Object actual)

Exempel:

DemoClass1 demo1 = ny DemoClass1 ();
DemoClass2 demo2 = ny DemoClass2 ();
Assert.assertSame (“Två objekt är lika”, demo1, demo2);

# 7) assertNotSame

hävdar inte samma verifierar att två objekt inte är lika. Om två objekt refererar till samma objekt kastas en AssertionError.

Observera att påståendet inte samma metod jämför referenserna för objekt och inte de värden som finns i objekten.

Syntax:

public static void assertNotSame(String message, Object expected, Object actual)

Exempel:

DemoClass1 demo1 = ny DemoClass1 ();
DemoClass2 demo2 = ny DemoClass2 ();
Assert.assertNotSame (“Två objekt är inte lika”, demo1, demo2);

# 8) assertArrayEquals

assert equals verifierar att två objektmatriser är lika. Om båda matriserna innehåller nollvärden betraktas de som lika. Denna metod kastar en AssertionError med meddelandet om båda objektmatriserna inte anses vara lika.

Syntax:

public static void assertArrayEquals(String message, Object() expected, Object() actual)

meddelande - Meddelande som ska visas i händelse av ett påståendefel.
förväntat - Array of objects.
faktiska - Array of objects.

Exempel:

Sträng () förväntad = {“Mango”, “Apple”, ”Banana”}

Sträng () actual = {“Mango”, “Apple”, ”Banana”}

Assert.assertArrayEquals (förväntad, faktisk);

TestNG-påståendemetoder

TestNG Assert-metoder kommer att vara desamma som Junit-påståendemetoderna som diskuteras ovan. Majoren skillnaden mellan Junit och TestNG påståendemetoder kommer i vägen för att hantera påståenden.

TestNG tillhandahåller mer avancerade påståendehanteringstekniker som beroende klasser, grupptester, parametrerade tester etc.

Videohandledning om TestNG-påståendemetoder

Del I

Del II

Del III

tvål intervju frågor och svar för erfarna

# 1) assertEquals

Denna metod används för att hävda om två datavärden är lika. Vi kan jämföra värdena för olika datatyper som sträng, booleskt, heltal. etc. När de förväntade och verkliga värdena är desamma, går påståendet utan undantag. Om de inte gör det kastas en påståendefel.

Användande : Denna typ av påstående används för att verifiera fallet när data som visas på webbsidan är som förväntat eller enligt det angivna kravet.

Syntax:

Assert.assertEquals(actual,expected)

Parametrar:

Nuvarande - Det verkliga värdet som vi förväntar oss av automatisering.
Förväntat –Det förväntade värdet.

Exempel: För att verifiera det, om Amazon-hemsidan har en titel som säger, ”Amazon.com: Online-shopping för elektronik, kläder, datorer, böcker, DVD-skivor och mer ”

@Test public void verifyTitle() { WebDriver driver = new FirefoxDriver(); driver.get(https://www.amazon.com); String ActualTitle = driver.getTitle(); String ExpectedTitle = “Amazon.com: Online Shopping for Electronics, Apparel, Computers, Books, DVDs & more”; Assert.assertEquals(ActualTitle, ExpectedTitle); System.out.println(“Assert passed”); }

Konsol:

Assert passerade.
PASSAD: VerifyTitle

I exemplet ovan verifierades två strängar för lika värden. På samma sätt kan likhet mellan andra datatyper som heltal, boolean etc. verifieras.

# 2) assertNotEquals

assertNotEquals används för att verifiera om två datavärden inte är lika. Det är precis motsatsen till att assertEquals Assertion fungerar. När de förväntade och verkliga värdena matchar misslyckas påståendet med ett undantag och markerar testfallet som 'misslyckades'.

Användande : Detta används i fall då vi vill verifiera att varje data är unik på en webbsida. Till exempel , en telefonkatalog där inga två telefonnummer är desamma.

Syntax:

Assert.assertNotEquals(actual,expected)

Parametrar:

Nuvarande - Det verkliga värdet som vi förväntar oss av automatisering.
Förväntat - Det förväntade värdet.

Exempel: För att verifiera att pinkoderna i två olika områden är unika / inte samma.

@Test // test case to verify AssertNotEquals public void verifyAssertNotEquals{ WebDriver driver = new FirefoxDriver(); driver.get('http://chennaiiq.com/chennai/pincode-by-name.php'); WebElement Adambakkam = driver.findElement(By.xpath('//table(contains(@class,'TBox'))/tbody/tr(5)/td(3)')); WebElement Aminijikarai = driver.findElement(By.xpath('//table(contains(@class,'TBox'))/tbody/tr(15)/td(3)')); String Pincode1 = Adambakkam.getText(); String Pincode2 = Aminijikarai.getText(); System.out.println('Two Unique pincodes are : ' +Pincode1 +' && '+Pincode2); Assert.assertNotEquals(Pincode1, Pincode2); System.out.println(“Assert passed”); }

Konsol:

Två unika pinkoder är: 600012 && 600001

Assert passerade.
PASSAD: verifiera AssertNotEqual

# 3) assertTrue

assertTrue används för att verifiera om ett visst booleskt tillstånd är sant. Detta påstående returnerar sant om det angivna villkoret passerar, om inte, kastas ett påståendefel.

Syntax:

Assert.assertTrue(BooleanCondition);

Parametrar :
BooleanCondition - Villkor för att kontrollera att returtypen är sant.

Användande :

Exempel: För att verifiera om Logga in-knappen finns på Amazon.in hemsida (hävda att knappen ska visas).

Assert.assertTrue(SignIn.isDisplayed());

Här verifierar det om det booleska tillståndet - SignIn.IsDisplayed () returnerar SANT.

Exempel: För att verifiera om det finns en knapp på webbsidan.

@Test // Test cases for AssertTrue public void verifyAssertTrue(){ WebDriver driver = new FirefoxDriver(); driver.get('https://www.amazon.in');// Open browser and pass URL in address bar WebElement Navigation = driver.findElement(By.xpath('//*(@id='nav-link-yourAccount')')); WebElement SignInButton = driver.findElement(By.xpath('//span(text()='Sign in')')); Actions move = new Actions(driver); move.moveToElement(Navigation).build().perform(); Boolean checkButtonPresence = SignInButton.isDisplayed(); Assert.assertTrue(checkButtonPresence); System.out.println('Button is displayed'); }

Konsol:

Knappen visas
PASSAD: verifiera AssertTrue

# 4) assertFalse

assertFalse används för att verifiera om ett givet booleskt tillstånd är falskt. Med andra ord bör returtypen för det givna booleska tillståndet vara Falsk. Detta påstående passerar om det angivna villkoret har en FALSE returtyp om inte, kastas ett påståendefel.

Syntax:

Assert.assertFlase(BooleanCondition);

Parametrar :
BooleanCondition - Villkor för att kontrollera att returtypen är falsk.

Användande : Ett scenario där det kan användas är att verifiera om ett element inte finns på en webbsida efter en viss åtgärd.

Exempel 1: Inloggningsknappen ska inte visas efter inloggning.

Assert.assertFalse(SignIn.isDisplayed());

Detta hävdar att det booleska tillståndet - SignIn.IsDisplayed () returnerar FALSE.

Exempel 2:

För att verifiera om en div försvinner efter en viss åtgärd. Så här verifierar vi att div inte visas, eller med andra ord, hävda för ett falskt tillstånd på en div som visas.

@Test // Test case for AssertFalse public void verifyAssertFalse() throws InterruptedException { WebDriver driver = new FirefoxDriver(); driver.get('https://www.irctc.co.in'); WebElement CaptchaDiv = driver.findElement(By.xpath('//div(contains(@id,'ImgContainer'))')); WebElement CheckBox = driver.findElement(By.xpath('//*(@id='otpId')')); CheckBox.click(); Assert.assertFalse(CaptchaDiv.isDisplayed()); System.out.println('Captcha div dimmed out of screen'); }

Konsol:

Captcha div dimades ut ur skärmen
PASSERADE:verifieraAssertFalse

# 5) assertNull

Detta påstående används för att verifiera om ett objekt har ett null-returvärde. Med andra ord kontrollerar den om resultatet är noll. När objektet är Null skickas påståendet utan något undantag.

Syntax:

AssertNull(Object)

Parametrar :
Objekt - Alla datavärden som har ett nollvärde.

Användande:

Exempel 1:

Påstå om en sträng är null.

@Test public void verifyAssertion () throws InterruptedException { WebDriver driver = new FirefoxDriver(); driver.get('https://www.irctc.co.in'); String str1 = null; String str2 = 'hello'; AssertNull(str1); // asserts if str1 holds null value System.out.println('String holds null value – Assert passed'); }

Exempel 2:

Påstå om drivrutinsvärdet är noll innan du startar kromdrivrutinen.

@Test public void verifyAssertion () throws InterruptedException { WebDriver driver; AssertNull(driver); System.out.println('Driver is null – Assert passed'); }

Här är drivarobjektet noll eftersom det inte initieras. Därför kommer AssertNull (drivrutin) att bli en framgång eftersom den verifierade om objektet 'drivrutin' har ett nollvärde

# 6) assertNotNull

Detta påstående förväntar sig en giltig returtyp, annan än Null-värdet. Med andra ord söker det efter ett objekt om det inte är Null. Returtypen kan vara boolesk, sträng, heltal, lista osv. När objektet inte är null skickas Assertion, om inte, kastas en AssertionError.

Syntax:

AssertNotNull(Object)

Parametrar :
Objekt - Alla datavärden som innehåller något datavärde.

Användande:

Exempel 1: Assert är en sträng som innehåller vissa data. Det är, det är inte Null.

@Test public void verifyAssertion () throws InterruptedException { WebDriver driver = new FirefoxDriver(); driver.get('https://www.irctc.co.in'); String str1 = null; String str2 = 'hello'; AssertNotNull(str2); // asserts if str2 holds some value System.out.println('String holds null value – Assert passed'); }

Exempel 2: Kontrollera att drivrutinsobjektet inte är null efter att du startat FirefoxDriver.

@Test public void verifyAssertion () throws InterruptedException { WebDriver driver; WebDriver driver = new FirefoxDriver(); AssertNotNull(driver); System.out.println('Driver is null – Assert passed'); }

Här initieras förarobjektet till Firefox-drivrutinen och därför har 'förarobjekt' ett visst värde eftersom det inte initieras. Därför kommer AssertNotNull (drivrutin) att bli en framgång eftersom det verifierades om objektet 'drivrutin' inte har ett nullvärde

Klick här för provtestfall.

Exempelprogram för påståenden

Hävda är lika med:

package Demo; import org.junit.Assert; import org.openqa.selenium.WebDriver; import org.openqa.selenium.firefox.FirefoxDriver; public class AssertionDemo { public static void main(String() args) throws InterruptedException{ String sValue = 'Assert Equals Test'; Assert.assertEquals('Assert Equals Test', sValue); System.out.println('Test Passed'); } }

Kodförklaring:

Ovanstående kod visar användningen av AssertEquals-metoden i enkla termer.

  • Som diskuterats tidigare tar assert lika med två parametrar, dvs. förväntat resultat och faktiskt resultat. Om det förväntade resultatet inte överensstämmer med det för det faktiska resultatet, kastas ett påståendefel och programkörningen avslutas med metoden för påstås lika.
  • Ovanstående kod jämför det användardefinierade strängvärdet med det förväntade strängvärdet.
  • Observera att i realtid kommer det faktiska resultatet att vara en användardefinierad operation för vilken värdet hämtas vid körningstid och skickas som en parameter till metoden för påstås lika.

Påstå sant:

package Demo; import org.junit.Assert; import org.openqa.selenium.By; import org.openqa.selenium.WebDriver; import org.openqa.selenium.firefox.FirefoxDriver; public class AssertionsDemo1 { public static void main(String() args) throws InterruptedException{ String expectedTitle = 'Google'; System.setProperty('webdriver.gecko.driver','D:\Data_Personal\Demo\geckodriver-v0.23.0-win64\geckodriver.exe'); WebDriver driver = new FirefoxDriver(); driver.get('https://www.google.com'); Assert.assertTrue('Title does not match', expectedTitle.equals(driver.getTitle())); driver.close(); } }

Kodförklaring:

Ovanstående kod visar användningen av assertTrue-metoden.

  • Vi skickar initialt den förväntade sidtiteln till en variabel. Vi installerar sedan ett objekt från Firefox-drivrutinen och navigerar det till webbsidan - https://www.google.com
  • Senare, med hjälp av assertsTrue-metoden jämför vi den öppnade sidrubriken med den för den förväntade sidrubriken. Om den öppnade sidans titel inte överensstämmer med den för den förväntade titeln kastas ett påståendefel och programkörningen avslutas med assertTrue-metoden.
  • Ovanstående kod kommer endast att köras framgångsrikt när den faktiska sidtiteln matchar den för den förväntade sidtiteln.

Påstå falskt:

package Demo; import org.junit.Assert; import org.openqa.selenium.By; import org.openqa.selenium.WebDriver; import org.openqa.selenium.firefox.FirefoxDriver; public class AssertionsDemo1 { public static void main(String() args) throws InterruptedException{ String expectedTitle = 'Google1'; System.setProperty('webdriver.gecko.driver','D:\Data_Personal\Demo\geckodriver-v0.23.0-win64\geckodriver.exe'); WebDriver driver = new FirefoxDriver(); driver.get('https://www.google.com'); Assert.assertFalse('Title does match', expectedTitle.equals(driver.getTitle())); driver.close(); } }

Kodförklaring:

Ovanstående kod visar användningen av assertfalse-metoden.

  • Vi skickar inledningsvis den förväntade sidrubriken till en variabel och startar sedan ett objekt från Firefox-drivrutinen och navigerar till webbsidan - https://www.google.com
  • Senare, med hjälp av assertfalse-metoden, jämför vi den öppnade sidrubriken med den för den förväntade sidrubriken. Om den öppnade sidans titel matchar den för den förväntade titeln kastas ett påståendefel och programkörningen avslutas med assert false-metoden.
  • Ovanstående kod kommer bara att köras framgångsrikt när den faktiska sidrubriken inte matchar den för den förväntade sidrubriken.

End to End-kod för påståenden

Nedan följer ett exempel på slutkod för påståenden. Vi har använt följande scenario för enkelhetsändamål.

Scenario:

  • Öppna webbsidan: https://www.google.com i webbläsaren Firefox.
  • Kontrollera om den öppna sidrubriken motsvarar den för den förväntade sidrubriken med asserttrue-metoden.
  • Ange sökordet: Selen i söktextrutan.
  • Tryck på Enter-knappen på tangentbordet.
  • Kontrollera om den öppnade sidrubriken på sökresultatsidan motsvarar den för den förväntade sidrubriken med assertequals-metoden och assertfalse-metoden.
  • Stäng webbläsaren.

Exempelkod:

packageDemo; import org.junit.Assert; import org.openqa.selenium.By; import org.openqa.selenium.Keys; import org.openqa.selenium.WebDriver; import org.openqa.selenium.WebElement; import org.openqa.selenium.firefox.FirefoxDriver; public class AssertionsDemo { public static void main(String args()) throws InterruptedException { String expectedTitle = 'Google'; String expectedText = 'selenium - Google Search'; System.setProperty('webdriver.gecko.driver','D:\Data_Personal\Demo\geckodriver-v0.23.0-win64\geckodriver.exe'); // Open the web page https://www.google.com using firefox browser WebDriver driver = new FirefoxDriver(); driver.get('https://www.google.com'); // Validate if actual web page title matches with that of expected title using assert true method System.out.println('Assert true method validation'); Assert.assertTrue('Title does not match', expectedTitle.equals(driver.getTitle())); // Enter the keyword selenium on the search textbox WebElementsearchBox = driver.findElement(By.xpath('//*(@name='q')')); searchBox.sendKeys('selenium'); searchBox.sendKeys(Keys.ENTER); Thread.sleep(8000); // Validate the actual page title with expected page title using assert equals method System.out.println('Assert equals method validation'); Assert.assertEquals(expectedText, driver.getTitle()); // Page title validation using assert false method System.out.println('Assert false method validation'); Assert.assertFalse('Title does match', expectedTitle.equals(driver.getTitle())); // Close the current browser driver.close(); } }

Kodutgång:

Initialt öppnas Firefox-webbläsarfönstret med webbsidan: https://www.google.com. Asserttrue-metoden kommer att verifiera om den öppnade sidrubriken matchar den för den förväntade sidrubriken - Google.

Googles startsida

Manuset kommer att ange sökordet som Selenium och klicka på Enter-knappen.

Sök på Google

Assertfalse och assertequals metoder jämför om den faktiska sidrubriken på sökresultatskärmen matchar den för den förväntade titeln - ”selen - Google Search”. Webbläsaren kommer sedan att stängas med hjälp av metoden driver.close.

Påståendemo

Konsolutgång:

Texten nedan kommer att vara konsolutgången på Eclipse IDE

Konsolutgång

Undvik vanliga misstag när du använder Assert Class

1. Antag att ditt projekt har JUnit, TestNG och python-bibliotek konfigurerade

två . Men i ditt skript använder du TestNG-anteckningar och av misstag väljer du Junit Assertion, då kommer din Assert-klass att upphöra. Se skärmdump nedan

Junit påstående

Assert-klass kommer att upphöra

3. Så det är mycket viktigt att välja rätt Assert-klass, för TestNg välj den enda org.TestNG Assert-klassen

Fyra. För Junit väljer du org.junit.Assert-klass och så vidare.

PC-reparationsprogramvara för Windows 10

5. För att utföra Soft Assertion måste vi kalla assertAll () -metoden obligatoriskt

6. När ett påstående misslyckas kommer det att påstå påståendefel inte undantaget

Slutsats

Vi kan avsluta den här artikeln om påståenden i selen med följande pekare:

  • Ett påstående används för att jämföra det faktiska resultatet av en applikation med det förväntade resultatet.
  • Ett testfall anses endast godkänt om alla påståenden har uppfyllts.
  • AssertEquals-metoden jämför det förväntade resultatet med det faktiska resultatet. Det kastar en AssertionError om det förväntade resultatet inte överensstämmer med det för det faktiska resultatet och avslutar programkörningen med assertequals-metoden.
  • AssertTrue-metoden hävdar att ett angivet villkor är sant. Det kastar en AssertionError om villkoret som skickas till asserttrue-metoden inte är uppfyllt.
  • AssertFalse-metoden hävdar att ett angivet villkor är falskt. Det kastar en AssertionError om villkoret som skickats för att hävda falsk metod inte är uppfyllt.
  • AssertEquals, AssertTrue och AssertFalse-metoder är de vanligaste påståendena i Selen.

I kommande handledning , kommer vi att diskutera olika exempel som används i realtidsprojektscenarier och förstå hur påståenden används enligt syftet.

Vi hoppas att den här artikeln berikade din kunskap om påståenden i selen !!

=> Läs igenom The Easy Selenium Training Series.

Rekommenderad läsning

^