软件测试 —— Selenium（等待）

主动化测试的时候，我们代码的速度是比网页渲染的速度要快的多，如果我们代码都执行完了，网页还没有渲染好的话，就会出现一些题目，这个时候我们就得等待，等待网页渲染完毕之后才华进行交互：
一个例子

我们在百度搜索“老番茄”，然后点击他的百度百科：

1. import time
3. from selenium import webdriver
4. from selenium.webdriver.common.by import By
5. from selenium.webdriver.firefox.service import Service
6. from webdriver_manager.firefox import GeckoDriverManager
8. FireFoxIns = GeckoDriverManager().install()
10. driver = webdriver.Firefox(service=Service(FireFoxIns))
12. driver.get("https://www.baidu.com/")
13. time.sleep(3)
15. driver.find_element(By.CSS_SELECTOR,"#kw").send_keys("老番茄")
16. driver.find_element(By.CSS_SELECTOR,"#su").click()
18. driver.find_element(By.CSS_SELECTOR,".pc-tag_2Nde8")
21. driver.quit()

复制代码

然子女码会报错：

这是由于，我们代码执行的速度太快了网页还没有渲染完，这个时候自然也找不到百度百科的词条。
此时，我们可以在点击之后休眠3秒：

这个时候就没题目，由于网页已经渲染完了，这个时候百度百科的词条自然也就可以找得到了。这次乐成的原因是，我么在点击之后等待了3秒，这个时候网页已经渲染好了。所以，适当的等待可以让网页有充分的时间去渲染，接下来我们要学习三种等待方式：
强制等待

强制等待或硬编码等待的方式。这种方式通过使用编程语言提供的睡眠函数来实现，比如 Python 的 time.sleep() 函数。强制等待会暂停脚本执行一个指定的时间长度，岂论在这段时间内元素是否变得可用
强制等待是最简朴但也可能是最不保举的一种等待方式，由于它并不智能，也不思量实际的页面加载状态或元素停当环境。它只是简朴地暂停测试脚本一段固定的时间，这可能会导致测试时间不须要的延伸，而且在不同的网络环境或设备上表现不稳固。
使用示例：

1. import time
3. # 打开浏览器并导航到目标网页
4. driver.get('http://example.com')
6. # 强制等待5秒
7. time.sleep(5)
9. # 继续执行后续操作...

复制代码

为什么不保举使用强制等待？

   

• 效率低下：即使元素在很短的时间内就已经可用，强制等待也会按照设定的时间长度进行等待，浪费时间。
  
• 不可靠性：如果等待的时间不够长，可能导致元素还没准备好就被实验访问；如果太长，则会无谓地增加测试时间。
  
• 维护成本高：每当页面加载时间变化时，都必要调整这些硬编码的等待时间。
  

  更好的选择

通常环境下，应该优先使用显式等待或 Fluent Wait 来处置惩罚动态内容，由于它们可以根据详细的条件来决定何时继承执行测试脚本，从而提供更可靠和高效的办理方案。
如果你确实必要在一个特定的位置添加短暂的停顿，比如为了让人眼观察某个动作的效果，可以思量使用较短的强制等待。但在主动化测试中，应只管制止使用强制等待，转而采用更加智能的等待计谋。
隐式等待 implicitly_wait（）

在 Selenium WebDriver 中，重要提供了三种类型的等待机制来同步测试脚本与网页加载行为：

• 隐式等待（Implicit Wait）：
  隐式等待是全局设置的，它告诉 WebDriver 在实验查找元素时，如果元素没有立刻出现，则等待一段时间再抛出 NoSuchElementException。一旦设置了隐式等待，它将应用于所有后续的元素定位调用。
  

1.    from selenium import webdriver
3.    driver = webdriver.Chrome()
4.    driver.implicitly_wait(10)  # 等待最长10秒

复制代码

隐式等待和强制等待的区别

隐式等待（Implicit Wait）和强制等待（Hardcoded Wait 或 Forced Wait）是两种不同的等待机制，它们在 Selenium WebDriver 中用于处置惩罚元素加载的时间题目。以下是两者的重要区别：
隐式等待（Implicit Wait）

   

• 智能等待：隐式等待是一种全局设置，它告诉 WebDriver 在查找元素时，如果元素没有立刻出现，则等待一段时间再抛出 NoSuchElementException。在这段时间内，WebDriver 会定期轮询 DOM 查找元素。
  

   

