蓝桥杯软件测试赛项之自动化测试备考知识点梳理

考察点	知识点
Selenium	1.Webdriver初始化；
	2.浏览器打开、关闭、窗口操作、导航操作；
	3.八种元素定位、窗口切换、frame切换；
	4.浏览器元素的基本操作、下拉框、弹出框、附件上传；
	5.时间等待的几种方式；
	6.JS 执行滚动条操作、页面元素属性的更改；
	7.模拟鼠标键盘的 Action 方法；
	8.页面元素截图和全屏截图方法；
	9.测试框架中注解、断言、执行顺序等；
	10.数据驱动、参数化；
	11.异常测试、超时测试等；
	12.PO 模式。

1.1. Webdriver初始化

在你的Python脚本中，导入 webdriver 模块，并创建一个WebDriver实例，这个实例会打开一个新的浏览器窗口或标签页。

from selenium import webdriver

# 指定ChromeDriver的路径
driver_path = 'path/to/chromedriver'

# 初始化WebDriver
driver = webdriver.Chrome(driver_path)

# 如果已经将ChromeDriver添加到PATH，则可以直接使用
# driver = webdriver.Chrome()

API是Seleniunm Webdriver的基础，通过组合使用这些API,可以构建出复杂的自动化测试脚本，以模拟用户的各种操作行为，并验证应用程序的功能和性能。在实际应用中，应根据具体的测试需求选择合适的API进行组合使用。

使用Chrome，已经设置如下的Webdriver打开blog网页的例子:

from selenium import webdriver

driver = webdriver.Chrome()
driver.get("https://blog.csdn.net/yueqingll?type=blog")

如果想使用其他浏览器，只需将 webdriver.Chrome() 替换为对应的浏览器驱动即可，例如 webdriver.Firefox()。

1.2 浏览器打开、关闭、窗口操作、导航操作：

1.2.1 浏览器打开：

初始化Webdriver后，可以使用get()方法访问网页：

# 打开一个网页
driver.get('http://www.example.com')

使用Chrome，已经设置如下的Webdriver打开blog网页的例子:

driver.get("https://blog.csdn.net/yueqingll?type=blog")

1.2.2 浏览器关闭：

关闭浏览器可以通过调用Webdriver实例的close()和quit()方法来完成：

# 关闭当前窗口或标签页
driver.close()

# 关闭浏览器并退出WebDriver
driver.quit()

close()方法关闭当前聚焦的窗口或标签页，而quit()方法关闭整个浏览器并退出WebDriver会话，释放资源。

1.2.3 窗口设置：

Selenium允许操作浏览器窗口，例如最大化，调整窗口大小，定位等：

# 最大化浏览器窗口
driver.maximize_window()

# 设置浏览器窗口大小为800x600
driver.set_window_size(800, 600)

# 获取当前窗口的尺寸
size = driver.get_window_size()
print(f"窗口尺寸: 宽度 - {size['width']}, 高度 - {size['height']}")

# 获取当前窗口的位置
position = driver.get_window_position()
print(f"窗口位置: X - {position['x']}, Y - {position['y']}")

# 切换到新的窗口或标签页
for handle in driver.window_handles:
    driver.switch_to.window(handle)
    # 在这里可以添加代码来检查新窗口的标题或URL，以确定是否为所需的窗口
    if driver.title == "期望的标题":
        break

1.2.4 导航操作：

导航操作包括打开网页、前进、后退和刷新页面：

# 打开一个网页
driver.get('http://www.example.com')

# 前进到下一个页面（如果可能）
driver.forward()

# 后退到上一个页面（如果可能）
driver.back()

# 刷新当前页面
driver.refresh()

1.2.5 其他操作：

Selenium还提供了许多其他操作，如执行JavaScript、获取页面源代码、获取页面标题等：

# 执行JavaScript代码，例如滚动到页面底部
driver.execute_script('window.scrollTo(0, document.body.scrollHeight);')

