当前位置： 首页 > article >正文

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

article 2024/11/14 6:25:48

本文转自测试人社区，原文链接：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 被测源码

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自动化测试设计

  • utils.py
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
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
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
  • conftest.py
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
[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
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 做接口测试，从入门到实战/ 接口抓包（最新最全教程）


http://www.kler.cn/a/293216.html

相关文章：

  • 【再谈设计模式】抽象工厂模式~对象创建的统筹者
  • 同三维T610UDP-4K60 4K60 DP或HDMI或手机信号采集卡
  • 金价大跌，特朗普胜选或成导火索
  • Ai创作新风标！仅需三步,利用ai工具免费制作抖音爆款的动物融合视频(含完整的步骤)
  • 使用ookii-dialogs-wpf在WPF选择文件夹时能输入路径
  • ubuntu20.04安装anaconda与基本使用
  • 什么是回流与重绘，如何尽力避免
  • ARM基础知识---CPU---处理器
  • Electron32-Vue3OS桌面管理os模板|vite5+electron32+arco后台os系统
  • openconnect-gui for qt 避坑指南
  • HTML的块级元素与行内元素
  • VM Workstation虚拟机AlmaLinux 9.4操作系统安装（桌面版安装详细教程）（宝塔面板的安装），填补CentOS终止支持维护的空白
  • 94. UE5 GAS RPG 实现攻击击退效果
  • 系统功能性能优化：从问题定位到解决方案的系统性分析
  • iOS——runLoop
  • 鸿蒙（API 12 Beta6版）图形加速【OpenGL ES平台内插模式】超帧功能开发
  • 【前端面试】事件监听机制React 的事件系统实现
  • HTTPS链接完整过程
  • 浅谈C#之232通讯
  • 【论文速读】| 基于大语言模型智能体对文本到图像模型进行越狱
  • X 射线测厚仪-高效精准，厚度测量的卓越之选
  • 基于free5gc模拟5G核心网和UERANSIM模拟5G用户设备的模拟5G网络环境的部署搭建方法总结和解析。
  • linux基础IO——用户缓冲区——概念深度探索、IO模拟实现
  • Faker在pytest中的应用
  • [数据集][目标检测]翻越栏杆行为检测数据集VOC+YOLO格式512张1类别
  • 鹏哥C语言自定义笔记重点(44-)