Question

任何人都可以让我如何让硒等到页面完全加载为止？我想要一些通用的东西，我知道我可以配置WebDriverWait并调用类似'find'的东西让它等待，但我不会那么远。我只需要测试页面加载成功并转到下一页进行测试。

我在.net中发现了一些东西但是无法在java中使用它...

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

有人想过吗？

Answer 1

您建议的解决方案仅等待DOM readyState发出complete信号。但是Selenium默认尝试通过driver.get()和element.click()方法在页面加载上等待那些（以及更多一点）。他们已经阻止，他们等待页面完全加载，这些应该正常工作。

显然，问题是通过AJAX请求和运行脚本重定向 - 这些不能被Selenium捕获，它不会等待它们完成。此外，您无法通过readyState可靠地捕获它们 - 它等待一点，这可能很有用，但它会在下载所有AJAX内容之前发出complete信号。

没有通用的解决方案可以在任何地方和每个人工作，这就是为什么它很难并且每个人都使用一些不同的东西。

一般规则是依靠WebDriver来完成他的工作，然后使用隐式等待，然后使用显式等待你想在页面上断言的元素，但是还有更多的技术可以完成。您应该在测试页面上选择最适合您的一个（或其中几个组合）。

有关详细信息，请参阅我的两个答案：

Answer 2

试用此代码：

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

以上代码将等待最多10秒的页面加载。如果页面加载超过了它将抛出TimeoutException的时间。你抓住了例外，满足了你的需求。我不确定是否在抛出异常后退出页面加载。我还没有尝试这个代码。想要尝试一下。

这是一个隐含的等待。如果你设置了一次它将具有范围，直到Web驱动程序实例销毁。

了解更多info.

Answer 3

这是您给出的示例的可用Java版本：

void waitForLoad(WebDriver driver) {
    new WebDriverWait(driver, 30).until((ExpectedCondition<Boolean>) wd ->
            ((JavascriptExecutor) wd).executeScript("return document.readyState").equals("complete"));
}

c＃：

的示例

public static void WaitForLoad(IWebDriver driver, int timeoutSec = 15)
{
  IJavaScriptExecutor js = (IJavaScriptExecutor)driver;
  WebDriverWait wait = new WebDriverWait(driver, new TimeSpan(0, 0, timeoutSec));
  wait.Until(wd => js.ExecuteScript("return document.readyState").ToString() == "complete");
}

Answer 4

这是我在Python中尝试完全通用的解决方案：

首先，通用＆＃34;等待＆＃34;函数（如果你愿意，可以使用WebDriverWait，我发现它们很难看）：

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

接下来，该解决方案依赖于selenium为页面上的所有元素记录（内部）id号的事实，包括顶级<html>元素。当页面刷新或加载时，它会获得一个带有新ID的新html元素。

因此，假设您要点击带有文字的链接＆＃34;我的链接＆＃34;例如：

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)

对于更多Pythonic，可重用的通用助手，您可以创建一个上下文管理器：

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)

然后你可以在几乎所有的硒交互中使用它：

with wait_for_page_load(browser):
    browser.find_element_by_link_text('my link').click()

我认为那是防弹的！你怎么看？

blog post about it here

中的更多信息

Answer 5

我有类似的问题。我需要等到我的文档准备就绪，直到所有Ajax调用完成。事实证明第二个条件很难被发现。最后，我检查了活动的Ajax调用，它确实有效。

使用Javascript：

return (document.readyState == 'complete' && jQuery.active == 0)

完整的C＃方法：

private void WaitUntilDocumentIsReady(TimeSpan timeout)
{
    var javaScriptExecutor = WebDriver as IJavaScriptExecutor;
    var wait = new WebDriverWait(WebDriver, timeout);            

    // Check if document is ready
    Func<IWebDriver, bool> readyCondition = webDriver => javaScriptExecutor
        .ExecuteScript("return (document.readyState == 'complete' && jQuery.active == 0)");
    wait.Until(readyCondition);
}

Answer 6

import socket

     def Main():
          host = '127.0.0.1'
          port = 5000
            s = socket.socket()
            s.bind((host,port))
            s.listen(2)
             c, addr = s.accept()
             print "Connecton from : " + str(addr)
             while True:
                       data = c.recv(1024)
                       if not data: 
                                break
                        print "from connected User:" + str(data)
                        data = str(data).upper() 
                        print "sending: " + str(data)
                           c.send()
           c.close

     if _name_ == '_main_':
       Main()

Answer 7

