it-swarm.com.de

Warten Sie, bis die Seite in Selen geladen ist

Wie lässt man Selenium 2.0 warten, bis die Seite geladen ist?

222
karthick kumar

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"));
126
Imran

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"));
86
Artem

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

34
Sam

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).

34
Paul Hadfield

Ruby-Implementierung:

wait = Selenium::WebDriver::Wait.new(:timeout => 10)
wait.until {
    @driver.execute_script("return document.readyState;") == "complete" 
}
21
allenhwkim

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");
        }
    });
}
17
QIKHAN

Alle diese Lösungen sind für bestimmte Fälle in Ordnung, leiden jedoch unter mindestens einem von mehreren möglichen Problemen:

  1. 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).

  2. 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

12
hwjp

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.

11
TedEd

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.

9
sibidiba

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");
        }
    });
9
Fin

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 )

9
Tristan

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.

7
Anuj Teotia

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.

5
Kuldeep Yadav

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.

4
Jack Mason

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");
}
4
Shubham Jain

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 .

Selenium Documentation (Nodejs)

4
sidanmor

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
}
3
KimiRai23

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)
3
Arpan Saini
/**
 * 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.

3
Marc

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

3
sonhu

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

2
IKo

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;
            }
        }
2
RichardK

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.

2
iamsankalp89

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(); 
 }
2
Praveen

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.

2
anirus

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;
1
Mohsin Awan

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.

1
Ælis

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.

1
forresthopkinsa

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';
}))
0
yuwanlin

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.

0
MMSA

Wie man Selen dazu bringt, nach einem Klick auf das Laden der Seite zu warten bietet den folgenden interessanten Ansatz:

  1. Speichern Sie einen Verweis auf WebElement von der alten Seite.
  2. Klicken Sie auf den Link.
  3. Rufen Sie weiterhin Operationen für WebElement auf, bis StaleElementReferenceException ausgelö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;
    }
});
0
Gili
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;
        }
    }
}
0
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();
    }

}
0

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();
    }
}
0
ANarula

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;
0
Michau

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.

0
Neel Gurbani
  1. WebDriver driver = new ff / chrome / anyDriverYouWish(); driver.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS); Wartet maximal 10 Sekunden.

  2. WebDriverWait wait = new WebDriverWait(driver, 10); wait.until(ExpectedConditions.visibilityOf(WebElement element));

  3. 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.

0
Vinod Kumar K V
driver.asserts().assertElementFound("Page was not loaded",
By.xpath("//div[@id='actionsContainer']"),Constants.LOOKUP_TIMEOUT);
0
Ran Adler

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();
}
0
iam_muqshid