# 获取当前页面的源代码
source = driver.page_source
print(source)

# 获取当前页面的标题
title = driver.title
print(title)

通过这些操作，可以完全控制浏览器，模拟用户的各种行为，并进行Web自动化测试。在实际的自动化测试脚本中，可能会结合使用这些操作来执行更复杂的任务，例如登录网站、填写表单、验证数据等。

1.3 八种元素定位、窗口切换、frame切换

1.3.1 八种元素定位：

1.3.1.1 ID定位：

使用元素的ID属性来定位。(ID在页面中通常是唯一的。)

element = driver.find_element_by_id('element_id')

或者使用By类：

element = driver.find_element(By.ID, 'element_id')

1.3.1.2 Name定位：

使用元素的name属性来定。(多个元素可能有相同的name属性。)

element = driver.find_element_by_name('element_name')

或者使用By类：

element = driver.find_element(By.NAME, 'element_name')

1.3.1.3 Class Name定位：

使用元素的class属性来定位。一个元素可能有多个class，你可以使用其中一个来定位。

element = driver.find_element_by_class_name('class_name')

或者使用By类：

element = driver.find_element(By.CLASS_NAME, 'class_name')

1.3.1.4 Tag Name定位：

使用元素的标签名来定位。例如，<input>或<div>。

element = driver.find_element_by_tag_name('tag_name')

或者使用By类：

element = driver.find_element(By.TAG_NAME, 'tag_name')

1.3.1.5 Link Text定位：

使用链接元素的完整文本内容来定位。

element = driver.find_element_by_link_text('link_text')

或者使用By类：

element = driver.find_element(By.LINK_TEXT, 'link_text')

1.3.1.6 Practical Link Text定位：

使用链接元素的部分文本内容来定位。

element = driver.find_element_by_partial_link_text('part_of_link_text')

或者使用By类：

element = driver.find_element(By.PARTIAL_LINK_TEXT, 'part_of_link_text')

1.3.1.7 Css Selector定位：

使用CSS选择器来定位元素。这是一种非常强大和灵活的定位方法。

element = driver.find_element_by_css_selector('css_selector')

或者使用By类：

element = driver.find_element(By.CSS_SELECTOR, 'css_selector')

1.3.1.8 XPath定位：

使用XPath表达式来定位元素。XPath是一种在XML和HTML文档中查找信息的语言。

element = driver.find_element_by_xpath('xpath_expression')

或者使用By类：

element = driver.find_element(By.XPATH, 'xpath_expression')

1.3.2 窗口切换：

当需要在不同窗口之间切换时，例如点击一个链接后在新窗口打开页面，可以使用以下方法：

# 获取当前窗口的句柄
main_window_handle = driver.current_window_handle

# 获取所有窗口的句柄
all_window_handles = driver.window_handles

# 切换到新窗口
for handle in all_window_handles:
    if handle != main_window_handle:
        driver.switch_to.window(handle)
        break

# 现在可以在新窗口中操作元素了

1.3.3 Frame切换：

如果页面中包含iframe或frame，可能需要切换到相应的frame才能操作其中的元素：

# 切换到指定的frame
driver.switch_to.frame('frame_name_or_id')

# 在frame中执行操作
# ...

# 切换回主内容（默认的content）
driver.switch_to.default_content()

如果需要嵌套在多个frame中，可以连续调用switch_to.frame()来深入到嵌套的frame中：

driver.switch_to.frame('outer_frame')
driver.switch_to.frame('inner_frame')

操作完成后，确保切换回主内容，以便可以继续操作页面的其他部分：

driver.switch_to.default_content()

1.3.4 Attention:

使用Selenium的find_element或find_elements方法尝试定位不存在的元素时，Selenium会抛出NoSuchElementException。为了避免程序因此异常而中断，可以使用Python的try和except语句来捕获和处理这个异常。

