Selenium Wachten – Impliciet en Expliciet met Syntaxis

In Selenium‘Wachten’ spelen een belangrijke rol bij het uitvoeren van tests. In deze tutorial leer je verschillende aspecten en het verschil tussen impliciet en expliciet wachten Selenium.

Waarom hebben we wachttijden nodig Selenium?

De meeste webapplicaties zijn ontwikkeld met behulp van 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 als het element niet gelokaliseerd is, zal het ook een “ElementNiet ZichtbaarUitzondering" uitzondering. Gebruik makend van Selenium Wacht, we kunnen dit probleem oplossen.

Laten we een scenario overwegen waarin we in onze test zowel impliciete als expliciete wachttijden moeten gebruiken. 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 iets heeft “Verwachte omstandigheden “(Expliciete wachttijd), Als het element zich niet binnen het tijdsbestek bevindt dat is gedefinieerd door de expliciete wachttijd (10 seconden), wordt het tijdsbestek gebruikt dat is gedefinieerd door de impliciete wachttijd (20 seconden) voordat een “ElementNiet ZichtbaarUitzondering'.

Selenium Webstuurprogramma wacht

Impliciete wachttijd
Expliciete wachttijd

In deze zelfstudie leert u over verschillende soorten wachttijden Selenium:

Impliciet Wacht binnen Selenium

Uw partner voor Impliciet Wacht binnen Selenium wordt gebruikt om de webdriver te vertellen dat hij een bepaalde tijd moet wachten voordat hij een "No Such Element Exception" gooit. De standaardinstelling is 0. Zodra we de tijd hebben ingesteld, wacht de webdriver die tijd op het element voordat hij een uitzondering gooit.

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

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

Om impliciet wachten aan te geven Selenium Webstuurprogramma:

Impliciete wacht-syntaxis:

driver.manage().timeouts().implicitlyWait(TimeOut, TimeUnit.SECONDS);

package guru.test99;
import java.util.concurrent.TimeUnit;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.testng.annotations.Test;
public class AppTest {
	
	protected WebDriver driver;
	@Test
	public void guru99tutorials() throws InterruptedException 
	{
	System.setProperty ("webdriver.chrome.driver",".\\chromedriver.exe" );
	driver = new ChromeDriver(); 
	driver.manage().timeouts().implicitlyWait(10,TimeUnit.SECONDS) ;
	String eTitle = "Demo Guru99 Page";
	String aTitle = "" ;
	// launch Chrome and redirect it to the Base URL
	driver.get("https://demo.guru99.com/test/guru99home/" );
	//Maximizes the browser window
	driver.manage().window().maximize() ;
	//get the actual value of the title
	aTitle = driver.getTitle();
	//compare the actual title with the expected title
	if (aTitle.equals(eTitle))
	{
	System.out.println( "Test Passed") ;
	}
	else {
	System.out.println( "Test Failed" );
	}
	//close browser
	driver.close();
}
}

Verklaring van code

In het bovenstaande voorbeeld,

Overweeg de volgende code:

driver.manage().timeouts().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 tijdsmeting in termen van SECONDEN, MINUTEN, MILISECONDEN, MICROSECONDEN, NANOSECONDEN, DAGEN, UREN, enz.

Expliciet Wacht binnen Selenium

Uw partner voor Expliciet Wacht binnen Selenium wordt gebruikt om de webdriver te vertellen te wachten op bepaalde voorwaarden (Expected Conditions) of maximale tijd overschreden voordat de uitzondering "ElementNotVisibleException" wordt gegooid. Het is een intelligent soort wachten, maar het kan alleen worden toegepast op opgegeven elementen. Het biedt betere opties dan impliciet wachten omdat het wacht op dynamisch geladen Ajax-elementen.

Zodra we expliciet wachten verklaren, moeten we “Verwachte omstandigheden'Of we kunnen configureren hoe vaak we de voorwaarde willen controleren met behulp van Vloeiend wachten. Tegenwoordig gebruiken we tijdens de implementatie Draad.Sleep() over het algemeen wordt het gebruik ervan niet aanbevolen

