软件测试学习笔记丨Pytest+Allure测试计算器

霍格沃兹测试开发学社测试人社区2024-09-07 6:08

本文转自测试人社区，原文链接：https://ceshiren.com/t/topic/31954

项目要求

3.1 项目简介

计算器是近代人发明的可以进行数字运算的机器。 计算器通过对加法、减法、乘法、除法等功能的运算，将正确的结果展示在屏幕上。 可帮助人们更方便的实现数字运算。一般情况下计算器除显示计算结果外，还常有溢出指示、错误指示等功能。

3.1.1 知识点

  • 测试流程与需求分析
  • bug 提交与管理
  • Pytest 测试框架基本用法
  • 参数化
  • 异常处理
  • 标签、跳过用例
  • 结合 Allure 生成测试报告与项目总结
  • 数据驱动
  • pytest fixture 实现测试装置及参数化
  • pytest conftest.py 的用法
  • pytest 文件配置 pytest.ini
  • 使用第三方插件控制用例的执行顺序，分布式并发执行
  • 使用分层思想，实现框架的合理构建
  • 了解内置插件 hook 体系，实现插件开发

3.1.2 受众

  • 资深测试工程师

3.1.3 作业内容

  1. 完整的测试流程，包含需求分析、测试计划设计、测试用例编写、测试执行、bug 的提交与管理。
  2. 使用思维导图完成需求分分析；提供完整测试计划模板，完成测试计划设计；应用多种测试用例设计方法，包括：等价类、边界值、错误推测法等。
  3. 测试执行过程中应用多种测试方法完成计算器的加法、除法运算。
  4. 结合项目管理工具完成 bug 的提交与管理，进行测试报告编写与项目总结。
  5. 编写自动化测试用例，结合 Allure 与截图技术等自动生成带截图与操作步骤的测试报告。
  6. 使用参数化减少代码量，提高代码的可维护性。
  7. 使用 mark 标签为测试用例分类
  8. 设置跳过、预期失败用例
  9. 对异常用例进行处理
  10. 掌握 Pytest 常用的装饰器，例如：添加标签、参数化、Fixture 等。
  11. 掌握 Pytest 自动化测试框架多种复杂配置，比如 pytest.ini 配置、conftest.py 配置等。
  12. 合理使用第三方插件，控制测试用例的执行顺序、分布式并发执行等场景。
  13. 掌握分层思想实现用例的分层，实现测试装置，测试数据，测试日志，测试报告等合理的框架构建。
  14. 开发一个插件，实现命令行传递参数

3.1.4 被测源码

python 复制代码 
class Calculator:
    def add(self, a, b):

        if a > 99 or a < -99 or b > 99 or b < -99:
            print("请输入范围为【-99, 99】的整数或浮点数")
            return "参数大小超出范围"

        return a + b

    def div(self, a, b):
        if a > 99 or a < -99 or b > 99 or b < -99:
            print("请输入范围为【-99, 99】的整数或浮点数")
            return "参数大小超出范围"

        return a / b

3.2 实现过程

3.2.1 代码提交

3.2.2 需求分析

3.2.3 测试计划（简版）

3.2.4 测试用例设计

3.2.5 Pytest自动化测试设计

python 复制代码 
from pandas.tests.io.excel.test_openpyxl import openpyxl

class Utils:

    @classmethod
    def get_excel_data(cls, excel_path, sheetname):
        """
        读取 excel文件中指定 sheet 页的数据
        :param excel_path: excel文件的路径
        :param sheetname: sheet页的名称
        :return: 返回读取的数据
        """
        # 打开 Excel 文件
        book = openpyxl.load_workbook(excel_path)
        # 获取指定名称的工作表
        sheet = book[sheetname]
        # 初始化一个空列表，用于存储行数据
        values = []
        for row in sheet.iter_rows(values_only=True):
            values.append(row)
        return values
  • test_add_excel.py
python 复制代码 
import sys
import pytest
import os
import allure
from Calculator_Project.base.base import Base
from Calculator_Project.utils.log_util import logger
from Calculator_Project.utils.utils import Utils

