【Python】Python之pytest接口自动化教程+从0到1demo：提升自动化代码能力

pytest是什么？

Pytest 概念

Pytest 是 Python 的一种单元测试框架，与 Python 自带的 unittest 测试框架类似，但 Pytest 使用起来更简洁，效率更高。

Pytest 特点

Pytest 是一个非常成熟的 Python 测试框架，主要特点有以下几点：

• 易上手：入门简单，文档丰富，文档中有很多实例可以参考。
• 支持多种测试：能够支持简单的单元测试和复杂的功能测试。
• 参数化：支持参数化测试。
• 跳过测试：在执行测试过程中可以将某些测试用例跳过（skip），或者对某些预期失败的 case 标记成失败。
• 重试失败：支持重复执行 (rerun) 失败的 case。
• 兼容性：支持运行由 nose、unittest 编写的测试 case。
• 报告生成：可生成 HTML 报告。
• 持续集成：方便与 Jenkins 等持续集成工具结合使用。
• 部分用例执行：可支持执行部分用例。
• 插件支持：具有很多第三方插件，并且可以自定义扩展。

如何安装pytest？

安装

pip install pytest

验证安装

pytest --version # 会展示当前已安装版本

pytest官方文档

官方文档：https://docs.pytest.org/en/latest/contents.html

---

pytest的基本用法

测试用例的规则

1. 创建 test_demo.py 开头的文件
2. 创建 Test 开头的类
3. 创建 test_ 开头的函数或者方法

如下：

import pytest

def test_a():  # 函数
    pass

class Test(object):  # 类
    def test_b(self):  # 方法
        pass

简单的执行用例的命令就是 pytest，从执行结果中我们可以看到它运行了2条用例，并且全部都测试通过了。

因此我们得出一个结论：

1. pytest是以每个函数或者方法作为一个用例的
2. pytest主要以名字区分普通函数/方法和用例
3. pytest的启动方式就是在命令行输入 pytest
4. pytest会自动输出用例情况，执行情况以及汇总情况

测试用例的断言

断言demo

import pytest

def test_a():  # 函数
    assert 1 == 1  # 这里会测试通过

class Test(object):  # 类
    def test_b(self):  # 方法
        assert 1 == 2  # 这里会测试失败

    def test_c(self):  # 方法
        assert 2 == 2  # 这里会测试通过

当我们用 pytest 运行的时候，我们会得到3个结果。1个失败2个通过。并且失败的用例会以报错的形式展现出来 AssertionError，但是它不会中断测试。

如下：

读懂测试用例结果

我们通过观察pytest的测试结果，其实每行结果都是有价值的。但是对我们来讲，我们更关心的是中间这行。

pytest代码/test_1.py .F. 这代表着执行用例的情况，是否百分之百完成，并且是否通过。

这里有两个绿点，中间是一个红色的F，这代表着执行了3条用例，并且第一条和最后一条是通过的，中间一条是失败的。

具体解析的表格如下：

缩写	单词	含义
.	passed	通过
F	failed	失败（用例执行时的错误）
E	error	出错（fixture执行报错）
s	skipped	跳过
X	xpassed	预期外的通过
x	xfailed	预期中的失败

上面的讲解是为了更好的介绍pytest的用法。但是基础用法知识知道让我们知道了怎么用。但无法运用在真实的测试场景，因此我们自己看下面的高阶用法的讲解。

pytest的运行方式

例如在终端输入命令

#终端输入：pytest ./test_one.py --html=./report/report.html

这就代表着运行pytest的test_one.py文件，并且输出测试报告

pytest的配置文件

pytest 支持多种配置文件格式，主要包括 pytest.ini、tox.ini 和 setup.cfg。这些文件可以包含不同的配置选项，如下：

pytest.ini 示例

[pytest]
# 指定测试文件的搜索路径
testpaths = tests

# 添加默认的命令行选项
addopts = -v --tb=short

# 设置命令行日志的级别
log_cli_level = INFO

# 定义自定义标记
markers =
    slow: mark test as slow
    smoke: mark test as smoke
    regression: mark test as regression

# 指定测试文件的匹配模式
python_files = test_*.py *_test.py

# 指定测试类的匹配模式
python_classes = Test*

# 指定测试函数的匹配模式
python_functions = test_*

# 指定缓存目录
cache_dir = .pytest_cache