对于C＃NUnit，您需要将WebDriver转换为JSExecuter，然后执行脚本以检查document.ready状态是否完整。请查看以下代码以供参考：

 public static void WaitForLoad(IWebDriver driver)
    {
        IJavaScriptExecutor js = (IJavaScriptExecutor)driver;
        int timeoutSec = 15;
        WebDriverWait wait = new WebDriverWait(driver, new TimeSpan(0, 0, timeoutSec));
        wait.Until(wd => js.ExecuteScript("return document.readyState").ToString() == "complete");
    }

这将等到条件满足或超时。

Answer 8

对于初始页面加载，我注意到＆＃34;最大化＆＃34;浏览器窗口几乎等到页面加载完成（包括源）

替换：

AppDriver.Navigate().GoToUrl(url);

使用：

public void OpenURL(IWebDriver AppDriver, string Url)
            {
                try
                {
                    AppDriver.Navigate().GoToUrl(Url);
                    AppDriver.Manage().Window.Maximize();
                    AppDriver.SwitchTo().ActiveElement();
                }
                catch (Exception e)
                {
                    Console.WriteLine("ERR: {0}; {1}", e.TargetSite, e.Message);
                    throw;
                }
            }

比使用：

OpenURL(myDriver, myUrl);

这将加载页面，等到完成，最大化并专注于它。我不知道为什么会这样，但它有效。

如果您想在点击下一个或任何其他页面导航触发器之后等待页面加载，那么＆＃34;导航（）＆＃34;，Ben Dyer的答案（在此主题中）将执行工作

Answer 9

当selenium从点击或提交或获取方法打开一个新页面时，它将等待untell页面加载但问题是当页面有xhr调用（ajax）时他永远不会等待xhr成为加载，所以创建一个新的方法来监视xhr并等待它们将是好的。（抱歉我的英语不好：D）

public boolean waitForJSandJQueryToLoad() {
    WebDriverWait wait = new WebDriverWait(webDriver, 30);
    // wait for jQuery to load
    ExpectedCondition<Boolean> jQueryLoad = new ExpectedCondition<Boolean>() {
      @Override
      public Boolean apply(WebDriver driver) {
        try {
            Long r = (Long)((JavascriptExecutor)driver).executeScript("return $.active");
            return r == 0;
        } catch (Exception e) {
            LOG.info("no jquery present");
            return true;
        }
      }
    };

    // wait for Javascript to load
    ExpectedCondition<Boolean> jsLoad = new ExpectedCondition<Boolean>() {
      @Override
      public Boolean apply(WebDriver driver) {
        return ((JavascriptExecutor)driver).executeScript("return document.readyState")
        .toString().equals("complete");
      }
    };

  return wait.until(jQueryLoad) && wait.until(jsLoad);
}

如果$ .active == 0所以没有活动的xhrs调用（仅适用于jQuery）。对于javascript ajax调用，你必须在项目中创建一个变量并进行模拟。

Answer 10

查看tapestry网络框架。你可以在那里download source code。

这个想法是通过body的html属性来表示页面已经准备就绪。你可以使用这个想法忽略复杂的诉讼案件。

<html>
<head>
</head>
<body data-page-initialized="false">
    <p>Write you page here</p>

    <script>
    $(document).ready(function () {
        $(document.body).attr('data-page-initialized', 'true');
    });
    </script>  
</body>
</html>

然后创建Selenium webdriver的扩展（根据tapestry框架）

public static void WaitForPageToLoad(this IWebDriver driver, int timeout = 15000)
{
    //wait a bit for the page to start loading
    Thread.Sleep(100);

    //// In a limited number of cases, a "page" is an container error page or raw HTML content
    // that does not include the body element and data-page-initialized element. In those cases,
    // there will never be page initialization in the Tapestry sense and we return immediately.
    if (!driver.ElementIsDisplayed("/html/body[@data-page-initialized]"))
    {                
        return;
    }

    Stopwatch stopwatch = Stopwatch.StartNew();

    int sleepTime = 20;

    while(true)
    {
        if (driver.ElementIsDisplayed("/html/body[@data-page-initialized='true']"))
        {
            return;
        }

        if (stopwatch.ElapsedMilliseconds > 30000)
        {
            throw new Exception("Page did not finish initializing after 30 seconds.");
        }

        Thread.Sleep(sleepTime);
        sleepTime *= 2; // geometric row of sleep time
    }          
}

使用扩展名ElementIsDisplayed written by Alister Scott。

public static bool ElementIsDisplayed(this IWebDriver driver, string xpath)
{
    try
    {
        return driver.FindElement(By.XPath(xpath)).Displayed;
    }
    catch(NoSuchElementException)
    {
        return false;
    }
}

最后创建测试：

driver.Url = this.GetAbsoluteUrl("/Account/Login");            
driver.WaitForPageToLoad();

Answer 11

Ben Dryer的答案没有在我的机器上编译（"The method until(Predicate<WebDriver>) is ambiguous for the type WebDriverWait"）。