以下是一个如何添加异常处理的示例：

from selenium import webdriver
from selenium.common.exceptions import NoSuchElementException

# 初始化WebDriver
driver = webdriver.Chrome()

# 打开网页
driver.get('http://www.example.com')

try:
    # 尝试定位元素
    element = driver.find_element_by_id('nonexistent_element_id')
    # 如果元素存在，执行以下操作
    print("元素找到了，可以执行操作，例如点击或输入文本。")
except NoSuchElementException:
    # 如果元素不存在，捕获异常并执行以下操作
    print("抱歉，找不到该元素。")

# 关闭浏览器
driver.quit()

在这个示例中，尝试定位一个ID为nonexistent_element_id的元素。如果这个元素不存在，find_element_by_id方法将抛出NoSuchElementException，这会被except块捕获。在except块中，可以打印一条错误消息或者执行其他任何我们想要的操作，比如记录日志、截图或者继续执行其他测试步骤。

同样的，如果使用的是find_elements方法来查找多个元素，并且没有找到任何元素，它不会抛出异常，而是返回一个空列表。因此，在这种情况下，不需要异常处理，只需检查返回的列表是否为空即可：

elements = driver.find_elements_by_css_selector('nonexistent_css_selector')
if not elements:
    print("没有找到匹配的元素。")

在实际的自动化测试中，异常处理是非常重要的，因为它可以帮助测试脚本更加健壮，能够处理各种预期之外的情况。

1.4 浏览器元素的基本操作、下拉框、弹出框、附件上传；

1.4.1 浏览器元素的基本操作：

1.4.1.1 点击元素：

element = driver.find_element_by_id('element_id')
element.click()

1.4.1.2 输入文本：

element = driver.find_element_by_name('input_name')
element.send_keys('输入的文本')

1.4.1.3 获取元素属性：

element = driver.find_element_by_xpath('xpath_expression')
attribute_value = element.get_attribute('attribute_name')
print(attribute_value)

1.4.1.4 获取元素文本：

element = driver.find_element_by_css_selector('css_selector')
text = element.text
print(text)

1.4.1.5 清除元素内容：

element = driver.find_element_by_tag_name('input')
element.clear()

1.4.2 下拉框

下拉框（<select>元素）通常需要使用Select类来处理。

1.4.2.1 选择下拉框选项：

from selenium.webdriver.support.ui import Select

select_element = Select(driver.find_element_by_id('select_id'))
select_element.select_by_value('option_value')
select_element.select_by_index(1)
select_element.select_by_visible_text('选项文本')

1.4.2.2 获取所有选项：

options = select_element.options
for option in options:
    print(option.text)

1.4.2.3 取消选择使用选项：

select_element.deselect_all()

1.4.3 弹出框：

JavaScript弹出框（如警告框、确认框、提示框）需要使用switch_to.alert来处理。

1.4.3.1 接受弹出框：

alert = driver.switch_to.alert
alert.accept()

1.4.3.2 dismiss弹出框：

alert = driver.switch_to.alert
alert.dismiss()

1.4.3.3 获取弹出框文本：

alert = driver.switch_to.alert
alert_text = alert.text
print(alert_text)

1.4.3.4 在弹出框中输入文本：

alert = driver.switch_to.alert
alert.send_keys('输入的文本')

1.4.4 附件上传：

文件上传通常通过<input type="file">元素完成。

# 定位文件上传元素
file_input = driver.find_element_by_css_selector('input[type="file"]')

# 发送文件路径到文件上传元素
file_input.send_keys('path/to/your/file.txt')

确保在执行文件上传操作之前，页面上的文件上传元素是可见的，并且没有被其他元素遮挡。

1.5 时间等待的几种方式：

在Selenium中，等待是自动化测试中的一个重要概念，因为页面元素可能因为网络延迟、JavaScript加载等原因而不立即出现。Selenium提供了两种主要的等待方式：显式等待（Explicit Waits）和隐式等待（Implicit Waits）。