# 禁用警告输出
disable_warnings = true

# 其他配置项可以根据需要添加

tox.ini 示例

[tox]
# 指定要测试的环境列表
envlist = py37, py38, py39

[testenv]
# 在每个环境中安装的依赖
deps = pytest
# 在每个环境中运行的命令
commands = pytest

setup.cfg 示例

[metadata]
name = your_package_name
version = 0.1.0
description = A sample Python package

[options]
packages = find:

[tool:pytest]
# pytest 的配置
testpaths = tests
addopts = -v --tb=short
markers =
    slow: mark test as slow
    smoke: mark test as smoke

• 将上述配置文件放置在项目根目录下。
• 根据项目的实际需求，我们可以修改相应的配置项。
• 运行 pytest 时，pytest 会自动读取这些配置文件，应用相应的设置。

pytest的高阶用法

1.mark

mark标记，就是为了让用例跟用例之间都不相同。实现用例的筛选（相当于一个人的身份证号，也代表着用例代号)

用户自己的标记

1. 使用标记
   我们在刚才的测试用例上添加@pytest.mark.api1

import pytest


@pytest.mark.api
def test_a():  # 函数
    assert 1 == 1  # 这里会测试通过

class Test(object):  # 类

    @pytest.mark.name
    def test_b(self):  # 方法
        assert 1 == 2  # 这里会测试失败

    @pytest.mark.age
    def test_c(self):  # 方法
        assert 2 == 2  # 这里会测试通过

2. 选择用例
   如果我们直接执行pytest，那么它仍然会全部执行。所以我们想要筛选用例，那么将会用到下面的命令

pytest -m api

那么我们可以看到，他只会执行一条带有api标签的用例，剩下的是不执行的。另外两个用例属于未执行的状态

但记住，一个用例可以有多个标记，如下：

import pytest


@pytest.mark.api
@pytest.mark.name
def test_a():  # 函数
    assert 1 == 1  # 这里会测试通过

class Test(object):  # 类

    @pytest.mark.name
    def test_b(self):  # 方法
        assert 1 == 2  # 这里会测试失败

    @pytest.mark.age
    def test_c(self):  # 方法
        assert 2 == 2  # 这里会测试通过

当我们执行pytest -m name的时候，它就会执行两条用例。

框架内置的标记

pytest 提供了多个基于 @pytest.mark 的标记（markers）来控制测试的执行方式。以下是一些常用的标记：

@pytest.mark.parametrize：

• 用于参数化测试，允许为测试函数提供多个参数集。

@pytest.mark.parametrize("input, expected", [(1, 2), (2, 3), (3, 4)])
def test_addition(input, expected):
    assert input + 1 == expected

@pytest.mark.skip：

• 跳过当前测试，不执行。

@pytest.mark.skip(reason="Skipping this test")
def test_to_be_skipped():
    assert False

@pytest.mark.skipif：

• 根据条件跳过测试，指定条件成立时跳过。

@pytest.mark.skipif(condition=True, reason="Skipping because condition is True")
def test_conditionally_skipped():
    assert False

@pytest.mark.xfail：

• 标记为预期失败的测试，允许失败但不算作测试失败。

@pytest.mark.xfail
def test_expected_failure():
    assert False

@pytest.mark.usefixtures：

• 为测试函数指定使用的 fixture。

@pytest.mark.usefixtures("some_fixture")
def test_using_fixture():
    assert True

@pytest.mark.filterwarnings：

• 用于过滤指定测试中的警告。

@pytest.mark.filterwarnings("ignore:Some warning")
def test_warning_filtering():
    # 触发警告
    pass

@pytest.mark.timeout：

• 设置测试的超时时间。

@pytest.mark.timeout(10)  # 设置超时为10秒
def test_long_running():
    pass

@pytest.mark.django_db（Django专用）：

• 指定测试访问数据库。

@pytest.mark.django_db
def test_with_db_access():
    pass

@pytest.mark.asyncio：

• 用于标记异步测试函数，特别是与 asyncio 协同工作时。

@pytest.mark.asyncio
async def test_async_code():
    pass

@pytest.mark.parametrize与多个参数化：

• 可以同时为多个参数进行参数化。

@pytest.mark.parametrize("param1", [1, 2, 3])
@pytest.mark.parametrize("param2", [4, 5, 6])
def test_multiple_parameters(param1, param2):
    print(param1 + param2)
    assert param1 + param2