使用Java 8版本：

Predicate<WebDriver> pageLoaded = wd -> ((JavascriptExecutor) wd).executeScript(
        "return document.readyState").equals("complete");
new FluentWait<WebDriver>(driver).until(pageLoaded);

Java 7版本：

Predicate<WebDriver> pageLoaded = new Predicate<WebDriver>() {

        @Override
        public boolean apply(WebDriver input) {
            return ((JavascriptExecutor) input).executeScript("return document.readyState").equals("complete");
        }

};
new FluentWait<WebDriver>(driver).until(pageLoaded);

Answer 12

我尝试了这段代码，它对我有用。每次移动到另一页时我都会调用此函数

public static void waitForPageToBeReady() 
{
    JavascriptExecutor js = (JavascriptExecutor)driver;

    //This loop will rotate for 100 times to check If page Is ready after every 1 second.
    //You can replace your if you wants to Increase or decrease wait time.
    for (int i=0; i<400; i++)
    { 
        try 
        {
            Thread.sleep(1000);
        }catch (InterruptedException e) {} 
        //To check page ready state.

        if (js.executeScript("return document.readyState").toString().equals("complete"))
        { 
            break; 
        }   
      }
 }

Answer 13

在Nodejs中你可以通过promises获得它......

如果您编写此代码，则可以确保在到达当时页面已完全加载...

driver.get('www.sidanmor.com').then(()=> {
    // here the page is fully loaded!!!
    // do your stuff...
}).catch(console.log.bind(console));

如果您编写此代码，您将导航，而selenium将等待3秒......

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

来自Selenium文档：

this.get（url）→Thenable

安排命令导航到给定的URL。

返回在文档完成加载时将解析的承诺。

Selenium Documentation (Nodejs)

Answer 14

等待document.ready事件并不是解决此问题的完整方法，因为此代码仍然处于竞争状态：有时在处理click事件之前触发此代码，因此直接返回，因为浏览器没有还没开始加载新页面。

经过一番搜索后，我在Obay the testing goat找到了一个帖子，该帖子有解决此问题的方法。该解决方案的c＃代码如下：

 IWebElement page = null;
 ...
 public void WaitForPageLoad()
 {
    if (page != null)
    {
       var waitForCurrentPageToStale = new WebDriverWait(driver, TimeSpan.FromSeconds(10));
       waitForCurrentPageToStale.Until(ExpectedConditions.StalenessOf(page));
    }

    var waitForDocumentReady = new WebDriverWait(driver, TimeSpan.FromSeconds(10));
    waitForDocumentReady.Until((wdriver) => (driver as IJavaScriptExecutor).ExecuteScript("return document.readyState").Equals("complete"));

    page = driver.FindElement(By.TagName("html"));

}