• 适用范围：一旦设置了隐式等待，它将应用于所有后续的元素定位调用。这意味着对于每个找不到的元素，WebDriver 都会等待设定的时间。
  

   

• 灵活性：隐式等待可以根据页面的实际加载环境主动调整，而不必要为每个元素单独编写等待逻辑。
  

   

• 代码简洁性：只必要一行代码就可以为整个测试脚本设置隐式等待，简化了代码结构。
  

   

• 性能影响：固然隐式等待可以提高测试的稳固性，但在某些环境下可能会导致测试执行时间延伸，特别是当页面上的许多元素都必要等待的时候。
  

  

• 实现方式：
  

1.    driver.implicitly_wait(10)  # 等待最长10秒

复制代码

强制等待（Hardcoded Wait 或 Forced Wait）

   

• 固定等待：强制等待使用编程语言提供的睡眠函数（如 Python 的 time.sleep()），来暂停脚本执行一个指定的时间长度，岂论在这段时间内元素是否变得可用。
  

   

• 非智能：强制等待不会根据元素的状态或页面加载环境作出反应，它只是简朴地暂停测试脚本一段固定的时间。
  

   

• 适用范围：每次必要暂停时都必须显式地调用睡眠函数，而且只对当前行代码生效。
  

   

• 缺乏灵活性：由于它是基于固定时间的，因此不能适应不同环境下的页面加载速度变化。
  

   

• 代码冗余：如果多个地方必要等待，那么就必要在每一处都插入相应的睡眠语句，增加了代码的冗余度。
  

   

• 性能影响：即使元素已经准备好，强制等待也会按照设定的时间长度进行等待，这可能导致不须要的耽误，尤其是在快速网络环境下。
  

  

• 实现方式：
  

1.    import time
2.    
3.    time.sleep(5)  # 暂停5秒

复制代码

  

• 保举使用隐式等待，由于它更智能、更灵活，能够根据实际环境主动调整，制止了硬编码等待带来的低效率和不可预测性。
  
• 只管制止使用强制等待，除非你确实必要在特定的位置添加短暂的停顿，比如为了让人眼观察某个动作的效果。但在主动化测试中，应优先思量使用隐式等待或显式等待等更智能的等待计谋。
  

  表现等待 WebDriverWait(driver,sec).until(functions)

1. from selenium import webdriver
2. from selenium.webdriver.common.by import By
3. from selenium.webdriver.firefox.service import Service
4. from selenium.webdriver.support.wait import WebDriverWait
5. from selenium.webdriver.support import expected_conditions as EC
6. from webdriver_manager.firefox import GeckoDriverManager
8. FireFoxIns = GeckoDriverManager().install()
10. driver = webdriver.Firefox(service=Service(FireFoxIns))
12. try:
13.     # 打开百度首页
14.     driver.get("https://www.baidu.com/")
16.     # 创建一个 WebDriverWait 实例，设置最大等待时间为10秒
17.     wait = WebDriverWait(driver, 10)
19.     # 等待搜索框出现并输入搜索关键词
20.     search_box = wait.until(EC.presence_of_element_located((By.CSS_SELECTOR, "#kw")))
21.     search_box.send_keys("老番茄")
23.     # 等待搜索按钮出现并点击它
24.     search_button = wait.until(EC.element_to_be_clickable((By.CSS_SELECTOR, "#su")))
25.     search_button.click()
27.     # 等待搜索结果中的特定元素出现
28.     result_element = wait.until(EC.presence_of_element_located((By.CSS_SELECTOR, ".pc-tag_2Nde8")))
30. finally:
31.     # 完成后关闭浏览器
32.     driver.quit()

复制代码

下面是一些方法
方法阐明title_is(title)检查页面标题是否等于指定的期望值。title_contains(partial_title)检查页面标题是否包含指定的区分大小写的子字符串。visibility_of_element_located(locator)检查元素是否存在于页面的DOM中而且是可见的。定位器用于指定要查找的元素。presence_of_element_located(locator)检查元素是否存在于页面的DOM中。定位器用于指定要查找的元素。visibility_of(element)检查已知存在于页面DOM上的元素是否可见。必要传入一个已经找到的元素对象。alert_is_present()检查是否有警告框（Alert）出现。 优点

   

• 智能等待：可以根据页面加载和元素状态动态调整等待时间。
  
• 灵活性：可以自定义表现等待的条件，操作更加灵活。
  

  缺点

   