1.5.1 隐式等待（Implicit Waits）

隐式等待是一种全局等待设置，它会在尝试查找任何元素时生效。如果Selenium WebDriver没有立即找到元素，它会等待一段预定义的时间，直到元素出现为止。如果在指定时间内找到了元素，WebDriver将继续执行代码。如果超时，将抛出NoSuchElementException。

from selenium import webdriver

# 初始化WebDriver
driver = webdriver.Chrome()

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

# 打开网页
driver.get('http://www.example.com')

# 尝试查找元素
element = driver.find_element_by_id('element_id')

# 执行其他操作...

1.5.2 显式等待（Explicit Waits）

显式等待是一种更复杂的等待方式，它允许你为某个特定的条件设置等待时间。这意味着WebDriver将等待某个特定的条件成立后再继续执行代码。显式等待通常用于等待某个特定的元素出现或者某个特定的条件成立。

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

# 初始化WebDriver
driver = webdriver.Chrome()

# 打开网页
driver.get('http://www.example.com')

try:
    # 设置显式等待，最长等待10秒
    element = WebDriverWait(driver, 10).until(
        EC.presence_of_element_located((By.ID, 'element_id'))
    )

    # 执行其他操作...
finally:
    # 关闭浏览器
    driver.quit()

1.5.3 固定时间等待（Timeouts）

除了隐式等待和显式等待，还可以使用Python的time模块来创建固定时间等待。

import time

# 等待5秒
time.sleep(5)

这种方法不推荐用于自动化测试，因为它不考虑页面的实际加载情况，可能会导致测试的不稳定。

1.5.4 总结

隐式等待是全局设置，适用于所有元素查找操作。
显式等待是针对特定条件的等待，更加灵活和精确。
固定时间等待应尽量避免，因为它不考虑页面的实际状态。

在实际的自动化测试中，通常会结合使用隐式等待和显式等待，以实现更稳定和可靠的测试脚本。

1.6 JS 执行滚动条操作、页面元素属性的更改：

在Selenium中，你可以使用JavaScript来执行滚动条操作和更改页面元素的属性。这是因为Selenium WebDriver提供了执行JavaScript代码的能力。以下是如何使用JavaScript来执行这些操作的示例。

1.6.1 执行滚动条操作：

使用JavaScript来滚动页面是一个非常灵活的方法，因为它允许根据需要精确地控制滚动行为。以下是一些常用的滚动操作：

# 初始化WebDriver
driver = webdriver.Chrome()

# 打开网页
driver.get('http://www.example.com')

# 使用JavaScript将页面滚动到底部
driver.execute_script('window.scrollTo(0, document.body.scrollHeight);')

# 使用JavaScript将页面滚动到顶部
driver.execute_script('window.scrollTo(0, 0);')

# 使用JavaScript滚动到指定元素
element = driver.find_element_by_id('element_id')
driver.execute_script('arguments[0].scrollIntoView();', element)

1.6.2 更改页面元素属性：

使用JavaScript来更改页面元素的属性也是一种常见的操作。例如，可以更改元素的样式、类名、属性等。

# 初始化WebDriver
driver = webdriver.Chrome()

# 打开网页
driver.get('http://www.example.com')

# 使用JavaScript更改元素的样式
driver.execute_script("document.getElementById('element_id').style.backgroundColor = 'red';")

# 使用JavaScript更改元素的类名
driver.execute_script("document.getElementById('element_id').className = 'new_class_name';")

# 使用JavaScript更改元素的属性
driver.execute_script("document.getElementById('element_id').setAttribute('data-custom', 'value');")

在这些示例中，execute_script方法用于执行JavaScript代码。可以传递任意的JavaScript代码作为字符串参数，以及必要的参数来执行操作。

1.6.3 Attention：