` 我在driver.navigate.gotourl之后直接触发此方法，以便它尽快获得页面的引用。玩得开心！

Answer 15

在Java中，它将如下所示： -

  private static boolean isloadComplete(WebDriver driver)
    {
        return ((JavascriptExecutor) driver).executeScript("return document.readyState").equals("loaded")
                || ((JavascriptExecutor) driver).executeScript("return document.readyState").equals("complete");
    }

Answer 16

以下代码可能有效：

WebDriverWait wait = new WebDriverWait(driver, 10);
wait.until(ExpectedConditions.presenceOfAllElementsLocated(By.xpath("//*")));

Answer 17

就像Rubanov为C＃写的那样，我是用Java编写的，它是：

    public void waitForPageLoaded() {
    ExpectedCondition<Boolean> expectation = new
            ExpectedCondition<Boolean>() {
                public Boolean apply(WebDriver driver) {
                    return (((JavascriptExecutor) driver).executeScript("return document.readyState").toString().equals("complete")&&((Boolean)((JavascriptExecutor)driver).executeScript("return jQuery.active == 0")));
                }
            };
    try {
        Thread.sleep(100);
        WebDriverWait waitForLoad = new WebDriverWait(driver, 30);
        waitForLoad.until(expectation);
    } catch (Throwable error) {
        Assert.fail("Timeout waiting for Page Load Request to complete.");
    }
}

Answer 18

如果页面或网络连接速度慢，则以上所有方法均不起作用。我已经尝试了所有方法，对我而言唯一有效的方法就是等待该页面上的最后一个可见元素。以Bing网页为例。他们在主要搜索按钮旁边放置了一个CAMERA图标（按图像搜索按钮），该图标仅在加载整个页面后才可见。如果每个人都这样做，那么我们要做的就是像上面的示例一样使用显式等待。

Answer 19

public boolean waitForElement(String zoneName, String element, int index, int timeout) {
        WebDriverWait wait = new WebDriverWait(appiumDriver, timeout/1000);
        wait.until(ExpectedConditions.visibilityOfElementLocated(By.xpath(element)));
        return true;
    }

Answer 20

我执行了一个javascript代码来检查文档是否准备就绪。节省了我很多时间为具有客户端渲染的站点调试selenium测试。

public static boolean waitUntilDOMIsReady(WebDriver driver) {
def maxSeconds = DEFAULT_WAIT_SECONDS * 10
for (count in 1..maxSeconds) {
    Thread.sleep(100)
    def ready = isDOMReady(driver);
    if (ready) {
        break;
    }
}

}

public static boolean isDOMReady(WebDriver driver){
    return driver.executeScript("return document.readyState");
}

Answer 21

你可以编写一些逻辑来处理这个问题。我编写了一个返回WebElement的方法，这个方法将被调用三次，或者你可以增加时间并为WebElement添加一个空检查。这是一个例子

public static void main(String[] args) {
        WebDriver driver = new FirefoxDriver();
        driver.get("https://www.crowdanalytix.com/#home");
        WebElement webElement = getWebElement(driver, "homekkkkkkkkkkkk");
        int i = 1;
        while (webElement == null && i < 4) {
            webElement = getWebElement(driver, "homessssssssssss");
            System.out.println("calling");
            i++;
        }
        System.out.println(webElement.getTagName());
        System.out.println("End");
        driver.close();
    }

    public static WebElement getWebElement(WebDriver driver, String id) {
        WebElement myDynamicElement = null;
        try {
            myDynamicElement = (new WebDriverWait(driver, 10))
                    .until(ExpectedConditions.presenceOfElementLocated(By
                            .id(id)));
            return myDynamicElement;
        } catch (TimeoutException ex) {
            return null;
        }
    }

Answer 22

您可以让线程休眠，直到重新加载页面。这不是最佳解决方案，因为您需要估计页面加载的时间。

driver.get(homeUrl); 
Thread.sleep(5000);
driver.findElement(By.xpath("Your_Xpath_here")).sendKeys(userName);
driver.findElement(By.xpath("Your_Xpath_here")).sendKeys(passWord);
driver.findElement(By.xpath("Your_Xpath_here")).click();

Answer 23

这里有类似的东西，在Ruby中：

wait = Selenium::WebDriver::Wait.new(:timeout => 10)
wait.until { @driver.execute_script('return document.readyState').eql?('complete') }

Answer 24

我检查了页面加载是否完成，可以在Selenium 3.14.0中工作

    public static void UntilPageLoadComplete(IWebDriver driver, long timeoutInSeconds)
    {
        Until(driver, (d) =>
        {
            Boolean isPageLoaded = (Boolean)((IJavaScriptExecutor)driver).ExecuteScript("return document.readyState").Equals("complete");
            if (!isPageLoaded) Console.WriteLine("Document is loading");
            return isPageLoaded;
        }, timeoutInSeconds);
    }

    public static void Until(IWebDriver driver, Func<IWebDriver, Boolean> waitCondition, long timeoutInSeconds)
    {
        WebDriverWait webDriverWait = new WebDriverWait(driver, TimeSpan.FromSeconds(timeoutInSeconds));
        webDriverWait.Timeout = TimeSpan.FromSeconds(timeoutInSeconds);
        try
        {
            webDriverWait.Until(waitCondition);
        }
        catch (Exception e)
        {
            Console.WriteLine(e);
        }
    }

Answer 25

适合需要等待特定元素出现的人们。（使用C＃）

public static void WaitForElement(IWebDriver driver, By element)
{
    WebDriverWait wait = new WebDriverWait(driver, TimeSpan.FromSeconds(20));
    wait.Until(ExpectedConditions.ElementIsVisible(element));
}

然后，如果您想等待DOM中是否存在class =“ error-message”，您只需执行以下操作：

WaitForElement(driver, By.ClassName("error-message"));

对于ID，它将为

WaitForElement(driver, By.Id("yourid"));

Answer 26

public void waitForPageToLoad()
  {
(new WebDriverWait(driver, DEFAULT_WAIT_TIME)).until(new ExpectedCondition<Boolean>() {
      public Boolean apply(WebDriver d) {
        return (((org.openqa.selenium.JavascriptExecutor) driver).executeScript("return document.readyState").equals("complete"));
      }
    });//Here DEFAULT_WAIT_TIME is a integer correspond to wait time in seconds

Answer 27

你在使用Angular吗？如果您是，那么webdriver可能无法识别异步调用已完成。

我建议查看Paul Hammants ngWebDriver。方法waitForAngularRequestsToFinish（）可以派上用场。

Selenium等到文档准备好了

27 个答案: