Selenium中的隐式等待和显式等待

在Selenium中，“等待”在执行测试中起着重要作用。在本文中，您将学习Selenium中“隐式”和“显式”等待的各个方面。 在本文中，您将学习到

1. 为什么我们需要在selenium中等待？

2. 隐瞒等待

3. 明确等待

4. 流利的等待

为什么我们需要在Selenium中等待？

大多数Web应用程序都是使用Ajax和Javascript开发的。当浏览器加载页面时，我们想要与之交互的元素可能以不同的时间间隔加载。

它不仅难以识别元素，而且如果元素未定位，它将抛出“ ElementNotVisibleException ”异常。使用Waits，我们可以解决此问题。

让我们考虑一个场景，我们必须在测试中使用隐式和显式等待。假设隐式等待时间设置为20秒，显式等待时间设置为10秒。

假设我们试图找到一个具有一些“ExpectedConditions ”（显式等待）的元素，如果该元素不在显式等待（10秒）定义的时间范围内，它将使用由隐式等待定义的时间帧（在抛出“ ElementNotVisibleException ” 之前20秒）。

Selenium Web驱动程序等待

隐含的等待 明确等待 隐含的等待 Selenium Web Driver借用了Watir隐式等待的想法。

隐式等待将告诉Web驱动程序在它抛出“No Such Element Exception”之前等待一定的时间。默认设置为0.一旦我们设置了时间，Web驱动程序将在抛出异常之前等待该时间。

在下面的示例中，我们声明了一个隐含的等待，时间范围为10秒。这意味着如果元素在该时间范围内不位于网页上，则会引发异常。

声明隐式等待：

1. driver.manage().timeouts().implicitlyWait(TimeOut, TimeUnit.SECONDS);

1. package guru.test99;

2. import java.util.concurrent.TimeUnit;

3. import org.openqa.selenium.By;

4. import org.openqa.selenium.WebDriver;

5. import org.openqa.selenium.chrome.ChromeDriver;

6. import org.testng.annotations.Test;

7. public class AppTest {

9. protected WebDriver driver;

10. @Test

11. public void guru99tutorials() throws InterruptedException

12. {

13. System.setProperty ("webdriver.chrome.driver",".\\chromedriver.exe" );

14. driver = new ChromeDriver();

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

16. String eTitle = "Demo Guru99 Page";

17. String aTitle = "" ;

18. // 启动Chrome并将其重定向到基本网址

19. driver.get("http://demo.guru99.com/test/guru99home/" );

20. //最大化浏览器窗口

21. driver.manage().window().maximize() ;

22. //获取标题的实际值

23. aTitle = driver.getTitle();

24. //将实际标题与预期标题进行比较

25. if (aTitle.equals(eTitle))

26. {

27. System.out.println( "Test Passed") ;

28. }

29. else {

30. System.out.println( "Test Failed" );

31. }

32. //关闭浏览器

33. driver.close();

34. }

35. }

代码说明

在上面的例子中，

考虑以下代码：

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

隐式等待将接受2个参数，第一个参数将接受时间作为整数值，第二个参数将接受时间测量，包括SECONDS，MINUTES，MILISECOND，MICROSECONDS，NANOSECONDS，DAYS，HOURS等。

明确等待 显式等待用于告诉Web驱动程序在抛出“ ElementNotVisibleException ”异常之前等待某些条件（预期条件）或超过最大时间。

显式等待是一种智能的等待，但它只能应用于指定的元素。显式等待提供比隐式等待更好的选项，因为它将等待动态加载的Ajax元素。

一旦我们声明显式等待，我们必须使用“ ExpectedCondtions ”，或者我们可以配置我们想要使用Fluent Wait检查条件的频率。这些天在实现我们使用Thread.Sleep（）时通常不建议使用

在下面的示例中，我们创建引用等待“ WebDriverWait ”类并使用“ WebDriver ”引用进行实例化，并且我们给出的最大时间帧为20秒。

句法：

WebDriverWait wait = new WebDriverWait(WebDriverRefrence,TimeOut);

