Impliciet, expliciet, & Vloeiend wachten in Selenium WebDriver

Inhoudsopgave:

Anonim

In Selenium spelen "Waits" een belangrijke rol bij het uitvoeren van tests. In deze tutorial leer je verschillende aspecten van zowel "Impliciet" als "Expliciet" wachten in Selenium.

In deze tutorial leer je:

  • Waarom hebben we wachttijden nodig in selenium?
  • Impliciet wachten
  • Expliciet wachten
  • Vloeiend wachten

Waarom hebben we wachttijden nodig in selenium?

De meeste webapplicaties zijn ontwikkeld met Ajax en Javascript. Wanneer een pagina door de browser wordt geladen, kunnen de elementen waarmee we willen communiceren met verschillende tijdsintervallen worden geladen.

Dit maakt het niet alleen moeilijk om het element te identificeren, maar ook als het element niet is gelokaliseerd, wordt er een " ElementNotVisibleException " -uitzondering gegenereerd . Met Selenium Waits kunnen we dit probleem oplossen.

Laten we eens kijken naar een scenario waarin we zowel impliciete als expliciete wachttijden moeten gebruiken in onze test. Stel dat de impliciete wachttijd is ingesteld op 20 seconden en de expliciete wachttijd is ingesteld op 10 seconden.

Stel dat we een element proberen te vinden dat een aantal "ExpectedConditions " heeft (expliciet wachten), als het element zich niet binnen het tijdsbestek bevindt dat is gedefinieerd door het expliciete wachten (10 seconden), zal het het tijdsbestek gebruiken dat is gedefinieerd door impliciet wachten ( 20 seconden) voordat je een " ElementNotVisibleException " gooit .

Selenium-webstuurprogramma wacht

  1. Impliciet wachten
  2. Expliciet wachten

Impliciet wachten in selenium

De Impliciete Wachten in Selenium wordt gebruikt om de webdriver te vertellen een bepaalde tijd te wachten voordat het een "No Such Element Exception" genereert. De standaardinstelling is 0. Zodra we de tijd hebben ingesteld, wacht het webstuurprogramma voor die tijd op het element voordat een uitzondering wordt gegenereerd.

Selenium Web Driver heeft het idee van impliciet wachten geleend van Watir.

In het onderstaande voorbeeld hebben we een impliciete wachttijd gedeclareerd met een tijdsbestek van 10 seconden. Het betekent dat als het element zich niet binnen dat tijdsbestek op de webpagina bevindt, het een uitzondering genereert.

Om impliciet wachten te verklaren:

Syntaxis :