# 定义一个获取加法数据的函数，接收一个参数 level
@pytest.mark.parametrize("type",
                         ["有效等价类", "无效等价类", "边界值", "错误推测"]
                         )
def get_add_data(type):
    """
    读取加法的测试数据
    :param type: 用例类型
    :return: 对应优先级的测试数据和 ids
    """
    # 获取当前文件的系统路径
    root_path = os.path.dirname(os.path.abspath(__file__))
    # 打印当前文件的系统路径
    print(f"当前系统路径：{root_path}")
    # 拼接 Excel文件的路径
    excel_path = os.sep.join([root_path, '..', 'datas', 'calculator.xlsx'])
    # 打印 Excel文件的路径
    print(f"excel文件路径：{excel_path}")
    sheetname = "加法"
    # 获取 Excel 数据
    excel_data = Utils.get_excel_data(excel_path, sheetname)
    # 打印 Excel 数据
    print(excel_data)
    # 初始化空列表，用于存储对应的测试数据
    datas = []
    ids = []
    # 遍历数据行，跳过标题行
    for row in excel_data[1:]:
        # 获取对应 level 优先级的数据
        if row[0] == type:
            datas.append([row[1], row[2], row[3]])  # 返回 a, b, expect
            ids.append(row[4])  # 返回 ids
    # 返回测试数据和测试标题的数组
    return [datas, ids]