In het onderstaande voorbeeld creëren we een referentiewachttijd voor “WebDriverWacht” klasse en instantiëren met behulp van “webdriver”referentie, en we geven een maximaal tijdsbestek van 20 seconden.

Expliciete wacht-syntaxis:

WebDriverWait wait = new WebDriverWait(WebDriverRefrence,TimeOut);

package guru.test99;

import java.util.concurrent.TimeUnit;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;
import org.testng.annotations.Test;

public class AppTest2 {
	protected WebDriver driver;
	@Test
	public void guru99tutorials() throws InterruptedException 
	{
	System.setProperty ("webdriver.chrome.driver",".\\chromedriver.exe" );
	driver = new ChromeDriver(); 
	WebDriverWait wait=new WebDriverWait(driver, 20);
	String eTitle = "Demo Guru99 Page";
	String aTitle = "" ;
	// launch Chrome and redirect it to the Base URL
	driver.get("https://demo.guru99.com/test/guru99home/" );
	//Maximizes the browser window
	driver.manage().window().maximize() ;
	//get the actual value of the title
	aTitle = driver.getTitle();
	//compare the actual title with the expected title
	if (aTitle.contentEquals(eTitle))
	{
	System.out.println( "Test Passed") ;
	}
	else {
	System.out.println( "Test Failed" );
	}
	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 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();

In dit wachtvoorbeeld van WebDriver wacht u gedurende de hoeveelheid tijd die is gedefinieerd in de tekst "WebDriverWacht'klas of de'Verwachte omstandigheden” zal optreden, afhankelijk van wat zich het eerst voordoet.

Bovenstaande Java code stelt dat we wachten op een element gedurende het tijdsbestek van 20 seconden zoals gedefinieerd in de “WebDriverWacht” klasse op de webpagina tot de “Verwachte omstandigheden' is voldaan en de voorwaarde is 'zichtbaarheidvanElementLocated'.

Hieronder staan de verwachte omstandigheden die kunnen worden gebruikt in Selenium Expliciete wachttijd

alertIsAanwezig()
elementSelectionStateToBe()
elementToBeClickable()
elementToBeSelected()
frameToBeAvaliableAndSwitchToIt()
onzichtbaarheidOfTheElementLocated()
onzichtbaarheidOfElementWithText()
aanwezigheidOfAllElementsLocatedBy()
aanwezigheidOfElementLocated()
textToBePresentInElement()
textToBePresentInElementLocated()
textToBePresentInElementValue()
titelIs()
titelBevat()
zichtbaarheidVan()
zichtbaarheidOfAllElements()
zichtbaarheidOfAllElementsLocatedBy()
zichtbaarheidOfElementLocated()

Vloeiend Wacht binnen Selenium

Uw partner voor Vloeiend Wacht binnen Selenium wordt gebruikt om de maximale tijd te definiëren voor de webdriver om te wachten op een voorwaarde, evenals de frequentie waarmee we de voorwaarde willen controleren voordat we een "ElementNotVisibleException"-uitzondering gooien. Het controleert op regelmatige intervallen op het webelement totdat het object is gevonden of er een time-out optreedt.

Frequentie: Een herhalingscyclus instellen met een tijdsbestek om de toestand met een regelmatig tijdsinterval te verifiëren/controleren

Laten we een scenario overwegen waarin een element op verschillende tijdsintervallen wordt geladen. Het element kan binnen 10 seconden, 20 seconden of zelfs langer laden als we een expliciete wachttijd van 20 seconden declareren. Het wacht tot de opgegeven tijd voordat er een uitzondering wordt gegenereerd. In dergelijke scenario's is de vloeiende wachttijd de ideale wachttijd om te gebruiken, omdat deze zal proberen het element op verschillende frequenties te vinden totdat het het vindt of de laatste timer afloopt.

Vloeiende wacht-syntaxis:

Wait wait = new FluentWait(WebDriver reference)
.withTimeout(timeout, SECONDS)
.pollingEvery(timeout, SECONDS)
.ignoring(Exception.class);

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

Wait wait = new FluentWait(WebDriver reference)
.withTimeout(Duration.ofSeconds(SECONDS))
.pollingEvery(Duration.ofSeconds(SECONDS))
.ignoring(Exception.class);

package guru.test99;

import org.testng.annotations.Test;
import java.util.NoSuchElementException;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.FluentWait;
import org.openqa.selenium.support.ui.Wait;
import org.openqa.selenium.support.ui.WebDriverWait;
import org.testng.annotations.Test;

public class AppTest3 {
	protected WebDriver driver;
	@Test
	public void guru99tutorials() throws InterruptedException 
	{
	System.setProperty ("webdriver.chrome.driver",".\\chromedriver.exe" );
	String eTitle = "Demo Guru99 Page";
	String aTitle = "" ;
	driver = new ChromeDriver();
	// launch Chrome and redirect it to the Base URL
	driver.get("https://demo.guru99.com/test/guru99home/" );
	//Maximizes the browser window
	driver.manage().window().maximize() ;
	//get the actual value of the title
	aTitle = driver.getTitle();
	//compare the actual title with the expected title
	if (aTitle.contentEquals(eTitle))
	{
	System.out.println( "Test Passed") ;
	}
	else {
	System.out.println( "Test Failed" );
		}
	
	Wait<WebDriver> wait = new FluentWait<WebDriver>(driver)							
			.withTimeout(30, TimeUnit.SECONDS) 			
			.pollingEvery(5, TimeUnit.SECONDS) 			
			.ignoring(NoSuchElementException.class);
	WebElement clickseleniumlink = wait.until(new Function<WebDriver, WebElement>(){
	
		public WebElement apply(WebDriver driver ) {
			return driver.findElement(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"));
		}
	});
	//click on the selenium link
	clickseleniumlink.click();
	//close~ browser
	driver.close() ;
	}
}

Verklaring van code

Overweeg de volgende code:

Wait<WebDriver> wait = new FluentWait<WebDriver>(driver)							
	.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 wordt de frequentie ingesteld op 5 seconden door “Geen DergelijkElementUitzondering"

Overweeg de volgende code:

public WebElement apply(WebDriver driver) {
        return driver.findElement(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"));

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

De frequentie is ingesteld op 5 seconden en de maximale tijd is ingesteld op 30 seconden. Dit betekent dat het elke 5 seconden controleert op het element op de webpagina voor de maximale tijd van 30 seconden. Als het element zich binnen dit tijdsbestek bevindt, voert het de bewerkingen uit, anders gooit het een "ElementNiet ZichtbaarUitzondering"

Controleer ook: - Selenium IDE-zelfstudie voor beginners

Verschil tussen impliciet wachten versus expliciet wachten

Hieronder volgt het belangrijkste verschil tussen impliciet wachten en expliciet wachten in Selenium:

Impliciete wachttijd	Expliciete wachttijd
Impliciete wachttijd wordt toegepast op alle elementen in het script	Expliciete wachttijd wordt alleen toegepast op die elementen die door ons zijn bedoeld
Bij impliciet wachten hebben we dat nodig niet specificeer “ExpectedConditions” op het te lokaliseren element	Bij Explicit Wait moeten we “ExpectedConditions” opgeven voor het element dat moet worden gelokaliseerd
Het wordt aanbevolen om te gebruiken wanneer de elementen zich bevinden binnen het opgegeven tijdsbestek Selenium impliciet wachten	Het wordt aanbevolen om dit te gebruiken wanneer het laden van de elementen lang duurt en ook voor het verifiëren van de eigenschap van het element, zoals (visibilityOfElementLocated, elementToBeClickable,elementToBeSelected)

Conclusie

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

Controleer ook: - Selenium Tutorial voor beginners: leer WebDriver in 7 dagen

Meer lezen