软件测试 —— Selenium（等待）

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

一个例子

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

import time

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.firefox.service import Service
from webdriver_manager.firefox import GeckoDriverManager

FireFoxIns = GeckoDriverManager().install()

driver = webdriver.Firefox(service=Service(FireFoxIns))

driver.get("https://www.baidu.com/")
time.sleep(3)

driver.find_element(By.CSS_SELECTOR,"#kw").send_keys("老番茄")
driver.find_element(By.CSS_SELECTOR,"#su").click()

driver.find_element(By.CSS_SELECTOR,".pc-tag_2Nde8")


driver.quit()

然后代码会报错：
这是因为，我们代码执行的速度太快了网页还没有渲染完，这个时候自然也找不到百度百科的词条。

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

强制等待

强制等待或硬编码等待的方式。这种方式通过使用编程语言提供的睡眠函数来实现，比如 Python 的 time.sleep() 函数。强制等待会暂停脚本执行一个指定的时间长度，不论在这段时间内元素是否变得可用

强制等待是最简单但也可能是最不推荐的一种等待方式，因为它并不智能，也不考虑实际的页面加载状态或元素就绪情况。它只是简单地暂停测试脚本一段固定的时间，这可能会导致测试时间不必要的延长，并且在不同的网络环境或设备上表现不稳定。

使用示例：

import time

# 打开浏览器并导航到目标网页
driver.get('http://example.com')

# 强制等待5秒
time.sleep(5)

# 继续执行后续操作...

为什么不推荐使用强制等待？

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

更好的选择

通常情况下，应该优先使用显式等待或 Fluent Wait 来处理动态内容，因为它们可以根据具体的条件来决定何时继续执行测试脚本，从而提供更可靠和高效的解决方案。

如果你确实需要在一个特定的位置添加短暂的停顿，比如为了让人眼观察某个动作的效果，可以考虑使用较短的强制等待。但在自动化测试中，应尽量避免使用强制等待，转而采用更加智能的等待策略。

隐式等待 implicitly_wait（）

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

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

   from selenium import webdriver

   driver = webdriver.Chrome()
   driver.implicitly_wait(10)  # 等待最长10秒

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

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

隐式等待（Implicit Wait）

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

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

3. 灵活性：隐式等待可以根据页面的实际加载情况自动调整，而不需要为每个元素单独编写等待逻辑。

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

5. 性能影响：虽然隐式等待可以提高测试的稳定性，但在某些情况下可能会导致测试执行时间延长，特别是当页面上的许多元素都需要等待的时候。

6. 实现方式：

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

强制等待（Hardcoded Wait 或 Forced Wait）

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

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

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

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

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

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

7. 实现方式：

   import time
   
   time.sleep(5)  # 暂停5秒

• 推荐使用隐式等待，因为它更智能、更灵活，能够根据实际情况自动调整，避免了硬编码等待带来的低效率和不可预测性。
• 尽量避免使用强制等待，除非你确实需要在特定的位置添加短暂的停顿，比如为了让人眼观察某个动作的效果。但在自动化测试中，应优先考虑使用隐式等待或显式等待等更智能的等待策略。

显示等待 WebDriverWait(driver,sec).until(functions)

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.firefox.service import Service
from selenium.webdriver.support.wait import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from webdriver_manager.firefox import GeckoDriverManager

FireFoxIns = GeckoDriverManager().install()

driver = webdriver.Firefox(service=Service(FireFoxIns))

try:
    # 打开百度首页
    driver.get("https://www.baidu.com/")

    # 创建一个 WebDriverWait 实例，设置最大等待时间为10秒
    wait = WebDriverWait(driver, 10)

    # 等待搜索框出现并输入搜索关键词
    search_box = wait.until(EC.presence_of_element_located((By.CSS_SELECTOR, "#kw")))
    search_box.send_keys("老番茄")

    # 等待搜索按钮出现并点击它
    search_button = wait.until(EC.element_to_be_clickable((By.CSS_SELECTOR, "#su")))
    search_button.click()

    # 等待搜索结果中的特定元素出现
    result_element = wait.until(EC.presence_of_element_located((By.CSS_SELECTOR, ".pc-tag_2Nde8")))

finally:
    # 完成后关闭浏览器
    driver.quit()

下面是一些方法

优点

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

缺点

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

显示等待和隐式等待的区别

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

显示等待（Explicit Wait）

1. 智能且灵活：

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

2. 自定义等待条件：

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

3. 局部应用：

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

4. 代码复杂度较高：

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

5. 性能优化：

• 显示等待可以在找到目标元素后立即结束等待，避免不必要的长时间等待，提高了测试速度。

6. 实现示例：

   from selenium.webdriver.support.ui import WebDriverWait
   from selenium.webdriver.support import expected_conditions as EC
   
   wait = WebDriverWait(driver, 10)
   element = wait.until(EC.presence_of_element_located((By.ID, 'myDynamicElement')))
   

隐式等待（Implicit Wait）

1. 全局设置：

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

2. 简单直接：

• 设置隐式等待只需要一行代码，易于理解和使用。

3. 固定等待时间：

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

4. 适用于所有元素查找：

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

5. 可能降低测试效率：

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

6. 实现示例：

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

总结

• 推荐使用显示等待，因为它可以根据实际情况自动调整，提供更高的灵活性和更精准的控制，有助于创建更加稳定和高效的自动化测试。
• 尽量避免混合使用显式等待和隐式等待，因为它们的组合可能会导致不可预测的行为。通常建议选择一种等待策略并坚持使用，以保持测试的一致性和可靠性。

隐式等待和显示等待混用

我们这里混用隐式等待和显示等待，看看最后等待的时间是不是20s：

try:
    # 打开百度首页
    driver.get("https://www.baidu.com/")

    # 设置隐式等待时间为10秒
    driver.implicitly_wait(10)

    # 创建一个 WebDriverWait 实例，设置最大等待时间为10秒
    wait = WebDriverWait(driver,10)
    start = time.time()

    # 输入搜索关键词并点击搜索按钮
    search_box = wait.until(EC.presence_of_element_located((By.CSS_SELECTOR,"#kw")))
    search_box.send_keys("老番茄")
    # driver.find_element(By.CSS_SELECTOR, "#kw").send_keys("老番茄")

    search_button = wait.until(EC.element_to_be_clickable((By.CSS_SELECTOR, "#su")))
    # driver.find_element(By.CSS_SELECTOR, "#su").click()
    search_button.click()

    # 尝试查找特定的元素（这里假设是搜索结果中的某个元素）
    result_element = wait.until(EC.presence_of_element_located((By.CSS_SELECTOR, ".pc-tag_2Nde81"))) # 故意写错，看时间
    driver.quit()

except:
    print("no such element")
    end = time.time()
    driver.quit()


print(end-start)

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