Selenium Warten – implizites, explizites und fließendes Warten


In Selenium, „Waits“ spielen eine wichtige Rolle bei der Durchführung von Tests. In diesem Tutorial lernen Sie verschiedene Aspekte und Unterschiede zwischen implizitem und explizitem Warten kennen Selenium.

Warum brauchen wir Wartezeiten? Selenium?

Die meisten Webanwendungen werden mit entwickelt Ajax und Javascript. Wenn eine Seite vom Browser geladen wird, werden die Elemente, mit denen wir interagieren möchten, möglicherweise in unterschiedlichen Zeitintervallen geladen.

Dies erschwert nicht nur die Identifizierung des Elements, sondern wirft auch eine Fehlermeldung aus, wenn das Element nicht gefunden wird:ElementNotVisibleException" Ausnahme. Benutzen Selenium Warten Sie, wir können dieses Problem lösen.

Betrachten wir ein Szenario, in dem wir in unserem Test sowohl implizite als auch explizite Wartezeiten verwenden müssen. Gehen Sie davon aus, dass die implizite Wartezeit auf 20 Sekunden und die explizite Wartezeit auf 10 Sekunden eingestellt ist.

Angenommen, wir versuchen, ein Element zu finden, das welche hat „Erwartete Bedingungen „(Explizites Warten): Wenn sich das Element nicht innerhalb des durch das explizite Warten (10 Sekunden) definierten Zeitrahmens befindet, wird vor dem Durchlaufen der durch das implizite Warten (20 Sekunden) definierte Zeitrahmen verwendetwing ein "ElementNotVisibleException".

Selenium Web-Treiber wartet

  1. Implizites Warten
  2. Explizites Warten

In diesem Tutorial erfahren Sie mehr über verschiedene Arten von Wartezeiten Selenium:

Implizites Warten Selenium

Das Implizites Warten Selenium wird verwendet, um den Webtreiber anzuweisen, eine bestimmte Zeit zu warten, bevor er eine „No Such Element Exception“ auslöst. Die Standardeinstellung ist 0. Sobald wir die Zeit eingestellt haben, wartet der Webtreiber diese Zeit auf das Element, bevor es durchgehtwing eine Ausnahme.

Selenium Web Driver hat die Idee des impliziten Wartens übernommen Watir.

Im folgenden Beispiel haben wir eine implizite Wartezeit mit einem Zeitrahmen von 10 Sekunden deklariert. Das bedeutet, dass eine Ausnahme ausgelöst wird, wenn das Element innerhalb dieses Zeitraums nicht auf der Webseite gefunden wird.

Implizites Warten deklarieren Selenium WebDriver:

Implizite Wait-Syntax:

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("http://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();
}
}

Erklärung des Codes

Im obigen Beispiel ist

Betrachten Sie Following Code:

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

Implizites Warten akzeptiert 2 Parameter, der erste Parameter akzeptiert die Zeit als ganzzahligen Wert und der zweite Parameter akzeptiert die Zeitmessung in Sekunden, Minuten, Milisesekunden, Mikrosekunden, Nanosekunden, Tagen, HOURS, usw.

Explizites Warten Selenium

Das Explizites Warten Selenium wird verwendet, um den Web-Treiber anzuweisen, auf bestimmte Bedingungen (erwartete Bedingungen) oder die Überschreitung der maximalen Zeit zu warten, bevor er durchkommtwing „ElementNotVisibleException“-Ausnahme. Es handelt sich um eine intelligente Art des Wartens, die jedoch nur für bestimmte Elemente angewendet werden kann. Es bietet bessere Optionen als das implizite Warten, da es auf dynamisch geladene Ajax-Elemente wartet.

Sobald wir explizites Warten deklarieren, müssen wir „Erwartete Bedingungen” oder wir können konfigurieren, wie oft wir den Zustand überprüfen möchten Fließend warten. Heutzutage verwenden wir bei der Implementierung Thread.Sleep() Im Allgemeinen wird die Verwendung nicht empfohlen

Im folgenden Beispiel erstellen wir eine Referenzwartezeit für „WebDriverWarten”-Klasse und Instanziierung mit „WebTreiber” Referenz, und wir geben einen maximalen Zeitrahmen von 20 Sekunden an.

Explizite Warte-Syntax:

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("http://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();
	}
	
}

Erklärung des Codes

Betrachten Sie Following 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();

Warten Sie in diesem WebDriver-Wartebeispiel die in „WebDriverWarten” Klasse oder die „Erwartete Bedingungen” tritt ein, je nachdem, was zuerst eintritt.

Die obige Javac Der Code besagt, dass wir für den Zeitraum von 20 Sekunden auf ein Element warten, wie im „WebDriverWarten”-Klasse auf der Webseite, bis das „Erwartete Bedingungen” sind erfüllt und die Bedingung ist „SichtbarkeitvonElementLocation".

