Pytest 1、安装，调试。基础前后置方法
Pytest 1、安装，调试。基础前后置方法
1、Pytest 和 UniTest
看完区别，我直接选择 Pytest,因为兼容Unitest
具体区别（转载）：https://www.cnblogs.com/liudinglong/p/12846986.html
2、安装Pytest
pip install -U pytest
3、启动测试
- 新建 test_pytest.py 文件
- 文件内容写入
# -*- coding: utf-8 -*-
import pytest
def test_aba():
b = 2
print('\n不在类中的普通函数，只运行一次')
assert b < 3
if __name__ == '__main__':
pytest.main(['-sv']) #显示逐步运行
4、基础规则
1. py文件需要以test_开头
2. 方法以test_开头，为单元测试用例，pytest.main会执行
3. 类以Test_开头，为单元测试类，类里面test_开头的方法会被执行
class Test_api():
def test_aa(self):
a = 1
print('\n我是 Test_api 类里的方法用例：test_aa')
assert a > 0
4. setup_module()，模块级别（最高）,放在文件内，会在启动.py时最先执行（放类里面，不会被检测到）全局的，整个模块开只运行一次，优先于测试用例。
def setup_class(self):
assert 1 < 3
print('\n Test_api 此类用例 前 只执行一次')
5. teardown_module()，模块级别（最高）,放在文件内，会在结束.py时最后执行（放类里面，不会被检测到）全局的，整个模块开只运行一次。
6. setup_class（），类级别：定义在类里面，只针对此类生效,类运行时第一时间运行，只运行一次，优先于测试用例。
7. teardown_class（），类级别：定义在类里面，只针对此类生效,类运行结束时运行，只运行一次。
8. setup_function()，函数级别：只对函数生效，类里面的函数不生效。每个test_开头的函数运行前都会先运行一次（放类里面，不会被检测到）
9. teardown_function()，函数级别：只对函数生效，类里面的函数不生效。每个test_开头的函数运行结束都会运行一次
10. setup_method（）,方法级别：定义在类里面，只有类运行后才生效，类里每个test_开头的方法用例执行前都会执行一次
11. teardown_method（）,方法级别：定义在类里面，只有类运行后才生效，类里每个test_开头的方法用例执行后都会执行一次
12. 执行顺序优先级： 模块级别 > 函数级别 > 类级别 > 类方法级别
5、 pytest中参数化的用法
在测试用例的前面加上：
@pytest.mark.parametrize("参数名",列表数据)
参数名：用来接收每一项数据，并作为测试用例的参数。
列表数据：一组测试数据。
@pytest.mark.parametrize("参数1,参数2",[(数据1，数据2),(数据1，数据2)])
示例:
@pytest.mark.parametrize("a,b,c",[(1,3,4),(10,35,45),(22.22,22.22,44.44)])
# 类以Test 开头
@pytest.mark.parametrize('data',[1,2,3])
class Test_ddt(object):
def test_001(self,data):
print(data)
运行结果
完整文件：
# -*- coding: utf-8 -*-
#test_pytest.py
import sys
import numpy as np
import time
import datetime
import pytest
# https://www.cnblogs.com/liudinglong/p/12846986.html
# 1.模块级：全局的，整个模块开只运行一次，优先于测试用例。
# 2.类级别：定义在类里面，只针对此类生效。类似unittest的cls装饰器
# 3.函数级：只对函数生效，类下面的函数不生效。
# 4.方法级：定义在类里面，每个用例都执行一次
# scope不填，默认函数级别
@pytest.fixture()
def login():
print("\n请输入账户，密码")
# 后置
yield
print("\n退出登录")
# 普通test_ 和 类同级，看先后顺序 从上到下 执行
def test_001():
b = 2
print('\n这是普通函数用例001 >>>>> 不在类中的普通test_开头函数，只运行一次')
assert b < 3
# 类以Test 开头
# 对于类中：setup_class > setup_method > setup(暂时没生效)
class Test_api():
def setup(self):
print("\n这是方法setup >>>>> 每条用例执行前执行----------------未执行")
def teardown(self):
print("\n这是方法teardown >>>>> 每条用例执行后执行----------------未执行")
def setup_class(self):
#assert 5 < 3
print("\n 这是类级 Test_api 方法 setup_class >>>>> 类里面的用例执行前执行，仅一次")
def teardown_class(self):
assert 1 < 3
print("\n这是类级 Test_api 方法 teardown_class >>>>> 类里面的用例全部结束时执行，仅一次")
def setup_method(self):
assert 2 < 3
print("\n这是方法级 Test_api 方法 setup_method >>>>> 类里面每个用例执行前 都会先执行")
def teardown_method(self):
assert 1 < 3
print("\n这是方法级 Test_api 方法 teardown_method >>>>> 类里面每个用例执行结束后 都会先执行")
def test_cls_001(self):
a = 1
print('\n我是 Test_api 类里的方法用例：test_cls_001') # pytest -s 显示打印内容
assert a > 0
def test_cls_002(self):
b = 2
print('\n我是类里的方法用例：test_cls_002') # pytest -s 显示打印内容
assert b < 3
def aba(self):
b = 5
print('\n Test_api 类里，不带test的普通函数，未调用则不运行，不允许则不影响用例结果')
assert b < 3
def setup_function(self):
print('\n 这是函数级 setup_function Test_api 在类里面，不会执行')
assert 2 < 3
def setup_module(self):
print('\n 这是模块级 setup_module ,Test_api 类里面 不会运行。。。')
#2.pytest中参数化的用法
#在测试用例的前面加上：
# @pytest.mark.parametrize("参数名",列表数据)
# 参数名：用来接收每一项数据，并作为测试用例的参数。
# 列表数据：一组测试数据。
# @pytest.mark.parametrize("参数1,参数2",[(数据1，数据2),(数据1，数据2)])
# 示例:
# @pytest.mark.parametrize("a,b,c",[(1,3,4),(10,35,45),(22.22,22.22,44.44)])
# 类以Test 开头，会运行
@pytest.mark.parametrize('data',[1,2,3])
class Test_ddt(object):
def test_001(self,data):
print('\n这是第二个类 Test_ddt 的方法 test_001 >>>>> 当前运行参数 ' + str(data))
# setup_module&teardown_module 全局，不论位置放哪里，都最高优先级先执行
# 模块级是最大的，全局的，针对.py模块的，你可以认为(setup_module/teardown_module)是global，针对整个py文件，你可以将测试数据初始化和清理数据放到这里。
def setup_module():
print('\n这是模块级 setup_module >>>>> 整个py文件运行 前 只运行一次')
#assert 5 < 3
def teardown_module():
print('\n这是模块级 teardown_module >>>>> 整个py文件运行 后 只运行一次')
assert 1 < 3
# setup_function & teardown_function 不在类中使用
def setup_function():
print("\n这是函数级 setup_function >>>>> 不在类中的每条test_开头用例执行前执行")
assert 2 < 3
def teardown_function():
print("\n这是函数级 teardown_function >>>>> 不在类中的每条test_开头用例执行后执行")
assert 1 < 3
# test开头的表示一个用例，会触发 setup_function 和 teardown_function
def test_002():
b = 2
print('\n这是普通函数用例002 >>>>> 不在类中的普通test_开头函数，只运行一次')
assert b < 3
def aba():
b = 2
print('\n不带test的普通函数，未调用则不运行')
assert b < 3
if __name__ == '__main__':
#pytest.main() #直接运行，不显示过程
#print("over")
#pytest.main(['-sv']) #显示逐步运行 和 单个test_ 执行结果
pytest.main(['-s']) #显示逐步运行
执行结果：
大概层级关系：
大佬整理好的笔记：https://www.cnblogs.com/liudinglong/category/1764435.html
浙公网安备 33010602011771号