# 设置allure报告的模块名称
@allure.epic("计算器测试")
# 设置allure报告的模块名称
@allure.feature("计算器加法测试")
# 定义一个加法测试类，继承自Base类
class TestAddExcel(Base):

    # 设置测试用例的执行顺序
    @pytest.mark.run(order=1)
    # 设置allure报告的用户故事
    @allure.story("加法-有效等价类的用例")
    # 使用 pytest的参数化装饰器，将get_add_datas("有效等价类")的结果解包成多个参数值，生成测试用例
    @pytest.mark.parametrize(
        "a, b, expect", get_add_data("有效等价类")[0], ids=get_add_data("有效等价类")[1]
    )
    # 定义一个测试加法的方法，接收3个参数：a, b, expect
    def test_add_valid(self, a, b, expect):
        # 添加图片
        allure.attach.file("./datas/pic2.jpg",
                           name="计算器图片2",
                           attachment_type=allure.attachment_type.JPG,
                           extension="JGP")
        # 记录测试用例参数的日志信息
        logger.info(f"a={a}, b={b}, expect={expect}")
        # 设置allure报告的测试步骤
        with allure.step(f"1. 调用被测程序进行计算{a}+{b}={expect}"):
            # 测试步骤：调用被测应用进行计算
            result = self.calculator.add(a, b)
        # 记录计算结果的日志信息
        logger.info(f"实际计算结果为：{result}")
        # 设置allure报告的测试步骤
        with allure.step(f"2. 断言{result} == {expect}"):
            # 断言实际结果是否与预期结果一致
            assert result == expect

    # 设置测试用例的执行顺序
    @pytest.mark.run(order=4)
    # 设置allure报告的用户故事
    @allure.story("加法-无效等价类的用例")
    # 使用 pytest的参数化装饰器，将get_add_datas("无效等价类")的结果解包成多个参数值，生成测试用例
    @pytest.mark.parametrize(
        "a,b,expect", get_add_data("无效等价类")[0], ids=get_add_data("无效等价类")[1]
    )
    # 定义一个测试加法的方法，接收3个参数：a, b, expect
    def test_add_unvalid(self, a, b, expect):
        # 记录测试用例参数的日志信息
        logger.info(f"a={a}, b={b}, expect={expect}")
        # 设置allure报告的测试步骤
        with allure.step(f"1. 调用被测程序进行计算{a}+{b}={expect}"):
            # 测试步骤：调用被测应用进行计算
            result = self.calculator.add(a, b)
        # 记录计算结果的日志信息
        logger.info(f"实际计算结果为：{result}")
        # 设置allure报告的测试步骤
        with allure.step(f"2. 断言{result} == {expect}"):
            # 断言实际结果是否与预期结果一致
            assert result == expect

    # 设置测试用例的执行顺序
    @pytest.mark.run(order=2)
    # 设置allure报告的用户故事
    @allure.story("加法-边界值的用例")
    # 使用 pytest的参数化装饰器，将get_add_datas("边界值")的结果解包成多个参数值，生成测试用例
    @pytest.mark.parametrize(
        "a, b, expect", get_add_data("边界值")[0], ids=get_add_data("边界值")[1]
    )
    # 定义一个测试加法的方法，接收3个参数：a, b, expect
    def test_add_boundary(self, a, b, expect):
        # 记录测试用例参数的日志信息
        logger.info(f"a={a}, b={b}, expect={expect}")
        # 设置allure报告的测试步骤
        with allure.step(f"1. 调用被测程序进行计算{a}+{b}={expect}"):
            # 测试步骤：调用被测应用进行计算
            result = self.calculator.add(a, b)
        # 记录计算结果的日志信息
        logger.info(f"实际计算结果为：{result}")
        # 设置allure报告的测试步骤
        with allure.step(f"2. 断言{result} == {expect}"):
            # 断言实际结果是否与预期结果一致
            assert result == expect

    # 设置测试用例的执行顺序
    @pytest.mark.run(order=3)
    # 设置allure报告的用户故事
    @allure.story("加法-错误推测的用例")
    # 使用 pytest的参数化装饰器，将get_add_datas("错误推测")的结果解包成多个参数值，生成测试用例
    @pytest.mark.parametrize(
        "a,b,expect", get_add_data("错误推测")[0], ids=get_add_data("错误推测")[1]
    )
    # 定义一个测试加法的方法，接收3个参数：a, b, expect
    def test_add_type_error(self, a, b, expect):
        # 记录测试用例参数的日志信息
        logger.info(f"a={a}, b={b}, expect={expect}")
        # 捕获预期的异常
        with pytest.raises(eval(expect)) as e:
            # 设置allure报告的测试步骤
            with allure.step(f"1. 调用被测程序进行计算{a}+{b}={expect}"):
                # 测试步骤：调用被测应用进行计算
                result = self.calculator.add(a, b)
            # 记录计算结果的日志信息
            logger.info(f"实际计算结果为：{result}")
            # 记录捕获的异常信息
            logger.info(f"类型错误为：{e}")
        # 设置allure报告的测试步骤
        with allure.step(f"2. 断言{e.type} == {TypeError}"):
            assert e.type == TypeError

    # 设置测试用例的执行顺序
    @pytest.mark.run(order=5)
    # 设置始终跳过的测试用例
    @pytest.mark.skip
    def test_error_message(self):
        print("详细提示信息未完成开发，暂不测试。")
        assert True

    # 设置测试用例的执行顺序
    @pytest.mark.run(order=7)
    # 设置特定条件下跳过的测试用例
    @pytest.mark.skipif(sys.platform == "darwin", reson = "不做mac的兼容")
    def test_sys(self):
        print("Mac系统不做兼容测试")
        assert True

    # 设置测试用例的执行顺序
    @pytest.mark.run(order=6)
    # 预期失败的测试用例
    @pytest.mark.xfail
    def test_fail(self):
        print("标记期望失败的案例，还没想好哪些失败。。。")
        assert True
  • test_div_excel.py
python 复制代码 
import sys
import pytest
import os
import allure
from Calculator_Project.base.base import Base
from Calculator_Project.utils.log_util import logger
from Calculator_Project.utils.utils import Utils

# 定义一个获取除法数据的函数，接收一个参数 level
@pytest.mark.parametrize("type",
                         ["有效等价类", "无效等价类", "边界值", "错误推测", "被除数为0"]
                         )