1. package guru.test99;

3. import java.util.concurrent.TimeUnit;

4. import org.openqa.selenium.By;

5. import org.openqa.selenium.WebDriver;

6. import org.openqa.selenium.WebElement;

7. import org.openqa.selenium.chrome.ChromeDriver;

8. import org.openqa.selenium.support.ui.ExpectedConditions;

9. import org.openqa.selenium.support.ui.WebDriverWait;

10. import org.testng.annotations.Test;

12. public class AppTest2 {

13. protected WebDriver driver;

14. @Test

15. public void guru99tutorials() throws InterruptedException

16. {

17. System.setProperty ("webdriver.chrome.driver",".\\chromedriver.exe" );

18. driver = new ChromeDriver();

19. WebDriverWait wait=new WebDriverWait(driver, 20);

20. String eTitle = "Demo Guru99 Page";

21. String aTitle = "" ;

22. // 启动Chrome并将其重定向到Base URL

23. driver.get("http://demo.guru99.com/test/guru99home/" );

24. //最大化浏览器窗口

25. driver.manage().window().maximize() ;

26. //获取标题的实际值

27. aTitle = driver.getTitle();

28. //将实际标题与预期标题进行比较

29. if (aTitle.contentEquals(eTitle))

30. {

31. System.out.println( "Test Passed") ;

32. }

33. else {

34. System.out.println( "Test Failed" );

35. }

36. WebElement guru99seleniumlink;

37. guru99seleniumlink= wait.until(ExpectedConditions.visibilityOfElementLocated(By.xpath( "/html/body/div[1]/section/div[2]/div/div[1]/div/div[1]/div/div/div/div[2]/div[2]/div/div/div/div/div[1]/div/div/a/i")));

38. guru99seleniumlink.click();

39. }

41. }

代码说明

考虑以下代码：

1. WebElement guru99seleniumlink;

2. guru99seleniumlink= wait.until(ExpectedConditions.visibilityOfElementLocated(By.xpath( "/html/body/div[1]/section/div[2]/div/div[1]/div/div[1]/div/div/div/div[2]/div[2]/div/div/div/div/div[1]/div/div/a/i")));

3. guru99seleniumlink.click();

在上面的示例中，等待“ WebDriverWait ”类或“ ExpectedConditions ”中定义的时间量，以先发生者为准。

上面的Java代码声明我们正在等待网页上“ WebDriverWait ”类中定义的20秒时间帧的元素，直到满足“ ExpectedConditions ”并且条件为“ visibilityofElementLocated ”。

以下是可以在显式等待中使用的预期条件

·  alertIsPresent（）

·  elementSelectionStateToBe（）

·  elementToBeClickable（）

·  elementToBeSelected（）

·  frameToBeAvaliableAndSwitchToIt（）

·  invisibilityOfTheElementLocated（）

·  invisibilityOfElementWithText（）

·  presenceOfAllElementsLocatedBy（）

·  presenceOfElementLocated（）

·  textToBePresentInElement（）

·  textToBePresentInElementLocated（）

·  textToBePresentInElementValue（）

·  titleIs（）

·  titleContains（）

·  visibilityOf（）

·  visibilityOfAllElements（）

·  visibilityOfAllElementsLocatedBy（）

·  visibilityOfElementLocated（）

流利的等待

流畅的等待用于告诉Web驱动程序等待条件，以及在抛出“ElementNotVisibleException”异常之前我们想要检查条件的频率。

频率：设置具有时间范围的重复循环，以定期验证/检查条件

让我们考虑一个场景，其中元素以不同的时间间隔加载。如果我们声明显式等待20秒，该元素可能会在10秒，20秒甚至更长时间内加载。在抛出异常之前它会等到指定的时间。在这种情况下，流畅的等待是理想的等待使用，因为这将尝试以不同的频率找到元素，直到它找到它或最终的计时器用完为止。 句法：

1. Wait wait = new FluentWait(WebDriver reference)

2. .withTimeout(timeout, SECONDS)