我们使用pytest -vs执行后的结果如下:

这些只是常用标记的一部分，pytest 支持更多的标记，并且通过 pytest.ini 文件可以定义自定义的标记。

你也可以通过 pytest --help 来查看完整的帮助文档和标记列表，或者查阅官方文档

2.fixture

@pytest.fixture()

它会自动在用例之前，在用例之后执行，是用于测试环境的一个构建和销毁的作用，非常重要。
也就是说我们每条用例在执行前，都会走一遍fixture， 代码如下：

import pytest


@pytest.fixture()
def fix():
    print("用例执行前")

    yield

    print("用例执行后")


def test_a(fix):  # 函数
    assert 1 == 1  # 这里会测试通过

class Test(object):  # 类

    def test_b(self, fix):  # 方法
        print("1 == 2")
        assert 1 == 2  # 这里会测试失败

    def test_c(self, fix):  # 方法
        assert 2 == 2  # 这里会测试通过

我们在代码中可以看到，我在所有的用例上面添加了一个生成器，并且在这个生成器上面添加了一个@pytest.fixture()

@pytest.fixture()
def fix():
    print("用例执行前")

    yield

    print("用例执行后")

然后再把@pytest.fixture()下面的这个方法fix全都让测试用例去调用。为了更清晰的打印出他前后执行的内容。但是运行结果正确的时候是不打印内容的，所以我们在运行结果错的地方去加一个print进行输出。

def test_a(fix):  # 函数
    assert 1 == 1  # 这里会测试通过

class Test(object):  # 类

    def test_b(self, fix):  # 方法
        print("1 == 2")
        assert 1 == 2  # 这里会测试失败

    def test_c(self, fix):  # 方法
        assert 2 == 2  # 这里会测试通过

在终端输入pytest我们看下面的结果。

我们很清楚的看到，这条失败的用例前面和后面都执行了fix里面的代码。
如果想每个结果都看到，那么我们在终端输入：pytest -vs，那么我们在用例结果处，就可以看到所有的执行过程。如下：

@pytest.mark.usefixtures(‘fix’)

我们除了用这个方法去使用fixtrue去进行调用，还可以用mark进行标记。如下：

import pytest

@pytest.fixture()
def fix():
    print("用例执行前")

    yield

    print("用例执行后")

@pytest.mark.usefixtures('fix')
def test_a():  # 函数
    assert 1 == 1  # 这里会测试通过

class Test(object):  # 类
    @pytest.mark.usefixtures('fix')
    def test_b(self):  # 方法
        print("1 == 2")
        assert 1 == 2  # 这里会测试失败

    @pytest.mark.usefixtures('fix')
    def test_c(self):  # 方法
        assert 2 == 2  # 这里会测试通过

运行结果如下：

用mark标记去执行，我们仍然可以使用fixtrue功能。所以fixtrue并非是一成不变的。

@pytest.fixture(scope=“module”)

fixture的作用范围控制：如果我们在fixture()里面加上scope="module"，那么它将会在所有的用例前后，去执行fixtrue的内容，而不是3条用例执行3次。

import pytest


@pytest.fixture(scope="module")  # 指定为模块，那么它会在所有用例的前面，和后面去执行。而不是一个用例执行一次
def test_a():  # 函数
    assert 1 == 1  # 这里会测试通过

class Test(object):  # 类

    @pytest.mark.api
    def test_b(self):  # 方法
        assert 1 == 2  # 这里会测试失败

    def test_c(self):  # 方法
        assert 2 == 2  # 这里会测试通过

结果如下：

配置全局fixtrue之conftest.py文件

所以在正常的情况下。我们一般都是把fixtrue的功能放在conftest.py文件内，然后外面调用的时候用@pytest.fixture时候去使用。这里要记住一点，那就是conftest.py文件的名称是固定的，也就是内置的。只有设置成这个文件的名称才回去直接执行里面的内容。
示例如下：

1. 创建一个conftest.py文件，然后把fixture的代码添加到该文件内。
   
2. 我们在测试用例里面删除fixture配置，直接用pytest -vs去运行。
   
3. 我们同样可以运行成功，并且fixture也会被执行。结果如下。
   
   看到这，fixtrue就介绍完了，如果还想深入了解可以参考官方文档。

pytest的相关框架封装demo