def get_div_data(type):
    """
    读取除法的测试数据
    :param type: 用例类型
    :return: 对应优先级的测试数据和 ids
    """
    # 获取当前文件的系统路径
    root_path = os.path.dirname(os.path.abspath(__file__))
    # 打印当前文件的系统路径
    print(f"当前系统路径：{root_path}")
    # 拼接 Excel文件的路径
    excel_path = os.sep.join([root_path, '..', 'datas', 'calculator.xlsx'])
    # 打印 Excel文件的路径
    print(f"excel文件路径：{excel_path}")
    # 获取 Excel 数据
    excel_data = Utils.get_excel_data(excel_path, "除法")
    # 打印 Excel 数据
    print(excel_data)
    # 初始化空列表，用于存储对应的测试数据
    datas = []
    ids = []
    # 遍历数据行，跳过标题行
    for row in excel_data[1:]:
        # 获取对应 level 优先级的数据
        if row[0] == type:
            datas.append([row[1], row[2], row[3]])  # 返回 a, b, expect
            ids.append(row[4])  # 返回 ids
    # 返回测试数据和测试标题的数组
    return [datas, ids]

# 设置allure报告的模块名称
@allure.epic("计算器测试")
# 设置allure报告的模块名称
@allure.feature("计算器除法测试")
# 定义一个除法测试类，继承自Base类
class TestDivExcel(Base):

    # 设置测试用例的执行顺序
    @pytest.mark.run(order=1)
    # 设置allure报告的用户故事
    @allure.story("除法-有效等价类的用例")
    # 使用 pytest的参数化装饰器，将get_div_datas("有效等价类")的结果解包成多个参数值，生成测试用例
    @pytest.mark.parametrize(
        "a, b, expect", get_div_data("有效等价类")[0], ids=get_div_data("有效等价类")[1]
    )
    # 定义一个测试除法的方法，接收3个参数：a, b, expect
    def test_div_valid(self, a, b, expect):
        # 添加图片
        allure.attach.file("./datas/pic1.jpg",
                           name="计算器图片1",
                           attachment_type=allure.attachment_type.JPG,
                           extension="JGP")
        # 记录测试用例参数的日志信息
        logger.info(f"a={a}, b={b}, expect={expect}")
        # 设置allure报告的测试步骤
        with allure.step(f"1. 调用被测程序进行计算{a}/{b}={expect}"):
            # 测试步骤：调用被测应用进行计算
            result = self.calculator.div(a, b)
        # 记录计算结果的日志信息
        logger.info(f"实际计算结果为：{result}")
        # 设置allure报告的测试步骤
        with allure.step(f"2. 断言{result} == {expect}"):
            # 断言实际结果是否与预期结果一致
            assert result == expect

    # 设置测试用例的执行顺序
    @pytest.mark.run(order=4)
    # 设置allure报告的用户故事
    @allure.story("除法-无效等价类的用例")
    # 使用 pytest的参数化装饰器，将get_div_datas("无效等价类")的结果解包成多个参数值，生成测试用例
    @pytest.mark.parametrize(
        "a,b,expect", get_div_data("无效等价类")[0], ids=get_div_data("无效等价类")[1]
    )
    # 定义一个测试除法的方法，接收3个参数：a, b, expect
    def test_div_unvalid(self, a, b, expect):
        # 记录测试用例参数的日志信息
        logger.info(f"a={a}, b={b}, expect={expect}")
        # 设置allure报告的测试步骤
        with allure.step(f"1. 调用被测程序进行计算{a}/{b}={expect}"):
            # 测试步骤：调用被测应用进行计算
            result = self.calculator.div(a, b)
        # 记录计算结果的日志信息
        logger.info(f"实际计算结果为：{result}")
        # 设置allure报告的测试步骤
        with allure.step(f"2. 断言{result} == {expect}"):
            # 断言实际结果是否与预期结果一致
            assert result == expect

    # 设置测试用例的执行顺序
    @pytest.mark.run(order=2)
    # 设置allure报告的用户故事
    @allure.story("除法-边界值的用例")
    # 使用 pytest的参数化装饰器，将get_div_datas("边界值")的结果解包成多个参数值，生成测试用例
    @pytest.mark.parametrize(
        "a, b, expect", get_div_data("边界值")[0], ids=get_div_data("边界值")[1]
    )
    # 定义一个测试除法的方法，接收3个参数：a, b, expect
    def test_div_boundary(self, a, b, expect):
        # 记录测试用例参数的日志信息
        logger.info(f"a={a}, b={b}, expect={expect}")
        # 设置allure报告的测试步骤
        with allure.step(f"1. 调用被测程序进行计算{a}/{b}={expect}"):
            # 测试步骤：调用被测应用进行计算
            result = self.calculator.div(a, b)
        # 记录计算结果的日志信息
        logger.info(f"实际计算结果为：{result}")
        # 设置allure报告的测试步骤
        with allure.step(f"2. 断言{result} == {expect}"):
            # 断言实际结果是否与预期结果一致
            assert result == expect

    # 设置测试用例的执行顺序
    @pytest.mark.run(order=3)
    # 设置allure报告的用户故事
    @allure.story("除法-错误推测的用例")
    # 使用 pytest的参数化装饰器，将get_div_datas("错误推测")的结果解包成多个参数值，生成测试用例
    @pytest.mark.parametrize(
        "a,b,expect", get_div_data("错误推测")[0], ids=get_div_data("错误推测")[1]
    )
    # 定义一个测试除法的方法，接收3个参数：a, b, expect
    def test_div_type_error(self, a, b, expect):
        # 记录测试用例参数的日志信息
        logger.info(f"a={a}, b={b}, expect={expect}")
        # 捕获预期的异常
        with pytest.raises(eval(expect)) as e:
            # 设置allure报告的测试步骤
            with allure.step(f"1. 调用被测程序进行计算{a}/{b}={expect}"):
                # 测试步骤：调用被测应用进行计算
                result = self.calculator.div(a, b)
            # 记录计算结果的日志信息
            logger.info(f"实际计算结果为：{result}")
            # 记录捕获的异常信息
            logger.info(f"类型错误为：{e}")
        # 设置allure报告的测试步骤
        with allure.step(f"2. 断言{e.type} == {TypeError}"):
            assert e.type == TypeError

    # 设置测试用例的执行顺序
    @pytest.mark.run(order=5)
    # 设置allure报告的用户故事
    @allure.story("除法-被除数为0的用例")
    # 使用 pytest的参数化装饰器，将get_div_datas("被除数为0")的结果解包成多个参数值，生成测试用例
    @pytest.mark.parametrize(
        "a, b, expect", get_div_data("被除数为0")[0], ids=get_div_data("被除数为0")[1]
    )
    # 定义一个测试除法的方法，接收3个参数：a, b, expect
    def test_div_zero(self, a, b, expect):
        # 记录测试用例参数的日志信息
        logger.info(f"a={a}, b={b}, expect={expect}")
        # 捕获预期的异常
        with pytest.raises(eval(expect)) as e:
            # 设置allure报告的测试步骤
            with allure.step(f"1. 调用被测程序进行计算{a}/{b}={expect}"):
                # 测试步骤：调用被测应用进行计算
                result = self.calculator.div(a, b)
            # 记录计算结果的日志信息
            logger.info(f"实际计算结果为：{result}")
            # 记录捕获的异常信息
            logger.info(f"类型错误为：{e}")
        # 设置allure报告的测试步骤
        with allure.step(f"2. 断言{e.type} == ZeroDivisionError"):
            assert e.type == ZeroDivisionError

    # 设置测试用例的执行顺序
    @pytest.mark.run(order=8)
    # 设置始终跳过的测试用例
    @pytest.mark.skip
    def test_error_message(self):
        print("详细提示信息未完成开发，暂不测试。")
        assert True

    # 设置测试用例的执行顺序
    @pytest.mark.run(order=7)
    # 设置特定条件下跳过的测试用例
    @pytest.mark.skipif(sys.platform == "darwin", reson = "不做mac的兼容")
    def test_sys(self):
        print("Mac系统不做兼容测试")
        assert True

    # 设置测试用例的执行顺序
    @pytest.mark.run(order=6)
    # 预期失败的测试用例
    @pytest.mark.xfail
    def test_fail(self):
        print("标记期望失败的案例，还没想好哪些失败。。。")
        assert True