在使用execute_script时，确保你的JavaScript代码是有效的，并且适合当前页面的上下文。此外，JavaScript执行是同步的，这意味着在执行JavaScript代码时，Selenium会等待JavaScript代码执行完成后再继续执行后续的代码。

这些操作在自动化测试中非常有用，尤其是在处理复杂的页面交互或者需要模拟用户特定行为时。

1.7 模拟鼠标键盘的 Action 方法：

在Selenium中，ActionChains类提供了一种模拟复杂用户交互的方法，如鼠标移动、拖放、右键点击、双击以及键盘操作等。使用ActionChains，可以构建一个动作链，然后执行它来模拟用户的复杂行为。

以下是一些常用的ActionChains方法：

1.7.1 鼠标操作：

1.7.1.1 移动鼠标到元素上：

from selenium.webdriver.common.action_chains import ActionChains

# 初始化WebDriver
driver = webdriver.Chrome()

# 打开网页
driver.get('http://www.example.com')

# 定位元素
element = driver.find_element_by_id('element_id')

# 创建ActionChains对象
actions = ActionChains(driver)

# 移动鼠标到元素上
actions.move_to_element(element)

# 执行动作
actions.perform()

1.7.1.2 点击并保持：

# 定位元素
element = driver.find_element_by_id('element_id')

# 创建ActionChains对象
actions = ActionChains(driver)

# 点击并保持
actions.click_and_hold(element)

# 执行动作
actions.perform()

1.7.1.3 释放鼠标：

# 释放鼠标
actions.release()

# 执行动作
actions.perform()

1.7.1.4 双击：

# 定位元素
element = driver.find_element_by_id('element_id')

# 创建ActionChains对象
actions = ActionChains(driver)

# 双击
actions.double_click(element)

# 执行动作
actions.perform()

1.7.1.5 右键点击：

# 定位元素
element = driver.find_element_by_id('element_id')

# 创建ActionChains对象
actions = ActionChains(driver)

# 右键点击
actions.context_click(element)

# 执行动作
actions.perform()

1.7.1.6 拖放：

# 定位源元素和目标元素
source_element = driver.find_element_by_id('source_element_id')
target_element = driver.find_element_by_id('target_element_id')

# 创建ActionChains对象
actions = ActionChains(driver)

# 拖放
actions.drag_and_drop(source_element, target_element)

# 执行动作
actions.perform()

1.7.2 键盘操作：

1.7.2.1 发送键盘按键：

# 定位元素
element = driver.find_element_by_id('element_id')

# 创建ActionChains对象
actions = ActionChains(driver)

# 点击元素以激活输入
actions.click(element)

# 发送键盘按键
actions.send_keys('Hello, World!')

# 执行动作
actions.perform()

1.7.2.2 发送特殊键：

# 定位元素
element = driver.find_element_by_id('element_id')

# 创建ActionChains对象
actions = ActionChains(driver)

# 点击元素以激活输入
actions.click(element)

# 发送特殊键，如CONTROL + A（全选）
actions.send_keys(Keys.CONTROL, 'a')

# 发送特殊键，如CONTROL + C（复制）
actions.send_keys(Keys.CONTROL, 'c')

# 发送特殊键，如CONTROL + V（粘贴）
actions.send_keys(Keys.CONTROL, 'v')

# 执行动作
actions.perform()

在使用ActionChains时，需要构建一个动作链，然后调用perform()方法来执行所有动作。动作链中的每个动作都会按照添加的顺序依次执行。

这些操作对于模拟复杂的用户交互非常有用，例如在拖放测试、右键菜单测试或需要键盘快捷键的测试场景中。

1.8 页面元素截图和全屏截图方法：

在Selenium中，可以使用多种方法来捕获网页的截图，包括页面元素的截图和全屏截图。以下是一些常用的方法：

1.8.1 页面元素截图：

要捕获页面元素的截图，可以使用WebDriver的get_screenshot_as_file()方法，结合元素的位置和大小信息。