Die folgendenwing sind die erwarteten Bedingungen, die verwendet werden können Selenium Explizites Warten

  1. alarmIsPresent()
  2. elementSelectionStateToBe()
  3. elementToBeClickable()
  4. elementToBeSelected()
  5. frameToBeAvaliableAndSwitchToIt()
  6. invisibilityOfTheElementLocated()
  7. invisibilityOfElementWithText()
  8. presentOfAllElementsLocatedBy()
  9. presentOfElementLocated()
  10. textToBePresentInElement()
  11. textToBePresentInElementLocated()
  12. textToBePresentInElementValue()
  13. titleIs()
  14. titleContains()
  15. SichtbarkeitOf()
  16. VisibilityOfAllElements()
  17. VisibilityOfAllElementsLocationBy()
  18. sichtbarkeitOfElementLocated()

Fließend warten Selenium

Das Fließend warten Selenium wird verwendet, um die maximale Zeit zu definieren, die der Web-Treiber auf eine Bedingung warten soll, sowie die Häufigkeit, mit der wir die Bedingung vor Durchlaufen überprüfen möchtenwing eine „ElementNotVisibleException“-Ausnahme. Es sucht in regelmäßigen Abständen nach dem Webelement, bis das Objekt gefunden wird oder eine Zeitüberschreitung auftritt.

Frequenz: Einrichten eines Wiederholungszyklus mit dem Zeitrahmen, um den Zustand in regelmäßigen Zeitintervallen zu überprüfen/überprüfen

Betrachten wir ein Szenario, in dem ein Element in unterschiedlichen Zeitintervallen geladen wird. Das Element kann innerhalb von 10 Sekunden, 20 Sekunden oder sogar noch länger geladen werden, wenn wir eine explizite Wartezeit von 20 Sekunden angeben. Es wird bis zur angegebenen Zeit gewartet, bevor es durchgehtwing eine Ausnahme. In solchen Szenarien ist das fließende Warten ideal, da dadurch versucht wird, das Element mit unterschiedlicher Häufigkeit zu finden, bis es gefunden wird oder der letzte Timer abgelaufen ist.

Fluent Wait-Syntax:

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

Der obige Code ist veraltet Selenium v3.11 und höher. Sie müssen verwenden

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("http://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() ;
	}
}

Erklärung des Codes

Betrachten Sie Following Code:

Wait<WebDriver> wait = new FluentWait<WebDriver>(driver)							
	.withTimeout(30, TimeUnit.SECONDS) 			
	.pollingEvery(5, TimeUnit.SECONDS) 			
	.ignoring(NoSuchElementException.class);				

Im obigen Beispiel deklarieren wir ein fließendes Warten mit einer Zeitüberschreitung von 30 Sekunden und die Häufigkeit wird durch Ignorieren von „ auf 5 Sekunden festgelegt.NoSuchElementException"

Betrachten Sie Following 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"));

Wir haben eine neue Funktion erstellt, um das Webelement auf der Seite zu identifizieren. (Beispiel: Hier ist Web Element nichts anderes als das Selenium Link auf der Webseite).

Die Frequenz ist auf 5 Sekunden und die maximale Zeit auf 30 Sekunden eingestellt. Das bedeutet also, dass die Webseite alle 5 Sekunden für einen Zeitraum von maximal 30 Sekunden nach dem Element sucht. Wenn das Element innerhalb dieses Zeitrahmens gefunden wird, führt es Folgendes aus operaAndernfalls wird ein „ElementNotVisibleException"

Überprüfen Sie auch: - Selenium IDE-Tutorial für Anfänger

Unterschied zwischen implizitem und explizitem Warten

Following ist der Hauptunterschied zwischen implizitem Warten und explizitem Warten Selenium:

Implizites Warten Explizites Warten
Die implizite Wartezeit wird auf alle Elemente im Skript angewendet Die explizite Wartezeit wird nur auf die von uns beabsichtigten Elemente angewendet
Im impliziten Warten brauchen wir nicht Geben Sie „ExpectedConditions“ für das zu suchende Element an Beim expliziten Warten müssen wir „ExpectedConditions“ für das zu suchende Element angeben
Die Verwendung wird empfohlen, wenn die Elemente innerhalb des in angegebenen Zeitrahmens lokalisiert werden Selenium implizites warten Die Verwendung wird empfohlen, wenn das Laden der Elemente lange dauert und auch zur Überprüfung der Eigenschaften des Elements wie (visibilityOfElementLocated, elementToBeClickable,elementToBeSelected)

Zusammenfassung

Implizites, explizites und fließendes Warten sind die verschiedenen Wartezeiten, die in verwendet werden Selenium. Die Verwendung dieser Wartezeiten basiert vollständig auf den Elementen, die in unterschiedlichen Zeitintervallen geladen werden. Es wird immer davon abgeraten, Thread.Sleep() while zu verwenden Testen unsere Anwendung oder den Aufbau unseres Frameworks.

Überprüfen Sie auch: - Selenium Tutorial für Anfänger: Erlernen Sie WebDriver in 7 Tagen