python 复制代码 
import pytest
import yaml

# 解决用例描述中的中文乱码问题
# 定义一个pytest的钩子函数，接收3个参数 session, config, items，返回值类型都为 None
# 主要用于在收集测试用例后，对其进行修改
def pytest_collection_modifyitems(session, config, items):
    # 循环遍历所有收集到的测试用例的 items
    for item in items:
        # 对每个 item的 name进行编码和解码
        # item.name.encode('utf-8')是将 item按照 UTF-8格式编码
        # decode("unicode-escape")是将编码后的字符串按照 unicode-escape格式解码，以便正确显示中文字符。
        item.name = item.name.encode("utf-8").decode("unicode-escape")
        # 对每个 item的 _nodeid进行编码和解码
        item._nodeid = item._nodeid.encode("utf-8").decode("unicode-escape")
  • pytest.ini
python 复制代码 
[pytest]

# 日志开关 true false
log_cli = true
# 日志级别
log_cli_level = info
# 使用4个并发进程运行测试
# 打印详细日志，相当于命令行加 -vs
# 在第3个失败的测试后停止执行
addopts = -n 4 --capture=no --maxfail=3
# 日志格式
log_cli_format = %(asctime)s [%(levelname)s] %(message)s (%(filename)s:%(lineno)s)
# 日志时间格式
log_cli_date_format = %Y-%m-%d %H:%M:%S
# 日志文件位置
log_file = ./log/test.log
# 日志文件等级
log_file_level = info
# 日志文件格式
log_file_format = %(asctime)s [%(levelname)s] %(message)s (%(filename)s:%(lineno)s)
# 日志文件日期格式
log_file_date_format = %Y-%m-%d %H:%M:%