from selenium import webdriver
from selenium.webdriver.common.by import By

# 初始化WebDriver
driver = webdriver.Chrome()

# 打开网页
driver.get('http://www.example.com')

# 定位元素
element = driver.find_element(By.ID, 'element_id')

# 获取元素的位置和大小
location = element.location
size = element.size

# 计算元素的坐标
x = location['x']
y = location['y']
width = size['width']
height = size['height']

# 截图并保存
driver.get_screenshot_as_file('screenshot.png')

# 关闭浏览器
driver.quit()

在上面的代码中，首先定位到要截图的元素，然后获取它的位置和大小。接着，使用get_screenshot_as_file()方法来捕获整个页面的截图。由于这个方法截取的是整个页面，所以需要在后期处理中根据元素的位置和大小来裁剪出元素的截图。

1.8.2 全屏截图：

要捕获整个网页的全屏截图，你可以直接使用get_screenshot_as_file()方法，而不需要定位元素。

from selenium import webdriver

# 初始化WebDriver
driver = webdriver.Chrome()

# 打开网页
driver.get('http://www.example.com')

# 截图并保存
driver.get_screenshot_as_file('full_screenshot.png')

# 关闭浏览器
driver.quit()

在这个例子中，get_screenshot_as_file()方法会截取当前页面的整个可视区域，并将其保存为指定的文件名。

1.8.3 Attention：

get_screenshot_as_file()方法在Selenium 3.x及更早版本中是save_screenshot()方法。如果使用的是Selenium 4.x或更高版本，请使用get_screenshot_as_file()。

此外，如果想要更精细地控制截图，比如只截取页面的一部分或者对截图进行裁剪，可能需要使用第三方库，如Pillow（Python Imaging Library），来处理截图。

在实际使用中，截图功能对于调试和记录测试结果非常有用。可以根据需要选择全屏截图或元素级别的截图。

1.9 测试框架中注解、断言、执行顺序等：

在Selenium和Python的测试框架中，可以使用多种注解、断言和执行顺序的机制来管理的测试用例。以下是一些详细的讲解：

1.9.1 注解（Annotations）

在Python的测试框架中，注解是一种用于标记测试方法或类的元数据。它们可以提供额外的信息，如测试的描述、优先级、环境依赖等。

示例（使用pytest）：

import pytest

@pytest.mark.smoke
def test_smoke():
    assert True

@pytest.mark.flaky
def test_flaky():
    assert False

在这个例子中，@pytest.mark.smoke和@pytest.mark.flaky是注解，它们可以用来标记测试方法，并提供额外的信息。test_smoke测试标记为烟雾测试，而test_flaky测试标记为易失败的。

1.9.2 断言（Assertions）：

断言是测试框架中用来验证某个条件是否为真的方法。如果条件不成立，测试框架将抛出异常，测试将失败。

在Python的unittest和pytest框架中，可以使用多种内置的断言方法，如assertTrue()、assertFalse()、assertEqual()等。

from selenium import webdriver

def test_login():
    driver = webdriver.Chrome()
    driver.get('http://www.example.com')
    driver.find_element_by_id('username').send_keys('correct_username')
    driver.find_element_by_id('password').send_keys('correct_password')
    driver.find_element_by_id('login_button').click()
    
    # 断言登录成功
    assert driver.find_element_by_id('welcome_message').text == 'Welcome, correct_username'
    
    driver.quit()

在这个例子中，使用assert语句来验证登录成功后的页面显示了欢迎消息。

1.9.3 执行顺序（Execution Order）：

在测试框架中，测试用例的执行顺序可以手动设置，也可以由框架自动管理。在pytest中，可以使用@pytest.mark.run(order=1)来指定测试用例的执行顺序。

import pytest

@pytest.mark.run(order=1)
def test_first():
    assert True

@pytest.mark.run(order=2)
def test_second():
    assert True