log日志封装demo

下面的log日志是完整的封装，想要使用直接进行调用即可

"""
log格式封装
"""
import os
import logging
import time
import datetime

BASE_PATH = os.path.dirname(os.path.dirname(__file__))
LOG_PATH = os.path.join(BASE_PATH, 'logs')


def del_log(folder_path):
    """
    # 清除不是当天的文件
    :param folder_path: 文件目录
    :return:
    """
    today = datetime.date.today()
    for file_name in os.listdir(folder_path):
        if file_name.endswith('.log'):
            file_date_str = file_name.split('.')[0]
            try:
                file_date = datetime.datetime.strptime(file_date_str, '%Y%m%d').date()
                if file_date != today:
                    file_path = os.path.join(folder_path, file_name)
                    os.remove(file_path)
            except ValueError:
                pass
    logger.info(f"清理不是 {time.strftime('%Y%m%d')} 时间的.log文件")


class Logger(object):

    def __init__(self):
        self.logName = os.path.join(LOG_PATH, f"{time.strftime('%Y%m%d')}.log")
        # 创建记录器
        self.logger = logging.getLogger("logs")

        self.fileFormat = logging.Formatter("%(asctime)s-%(funcName)s [line:%(lineno)d]-> %(levelname)s: %(message)s")

        # 创建控制台处理程序并设置调试级别
        self.console = logging.StreamHandler()
        self.file = logging.FileHandler(self.logName, mode='a', encoding="UTF-8")

        # debug阈值是10，设置低于10的将忽略过滤掉
        debug = logging.DEBUG
        self.logger.setLevel(debug)
        self.console.setLevel(debug)
        self.file.setLevel(debug)

        # 将格式化程序添加到控制台处理程序
        self.console.setFormatter(self.fileFormat)
        self.file.setFormatter(self.fileFormat)

        # 添加到记录器
        self.logger.addHandler(self.console)
        self.logger.addHandler(self.file)


logger = Logger().logger

if __name__ == '__main__':
    logger.info("test start")
    logger.debug("test stop")

    # del_log(LOG_PATH)

运行结果如下：

想要直接运行到pytest当中，那么直接用logger.info("test start")里面添加要记录的日志。

数据库封装demo

下面是完整的封装数据库demo，但是需要注意自己替换connect里面的host和user等等

"""
测试数据库连接，以及语法封装
"""
import pymysql


class MysqlTest(object):
    """
    测试环境数据库
    """

    def __init__(self):
        pass

    # 数据库连接
    def connect_mysql(self):
        try:
            connect = pymysql.connect(host='自己的',
                                      user='自己的',
                                      password='自己的',
                                      database='bit', port=自己的, charset='utf8')
        except Exception as e:
            print("连接数据库失败：", e)
        return connect

    # 查询数据库封装
    def select(self, sql):
        con = self.connect_mysql()
        s_sql = sql
        # 建立操作游标管理员
        cur = con.cursor()
        try:
            cur.execute(sql)
            print("查询sql语句：", s_sql)
            select_sql = cur.fetchall()
            # print(select_sql)

            cur.close()
            con.close()
            return select_sql
        except Exception as e:
            print("查询sql语句执行失败", e)
            print("查询sql语句执行失败，请检查语句是否正确：", s_sql)
            con.close()
            cur.close()
            print("查询sql语句执行失败：关闭连接数据库、释放游标管理员")

    def update(self, sql):
        con = self.connect_mysql()
        s_sql = sql
        # 建立操作游标管理员
        cur = con.cursor()
        try:
            cur.execute(sql)
            print("更新sql语句：", s_sql)
            con.commit()

            con.close()
            cur.close()
            print("sql执行成功：关闭连接数据库、释放游标管理员")
            return
        except Exception as e:
            print("更新sql语句执行失败", e)
            print("更新sql语句执行失败，请检查语句是否正确：", s_sql)
            con.close()
            cur.close()
            print("更新sql语句执行失败：关闭连接数据库、释放游标管理员")

    # 数据库删除封装
    def delete(self, sql):
        d_sql = sql
        con = self.connect_mysql()
        cur = con.cursor()
        try:
            cur.execute(d_sql)
            con.commit()
            print("删除sql语句执行成功：", d_sql)
            con.close()
            cur.close()
            print("sql执行成功：关闭连接数据库、释放游标管理员")
            return
        except Exception as e:
            print("删除sql语句执行失败：", e)
            print("删除sql语句执行失败：", d_sql)
            # 发生错误时回滚
            con.rollback()
            con.close()
            cur.close()
            print("删除sql语句执行失败：数据库已回滚、已关闭连接数据库、已释放游标管理员")