• 写法复杂：相较于隐式等待和强制等待，代码编写较为复杂，必要为每个特定条件设置等待逻辑。
  

  表现等待和隐式等待的区别

表现等待（Explicit Wait）和隐式等待（Implicit Wait）是 Selenium WebDriver 中用于处置惩罚元素加载时间的两种不同机制。它们在实现方式、应用范围以及对测试稳固性的影响上都有显著的区别。以下是两者的重要区别：
表现等待（Explicit Wait）

• 智能且灵活：
  

   

• 表现等待答应你为每个元素或条件设置单独的等待时间，而且只在特定条件满足时继承执行脚本。
  
• 它们可以更精确地控制等待逻辑，从而提高测试的稳固性和效率。
  

  

• 自定义等待条件：
  

   

• 使用 WebDriverWait 和 expected_conditions，你可以定义非常详细的等待条件，如元素是否可见、可点击等。
  

  

• 局部应用：
  

   

• 表现等待仅应用于指定的元素查找操作，不会影响整个 WebDriver 实例的行为。
  

  

• 代码复杂度较高：
  

   

• 由于必要为每个等待条件编写相应的逻辑，因此代码会相对复杂一些。
  

  

• 性能优化：
  

   

• 表现等待可以在找到目标元素后立刻结束等待，制止不须要的长时间等待，提高了测试速度。
  

  

• 实现示例：
  1. from selenium.webdriver.support.ui import WebDriverWait
  2. from selenium.webdriver.support import expected_conditions as EC
  4. wait = WebDriverWait(driver, 10)
  5. element = wait.until(EC.presence_of_element_located((By.ID, 'myDynamicElement')))

  复制代码

隐式等待（Implicit Wait）

• 全局设置：
  

   

• 隐式等待是一次性设置给 WebDriver 实例的，它会影响所有后续的元素查找操作。
  

  

• 简朴直接：
  

   

• 设置隐式等待只必要一行代码，易于明白和使用。
  

  

• 固定等待时间：
  

   

• 如果在设定的时间内没有找到元素，才会抛出异常；即使元素已经出现也会等到设定的时间结束，这可能导致不须要的耽误。
  

  

• 适用于所有元素查找：
  

   

• 隐式等待对所有元素查找都生效，无法针对单个元素进行定制化等待。
  

  

• 可能降低测试效率：
  

   

• 当页面上的许多元素都必要等待时，可能会导致测试执行时间延伸。
  

  

• 实现示例：
  1. driver.implicitly_wait(10)  # 等待最长10秒

  复制代码

总结

   

• 保举使用表现等待，由于它可以根据实际环境主动调整，提供更高的灵活性和更精准的控制，有助于创建更加稳固和高效的主动化测试。
  
• 只管制止混淆使用显式等待和隐式等待，由于它们的组合可能会导致不可预测的行为。通常建议选择一种等待计谋并坚持使用，以保持测试的一致性和可靠性。
  

  隐式等待和表现等待混用

我们这里混用隐式等待和表现等待，看看末了等待的时间是不是20s：

1. try:
2.     # 打开百度首页
3.     driver.get("https://www.baidu.com/")
5.     # 设置隐式等待时间为10秒
6.     driver.implicitly_wait(10)
8.     # 创建一个 WebDriverWait 实例，设置最大等待时间为10秒
9.     wait = WebDriverWait(driver,10)
10.     start = time.time()
12.     # 输入搜索关键词并点击搜索按钮
13.     search_box = wait.until(EC.presence_of_element_located((By.CSS_SELECTOR,"#kw")))
14.     search_box.send_keys("老番茄")
15.     # driver.find_element(By.CSS_SELECTOR, "#kw").send_keys("老番茄")
17.     search_button = wait.until(EC.element_to_be_clickable((By.CSS_SELECTOR, "#su")))
18.     # driver.find_element(By.CSS_SELECTOR, "#su").click()
19.     search_button.click()
21.     # 尝试查找特定的元素（这里假设是搜索结果中的某个元素）
22.     result_element = wait.until(EC.presence_of_element_located((By.CSS_SELECTOR, ".pc-tag_2Nde81"))) # 故意写错，看时间
23.     driver.quit()
25. except:
26.     print("no such element")
27.     end = time.time()
28.     driver.quit()
31. print(end-start)

复制代码

所以我们才说，不要混淆隐式和显式等待，可能会导致不可预测的等待时间。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。