在这个例子中，test_first()测试用例将首先执行，然后是test_second()。

1.9.4 总结：

注解：用于标记测试方法或类，提供额外的信息。
断言：用于验证测试用例中某个条件是否为真，如果条件不成立，测试将失败。
执行顺序：可以手动设置或由测试框架自动管理。

在编写测试用例时，合理使用注解、断言和执行顺序可以帮助更好地组织和管理测试。

1.10 数据驱动、参数化：

在自动化测试中，数据驱动和参数化是两个重要的概念，它们允许将测试数据与测试脚本分离，从而实现更灵活和可扩展的测试。

1.10.1 数据驱动测试：

数据驱动测试是一种测试方法，它允许你使用外部数据源（如Excel文件、CSV文件、数据库等）来驱动测试。这意味着测试脚本中的数据与测试用例分离，从而使得测试更加灵活和可扩展。

假设有一个登录功能，需要测试不同的用户名和密码组合。可以使用一个Excel文件来管理这些组合。

首先，需要一个Excel文件，其中包含用户名和密码的组合。例如：

User Name	Password
user1	password1
user2	password2

然后，可以使用Python的openpyxl库来读取这个Excel文件，并获取测试数据。

1.10.2 参数化：

参数化是一种将测试用例与测试数据分离的技术。在Selenium中，可以使用参数化来为测试用例提供不同的输入数据。

可以使用pytest的参数化功能来为测试用例提供不同的用户名和密码组合。示例（使用pytest）：

import pytest
from openpyxl import load_workbook

# 加载Excel文件
wb = load_workbook('test_data.xlsx')
ws = wb.active

# 定义一个函数来获取测试数据
def get_test_data():
    data = []
    for row in ws.iter_rows(min_row=2, max_row=ws.max_row, min_col=1, max_col=2):
        data.append((row[0].value, row[1].value))
    return data

# 参数化测试用例
@pytest.mark.parametrize('username, password', get_test_data())
def test_login(username, password):
    driver = webdriver.Chrome()
    driver.get('http://www.example.com')
    driver.find_element_by_id('username').send_keys(username)
    driver.find_element_by_id('password').send_keys(password)
    driver.find_element_by_id('login_button').click()
    
    # 断言登录成功
    assert driver.find_element_by_id('welcome_message').text == 'Welcome, %s' % username
    
    driver.quit()

在这个例子中，首先定义了一个函数get_test_data()来从Excel文件中获取测试数据。然后，使用@pytest.mark.parametrize来为测试用例提供不同的用户名和密码组合。这样，当运行测试时，每个组合都会被单独测试。

1.10.3 总结：

数据驱动测试：允许使用外部数据源来驱动测试，实现更灵活和可扩展的测试。
参数化：允许你为测试用例提供不同的输入数据，从而提高测试的覆盖率和灵活性。

在这个例子中，使用了数据驱动和参数化来测试登录功能。使用Excel文件来管理不同的用户名和密码组合，并使用pytest的参数化功能来为测试用例提供不同的输入数据。这样，就可以更有效地管理测试数据，并提高测试的质量和效率。

1.11 异常测试、超时测试等:

在自动化测试中，异常测试和超时测试是确保应用程序能够正确处理错误情况和延迟情况的重要方面。以下是如何在Selenium和Python中实现这些测试的详细说明：

1.11.1 异常测试：

异常测试通常用于验证应用程序在遇到异常情况时是否能够正确地处理这些异常。这可以通过模拟异常情况并检查应用程序的响应来实现。

示例：

from selenium import webdriver

def test_exception():
    driver = webdriver.Chrome()
    driver.get('http://www.example.com')
    
    # 模拟异常情况，例如通过触发一个JavaScript错误
    driver.execute_script("throw new Error('This is an exception!');")
    
    # 断言异常被正确处理
    assert 'This is an exception!' in driver.page_source
    
    driver.quit()