driver.manage (). timeouts (). implicitlyWait (TimeOut, TimeUnit.SECONDS); 
pakket guru.test99;importeer java.util.concurrent.TimeUnit;import org.openqa.selenium.By;importeer org.openqa.selenium.WebDriver;importeer org.openqa.selenium.chrome.ChromeDriver;importeer org.testng.annotations.Test;openbare klasse AppTest {beschermde WebDriver-driver;@Testpublic void guru99tutorials () gooit InterruptedException​System.setProperty ("webdriver.chrome.driver", ". \\ chromedriver.exe");driver = nieuwe ChromeDriver ();driver.manage (). time-outs (). implicitlyWait (10, TimeUnit.SECONDS);String eTitle = "Demo Guru99-pagina";String aTitle = "";// start Chrome en stuur het door naar de basis-URLdriver.get ("http://demo.guru99.com/test/guru99home/");// Maximaliseert het browservensterdriver.manage (). window (). maximaliseren ();// haal de werkelijke waarde van de titel opaTitle = driver.getTitle ();// vergelijk de werkelijke titel met de verwachte titelif (aTitle.equals (eTitle))​System.out.println ("Test geslaagd");​anders {System.out.println ("Test mislukt");​// browser sluitendriver.close ();​​

Verklaring van de code

In het bovenstaande voorbeeld

Overweeg de volgende code:

driver.manage (). time-outs (). implicitlyWait (10, TimeUnit.SECONDS);

Impliciet wachten accepteert 2 parameters, de eerste parameter accepteert de tijd als een geheel getal en de tweede parameter accepteert de tijdmeting in termen van SECONDEN, MINUTEN, MILISECONDE, MICROSECONDS, NANOSECONDS, DAGEN, UREN, etc.

Expliciet wachten in selenium

De expliciete wachttijd in Selenium wordt gebruikt om het webstuurprogramma te vertellen te wachten op bepaalde voorwaarden (verwachte voorwaarden) of de maximale tijd die is overschreden voordat de uitzondering "ElementNotVisibleException" wordt gegenereerd. Het is een intelligent soort wachten, maar het kan alleen voor gespecificeerde elementen worden toegepast. Het geeft betere opties dan impliciet wachten terwijl het wacht op dynamisch geladen Ajax-elementen.

Zodra we expliciet wachten declareren, moeten we " ExpectedConditions " gebruiken of we kunnen configureren hoe vaak we de conditie willen controleren met Fluent Wait . Tegenwoordig gebruiken we tijdens de implementatie Thread.Sleep () over het algemeen wordt het niet aanbevolen om

In het onderstaande voorbeeld maken we een referentie-wachttijd voor de " WebDriverWait " -klasse en instantiëren we met behulp van de " WebDriver " -referentie , en we geven een maximum tijdsbestek van 20 seconden.

Syntaxis: 

WebDriverWait wait = nieuwe WebDriverWait (WebDriverRefrence, TimeOut);
pakket guru.test99;importeer java.util.concurrent.TimeUnit;import org.openqa.selenium.By;importeer org.openqa.selenium.WebDriver;importeer org.openqa.selenium.WebElement;importeer org.openqa.selenium.chrome.ChromeDriver;import org.openqa.selenium.support.ui.ExpectedConditions;importeer org.openqa.selenium.support.ui.WebDriverWait;importeer org.testng.annotations.Test;openbare klasse AppTest2 {beschermde WebDriver-driver;@Testpublic void guru99tutorials () gooit InterruptedException​System.setProperty ("webdriver.chrome.driver", ". \\ chromedriver.exe");driver = nieuwe ChromeDriver ();WebDriverWait wait = nieuwe WebDriverWait (driver, 20);String eTitle = "Demo Guru99-pagina";String aTitle = "";// start Chrome en stuur het door naar de basis-URLdriver.get ("http://demo.guru99.com/test/guru99home/");// Maximaliseert het browservensterdriver.manage (). window (). maximaliseren ();// haal de werkelijke waarde van de titel opaTitle = driver.getTitle ();// vergelijk de werkelijke titel met de verwachte titelif (aTitle.contentEquals (eTitle))​System.out.println ("Test geslaagd");​anders {System.out.println ("Test mislukt");​WebElement guru99seleniumlink;guru99seleniumlink = wait.until (ExpectedConditions.visibilityOfElementLocated (By.xpath ("/ html / body / div [1] / section / div [2] / div / div [1] / div / div [1] / div / div / div / div [2] / div [2] / div / div / div / div / div [1] / div / div / a / i ")));guru99seleniumlink.click ();​​

Verklaring van de code

Overweeg de volgende code:

WebElement guru99seleniumlink;guru99seleniumlink = wait.until (ExpectedConditions.visibilityOfElementLocated (By.xpath ("/ html / body / div [1] / section / div [2] / div / div [1] / div / div [1] / div / div / div / div [2] / div [2] / div / div / div / div / div [1] / div / div / a / i ")));guru99seleniumlink.click ();

Wacht in dit WebDriver-wachtvoorbeeld totdat de hoeveelheid tijd die is gedefinieerd in de " WebDriverWait " -klasse of de " ExpectedConditions " plaatsvindt, afhankelijk van wat zich het eerst voordoet.

De bovenstaande Java-code staat dat we wachten op een element voor het tijdsbestek van 20 seconden, zoals gedefinieerd in de " WebDriverWait " class op de webpagina totdat de " ExpectedConditions " wordt voldaan en de conditie is " visibilityofElementLocated ".

Hieronder volgen de verwachte condities die kunnen worden gebruikt in Selenium Explicit Wait

  1. alertIsPresent ()
  2. elementSelectionStateToBe ()
  3. elementToBeClickable ()
  4. elementToBeSelected ()
  5. frameToBeAvaliableAndSwitchToIt ()
  6. invisibilityOfTheElementLocated ()
  7. invisibilityOfElementWithText ()
  8. presenceOfAllElementsLocatedBy ()
  9. presenceOfElementLocated ()
  10. textToBePresentInElement ()
  11. textToBePresentInElementLocated ()
  12. textToBePresentInElementValue ()
  13. titleIs ()
  14. titleContains ()
  15. zichtbaarheid ()
  16. zichtbaarheidOfAllElements ()
  17. zichtbaarheidOfAllElementsLocatedBy ()
  18. zichtbaarheidOfElementLocated ()

Vloeiend wachten in selenium

De vloeiende wachttijd in Selenium wordt gebruikt om de maximale tijd te definiëren voor het webstuurprogramma om op een voorwaarde te wachten, evenals de frequentie waarmee we de voorwaarde willen controleren voordat een "ElementNotVisibleException" -uitzondering wordt gegenereerd. Het controleert met regelmatige tussenpozen op het webelement totdat het object is gevonden of er een time-out optreedt.

Frequentie: het opzetten van een herhalingscyclus met het tijdsbestek om de toestand op regelmatige tijdstippen te verifiëren / controleren

Laten we eens kijken naar een scenario waarin een element met verschillende tijdsintervallen wordt geladen. Het element kan binnen 10 seconden, 20 seconden of zelfs meer worden geladen als we een expliciete wachttijd van 20 seconden aangeven. Het wacht tot de opgegeven tijd voordat een uitzondering wordt gegenereerd. In dergelijke scenario's is het vloeiende wachten het ideale wachten om te gebruiken, omdat dit zal proberen het element met een andere frequentie te vinden totdat het het vindt of de laatste timer afloopt.

Syntaxis:

Wait wait = new FluentWait (WebDriver-referentie).withTimeout (time-out, SECONDS).pollingEvery (time-out, SECONDS).ignoring (Exception.class);

Bovenstaande code is verouderd in Selenium v3.11 en hoger. U moet

Wait wait = new FluentWait (WebDriver-referentie).withTimeout (Duration.ofSeconds (SECONDS)).pollingEvery (Duration.ofSeconds (SECONDS)).ignoring (Exception.class);
pakket guru.test99;importeer org.testng.annotations.Test;importeer java.util.NoSuchElementException;importeer java.util.concurrent.TimeUnit;importeer java.util.function.Function;import org.openqa.selenium.By;importeer org.openqa.selenium.WebDriver;importeer org.openqa.selenium.WebElement;importeer org.openqa.selenium.chrome.ChromeDriver;import org.openqa.selenium.support.ui.ExpectedConditions;importeer org.openqa.selenium.support.ui.FluentWait;importeer org.openqa.selenium.support.ui.Wait;importeer org.openqa.selenium.support.ui.WebDriverWait;importeer org.testng.annotations.Test;openbare klasse AppTest3 {beschermde WebDriver-driver;@Testpublic void guru99tutorials () gooit InterruptedException​System.setProperty ("webdriver.chrome.driver", ". \\ chromedriver.exe");String eTitle = "Demo Guru99-pagina";String aTitle = "";driver = nieuwe ChromeDriver ();// start Chrome en stuur het door naar de basis-URLdriver.get ("http://demo.guru99.com/test/guru99home/");// Maximaliseert het browservensterdriver.manage (). window (). maximaliseren ();// haal de werkelijke waarde van de titel opaTitle = driver.getTitle ();// vergelijk de werkelijke titel met de verwachte titelif (aTitle.contentEquals (eTitle))​System.out.println ("Test geslaagd");​anders {System.out.println ("Test mislukt");​Wacht  wait = new FluentWait  (stuurprogramma).withTimeout (30, TimeUnit.SECONDS).pollingEvery (5, TimeUnit.SECONDS).ignoring (NoSuchElementException.class);WebElement clickseleniumlink = wait.until (nieuwe functie  () {openbare WebElement toepassen (WebDriver-stuurprogramma) {return driver.findElement (By.xpath ("/ html / body / div [1] / sectie / div [2] / div / div [1] / div / div [1] / div / div / div / div [2 ] / div [2] / div / div / div / div / div [1] / div / div / a / i "));​​// klik op de seleniumlinkclickseleniumlink.click ();// sluit ~ browserdriver.close ();​​

Verklaring van de code

Overweeg de volgende code:

Wacht  wait = new FluentWait  (stuurprogramma).withTimeout (30, TimeUnit.SECONDS).pollingEvery (5, TimeUnit.SECONDS).ignoring (NoSuchElementException.class);

In het bovenstaande voorbeeld verklaren we een vloeiende wachttijd met een time-out van 30 seconden en de frequentie is ingesteld op 5 seconden door " NoSuchElementException " te negeren

Overweeg de volgende code:

openbare WebElement toepassen (WebDriver-stuurprogramma) {return driver.findElement (By.xpath ("/ html / body / div [1] / sectie / div [2] / div / div [1] / div / div [1] / div / div / div / div [2 ] / div [2] / div / div / div / div / div [1] / div / div / a / i "));

We hebben een nieuwe functie gemaakt om het webelement op de pagina te identificeren. (Bijv: hier is Web Element niets anders dan de Selenium-link op de webpagina).

De frequentie is ingesteld op 5 seconden en de maximale tijd is ingesteld op 30 seconden. Dit betekent dus dat het gedurende maximaal 30 seconden om de 5 seconden naar het element op de webpagina zal zoeken. Als het element zich binnen dit tijdsbestek bevindt, voert het de bewerkingen uit, anders genereert het een " ElementNotVisibleException "

Verschil tussen impliciet wachten en expliciet wachten

Impliciet wachten Expliciet wachten
  • Impliciete wachttijd wordt toegepast op alle elementen in het script
  • Expliciete wachttijd wordt alleen toegepast op die elementen die door ons zijn bedoeld
  • In Impliciete Wacht, moeten we niet "ExpectedConditions" specificeren op het element te worden geplaatst
  • In Explicit Wait moeten we "ExpectedConditions" specificeren voor het element dat moet worden gelokaliseerd
  • Het wordt aanbevolen om te gebruiken wanneer de elementen zich bevinden binnen het tijdsbestek dat is gespecificeerd in Selenium impliciet wachten
  • Het wordt aanbevolen om te gebruiken wanneer het laden van de elementen lang duurt en ook voor het verifiëren van de eigenschap van het element zoals (visibleOfElementLocated, elementToBeClickable, elementToBeSelected)

Gevolgtrekking:

Impliciet, expliciet en vloeiend wachten zijn de verschillende wachttijden die in Selenium worden gebruikt. Het gebruik van deze wachttijden is volledig gebaseerd op de elementen die met verschillende tijdsintervallen worden geladen. Het wordt altijd niet aanbevolen om Thread.Sleep () te gebruiken tijdens het testen van onze applicatie of het bouwen van ons framework.

Dit artikel is bijgedragen door Chaitanya Pujari