3. .pollingEvery(timeout, SECONDS)

4. .ignoring(Exception.class);

1. package guru.test99;

3. import org.testng.annotations.Test;

4. import java.util.NoSuchElementException;

5. import java.util.concurrent.TimeUnit;

6. import java.util.function.Function;

8. import org.openqa.selenium.By;

9. import org.openqa.selenium.WebDriver;

10. import org.openqa.selenium.WebElement;

11. import org.openqa.selenium.chrome.ChromeDriver;

12. import org.openqa.selenium.support.ui.ExpectedConditions;

13. import org.openqa.selenium.support.ui.FluentWait;

14. import org.openqa.selenium.support.ui.Wait;

15. import org.openqa.selenium.support.ui.WebDriverWait;

16. import org.testng.annotations.Test;

18. public class AppTest3 {

19. protected WebDriver driver;

20. @Test

21. public void guru99tutorials() throws InterruptedException

22. {

23. System.setProperty ("webdriver.chrome.driver",".\\chromedriver.exe" );

24. String eTitle = "Demo Guru99 Page";

25. String aTitle = "" ;

26. driver = new ChromeDriver();

27. // 启动Chrome并将其重定向到Base URL

28. driver.get("http://demo.guru99.com/test/guru99home/" );

29. //最大化浏览器窗口

30. driver.manage().window().maximize() ;

31. //获取标题的实际值

32. aTitle = driver.getTitle();

33. //将实际标题与预期标题进行比较

34. if (aTitle.contentEquals(eTitle))

35. {

36. System.out.println( "Test Passed") ;

37. }

38. else {

39. System.out.println( "Test Failed" );

40. }

42. Wait<WebDriver> wait = new FluentWait<WebDriver>(driver)

43. .withTimeout(30, TimeUnit.SECONDS)

44. .pollingEvery(5, TimeUnit.SECONDS)

45. .ignoring(NoSuchElementException.class);

46. WebElement clickseleniumlink = wait.until(new Function<Webdriver, WebElement>(){

48. public WebElement apply(WebDriver driver ) {

49. return driver.findElement(By.xpath("/html/body/div[1]/section/div[2]/div/div[1]/div/div[1]/div/div/div/div[2]/div[2]/div/div/div/div/div[1]/div/div/a/i"));

50. }

51. });

52. //点击selenium链接

53. clickseleniumlink.click();

54. //关闭浏览器

55. driver.close() ;

56. }

57. }

代码说明

考虑以下代码：

1. public WebElement apply(WebDriver driver ) {

2. return driver.findElement(By.xpath("/html/body/div[1]/section/div[2]/div/div[1]/div/div[1]/div/div/div/div[2]/div[2]/div/div/div/div/div[1]/div/div/a/i"));

3. }

我们创建了一个新功能来识别页面上的Web元素。（例如：这里的Web元素只不过是网页上的selenium链接）。

频率设置为5秒，最大时间设置为30秒。因此，这意味着它将每隔5秒检查网页上的元素，最长时间为30秒。如果元素位于此时间范围内，它将执行操作，否则将抛出“ ElementNotVisibleException ”

隐式等待与显式等待的区别

结论：

隐式，显式和流利等待是selenium中使用的不同等待。这些等待的使用完全基于以不同时间间隔加载的元素。在测试我们的应用程序或构建我们的框架时，始终不建议使用Thread.Sleep（）。

 

总结：

感谢每一个认真阅读我文章的人！！！

作为一位过来人也是希望大家少走一些弯路，如果你不想再体验一次学习时找不到资料，没人解答问题，坚持几天便放弃的感受的话，在这里我给大家分享一些自动化测试的学习资源，希望能给你前进的路上带来帮助。

软件测试面试文档

我们学习必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有字节大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。

 

          视频文档获取方式：
这份文档和视频资料，对于想从事【软件测试】的朋友来说应该是最全面最完整的备战仓库，这个仓库也陪伴我走过了最艰难的路程，希望也能帮助到你！以上均可以分享，点下方小卡片即可自行领取。