精华内容
下载资源
问答
  • selenium等待

    2018-10-14 20:35:00
    selenium操作浏览器的过程中,每一次请求url,selenium都会等待页面加载完成以后, 才会将操作权限在交给我们的程序。 但是,由于ajax和各种JS代码的异步加载问题,当一个页面被加载到浏览器时, 该页面内的...

    简介

    在selenium操作浏览器的过程中,每一次请求url,selenium都会等待页面加载完成以后,

    才会将操作权限在交给我们的程序。

    但是,由于ajax和各种JS代码的异步加载问题,当一个页面被加载到浏览器时,

    该页面内的元素可以在不同的时间点被加载,这就使得元素的定位变得十分困难,

    当元素不再页面中时,使用会抛出ElementNotVisibleException异常,为了解决这个问题,

    selenium提供了两种等待页面加载的方式,显示等待和隐式等待,

    让我们可以等待元素加载完成后在进行操作。

     


     

     

    显示等待: 显式等待指定某个条件,然后设置最长等待时间,程序每隔XX时间看一眼,如果条件成立,

          则执行下一步,否则继续等待,直到超过设置的最长时间,然后抛出超时异常(TimeoutException)。

    隐性等待:设置了一个最长等待时间,如果在规定时间内网页加载完成,则执行下一步,

         否则一直等到时间截止,然后执行下一步。

     


     

     

    显示等待主要使用了WebDriverWait类与expected_conditions模块。

    一般写法:WebDriverWait(driver, timeout, poll_frequency, igonred_exceptions).until(method, message)

    WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.ID, "myDynamicElement"))

    Driver:传入WebDriver实例。

    timeout: 超时时间,等待的最长时间(同时要考虑隐性等待时间)

    poll_frequency: 调用until中的方法的间隔时间,默认是0.5秒

    ignored_exceptions: 忽略的异常,如果在调用until的过程中抛出这个元组中的异常,则不中断代码,继续等待.

    Method:可执行方法

    Message: 超时时返回的信息

     


     

    显式等待

    例子

    
    
    from selenium import webdriver
    from selenium.webdriver.common.by import By
    from selenium.webdriver.support.ui import WebDriverWait
    from selenium.webdriver.support import expected_conditions as EC
    ​
    driver = webdriver.Chrome()
    driver.get("http://somedomain/url_that_delays_loading")
    try:
        element = WebDriverWait(driver, 10).until(
            EC.presence_of_element_located((By.ID, "myDynamicElement"))
        )
    finally:
        driver.quit()

     

    在这个例子中,我们在查找一个元素的时候,不再使用find_element_by_*这样的方式来查找元素,

    而是使用了WebDriverWait

    try代码块中的代码的意思是:在抛出元素不存在异常之前,最多等待10秒。在这10秒中,

    WebDriverWait会默认每500ms运行一次until之中的内容,

    而until中的EC.presence_of_element_located则是检查元素是否已经被加载,检查的元素则通过By.

    ID这样的方式来进行查找。

    就是说,在10秒内,默认每0.5秒检查一次元素是否存在,存在则将元素赋值给element这个变量。

    如果超过10秒这个元素仍不存在,则抛出超时异常。

     

    expected_conditions是selenium的一个模块,其中包含一系列可用于判断的条件,配合该类的方法,

    就能够根据条件而进行灵活地等待了

    例子:

    from selenium.webdriver.support import expected_conditions as EC
    ​
    wait = WebDriverWait(driver, 10)
    # 等待直到元素可以被点击
    element = wait.until(EC.element_to_be_clickable((By.ID, 'someid')))

     

     

    隐式等待

    隐式等待指的是,在webdriver中进行find_element这一类查找操作时,如果找不到元素,则会默认的轮询等待一段时间。

    这个值默认是0,可以通过以下方式进行设置:

    from selenium import webdriver
    ​
    driver = webdriver.Chrome()
    driver.implicitly_wait(10) # 单位是秒
    driver.get("http://somedomain/url_that_delays_loading")
    myDynamicElement = driver.find_element_by_id("myDynamicElement")
    
     

     

     

     

    转载于:https://www.cnblogs.com/pywjh/p/9787801.html

    展开全文
  • Selenium等待

    2018-09-24 13:26:21
    implicitly_wait() WebDriverWait() 工具类  

    implicitly_wait()

    WebDriverWait()

    工具类

     

    展开全文
  • Selenium等待页面加载在Selenium脚本中起着重要的作用。 它们有助于使它们不易剥落,更可靠。 Selenium提供多次等待,以根据某些条件在脚本执行中提供足够的等待或暂停。 从而确保您在使用Selenium执行自动化测试时...

    selenium 等待

    Selenium等待页面加载在Selenium脚本中起着重要的作用。 它们有助于使它们不易剥落,更可靠。 Selenium提供多次等待,以根据某些条件在脚本执行中提供足够的等待或暂停。 从而确保您在使用Selenium执行自动化测试时不会导致脚本失败。 在本教程中,我们将解释Selenium等待和睡眠的类型,并提供实时示例以及对它们的比较研究。 让我们首先回答一个关键问题:“为什么要使用Selenium等待?”

    为什么我们需要Selenium等待?

    大多数现代应用程序的前端都是基于JavaScript或Ajax构建的,使用诸如React,Angular之类的框架,或任何其他需要花费一定时间才能在页面上加载或刷新Web元素的框架。 因此,如果您倾向于在脚本中找到尚未加载到页面上的元素,则selenium会向您抛出“ ElementNotVisibleException ”消息。

    下面的代码段将帮助您展示与使用Selenium执行自动化测试时相同的问题。 在此代码段中,我使用的是easymytrip.com的示例,在该示例中,post用户选择行程日期的“ From”和“ To”目的地,Web应用程序需要花费一些时间来加载所需的航班详细信息。 在这种情况下,用户无需等待就可以从列表中预订第一个航班。 现在,由于页面尚未加载,脚本无法找到“立即预订”按钮。 结果抛出“ NoSuchElementException ”。 下面的代码段和控制台输出:

     import java.util.concurrent.TimeUnit;   import org.openqa.selenium.By;  import org.openqa.selenium.JavascriptExecutor;  import org.openqa.selenium.Keys;  import org.openqa.selenium.WebDriver;  import org.openqa.selenium.chrome.ChromeDriver;   import com.gargoylesoftware.htmlunit.javascript.background.JavaScriptExecutor;   public class NoWaitImplemented {  
         public static void main(String[] args) throws InterruptedException {         
             System.setProperty( "webdriver.chrome.driver" , ".\\Driver\\chromedriver.exe" );         
             WebDriver driver= new ChromeDriver();         
             driver.manage().window().maximize();                 
             driver.get( " https://www.easemytrip.com/ " );         
             driver.findElement(By.id( "FromSector_show" )).sendKeys( "Delhi" , Keys.ENTER); 
             driver.findElement(By.id( "Editbox13_show" )).sendKeys( "Mumbai" , Keys.ENTER); 
             driver.findElement(By.id( "ddate" )).click(); 
             driver.findElement(By.id( "snd_4_08/08/2019" )).click(); 
             driver.findElement(By.className( "src_btn" )).click(); 
             driver.findElement(By.xpath( "//button[text()='Book Now']" )).click();                              
         }   } 

    控制台输出:

    我已经使用XPath通过脚本对Selenium进行自动化测试来查找Web元素。

    阅读更多:带有示例的Selenium中使用XPath的完整指南

    Selenium等待页面加载有助于解决此问题。 Selenium等待有不同类型,例如隐式等待和显式等待,可确保在Selenium脚本发现元素之前,将元素加载到页面中以进行进一步的操作。

    Selenium类型等待页面加载

    使用Selenium执行自动化测试时,我们在生成Selenium脚本时使用以下类型的等待:

    • Thread.Sleep()方法
    • 隐式等待
    • 显式等待
    • 流利的等待

    让我们深入了解其中的每一个。

    Thread.Sleep()用于使用Selenium进行自动化测试

    Sleep是属于线程类的静态方法。 可以使用类名(即Thread)的引用来调用此方法。 如果在使用Selenium执行自动化测试时使用Thread.sleep ,则此方法将在指定的时间段内停止脚本的执行,无论在网页上是否找到该元素。 它接受持续时间(以毫秒为单位)。 相同的语法是:

    Thread.sleep(3000);

    睡眠函数抛出InterruptedException,因此应使用try-catch块进行处理,如下所示:

     try {  Thread.sleep( 5000 );  }  catch (InterruptedException ie){  } 

    为什么使用Thread.Sleep()不是一个好主意?

    现在,我将重点介绍使用thread.sleep()的一些缺点。

    • Selenium Webdriver等待指定的时间,无论是否找到元素。 如果在指定的持续时间之前找到元素,脚本将仍然等待持续的时间,从而增加了脚本的执行时间。
    • 如果要显示的元素在静态时间后没有出现并且一直在变化,那么您将永远不会知道睡眠功能所需的估计时间。 如果花费的时间超过了定义的时间,脚本将抛出错误。 这就是为什么,如果您正在使用Selenium waits处理动态元素,那么最好不要使用Thread.sleep()。
    • Thread.sleep仅适用于之前编写的元素。 如果您有两到四个元素需要等待一定的时间才能加载,则在这种情况下,需要多次指定Thread.sleep。 如果这样做的话! 好吧,您到处都会发现脚本中充满了Thread.sleep()语法。

    由于上述缺点,在脚本创建中使用Thread.Sleep()被认为是一种不好的做法。

    下面的代码片段突出显示了Thread.Sleep()在Selenium自动化测试中的用法。 在此示例中,我们使用与上面的easymytrip相同的示例,在该示例中,一旦用户单击搜索,我们将停止线程执行。 在这种情况下,代码可以正常运行,而不会引发任何错误。

     import java.util.concurrent.TimeUnit;   import org.openqa.selenium.By;  import org.openqa.selenium.JavascriptExecutor;  import org.openqa.selenium.Keys;  import org.openqa.selenium.WebDriver;  import org.openqa.selenium.chrome.ChromeDriver;   import com.gargoylesoftware.htmlunit.javascript.background.JavaScriptExecutor;   public class ThreadWait {  
         public static void main(String[] args) throws InterruptedException { 
             // TODO Auto-generated method stub         
             //setting the driver executable 
             System.setProperty( "webdriver.chrome.driver" , ".\\Driver\\chromedriver.exe" );         
             //Initiating your chromedriver 
             WebDriver driver= new ChromeDriver();         
             driver.manage().window().maximize();                 
             driver.get( " https://www.easemytrip.com/ " );         
             driver.findElement(By.id( "FromSector_show" )).sendKeys( "Delhi" , Keys.ENTER); 
             driver.findElement(By.id( "Editbox13_show" )).sendKeys( "Mumbai" , Keys.ENTER); 
             driver.findElement(By.id( "ddate" )).click(); 
             driver.findElement(By.id( "snd_4_08/08/2019" )).click(); 
             driver.findElement(By.className( "src_btn" )).click(); 
             Thread.sleep( 5000 ); 
             driver.findElement(By.xpath( "//button[text()='Book Now']" )).click();                                  
         }   } 

    现在,如果我有同一应用程序的另一个页面需要花费一些时间来加载,该怎么办? 在这种情况下,我不想在脚本中多次使用thread.sleep()。

    您可能会认为,如果不是Thread.sleep(),那么哪个Selenium等待页面加载就足以满足测试要求?

    在这种情况下,这就是隐式等待的地方。 让我们详细检查隐式Selenium。

    Selenium隐式等待自动化测试

    Selenium克服了Thread.sleep()提供的问题,提出了两个Selenium等待页面加载的方法。 其中之一是隐式等待,它允许您将WebDriver暂停特定的时间,直到WebDriver在网页上找到所需的元素为止。

    这里要注意的关键点是,与Thread.sleep()不同,它不等待整个时间段。 如果在指定的持续时间之前找到元素,它将继续执行代码的下一行,从而减少了脚本执行的时间。 这就是为什么隐式等待也称为动态等待的原因。 如果未在指定的持续时间内找到该元素,则抛出ElementNotVisibleException

    关于隐式等待的另一件值得注意的事情是它是全局应用的,这使其比Thread.sleep()更好。 这意味着您只需编写一次即可,它适用于整个WebDriver实例中脚本上指定的所有Web元素。 方便吗? 实现相同的语法是:

     driver.manage().timeouts().implicitlyWait(Time Interval to wait for , TimeUnit.SECONDS); 

    隐式等待的默认时间为零,并且每隔500毫秒会不断轮询所需的元素。 让我们看下面的代码片段,展示隐式等待的用法。 在此示例中,我使用了相同的easymytrip示例。 在这种情况下,我们将向前迈进并继续进行预订过程,在此过程中页面需要花费更多的时间来加载。 这里有两个页面的页面加载问题,我们使用隐式等待而不是多次使用Thread.sleep()来处理一行代码。

     import java.util.concurrent.TimeUnit;   import org.openqa.selenium.By;  import org.openqa.selenium.JavascriptExecutor;  import org.openqa.selenium.Keys;  import org.openqa.selenium.WebDriver;  import org.openqa.selenium.WebElement;  import org.openqa.selenium.chrome.ChromeDriver;  import org.openqa.selenium.support.ui.Select;   import com.gargoylesoftware.htmlunit.javascript.background.JavaScriptExecutor;   public class ImplicitWait {  
         public static void main(String[] args) throws InterruptedException { 
             // TODO Auto-generated method stub         
             //setting the driver executable 
             System.setProperty( "webdriver.chrome.driver" , ".\\Driver\\chromedriver.exe" );         
             //Initiating your chromedriver 
             WebDriver driver= new ChromeDriver();         
             driver.manage().window().maximize();         
             driver.manage().timeouts().implicitlyWait( 30 , TimeUnit.SECONDS); 
             driver.get( " https://www.easemytrip.com/ " );         
             driver.findElement(By.id( "FromSector_show" )).sendKeys( "Delhi" , Keys.ENTER); 
             driver.findElement(By.id( "Editbox13_show" )).sendKeys( "Mumbai" , Keys.ENTER); 
             driver.findElement(By.id( "ddate" )).click(); 
             driver.findElement(By.id( "snd_4_08/08/2019" )).click(); 
             driver.findElement(By.className( "src_btn" )).click();  
             driver.findElement(By.xpath( "//button[text()='Book Now']" )).click();         
             JavascriptExecutor jse = (JavascriptExecutor)driver; 
             jse.executeScript( "window.scrollBy(0,750)" );         
             driver.findElement(By.xpath( "//input[@type='email']" )).sendKeys( "sadhvisingh9049@gmail.com" );         
             driver.findElement(By.xpath( "//span[text()='Continue Booking']" )).click();         
             WebElement title=driver.findElement(By.id( "titleAdult0" ));         
             Select titleTraveller= new Select(title);         
             titleTraveller.selectByVisibleText( "MS" ); 
             driver.findElement(By.xpath( "//input[@placeholder='Enter First Name']" )).sendKeys( "Sadhvi" ); 
             driver.findElement(By.xpath( "//input[@placeholder='Enter Last Name']" )).sendKeys( "Singh" );         
             driver.findElement(By.xpath( "//input[@placeholder='Mobile Number']" )).sendKeys( "9958468819" );         
             driver.findElement(By.xpath( "//div[@class='con1']/span[@class='co1']" )).click();          
         }   } 

    现在,在这里我们知道了一个事实,即应该在一定的持续时间内加载页面,但是如果我们不知道加载时元素是可见/可点击的,该怎么办。 由于它的出现是动态的,并且会不时地变化。 在这种情况下,显式等待将帮助您克服此问题。 让我们研究它的细节。

    明确等待使用Selenium进行自动化测试

    显式等待是动态Selenium等待的另一种。 显式等待帮助可在特定的时间内基于特定条件停止脚本的执行。 时间到头后,您将获得ElementNotVisibleException 在您不知道要等待的时间的情况下,此显式等待会派上用场。 使用elementToBeClickable()textToBePresentInElement()之类的条件 ,可以等待指定的持续时间。 可以结合使用WebDriverWait和ExpectedConditions类来使用这些预定义方法。 为了使用这种情况,请在您的课程中导入以下软件包:

     import org.openqa.selenium.support.ui.ExpectedConditions  import org.openqa.selenium.support.ui.WebDriverWait 

    发布此代码后,需要为WebDriverWait类创建一个引用变量,并使用WebDriver实例实例化该变量,并提供可能需要的Selenium等待页面加载的数量。 时间单位是秒。 可以如下定义它:

     WebDriverWait wait = new WebDriverWait(driver, 30 ); 

    为了使用ExpectedCondition类的预定义方法,我们将使用如下的wait引用变量:

     wait.until(ExpectedConditions.visibilityOfElementLocated(Reference of Element to be  located using locator)); 

    预期条件的类型:

    以下是在使用Selenium执行自动化测试时通常使用的几种预期条件。

    • visibleOfElementLocated()-验证给定元素是否存在
    • alertIsPresent()-验证是否存在警报。
    • elementToBeClickable()-验证给定元素是否在屏幕上存在/可单击
    • textToBePresentInElement()-验证给定元素是否具有必需的文本
    • titlels()-验证条件,等待具有给定标题的页面

    还有更多可用的预期条件,您可以通过Selenium官方GitHub页面进行引用。 像隐式等待一样,显式等待也会在每500毫秒后继续轮询。

    下面是突出显示显式Selenium等待的用法的代码段。 在此示例中,我们使用的是“ rentomojo”应用程序,其中的模式在动态时间显示在主页上。 使用显式等待,根据元素的可见性,我们将等待元素并关闭弹出窗口。 参考代码:

     import java.util.concurrent.TimeUnit;   import org.openqa.selenium.By;  import org.openqa.selenium.JavascriptExecutor;  import org.openqa.selenium.WebDriver;  import org.openqa.selenium.chrome.ChromeDriver;  import org.openqa.selenium.support.ui.ExpectedConditions;  import org.openqa.selenium.support.ui.WebDriverWait;   public class ExplicitWait {  
         public static void main(String[] args) { 
             // TODO Auto-generated method stub         
             //setting the driver executable 
                     System.setProperty( "webdriver.chrome.driver" , ".\\Driver\\chromedriver.exe" );                 
                     //Initiating your chromedriver 
                     WebDriver driver= new ChromeDriver();                                                 
                     driver.manage().window().maximize();                 
                     driver.get( " https://www.rentomojo.com/ " );                 
                     driver.findElement(By.xpath( "//span[@class='rm-city__selectorBoxLoca'][contains(text(),'Delhi')]" )).click();                                                 
                     WebDriverWait wait= new WebDriverWait(driver, 120 );                                 
                     wait.until(ExpectedConditions.visibilityOf(driver.findElement(By.xpath( "//div[@class='Campaign__innerWrapper']/button" )))); 
                     driver.findElement(By.xpath( "//div[@class='Campaign__innerWrapper']/button" )).click();  
         }   } 

    注意-当同时使用隐式等待和显式等待时,它们将在累积时间上工作,而不是在单个等待条件下工作。 例如,如果给定隐式等待30秒,给定显式等待10秒,则它正在寻找的显式元素将等待40秒。

    Selenium等待之间的区别:显式与隐式

    现在,由于您已经知道隐式等待和显式等待的用法,因此让我们研究一下这两个Selenium等待之间的区别:

    隐式等待

    显式等待

    默认情况下,它将应用于脚本中的所有元素。 它仅适用于特定条件的特定元素。
    我们不能根据指定条件(例如元素selectable / clickable)而不是显式进行等待。 明确地说,我们可以根据特定条件指定等待时间。
    当您确定该元素在特定时间内可能可见时,通常使用它 当您不知道元素可见性的时间时,通常使用它。 它具有动态性质。

    Fluent等待使用Selenium进行自动化测试

    就其功能而言,Fluent等待类似于显式等待。 在Fluent等待中,当您不知道某个元素可见或单击所需的时间时,将对它执行Selenium等待。 Fluent等待提供的一些差异因素是:

    • 轮询频率-在显式等待的情况下,默认情况下此轮询频率为500毫秒。 使用Fluent wait,您可以根据需要更改此轮询频率,即,您可以告诉脚本在每个“ x”秒之后继续检查元素。
    • 忽略异常-在轮询期间,如果找不到元素,则可以忽略任何异常,例如'NoSuchElement'异常等。

    除了这些差异因素(例如显式等待或隐式等待)之外,您还可以定义等待元素可见或可操作的时间。 以下语法或代码行用于定义Selenium中的Fluent等待:

    默认情况下,它将应用于脚本中的所有元素。

    语法似乎很复杂,但是一旦开始使用,它可能会变得很方便。 可能这是测试人员选择进行显式等待而不是进行Fluent等待的最大原因之一。 另外,Explicit等待和Fluent等待之间的主要区别在于Explicit Selenium Wait提供了预定义条件,这些条件适用于我们需要等待的元素,而对于Fluent Selenium Wait,则可以定义自己的自定义条件适用方法中的条件。

    我对Fluent Selenium Wait的看法?

    我个人还没有在实时示例中找到任何有用的流畅等待的实现,因此到目前为止,我希望自己不要执行它。 我和您一样渴望Selenium 4的发布 我希望在发布之后,我们可以对使用Fluent等待而不是其他Selenium等待的实际优势有更多的了解。 到目前为止,根据我的经验,我碰巧倾向于使用Explicit Selenium wait,因为它比Fluent Selenium wait更容易实现代码。 如果您有其他意见,请在下面的评论中告诉我。

    Selenium的角色等待基于云的Selenium网格

    大多数测试人员通常更喜欢使用基于云的服务提供商执行自动化的网站测试,以进行Selenium测试,例如LambdaTest(云上的跨浏览器测试工具)。 想知道为什么吗?

    那么,如果您在基于云的Selenium网格(例如LambdaTest)上运行自动化脚本 ,会发生什么呢? Selenium等待如何有助于有效的测试结果?

    每个基于云的提供程序都会在抛出Selenium超时异常之前提供默认的时间限制。 这样做是为了防止过度利用云资源。 在LamdaTest中,默认超时为90秒。 现在,如果您对Web元素的加载时间超过90秒,那该怎么办?

    这就是Selenium等待出现的地方。 如果您的测试套件很复杂,可能会在云Selenium Grid上面临超时问题,那么您可以使用Selenium wait将WebDriver暂停默认时间超过90秒。 因此,避免在成功运行自动化脚本时发生超时错误。

    Selenium的最终裁决正在等待中!

    Selenium Waits可以帮助您减少脚本的脆弱性和可靠性。 无论选择哪种等待方式,都要确保它能帮助您实现Selenium自动化测试背后的目标。 另一要注意的关键是要确保在应用程序中不保留不必要的Selenium等待。 Thread.sleep()过去可能是一个选项,但是现在我们有了新的Selenium等待和来临,我宁愿建议您远离Thread.sleep()来推动Selenium自动化测试。 因此,下一次您遇到了元素或页面加载问题时,便知道在哪里寻找。 测试愉快!

    翻译自: https://www.javacodegeeks.com/2019/08/selenium-waits-implicit-explicit-fluent-sleep.html

    selenium 等待

    展开全文
  • Selenium等待页面加载在Selenium自动化测试中起着重要的作用。它们有助于使测试用例更加稳定,增强健壮性。Selenium提供多种等待,根据某些条件在脚本执行相应的等待,从而确保Selenium执行自动化测试时不会导致脚本...

    Selenium等待页面加载在Selenium自动化测试中起着重要的作用。它们有助于使测试用例更加稳定,增强健壮性。Selenium提供多种等待,根据某些条件在脚本执行相应的等待,从而确保Selenium执行自动化测试时不会导致脚本失败。

    在本文中,我们将介绍Selenium等待和睡眠的类型,并提供演示Demo以及对它们的比较分析。

    为什么需要等待

    大多数应用程序的前端都是基于JavaScriptAjax构建的,使用诸如ReactAngularVue之类的框架,都是需要花费一定时间才能在页面上加载或刷新Web元素。因此,如果测试用例在脚本中找到尚未加载到页面上的元素,则Selenium会向抛出ElementNotVisibleException的异常。

    下面的代码片段将展示与使用Selenium执行自动化测试时的问题。在此代码段中,使用的是某一航空订票网站的示例,在该示例中,post用户选择行程日期的FromTo目的地,Web应用程序需要花费一些时间来加载所需的航班详细信息。在正常用户使用情况下,可以从列表中预订某一班航班。现在,由于页面尚未完全加载,测试脚本无法找到立即预订按钮。结果抛出NoSuchElementException异常。下面的代码段和控制台输出:

    import java.util.concurrent.TimeUnit;

    import org.openqa.selenium.By;
    import org.openqa.selenium.JavascriptExecutor;
    import org.openqa.selenium.Keys;
    import org.openqa.selenium.WebDriver;
    import org.openqa.selenium.chrome.ChromeDriver;

    import com.gargoylesoftware.htmlunit.javascript.background.JavaScriptExecutor;

    public class NoWaitImplemented {

        public static void main(String[] args) throws InterruptedException {
            System.setProperty("webdriver.chrome.driver"".\\Driver\\chromedriver.exe");
            WebDriver driver=new ChromeDriver();
            driver.manage().window().maximize();
            driver.get("https://www.***.com/");
            driver.findElement(By.id("FromSector_show")).sendKeys("北京", Keys.ENTER);
            driver.findElement(By.id("Editbox13_show")).sendKeys("上海", Keys.ENTER);
            driver.findElement(By.id("ddate")).click();
            driver.findElement(By.id("snd_4_08/08/2020")).click();
            driver.findElement(By.className("src_btn")).click();
            driver.findElement(By.xpath("//button[text()='立即预定']")).click();
       }

    }

    控制台输出:


    *** Element info: (Us ing=xpath, value=//button(text()='立即预定']
    at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
    at sun.reflect.NativeConstructorAccessorImpl.newInstance (Unknown Source )
    at sun.reflect.DelegatingConstructorAcces sorImp1.newInstance (Unknown Source )
    at java.lang.reflect.Constructor.newInstance (Unknown Source )
    at org.openqa.selenium.remote.http.W3CHttpResponseCodec.createException(W3CHttpResponseCodec.java:187)at org.openqa.selenium.remote.http.W3CHttpResponseCodec.decode (W3CHttpResponseCodec.java:122)
    at org.openqa.selenium.remote.http.W3CHttpResponseCodec.decode (W3CHttpResponseCodec.java:49)
    at org.openqa.selenium.remote.HttpC ommandExecutor.execute (HttpC ommandExecutor.java:158)
    at org.openqa.selenium.remote.service.DriverCommandExecutor.execute(DriverCommandExecutor.java:83)at org.openqa.selenium.remote.RemoteWebDriver.execute ( RemoteWebDriver.java:

    Selenium等待页面加载有助于解决此问题。Selenium等待有不同类型,例如隐式等待显式等待,可确保在Selenium脚本执行元素定位之前,页面元素加载到页面中以进行进一步的操作。

    Selenium等待

    在使用Selenium执行自动化测试时,在编写Selenium脚本时,我们使用以下类型的等待:

    • Thread.Sleep()方法
    • 隐式等待
    • 显式等待
    • Fluent等待

    Thread.Sleep()方法

    Thread.Sleep()是属于线程类的静态方法。可以使用类名(即Thread)的引用来调用此方法。如果在使用Selenium执行自动化测试时使用Thread.Sleep(),则此方法将在指定的时间段内停止执行脚本,而不管是否在网页上找到了该元素。Thread.Sleep()方法中时间参数的单位是毫秒。相同的语法是:

    Thread.sleep(3000);

    睡眠函数抛出InterruptedException,因此应使用try-catch块进行处理,如下所示

            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                logger.error("error", e);
            }

    Thread.Sleep()不是好主意

    下面我将重点介绍使用Thread.Sleep()的一些缺点。

    使用Thread.Sleep()方法Selenium Webdriver等待指定的时间,无论是否找到对应元素。如果在指定的持续时间之前找到元素,脚本将仍然等待持续的时间,从而增加了脚本的执行时间。如果花费的时间超过了定义的时间,脚本将抛出错误。这就是为什么使用Selenium处理动态元素,那么最好不要使用Thread.Sleep()

    下面的代码片段突出显示了Thread.Sleep()Selenium自动化测试中的用法。

    import java.util.concurrent.TimeUnit;

    import org.openqa.selenium.By;
    import org.openqa.selenium.JavascriptExecutor;
    import org.openqa.selenium.Keys;
    import org.openqa.selenium.WebDriver;
    import org.openqa.selenium.chrome.ChromeDriver;

    import com.gargoylesoftware.htmlunit.javascript.background.JavaScriptExecutor;

    public class ThreadWait {

        public static void main(String[] args) throws InterruptedException {
            System.setProperty("webdriver.chrome.driver"".\\Driver\\chromedriver.exe");
            WebDriver driver=new ChromeDriver();
            driver.manage().window().maximize();
            driver.get("https://www.***.com/");
            
            driver.findElement(By.id("FromSector_show")).sendKeys("北京", Keys.ENTER);
            driver.findElement(By.id("Editbox13_show")).sendKeys("上海", Keys.ENTER);
            driver.findElement(By.id("ddate")).click();
            driver.findElement(By.id("snd_4_08/08/2020")).click();
            driver.findElement(By.className("src_btn")).click();
            Thread.sleep(5000);
            driver.findElement(By.xpath("//button[text()='立即预定']")).click();

        }

    }

    如果不使用Thread.sleep(),那么哪个Selenium等待页面加载就足以满足测试要求?在这种情况下,这就需要隐式等待来处理。

    隐式等待

    Selenium解决了Thread.Sleep()存在的问题,并提出了两个Selenium等待页面加载的方法。其中之一是隐式等待,它允许您将WebDriver暂停特定的时间,直到WebDriver在网页上找到所需的元素为止。

    这里要注意的关键点是,与Thread.Sleep()不同,它不需要等待整个时间段。如果在指定的持续时间之前找到元素,将继续执行下一行代码,从而减少了脚本执行的时间。这就是为什么隐式等待也称为动态等待的原因。如果在指定的持续时间内未找到该元素,则抛出ElementNotVisibleException

    关于隐式等待的另一件值得注意的事情是,它是全局应用的,这使其比Thread.Sleep()更好。这意味着测试人员只需编写一次即可,它适用于整个WebDriver实例中脚本上指定的所有Web元素。是不是特别方便?实现相同的语法是:

    driver.manage().timeouts().implicitlyWait(Time Interval to wait for, TimeUnit.SECONDS);

    隐式等待的默认时间为,并且每隔500毫秒会不断轮询所需的元素。让我们看下面的代码片段,展示隐式等待的用法。在此示例中,我使用了相同的订票网站示例。在这种情况下,我们将进行预订过程,在此过程中页面需要花费更多的时间来加载。在这里,存在两个页面的页面加载问题,我们使用Thread.Sleep()而不是多次使用Thread.Sleep()来处理一行代码。

    import java.util.concurrent.TimeUnit;

    import org.openqa.selenium.By;
    import org.openqa.selenium.JavascriptExecutor;
    import org.openqa.selenium.Keys;
    import org.openqa.selenium.WebDriver;
    import org.openqa.selenium.WebElement;
    import org.openqa.selenium.chrome.ChromeDriver;
    import org.openqa.selenium.support.ui.Select;

    import com.gargoylesoftware.htmlunit.javascript.background.JavaScriptExecutor;

    public class ImplicitWait {

        public static void main(String[] args) throws InterruptedException {

            System.setProperty("webdriver.chrome.driver"".\\Driver\\chromedriver.exe");
            WebDriver driver=new ChromeDriver();
            driver.manage().window().maximize();
            driver.manage().timeouts().implicitlyWait(30, TimeUnit.SECONDS);
            driver.get("https://www.***.com/");
            
            driver.findElement(By.id("FromSector_show")).sendKeys("北京", Keys.ENTER);
            driver.findElement(By.id("Editbox13_show")).sendKeys("上海", Keys.ENTER);
            driver.findElement(By.id("ddate")).click();
            driver.findElement(By.id("snd_4_08/08/2020")).click();
            driver.findElement(By.className("src_btn")).click();
           driver.findElement(By.xpath("//button[text()='立即预定']")).click();
            
            JavascriptExecutor jse = (JavascriptExecutor)driver;
            jse.executeScript("window.scrollBy(0,750)");
            
            driver.findElement(By.xpath("//input[@type='email']")).sendKeys("***@FunTester.com");
            driver.findElement(By.xpath("//span[text()='继续']")).click();
            WebElement title=driver.findElement(By.id("titleAdult0"));
            Select titleTraveller=new Select(title);
            titleTraveller.selectByVisibleText("MS");
            driver.findElement(By.xpath("//input[@placeholder='Enter First Name']")).sendKeys("FunTester");
            driver.findElement(By.xpath("//input[@placeholder='Enter Last Name']")).sendKeys("FunTester");
            driver.findElement(By.xpath("//input[@placeholder='Mobile Number']")).sendKeys("*********");
            driver.findElement(By.xpath("//div[@class='con1']/span[@class='co1']")).click();
            }

    }

    我们知道了一个事实,即应该在一定的持续时间内加载页面,但是如果我们不知道在加载时该元素是可见/可点击的,该怎么办?正如它出现的时候一样,元素是动态的,并且可能会不时地变化。在这种情况下,显式等待将帮助解决此问题。让我们看一下显示等待的细节。

    显示等待

    显式等待是动态Selenium等待的另外一种类型。显式等待帮助可在特定时间段内根据特定条件停止脚本的执行。时间到了以后,脚本将抛出ElementNotVisibleException异常。在测试人员不确定要等待的时间的情况下,显式等待会派上大用场。使用elementToBeClickable()textToBePresentInElement()之类的条件,可以等待指定的持续时间。可以结合使用WebDriverWaitExpectedConditions类来使用这些预定义方法。为了使用这种情况,请在代码中导入以下软件包:

    import org.openqa.selenium.support.ui.ExpectedConditions
    import org.openqa.selenium.support.ui.WebDriverWait

    添加该代码后,需要为WebDriverWait类创建一个引用变量,并使用WebDriver实例实例化该变量,并提供可能需要的Selenium等待页面加载的数量。时间单位是秒。可以如下定义它:

    WebDriverWait wait = new WebDriverWait(driver,30);

    为了使用ExpectedCondition类的预定义方法,我们将使用如下的wait引用变量:

    wait.until(ExpectedConditions.visibilityOfElementLocated());

    预期条件的类型

    以下是在使用Selenium执行自动化测试时通常使用的几种预期条件。

    • visibleOfElementLocated():验证给定元素是否存在
    • alertIsPresent():验证是否存在警报。
    • elementToBeClickable():验证给定元素是否在屏幕上存在/可单击
    • textToBePresentInElement():验证给定元素是否具有必需的文本
    • titlels():验证条件,等待具有给定标题的页面

    还有更多可用的预期条件,您可以通过Selenium官方GitHub页面进行引用。与隐式等待一样,显式等待也会在每500毫秒后继续轮询。

    下面是显示等待Selenium中用法的代码段。在此示例中,我们使用的是订票网站,其中的模式在动态时间显示在主页上。使用显式等待,基于元素的可见性,我们将等待元素并关闭弹出窗口。

    参考代码:

    import java.util.concurrent.TimeUnit;

    import org.openqa.selenium.By;
    import org.openqa.selenium.JavascriptExecutor;
    import org.openqa.selenium.WebDriver;
    import org.openqa.selenium.chrome.ChromeDriver;
    import org.openqa.selenium.support.ui.ExpectedConditions;
    import org.openqa.selenium.support.ui.WebDriverWait;

    public class ExplicitWait {

        public static void main(String[] args) {
                    System.setProperty("webdriver.chrome.driver"".\\Driver\\chromedriver.exe");
                    WebDriver driver=new ChromeDriver();
                    driver.manage().window().maximize();
                    
                    driver.get("https://www.*****.com/");
                    
                    driver.findElement(By.xpath("//span[@class='rm-city__selectorBoxLoca'][contains(text(),'北京')]")).click();
                    WebDriverWait wait=new WebDriverWait(driver, 120);
                    wait.until(ExpectedConditions.visibilityOf(driver.findElement(By.xpath("//div[@class='Campaign__innerWrapper']/button"))));
                    driver.findElement(By.xpath("//div[@class='Campaign__innerWrapper']/button")).click();

        }

    }
    • 注意:当同时使用隐式等待显式等待时,它们等待的时间是累计的,而不是在单个等待条件下工作。例如,如果给定隐式等待30秒,给定显式等待10秒,那么它正在寻找的显式元素将等待40秒

    显式等待与隐式等待

    现在各位已经知道隐式等待显式等待的用法,因此让我们看一下一下这两个Selenium等待之间的区别:

    隐式等待显式等待
    默认情况下应用于脚本中的所有元素。仅适用于特定条件的特定元素。
    不能基于指定条件(例如元素选择/可点击)而不是显式地等待。可以根据特定条件指定等待时间。
    确定该元素在特定时间内可能可见时,通常使用它不知道元素可见性的时间时,通常使用它。它具有动态性质。

    Fluent等待

    就其本身功能而言,Fluent等待类似于显式等待。在Fluent等待中,当测试人员不知道某个元素可见或单击所需的时间时,而需要对其执行Selenium等待。Fluent等待提供的一些差异因素:

    • 轮询频率:在显式等待的情况下,默认情况下此轮询频率为500毫秒。使用Fluent wait,测试工程师可以根据需要更改此轮询频率。
    • 忽略异常:在轮询期间,如果找不到元素,则可以忽略任何异常,例如NoSuchElement异常等。
    • 除了这些差异因素(例如显式等待或隐式等待)之外,Fluent还可以定义等待元素可见或可操作的时间。以下语法或代码行用于定义Selenium中的Fluent等待:
            Wait fluentWait = new FluentWait(driver)
                    .withTimeout(60, SECONDS) // 自定义等待的总时间
                    .pollingEvery(2, SECONDS) // 自定义轮询频率
                    .ignoring(NoSuchElementException.class); //  自定义要忽略的异常
            WebElement foo = fluentWait.until(new Function() {public WebElement apply(WebDriver driver)  // 自定义等待条件{return driver.findElement(By.id("FunTester"));
                }
            });

    咋一看语法似乎很复杂,但是一旦开始学习使用,熟练之后,Fluent会变得很方便。这是测试人员选择显式等待而不是Fluent等待的最大原因之一。另外,显式等待Fluent等待之间的主要区别在于显式等待提供了预定义的条件,这些条件适用于我们需要等待的元素,而对于Fluent Selenium等待,则可以自定义适用方法中的条件。


    公众号FunTester首发,原创分享爱好者,腾讯云和掘金社区首页推荐,知乎七级原创作者,欢迎关注、交流,禁止第三方擅自转载。

    FunTester热文精选

    • 写给所有人的编程思维
    • 2020年Tester自我提升
    • 未来的神器fiddler Everywhere
    • 测试开发工程师工作技巧
    • Selenium4 IDE,它终于来了
    • 如何成为全栈自动化工程师
    • 为什么测试覆盖率如此重要
    • 为什么测试覆盖率如此重要
    • 吐个槽,非测误入。
    • 自动化测试框架
    bac3d13ce521d781c6d13854f8442ba0.png
    展开全文
  • selenium Selenium等待页面加载在Selenium脚本中起着重要的作用。 它们有助于使它们不易剥落,更可靠。 Selenium提供多次等待,以根据某些条件在脚本执行中提供足够的等待或暂停。 从而确保您在使用Selenium执行自动...
  • Selenium等待条件 1、条件类的实现原理 在selenium.webdriver.support.expected_conditions这个模块里,存放着所有的等待条件,每个条件类的结构都是一样的一个__init__构造方法和一个__call__方法。 在python中...
  • 您需要了解的有关Selenium等待方法

    千次阅读 2020-06-22 10:18:00
    在编写第一个Selenium程序时,您可能会遇到等待命令。但是,您知道Selenium到底在等待什么吗?好吧,Selenium等待是执行测试用例所需的基本代码。在本文中,我将为您简要介...
  • 我希望硒在截图之前先等待。当我使用time.sleep(1)时,出现以下错误:追溯(最近一次通话最近):driver.save_screenshot('page.png')中文件“ test.py”,第12行,文件“ /Library/Frameworks/Python.framework/...
  • Selenium等待方式

    2019-07-22 15:22:48
    隐式等待 当使用了隐式等待执行测试的时候,如果 WebDriver没有在DOM中找到元素,将继续等待, 超出设定时间后则抛出找不到元素的异常,换句话说,当查找元素或元素并没有立即出现的时候, 隐式等待等待一段时间再...
  • 考虑到Mr.E.和Arran的评论,我在CSS选择器...我通过搜索任何未加载状态的内容来处理等待几个元素的问题。您也可以使用“:nth child”选择器,如下所示:#in for loop with enumerate for iselector.append(' > ...
  • 1、显式等待from selenium import webdriverfrom selenium.webdriver.common.by import Byfrom selenium.webdriver.support.ui import WebDriverWaitfrom selenium.webdriver.support import expected_conditions as...
  • python爬虫--selenium等待页面加载

    千次阅读 2017-05-01 20:15:00
    python爬虫,使用selenium 等待页面加载完成后,获取页面信息 指定等待时长内没有加载完成,抛出异常 from selenium import webdriver from selenium.common.exceptions import TimeoutException from ...
  • selenium等待处理

    千次阅读 2018-02-27 12:24:54
    time.sleep(1) #强制等待一秒二,隐式等待from selenium import webdriver driver = webdriver.Chrome() driver.implicitly_wait(30) # 隐性等待,最长等30秒 driver.get('http://www.baidu.com') driver.quit()三...
  • 1、显式等待from selenium import webdriverfrom selenium.webdriver.common.by import Byfrom selenium.webdriver.support.ui import WebDriverWaitfrom selenium.webdriver.support import expected_conditions as...
  • selenium 等待时间

    2017-09-19 17:36:47
    1.简单粗暴: import time time.sleep(20) ...2.隐式等待:最长等待多少秒,等待时间内:如果元素加载出来则不再继续等待执行下一步操作,超过最长等待时间:如果未加载出来,selenium直接报错  driver.impl
  • #coding=utf-8from selenium import webdriverfrom selenium.webdriver.common.by import Byfrom selenium.webdriver.support.ui import WebDriverWaitfrom selenium.webdriver.support import expected_conditions ...
  • selenium 等待机制

    2018-07-10 13:06:40
    转载至: https://blog.csdn.net/huilan_same/article/details/525445211. 强制等待第一种也是最简单粗暴的一种办法就是强制等待sleep(xx),强制让闪电侠等xx时间,不管凹凸曼能不...from selenium import webdriv...
  • self.driver.implicitly_wait(10) #在一开始设置10秒钟等待时间 self.driver.find_element_by_id('kw').send_keys('su') self.driver.find_element_by_id('su').click() from selenium.webdriver.support.wait...
  • 强制等待(time.sleep)通过time模块的sleep方法让程序睡眠# coding=utf-8import time # 导入time模块time.sleep(second) # 程序休眠,其中second为休眠时间(单位为秒)隐性等待(implicitly_wait)设置隐性等待后每次d...
  • 主要内容1. 强制等待 (`time.sleep()`)2. 显式等待 (`WebDriverWait`)3. 隐式等待 (`implicitly_wait()`) 1. 强制等待 (time.sleep())     当一个页面被加载到浏览器时, 该页面内...from selenium import webdriv
  • 常用的有3种等待方式:强制等待隐式等待显示等待强制等待使用 Python 自身的库 time.sleep() 可以实现强制等待。强制等待使用简单,但是,当网络条件良好的时候,建议减少使用,因为如果频繁使用强制等待的方式等待...
  • selenium-webdriver中我们用两种方式进行等待:明确的等待和隐性的等待。明确的等待明确的等待是指在代码进行下一步操作之前等待某一个条件的发生。最不好的情况是使用Thread.sleep()去设置...
  • selenium等待方式详解

    2019-10-05 21:50:52
    # coding=utf-8 from time import sleep ...from selenium import webdriver from selenium.webdriver.common.by import By from selenium.webdriver.support import expected_conditions as EC from selen...
  • Selenium学习和使用过程中,比较常见的一个问题就是,弹窗定位不到、元素定位不到等,除了页面有frame、多窗口,就是没有加等待。代码运行的速度远远高于浏览器加载的速度,就像双人跑步运动,一个人快一个人慢总是...
  • selenium等待特定元素加载完毕 is_disappeared = WebDriverWait(driver, 8, 0.5, ignored_exceptions=TimeoutException).until(lambda x: x.find_element_by_id("id").is_displayed()) 转载于:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,384
精华内容 1,353
关键字:

selenium等待