调用方式如下：

from db.connect_sql_test import *

MysqlTest().select('select * from 表 ORDER BY id DESC LIMIT 1')

上面的调用方式自己替换sql语句，修改就调用修改的方法。

redis封装demo

import redis


class RedisTools():

    def __init__(self, envs_type):
        self.envs = envs_type
        self.redis_dict = {
            '测试环境': '替换环境',  
        }

    def test_redis_all(self):
        conn = redis.Redis(host=self.redis_dict[self.envs], port=6379, password='')  # 测试环境
        return conn

    def set_data(self, key, value):
        redis_tools = self.test_redis_all()
        content = redis_tools.set(key, value)
        return content

    def get_data(self, key):
        redis_tools = self.test_redis_all()
        content = redis_tools.get(key)
        return content

    def set_hash_data(self, name, key, value):
        redis_tools = self.test_redis_all()
        content = redis_tools.hset(name, key, value)
        return content

    def get_hash_data(self, name, key):
        redis_tools = self.test_redis_all()
        content = redis_tools.hget(name, key)
        return content

    def del_data(self, key):
        redis_tools = self.test_redis_all()
        content = redis_tools.delete(key)
        return content

    def hdel_data(self, name, key):
        redis_tools = self.test_redis_all()
        content = redis_tools.hdel(name, key)
        return content

    def hmset_add(self, key_name, value):
        r = self.test_redis_all()
        data = r.hmset(key_name, mapping=value)
        return data

    def hincrby_add(self, key, value1, value2):
        r = self.test_redis_all()
        data = r.hincrby(key, value1, value2)
        return data

    def get_hash_keys(self, name):
        r = self.test_redis_all()
        data = r.hkeys(name)
        return data

    # 添加redis
    def z_add(self, key, value):
        r = self.test_redis_all()
        data = r.zadd(key, mapping=value)  # result.z_add('userShareQueue', {0: 889429895_1000286_101_0})
        return data

    # 设置redis过期时间
    def expire(self, name, time):
        r = self.test_redis_all()
        data = r.expire(name, time)
        return data


if __name__ == "__main__":
    redi = RedisTools("测试环境")

生成测试报告

allure生成测试报告

1. 官方地址：allure官方下载地址

pip install allure-pytest

​​​​​​​验证是否安装成功：allure – version

3. pytest.ini文件中添加下面的命令

addopts = --alluredir=./temps --clean-alluredir

3. 生成测试报告

然后我们直接创建一个run.py，里面添加下列代码：

import os
import pytest

pytest.main()  # 执行pytest测试

os.system('allure generate -o report temps')  # 生成Allure测试报告

运行后即可展示allure的测试报告。

内置测试报告html

直接在终端输入下面的命令：

 pytest test_1.py --html=report.html

然后会生成一个report.html文件，我们选择在浏览器打开，那么他讲展示如报告。

pytest和unittest的区别

unittest

• python内置的，无需要自己安装。
• unittest最开始是pyunit，参考的是junit有一定的java风格，最后改成了unittest。
• unittest没有插件机制，在功能和使用方面是有限的。
• unittest需要使用unittest.TestCase来实现参数化。代码示例如下：

import unittest

class TestMath(unittest.TestCase):
    def test_add(self):
        test_cases = [
            (1, 2, 3),
            (-1, 1, 0),
            (0, 0, 0),
        ]
        for a, b, expected in test_cases:
            with self.subTest(a=a, b=b):
                self.assertEqual(add(a, b), expected)

if __name__ == '__main__':
    unittest.main()

pytest

• 第三方库，手动安装自由选择版本。
• pytest是python团队开发的，是专属于python风格的。
• 有丰富的第三方插件，可以按需扩展。
• pytest支持参数化测试，使用@pytest.mark.parametrize装饰器。示例如下：

import pytest

@pytest.mark.parametrize("a, b, expected", [
    (1, 2, 3),
    (-1, 1, 0),
    (0, 0, 0),
])
def test_add(a, b, expected):
    assert add(a, b) == expected