# 设置执行的路径
testpaths = tests
# 匹配测试文件的命名模式
python_files = test_*.py
# 匹配测试类的命名模式
python_classes = Test*
# 匹配测试函数的命名模式
python_functions = test_*
markers =
    run: specify order of test exection
  • log_util.py
python 复制代码 
import logging
import os

from logging.handlers import RotatingFileHandler

# 绑定绑定句柄到logger对象
logger = logging.getLogger(__name__)
# 获取当前工具文件所在的路径
root_path = os.path.dirname(os.path.abspath(__file__))
# 拼接当前要输出日志的路径
log_dir_path = os.sep.join([root_path, '..', f'/logs'])
if not os.path.isdir(log_dir_path):
    os.mkdir(log_dir_path)
# 创建日志记录器，指明日志保存路径,每个日志的大小，保存日志的上限
file_log_handler = RotatingFileHandler(os.sep.join([log_dir_path, 'log.log']), maxBytes=1024 * 1024, backupCount=10)
# 设置日志的格式
date_string = '%Y-%m-%d %H:%M:%S'
formatter = logging.Formatter(
    '[%(asctime)s] [%(levelname)s] [%(filename)s]/[line: %(lineno)d]/[%(funcName)s] %(message)s ', date_string)
# 日志输出到控制台的句柄
stream_handler = logging.StreamHandler()
# 将日志记录器指定日志的格式
file_log_handler.setFormatter(formatter)
stream_handler.setFormatter(formatter)
# 为全局的日志工具对象添加日志记录器
# 绑定绑定句柄到logger对象
logger.addHandler(stream_handler)
logger.addHandler(file_log_handler)
# 设置日志输出级别
logger.setLevel(level=logging.INFO)

3.2.6 Allure报告

  • 在线Allure报告



  • 静态Allure报告

推荐学习

【霍格沃兹测试开发】7天软件测试快速入门带你从零基础/转行/小白/就业/测试用例设计实战

【霍格沃兹测试开发】最新版！Web 自动化测试从入门到精通/ 电子商务产品实战/Selenium （上集）

