Warten Sie, bis die Seite in Selen geladen ist
Wie lässt man Selenium 2.0 warten, bis die Seite geladen ist?
Sie können pageloaded auch mit folgendem Code überprüfen
IWait<IWebDriver> wait = new OpenQA.Selenium.Support.UI.WebDriverWait(driver, TimeSpan.FromSeconds(30.00));
wait.Until(driver1 => ((IJavaScriptExecutor)driver).ExecuteScript("return document.readyState").Equals("complete"));
Verwenden Sie die Klasse WebDriverWait
Siehe auch hier
Sie können erwarten, ein Element zu zeigen. so etwas wie in C #:
WebDriver _driver = new WebDriver();
WebDriverWait _wait = new WebDriverWait(_driver, new TimeSpan(0, 1, 0));
_wait.Until(d => d.FindElement(By.Id("Id_Your_UIElement"));
Wenn Sie die implizite Wartezeit des Treibers festlegen und dann die Methode findElement für ein Element aufrufen, von dem Sie erwarten, dass es sich auf der geladenen Seite befindet, fragt der WebDriver dieses Element ab, bis es das Element findet oder das Zeitlimit erreicht.
driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
quelle: implizite Wartezeiten
In der Regel sollte der Web-Treiber mit Selenium 2.0 die Kontrolle erst dann an den aufrufenden Code zurückgeben, wenn festgestellt wurde, dass die Seite geladen wurde. Wenn dies nicht der Fall ist, können Sie waitforelemement aufrufen. Dabei wird findelement so lange aufgerufen, bis es gefunden wird, oder es tritt eine Zeitüberschreitung auf (eine Zeitüberschreitung kann festgelegt werden).
Ruby-Implementierung:
wait = Selenium::WebDriver::Wait.new(:timeout => 10)
wait.until {
@driver.execute_script("return document.readyState;") == "complete"
}
Sie können die Zeile System.out entfernen. Es wird zu Debug-Zwecken hinzugefügt.
WebDriver driver_;
public void waitForPageLoad() {
Wait<WebDriver> wait = new WebDriverWait(driver_, 30);
wait.until(new Function<WebDriver, Boolean>() {
public Boolean apply(WebDriver driver) {
System.out.println("Current Window State : "
+ String.valueOf(((JavascriptExecutor) driver).executeScript("return document.readyState")));
return String
.valueOf(((JavascriptExecutor) driver).executeScript("return document.readyState"))
.equals("complete");
}
});
}
Alle diese Lösungen sind für bestimmte Fälle in Ordnung, leiden jedoch unter mindestens einem von mehreren möglichen Problemen:
Sie sind nicht allgemein genug - sie möchten, dass Sie im Voraus wissen, dass eine bestimmte Bedingung für die Seite, die Sie aufrufen, zutrifft (z. B., dass ein Element angezeigt wird).
Sie sind offen für eine Rennbedingung, bei der Sie ein Element verwenden, das sowohl auf der alten als auch auf der neuen Seite vorhanden ist.
Hier ist mein Versuch einer generischen Lösung, die dieses Problem vermeidet (in Python):
Zuerst eine generische "Warte" -Funktion (benutze einen WebDriverWait, wenn du magst, ich finde sie hässlich):
def wait_for(condition_function):
start_time = time.time()
while time.time() < start_time + 3:
if condition_function():
return True
else:
time.sleep(0.1)
raise Exception('Timeout waiting for {}'.format(condition_function.__name__))
Als nächstes beruht die Lösung auf der Tatsache, dass Selen eine (interne) ID-Nummer für alle Elemente auf einer Seite aufzeichnet, einschließlich des <html> -Elements der obersten Ebene. Wenn eine Seite aktualisiert oder geladen wird, erhält sie ein neues HTML-Element mit einer neuen ID.
Angenommen, Sie möchten beispielsweise auf einen Link mit dem Text "Mein Link" klicken:
old_page = browser.find_element_by_tag_name('html')
browser.find_element_by_link_text('my link').click()
def page_has_loaded():
new_page = browser.find_element_by_tag_name('html')
return new_page.id != old_page.id
wait_for(page_has_loaded)
Für mehr Pythonic, wiederverwendbare, generische Helfer können Sie einen Kontextmanager erstellen:
from contextlib import contextmanager
@contextmanager
def wait_for_page_load(browser):
old_page = browser.find_element_by_tag_name('html')
yield
def page_has_loaded():
new_page = browser.find_element_by_tag_name('html')
return new_page.id != old_page.id
wait_for(page_has_loaded)
Und dann können Sie es für so ziemlich jede Selen-Wechselwirkung verwenden:
with wait_for_page_load(browser):
browser.find_element_by_link_text('my link').click()
Ich denke, das ist kugelsicher! Was denkst du?
Mehr Infos in einem Blogpost darüber hier
Sie können auch die Klasse: ExpectedConditions verwenden, um explizit darauf zu warten, dass ein Element auf der Webseite angezeigt wird, bevor Sie weitere Aktionen ausführen können
Mit der Klasse ExpectedConditions können Sie ermitteln, ob ein Element sichtbar ist:
WebElement element = (new WebDriverWait(getDriver(), 10)).until(ExpectedConditions.visibilityOfElementLocated(By.cssSelector("input#houseName")));
In ExpectedConditions class Javadoc finden Sie eine Liste aller Bedingungen, die Sie überprüfen können.
Dies scheint eine ernsthafte Einschränkung von WebDriver zu sein. Offensichtlich bedeutet das Warten auf ein Element nicht, dass die Seite geladen wird. Insbesondere kann das DOM vollständig erstellt werden (bereits vorhandener Zustand), wobei JS noch ausgeführt wird und CSS und Bilder noch geladen werden.
Ich glaube, die einfachste Lösung ist, eine JS-Variable beim Onload-Ereignis zu setzen, nachdem alles initialisiert wurde, und auf diese JS-Variable in Selen zu prüfen und zu warten.
Imrans Antwort auf Java 7:
WebDriverWait wait = new WebDriverWait(driver, 30);
wait.until(new ExpectedCondition<Boolean>() {
public Boolean apply(WebDriver wdriver) {
return ((JavascriptExecutor) driver).executeScript(
"return document.readyState"
).equals("complete");
}
});
Wenn Sie warten möchten, bis ein bestimmtes Element geladen ist, können Sie die Methode isDisplayed() für ein RenderedWebElement verwenden:
// Sleep until the div we want is visible or 5 seconds is over
long end = System.currentTimeMillis() + 5000;
while (System.currentTimeMillis() < end) {
// Browsers which render content (such as Firefox and IE) return "RenderedWebElements"
RenderedWebElement resultsDiv = (RenderedWebElement) driver.findElement(By.className("gac_m"));
// If results have been returned, the results are displayed in a drop down.
if (resultsDiv.isDisplayed()) {
break;
}
}
(Beispiel aus Das 5-Minuten-Handbuch für die ersten Schritte )
Warten Sie explizit oder bedingt, bis diese Bedingung erfüllt ist.
WebDriverWait wait = new WebDriverWait(wb, 60);
wait.until(ExpectedConditions.elementToBeClickable(By.name("value")));
Dies wartet 60 Sekunden lang auf jedes Webelement.
Verwenden Sie implizit Wait for Wait für jedes Element auf der Seite bis zu diesem Zeitpunkt.
driver.manage().timeouts().implicitlyWait(60, TimeUnit.SECONDS);
Dies wartet 60 Sekunden lang auf jedes Webelement.
Verwenden Sie implizit Wait for Wait für jedes Element auf der Seite, bis eine bestimmte Zeit verstrichen ist.
driver.manage().timeouts().implicitlyWait(30, TimeUnit.SECONDS);
warten Sie 30 Sekunden lang auf jedes Element auf der Seite.
Eine weitere Wartezeit ist Explizites Warten oder Bedingtes Warten in dieser Wartezeit bis zu einer bestimmten Bedingung.
WebDriverWait wait = new WebDriverWait(driver, 40);
WebElement element = wait.until(ExpectedConditions.elementToBeClickable(By.id("someid")));
Geben Sie in id das statische Element id an, das auf der Seite unterschiedlich angezeigt wird, sobald die Seite geladen ist.
Ich bin überrascht, dass Prädikate nicht die erste Wahl waren, da Sie normalerweise wissen, mit welchen Elementen Sie als Nächstes auf der Seite, die Sie laden möchten, interagieren werden. Mein Ansatz war es immer, Prädikate/Funktionen wie waitForElementByID(String id) und waitForElemetVisibleByClass(String className) usw. zu erstellen und diese dann zu verwenden und wiederzuverwenden, wo immer ich sie benötige, sei es zum Laden einer Seite oder zum Ändern des Seiteninhalts warten auf.
Zum Beispiel,
In meiner Testklasse:
driverWait.until(textIsPresent("expectedText");
In meiner Testklasse Eltern:
protected Predicate<WebDriver> textIsPresent(String text){
final String t = text;
return new Predicate<WebDriver>(){
public boolean apply(WebDriver driver){
return isTextPresent(t);
}
};
}
protected boolean isTextPresent(String text){
return driver.getPageSource().contains(text);
}
Obwohl dies viel zu sein scheint, ist es wichtig, dass Sie wiederholt nachsehen, und das Intervall für die Häufigkeit der Nachprüfung kann zusammen mit der endgültigen Wartezeit vor dem Zeitlimit festgelegt werden. Sie werden solche Methoden auch wiederverwenden.
In diesem Beispiel hat die übergeordnete Klasse den WebDriver driver und den WebDriverWait driverWait definiert und initiiert.
Ich hoffe das hilft.
Aufruf unten Funktion in Ihrem Skript, dies wird warten, bis die Seite nicht mit Javascript geladen wird
public static boolean isloadComplete(WebDriver driver)
{
return ((JavascriptExecutor) driver).executeScript("return document.readyState").equals("loaded")
|| ((JavascriptExecutor) driver).executeScript("return document.readyState").equals("complete");
}
NodeJS-Lösung:
In Nodejs kann man es über Versprechen bekommen ...
Wenn Sie diesen Code schreiben, können Sie sicher sein, dass die Seite vollständig geladen ist, wenn Sie zum dann ...
driver.get('www.sidanmor.com').then(()=> {
// here the page is fully loaded!!!
// do your stuff...
}).catch(console.log.bind(console));
Wenn Sie diesen Code schreiben, navigieren Sie und Selen wartet 3 Sekunden ...
driver.get('www.sidanmor.com');
driver.sleep(3000);
// you can't be sure that the page is fully loaded!!!
// do your stuff... hope it will be OK...
Aus der Selenium-Dokumentation:
this.get (url) → Thenable
Plant einen Befehl zum Navigieren zur angegebenen URL.
Gibt ein Versprechen zurück, das aufgelöst wird, wenn das Dokument vollständig geladen ist .
SeleniumWaiter:
import com.google.common.base.Function;
import org.openqa.Selenium.By;
import org.openqa.Selenium.WebDriver;
import org.openqa.Selenium.WebElement;
import org.openqa.Selenium.support.ui.WebDriverWait;
public class SeleniumWaiter {
private WebDriver driver;
public SeleniumWaiter(WebDriver driver) {
this.driver = driver;
}
public WebElement waitForMe(By locatorname, int timeout){
WebDriverWait wait = new WebDriverWait(driver, timeout);
return wait.until(SeleniumWaiter.presenceOfElementLocated(locatorname));
}
public static Function<WebDriver, WebElement> presenceOfElementLocated(final By locator) {
// TODO Auto-generated method stub
return new Function<WebDriver, WebElement>() {
@Override
public WebElement apply(WebDriver driver) {
return driver.findElement(locator);
}
};
}
}
Und für dich benutze es:
_waiter = new SeleniumWaiter(_driver);
try {
_waiter.waitForMe(By.xpath("//..."), 10);
}
catch (Exception e) {
// Error
}
Sie können die unten angegebene vorhandene Methode verwenden, um die Zeit für pageeLoadTimeout im folgenden Beispiel festzulegen. Wenn das Laden der Seite länger als 20 Sekunden dauert, wird eine Ausnahme für das Neuladen der Seite ausgelöst
WebDriver driver = new FirefoxDriver();
driver.manage().timeouts().pageLoadTimeout(20, TimeUnit.SECONDS)
/**
* Call this method before an event that will change the page.
*/
private void beforePageLoad() {
JavascriptExecutor js = (JavascriptExecutor) driver;
js.executeScript("document.mpPageReloaded='notYet';");
}
/**
* Call this method after an event that will change the page.
*
* @see #beforePageLoad
*
* Waits for the previous page to disappear.
*/
private void afterPageLoad() throws Exception {
(new WebDriverWait(driver, 10)).until(new Predicate<WebDriver>() {
@Override
public boolean apply(WebDriver driver) {
JavascriptExecutor js = (JavascriptExecutor) driver;
Object obj = js.executeScript("return document.mpPageReloaded;");
if (obj == null) {
return true;
}
String str = (String) obj;
if (!str.equals("notYet")) {
return true;
}
return false;
}
});
}
Sie können vom Dokument zu einem Element wechseln, wenn nur ein Teil eines Dokuments geändert wird.
Diese Technik wurde von der Antwort von sincebasic inspiriert.
Wenn Sie die Java -Bindungen für WebDriver verwenden, können Sie am besten auf das Laden von Seiten warten, indem Sie das Seitenobjekt-Entwurfsmuster mit PageFactory verwenden. Auf diese Weise können Sie AjaxElementLocatorFactory verwenden, was einfach als globales Warten auf alle Ihre Elemente fungiert. Elemente wie Drop-Boxes oder komplexe Javascript-Übergänge sind eingeschränkt, aber die benötigte Codemenge wird drastisch reduziert und die Testzeiten verkürzt. Ein gutes Beispiel finden Sie in diesem Blogpost. Grundlegendes Verständnis von Core Java wird vorausgesetzt.
http://startingwithseleniumwebdriver.blogspot.ro/2015/02/wait-in-page-factory.html
Wenn jemand Selenid verwendet:
public static final Long SHORT_WAIT = 5000L; // 5 seconds
$("some_css_selector").waitUntil(Condition.appear, SHORT_WAIT);
Weitere Bedingungen finden Sie hier: http://selenide.org/javadoc/3.0/com/codeborne/selenide/Condition.html
Mein einfacher Weg:
long timeOut = 5000;
long end = System.currentTimeMillis() + timeOut;
while (System.currentTimeMillis() < end) {
if (String.valueOf(
((JavascriptExecutor) driver)
.executeScript("return document.readyState"))
.equals("complete")) {
break;
}
}
Sie können wait verwenden. Es gibt grundsätzlich 2 Arten von Wartezeiten in Selen
- Implizites Warten
- Explizites Warten
- Implizites Warten
Dies ist sehr einfach, siehe Syntax unten:
driver.manage().timeouts().implicitlyWait(20, TimeUnit.SECONDS);
- Explizites Warten
Warten Sie explizit oder bedingt, bis eine bestimmte Bedingung erfüllt ist.
WebDriverWait wait = new WebDriverWait(driver, 40);
WebElement element = wait.until(ExpectedConditions.elementToBeClickable(By.id("someid")));
Sie können andere Eigenschaften wie visblityOf(), visblityOfElement() verwenden.
In meinem Fall habe ich Folgendes verwendet, um den Seitenladestatus zu ermitteln. In unserer Anwendung sind Lade-GIFs vorhanden, die ich wie folgt anhöre, um unerwünschte Wartezeiten im Skript zu vermeiden.
public static void processing(){
WebDriverWait wait = new WebDriverWait(driver, 30);
wait.until(ExpectedConditions.visibilityOfElementLocated(By.xpath("//div[@id='Msgpanel']/div/div/img")));
wait.until(ExpectedConditions.invisibilityOfElementLocated(By.xpath("//div[@id='Msgpanel']/div/div/img")));
}
Wo der xpath das GIF im HTML-DOM findet. Danach können Sie auch Ihre Aktionsmethoden implementieren. Klicken Sie auf.
public static void click(WebElement elementToBeClicked){
WebDriverWait wait = new WebDriverWait(driver, 45);
wait.until(ExpectedConditions.visibilityOf(element));
wait.until(ExpectedConditions.elementToBeClickable(element));
wait.ignoring(NoSuchElementException.class).ignoring(StaleElementReferenceException.class); elementToBeClicked.click();
}
Sie können explizit warten, bis ein Element auf der Webseite angezeigt wird, bevor Sie eine Aktion ausführen können (z. B. element.click ()).
driver.get("http://somedomain/url_that_delays_loading");
WebElement myDynamicElement = (new WebDriverWait(driver, 10))
.until(new ExpectedCondition<WebElement>(){
@Override
public WebElement apply(WebDriver d) {
return d.findElement(By.id("myDynamicElement"));
}});
Dies ist, was ich für ein ähnliches Szenario verwendet habe und es funktioniert gut.
Sie können diesen Codeausschnitt zum Laden der Seite verwenden:
IWait wait = new OpenQA.Selenium.Support.UI.WebDriverWait(driver,TimeSpan.FromSeconds(30.00));
wait.Until(driver1 => ((IJavaScriptExecutor)driver).ExecuteScript("return document.readyState").Equals("complete"));Oder Sie können waiter verwenden, damit jedes Element geladen wird und auf dieser Seite sichtbar/anklickbar wird. Dies wird höchstwahrscheinlich am Ende des Ladevorgangs geladen:
Wait.Until(ExpectedConditions.ElementToBeClickable(By.XPath(xpathOfElement));
var element = GlobalDriver.FindElement(By.XPath(xpathOfElement));
var isSucceededed = element != null;Hier ist eine Java 8-Version der aktuell am besten bewertete Antwort :
WebDriverWait wait = new WebDriverWait(myDriver, 15);
wait.until(webDriver -> ((JavascriptExecutor) myDriver).executeScript("return document.readyState").toString().equals("complete"));
Wobei myDriver ein WebDriver Objekt ist (vorher deklariert).
Hinweis : Beachten Sie, dass diese Methode (document.readyState) nur das DOM überprüft.
Der beste Weg, den ich gesehen habe, ist die Verwendung der stalenessOf ExpectedCondition, um zu warten, bis die alte Seite veraltet ist.
Beispiel:
WebDriver driver = new FirefoxDriver();
WebDriverWait wait = new WebDriverWait(driver, 10);
WebElement oldHtml = driver.findElement(By.tagName("html"));
wait.until(ExpectedConditions.stalenessOf(oldHtml));
Es dauert zehn Sekunden, bis das alte HTML-Tag veraltet ist, und löst dann eine Ausnahme aus, wenn dies nicht der Fall ist.
Ich benutze Node + Selenium-Webdriver (welche Version ist jetzt 3.5.0). was ich dafür tue ist:
var webdriver = require('Selenium-webdriver'),
driver = new webdriver.Builder().forBrowser('chrome').build();
;
driver.wait(driver.executeScript("return document.readyState").then(state => {
return state === 'complete';
}))
Für implizites Warten können Sie Folgendes verwenden:
driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS)
Damit die Webseite darauf wartet, dass ein bestimmtes Objekt sichtbar ist oder die Bedingung wahr ist. Sie können wait feather von web driver verwenden.
//120 is maximum number of seconds to wait.
WebDriverWait wait = new WebDriverWait(driver,120);
wait.until(ExpectedConditions.elementToBeClickable("CONDITITON"));
In Java kann der Thread auch für eine bestimmte Zeit in den Ruhezustand versetzt werden.
Thread.sleep(numberOfSeconds*1000);
//This line will cause thread to sleep for seconds as variable
Ich habe eine Methode erstellt, um die Methode thread.sleep zu vereinfachen
public static void wait_time(int seconds){
try {
Thread.sleep(seconds*1000);
}catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
Verwenden Sie die Methode als wait_time (10); Der Thread wird für 10 Sekunden schlafen.
Wie man Selen dazu bringt, nach einem Klick auf das Laden der Seite zu warten bietet den folgenden interessanten Ansatz:
- Speichern Sie einen Verweis auf
WebElementvon der alten Seite. - Klicken Sie auf den Link.
- Rufen Sie weiterhin Operationen für
WebElementauf, bisStaleElementReferenceExceptionausgelöst wird.
Beispielcode:
WebElement link = ...;
link.click();
new WebDriverWait(webDriver, timeout).until((org.openqa.Selenium.WebDriver input) ->
{
try
{
link.isDisplayed();
return false;
}
catch (StaleElementReferenceException unused)
{
return true;
}
});
private static void checkPageIsReady(WebDriver driver) {
JavascriptExecutor js = (JavascriptExecutor) driver;
// Initially bellow given if condition will check ready state of page.
if (js.executeScript("return document.readyState").toString().equals("complete")) {
System.out.println("Page Is loaded.");
return;
}
// This loop will rotate for 25 times to check If page Is ready after
// every 1 second.
// You can replace your value with 25 If you wants to Increase or
// decrease wait time.
for (int i = 0; i < 25; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
}
// To check page ready state.
if (js.executeScript("return document.readyState").toString().equals("complete")) {
break;
}
}
}
public static int counter = 0;
public void stepGeneralWait() {
boolean breakIt = true;
while (true) {
breakIt = true;
try {
do{
// here put e.g. your spinner ID
Controller.driver.findElement(By.xpath("//*[@id='static']/div[8]/img")).click();
Thread.sleep(10000);
counter++;
if (counter > 3){
breakIt = false;
}
}
while (breakIt);
} catch (Exception e) {
if (e.getMessage().contains("element is not attached")) {
breakIt = false;
}
}
if (breakIt) {
break;
}
}
try {
Thread.sleep(12000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
Sie können diesen Code verwenden, damit die Seite vollständig geladen wird, bis das Element gefunden wird.
public void waitForBrowserToLoadCompletely() {
String state = null;
String oldstate = null;
try {
System.out.print("Waiting for browser loading to complete");
int i = 0;
while (i < 5) {
Thread.sleep(1000);
state = ((JavascriptExecutor) driver).executeScript("return document.readyState;").toString();
System.out.print("." + Character.toUpperCase(state.charAt(0)) + ".");
if (state.equals("interactive") || state.equals("loading"))
break;
/*
* If browser in 'complete' state since last X seconds. Return.
*/
if (i == 1 && state.equals("complete")) {
System.out.println();
return;
}
i++;
}
i = 0;
oldstate = null;
Thread.sleep(2000);
/*
* Now wait for state to become complete
*/
while (true) {
state = ((JavascriptExecutor) driver).executeScript("return document.readyState;").toString();
System.out.print("." + state.charAt(0) + ".");
if (state.equals("complete"))
break;
if (state.equals(oldstate))
i++;
else
i = 0;
/*
* If browser state is same (loading/interactive) since last 60
* secs. Refresh the page.
*/
if (i == 15 && state.equals("loading")) {
System.out.println("\nBrowser in " + state + " state since last 60 secs. So refreshing browser.");
driver.navigate().refresh();
System.out.print("Waiting for browser loading to complete");
i = 0;
} else if (i == 6 && state.equals("interactive")) {
System.out.println(
"\nBrowser in " + state + " state since last 30 secs. So starting with execution.");
return;
}
Thread.sleep(4000);
oldstate = state;
}
System.out.println();
} catch (InterruptedException ie) {
ie.printStackTrace();
}
}
Am einfachsten ist es, auf ein Element zu warten, das auf der geladenen Seite angezeigt wird.
Wenn Sie bereits nach dem Laden einer Seite auf eine Schaltfläche klicken möchten, können Sie wait und click verwenden:
await().until().at.most(20, TimeUnit.Seconds).some_element.isDisplayed(); // or another condition
getDriver().find(some_element).click;
verwenden Sie folgenden Code, es ist sehr einfach und einfach für das Laden von Seiten.
public void PageLoad(IWebDriver driver, By by)
{
try
{
Console.WriteLine("PageLoad" + by);
WebDriverWait wait = new WebDriverWait(driver, TimeSpan.FromSeconds(30));
wait.Until(ExpectedConditions.ElementIsVisible(by));
wait = new WebDriverWait(driver, TimeSpan.FromSeconds(30)); // 30 seconds wait until element not found.
wait.Until(ExpectedConditions.ElementToBeClickable(by));
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
Assert.Fail("Element not found!")
}
}
ich hoffe das hilft dir.
WebDriver driver = new ff / chrome / anyDriverYouWish(); driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);Wartet maximal 10 Sekunden.WebDriverWait wait = new WebDriverWait(driver, 10); wait.until(ExpectedConditions.visibilityOf(WebElement element));FluentWait<Driver> fluentWait; fluentWait = new FluentWait<>(driver).withTimeout(30, TimeUnit.SECONDS) .pollingEvery(200, TimeUnit.MILLISECONDS) .ignoring(NoSuchElementException.class);
Der Vorteil der letzten Option besteht darin, dass Sie eine zu erwartende Ausnahme einfügen können, damit die Ausführung fortgesetzt wird.
driver.asserts().assertElementFound("Page was not loaded",
By.xpath("//div[@id='actionsContainer']"),Constants.LOOKUP_TIMEOUT);
verwenden Sie eine if-Bedingung und für jedes der vorhandenen Elemente
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}