在这个例子中，使用execute_script方法来触发一个JavaScript错误，并使用断言来验证页面源代码中是否包含了异常消息。

1.11.2 超时测试：

超时测试用于验证应用程序在长时间等待后是否能够正确响应。这可以通过设置超时参数并检查应用程序的响应来实现。

示例：

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

def test_timeout():
    driver = webdriver.Chrome()
    driver.get('http://www.example.com')
    
    # 设置超时时间为10秒
    element = WebDriverWait(driver, 10).until(
        EC.presence_of_element_located((By.ID, 'element_id'))
    )
    
    # 断言元素存在
    assert element.is_displayed()
    
    # 设置另一个超时时间为5秒
    element = WebDriverWait(driver, 5).until(
        EC.element_to_be_clickable((By.ID, 'element_id'))
    )
    
    # 断言元素可点击
    assert element.is_enabled()
    
    driver.quit()

在这个例子中，使用WebDriverWait方法来设置超时时间，并使用expected_conditions来等待元素的存在和可点击性。使用断言来验证这些条件是否在超时时间内成立。

1.11.3 总结：

异常测试：用于验证应用程序在遇到异常情况时是否能够正确地处理这些异常。
超时测试：用于验证应用程序在长时间等待后是否能够正确响应。

在编写测试用例时，合理使用异常测试和超时测试可以帮助确保应用程序在各种情况下都能正常工作。

1.12 PO 模式：

在自动化测试中，页面对象（Page Object）模式是一种设计模式，用于将页面元素的定位逻辑与测试用例分离，从而使测试更加模块化、可维护和易于扩展。

1.12.1 页面对象模式的基本结构：

页面对象模式通常包含以下几个关键部分：

页面类：用于表示一个页面，包含页面上所有元素的定位逻辑和操作方法。
页面元素：用于表示页面上的特定元素，通常包含元素的定位方法。
页面操作：用于表示对页面元素的操作，如点击、输入文本等。

示例：

假设我们有一个登录页面，我们可以创建一个登录页面对象，包含页面上所有元素的定位和操作方法。

from selenium import webdriver

class LoginPage:
    def __init__(self, driver):
        self.driver = driver
        self.username_input = self.driver.find_element_by_id('username')
        self.password_input = self.driver.find_element_by_id('password')
        self.login_button = self.driver.find_element_by_id('login_button')

    def login(self, username, password):
        self.username_input.send_keys(username)
        self.password_input.send_keys(password)
        self.login_button.click()

# 使用示例
driver = webdriver.Chrome()
page = LoginPage(driver)
page.login('user1', 'password1')
driver.quit()

在这个例子中，我们创建了一个登录页面对象LoginPage，它包含了一个构造函数和登录方法。在测试中，我们可以直接使用这个对象来登录，而不需要关心页面上元素的定位逻辑。

1.12.2 总结：

页面对象模式可以帮助你将页面上元素的定位和操作逻辑封装在一个类中，从而使测试更加模块化、可维护和易于扩展。在编写测试用例时，合理使用页面对象模式可以帮助你提高测试的质量和效率。

yueqingll

关注

20
点赞
踩
28

收藏

觉得还不错? 一键收藏
打赏
0
评论
蓝桥杯软件测试赛项之自动化测试备考知识点梳理

隐式等待是全局设置，适用于所有元素查找操作。显式等待是针对特定条件的等待，更加灵活和精确。固定时间等待应尽量避免，因为它不考虑页面的实际状态。在实际的自动化测试中，通常会结合使用隐式等待和显式等待，以实现更稳定和可靠的测试脚本。注解：用于标记测试方法或类，提供额外的信息。断言：用于验证测试用例中某个条件是否为真，如果条件不成立，测试将失败。执行顺序：可以手动设置或由测试框架自动管理。在编写测试用例时，合理使用注解、断言和执行顺序可以帮助更好地组织和管理测试。
复制链接

扫一扫