【霍格沃兹测试开发】最新版！Web 自动化测试从入门到精通/ 电子商务产品实战/Selenium （下集）

【霍格沃兹测试开发】明星讲师精心打造最新Python 教程软件测试开发从业者必学（上集）

【霍格沃兹测试开发】明星讲师精心打造最新Python 教程软件测试开发从业者必学（下集）

【霍格沃兹测试开发】精品课合集/ 自动化测试/ 性能测试/ 精准测试/ 测试左移/ 测试右移/ 人工智能测试

【霍格沃兹测试开发】腾讯/ 百度/ 阿里/ 字节测试专家技术沙龙分享合集/ 精准化测试/ 流量回放/Diff

【霍格沃兹测试开发】Pytest 用例结构/ 编写规范 / 免费分享

【霍格沃兹测试开发】JMeter 实时性能监控平台/ 数据分析展示系统Grafana/Docker 安装

【霍格沃兹测试开发】接口自动化测试的场景有哪些？为什么要做接口自动化测试？如何一键生成测试报告？

【霍格沃兹测试开发】面试技巧指导/ 测试开发能力评级/1V1 模拟面试实战/ 冲刺年薪百万！

【霍格沃兹测试开发】腾讯软件测试能力评级标准/ 要评级表格的联系我

【霍格沃兹测试开发】Pytest 与Allure2 一键生成测试报告/ 测试用例断言/ 数据驱动/ 参数化

【霍格沃兹测试开发】App 功能测试实战快速入门/adb 常用命令/adb 压力测试

【霍格沃兹测试开发】阿里/ 百度/ 腾讯/ 滴滴/ 字节/ 一线大厂面试真题讲解，卷完拿高薪Offer ！

【霍格沃兹测试开发】App自动化测试零基础快速入门/Appium/自动化用例录制/参数配置

【霍格沃兹测试开发】如何用Postman 做接口测试，从入门到实战/ 接口抓包（最新最全教程）

相关推荐
无心水4 分钟前
24、系统架构师论文写作专题 核心考点与学习笔记
笔记·学习·系统架构·架构师·安全架构·软考架构师·软考系统架构设计师
蒸蒸yyyyzwd18 分钟前
邓明 Agent 系统面试-意图识别学习笔记
笔记·学习
Zhao-Jichao3 小时前
AI Prompting for Everyone 课程笔记 - P21 总结 Conclusion
人工智能·笔记
欢欢李4 小时前
【LTE L3 笔记 05】LTE同步信号
笔记·无线通信·物理层·lte·空口协议
La Pulga5 小时前
【FreeRTOS源码学习笔记】空闲任务与阻塞延时
笔记·mcu·学习·嵌入式·freertos·实时操作系统
蒸蒸yyyyzwd5 小时前
秋招学习笔记 day106
笔记·学习
小李不想当小白7 小时前
WDG看门狗（STM32标准库学习笔记）
笔记·stm32·单片机·嵌入式硬件·学习·嵌入式
欢欢李7 小时前
【LTE L3 笔记 04】LTE帧结构
笔记·无线通信·物理层·lte·空口协议
测试界的小码农7 小时前
【让 AI 生成的测试用例变成 pytest API 自动化脚本】
人工智能·测试用例·pytest
Zhao-Jichao9 小时前
AI Prompting for Everyone 课程笔记 - P20 实验与期末项目 Lab and Final Project
前端·人工智能·笔记
热门推荐
01国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）02历年考研数学一、数学二、数学三真题试卷及答案PDF03几个好用的ip纯净度检测网站04GitHub 镜像站点05昇腾910B系列芯片完全指南：四款型号对比、服务器选型与大模型部署实战06苹果iPA游戏软件资源下载网站07蜘蛛磁力 搜索引擎大全，如何使用蜘蛛磁力查找磁力链接08如何新建文件夹？ 电脑新建文件夹的4种方法09微信历史版本含下载地址（ Windows PC | 安卓 | MAC ）及设置微信不更新10Dify：一站式AI应用开发平台全解析与Windows部署指南