import pytest@pytest.fixture(scope="class")   　　　　　　　　#类级别的初始化函数  scope="class" 就是把这个初始化定义成类级别的def statr1_func():print("------初始化操作1------")class Test_00:　　　　　　　　　　　　　　　　　　#需要执行 Test_00测试类，需要做初始化(可以setup_class)# def setup_class(self):#     print("类内部的初始化,")  　　　　    #只对类有用,类级别的，类里只做一次(几个类的初始化操作一样这种不适合，需要重复写)#fixture初始化类就是避免重复代码def test_001(self,statr1_func):print("-----test01------")def test_002(self,statr1_func):print("-----test02 ------")if __name__ == '__main__':pytest.main(["test_pytest01.py","-s"])

类级别初始化fixture，虽然test_001和test_002都调用了statr1_func这个类级别的初始化函数，但是执行类测试用例的时候只执行statr1_func初始函数一次
　　
多个类都可以调用statr1_func这个类级别的初始化方法,调用的时候最好放在类里的第一个函数，后面的函数可以不传(因为对应的是类级别的初始化)

   import pytest@pytest.fixture(scope="class")   　　　　　　#类级别的初始化函数def statr1_func():print("------初始化操作1------")#一个模块里面有函数用例也有类的用例怎么做：（class级别的初始化只对类有用，对函数没用）def test_003(statr1_func):                  #测试函数,print("-----test03------")class Test_00:                        #需要执行test00测试类，需要做初始化(可以setup_class)def test_001(self,statr1_func):print("-----test01------")def test_002(self,statr1_func):print("-----test02 ------")if __name__ == '__main__':pytest.main(["test_pytest01.py","-s"])

初始化方法statr1_func定义成class类级别的，函数级别的测试测试用例test__003调用初始化函数会执行一次，
　　class类级别的测试用例Test_00调用初始化函数会执行一次（一共执行两次）
　　看级别的，整个模块的级别的化最好用module，否则有问题，fixture可以做return，会有返回值的，对应级别来做，
执行结果：
　　　　test_pytest01.py
　　　　------初始化操作1------
　　　　-----test03------
　　　　.------初始化操作1------
　　　　-----test01------
　　　　.-----test02 ------

13：类级别初始化实际代码：初始化操作是登录操作

#课程模块的测试类import pytestfrom lib.api_lib.lesson import Lessonfrom lib.api_lib.lesson import Loginfrom tools.execlMethod import get_excelDataimport jsonimport os@pytest.fixture(scope="class")   　　　　　　　　#类级别的初始化函数def start_func():global sessionidsessionid = Login().login('{"username":"auto","password":"sdfsdfsdf"}')class Test_lesson:#1:课程新增接口,前置条件登录(封装完一个方法后想办法做数据驱动)，课程增加需要通过excel表用例来做@pytest.mark.parametrize("inData,repsData", get_excelData('2-课程模块', 2, 26))def test_lesson_add(self,start_func,inData,repsData):reps=Lesson(sessionid).lesson_add(inData)print(reps)assert reps["retcode"]==json.loads(repsData)["retcode"]if __name__ == '__main__':pytest.main(["test_lesson01.py", "-s", "--alluredir", "../report/tmp"])os.system("allure serve ../report/tmp")

14：模块级别的初始化mudule，不管是类还是方法　　　　@pytest.fixture(scope=“module”)
　　　　模块（module）级别的初始化，（整个模块所有的类所有的东西要做一步操作，可以使用module这个模式）

只在模块运行前面只做一次，后面不做了，哪怕多调用也没用，一个模块里面有test_003函数测试用例，

也有classTest_00类级别的测试用例，定义一个模块级别的初始化函数statr1_func

函数里面调用初始化方法def test_003(statr1_func):和类里面的方法调用初始化方法test_001(self,statr1_func):，test_001(self,statr1_func):

整个模块执行的时候初始化函数都只执行一次（不管你这个模块里面调用多少次）

import pytest@pytest.fixture(scope="module")   　　　　　　#模块级别的初始化函数def statr1_func():print("------初始化操作1------")#一个模块里面有函数用例也有类的用例怎么做：（class级别的初始化只对类有用，对函数没用）def test_003(statr1_func):  　　　　　　　　  #测试函数,print("-----test03------")class Test_00:                        　　#需要执行test00测试类，需要做初始化(可以setup_class)# def setup_class(self):#     print("类内部的初始化,")  　　　　#只对类有用,类级别的，类里只做一次(几个类的初始化操作一样这种不适合，需要重复写)#                               　　　　#fixture初始化类就是避免重复代码def test_001(self,statr1_func):print("-----test01------")def test_001(self,statr1_func):print("-----test02 ------")if __name__ == '__main__':pytest.main(["test_pytest01.py","-s"])

执行结果：test_pytest01.py
　　　　　　　　　　------初始化操作1------
　　　　　　　　　　-----test03------
　　　　　　　　　　.-----test01------
　　　　　　　　　　.-----test02 ------

在这个模块下面所有的都会调用（包级别的，包里面运行前做个环境清除）

需要在testcase文件夹里面创建一个conftest.py模块，这个

固定名称，pytest自动识别这个名称

testcase里面：新增课程前面需要登录，增加课程前面需要清除数据，需要2个级别的初始化，1：登录 2：整个环境的清除

test_case（测试用例文件夹）创建一个：conftest.py文件　　里面写包级别的初始化

conftest.py文件里也能写类级别和模块级别的初始化，而且不需要调用，这个conftest.py模块是pytest自动识别导入的

    test_case　　　　　　　　　　　　　　　　#文件夹conftest.py           import pytest#包级别的初始化，在运行整个包之前做个初始化，包里面不同作用域，每个包里面都可以放一个，每个包里面的操作都可以不一样@pytest.fixture(scope="session",autouse=True)   　　　　　　　　#session级别的处于时候autouse=True默认自动执行def start_demo(request):                                     #包的开始print("我是整个包的初始化")def fin():  　　　　　　　　　　　　　　　　　　　　　　　　　　 #尾部这是包级别的，整个包做完后做个环境数据的清除    包的结束print('---测试完成，包的数据清除---')request.addfinalizer(fin)　　　　　　　　　　　　　　　　　　 #回调，当我整个包运行完了后回调fin这个方法#fixture的参数autouse: bool = False,---自动执行参数

#session的级别，包里面有很多模块，很多模块需要对整个包进行初始化在conftest.py里面做模块的数据初始化和清除（conftest.py只对当前包有用）

15：两种调用初始化和清除函数的方式+初始化清除函数的返回值的使用

import pytest
@pytest.fixture()
def befor_func():print('xxxxxxxxxxxxx测试用例的初始化xxxxxxxxxxxxxxxx')yield 10print('zzzzzzzzzzzzzzzzzz测试用例的清除zzzzzzzzzzzzzz')def test_001(befor_func):　　　　　　　　　　　　　　　　#调用初始化和清除方式一：直接在测试用例里传递初始化清除函数的函数名来调用print("测试用例001")res=befor_func　　　　　　　　　　　　　　　　　　　　#如果初始化清除函数有返回值，可以直接这样接收参数来使用print(res)@pytest.mark.usefixtures('befor_func')　　　　　　　　#调用初始化和清除方式二：使用usefixtures放在测试用例前面直接调用初始化清除函数
def test_002():print("测试用例002")if __name__ == '__main__':pytest.main(["test1.py",'-s'])

七：pytest前置条件+后置条件的两种写法

1：使用yield关键字来是实现　　推荐使用这种，因为yield关键字能返回函数的值

import pytest
@pytest.fixture()
def befor_func():print('xxxxxxxxxxxxx测试用例的初始化xxxxxxxxxxxxxxxx')yield 10　　　　　　　　　　　　　　　　　　　　　　　　　　　　#yield后面跟的是测试用例的后置条件，支持用例执行后就执行yield里的内容print('zzzzzzzzzzzzzzzzzz测试用例的清除zzzzzzzzzzzzzz')def test_001(befor_func):print("测试用例001")res=befor_funcprint(res)if __name__ == '__main__':pytest.main(["test1.py",'-s'])

2：使用finc()函数来实现　　　　这种就不能返回返回值了

 
import pytest
@pytest.fixture()
def befor_func(request):print('xxxxxxxxxxxxx测试用例的初始化xxxxxxxxxxxxxxxx')def fin():　　　　　　　　　　　　　　　　　　　　　　　　#尾部这是后置条件，测试用例执行后就会调用这个函数　　　　　　print('zzzzzzzzzzzz测试用例的清除zzzzzzzzzzz')request.addfinalizer(fin)　　　　　　　　　　　　　　　#回调，当我整个包运行完了后回调fin这个方法　　　　　　　　　　
def test_001(befor_func):print("测试用例001")if __name__ == '__main__':pytest.main(["test1.py",'-s'])

16：pytest数据驱动（参数化）　
　　pytest数据驱动的意义：

参数化（登录用例4条，每一个账号密码都不同，使用框架把4个用例全部执行完，不需要for循环遍历执行，采用数据驱动方案来做）

pytest内置装饰器@pytest.mark.parametrize可以让测试数据参数化，把测试数据单独管理，类似ddt数据驱动的作用，方便代码和测试数据分离

@pytest.mark.parametrize(“a”,[1,2,3])：　　　　　　　　参数化传一组参数

@pytest.mark.parametrize(“a,b”, [(1,2),(3,4),(5,6)]) 　　 参数化传多组参数

登录账户密码（name和psw不同的用例组合，一个接口几十个用例怎么做----几十组数据----传的参数不同（什么请求方式和各种都一样）

可以把name和psw分别采取多组数据进行参数化，数据分离，一个接口跑4次，每次用不同的参数）

    import pytest#[(1,2),(3,4),(5,6)]   [1,2,3]class Test_login():  def setup_class(self):print("执行测试类之前，我需要执行操作")@pytest.mark.parametrize("a",[1,2,3])            #("变量名",[1,2,3]),数据需要封装成一个列表，多个数据需要封装成列表嵌套元组   ----数据驱动def test_login01(self,a):                  #数据驱动，一定要把变量名a引入引来，不然无法参数化

print("---test_login01----")assert 1 + 1 == a@pytest.mark.parametrize("a,b", [(1,2),(3,4),(5,6)])    #数据驱动传多组参数def test_login02(self,a,b):print("---test_login02----")assert a + 1 == bdef teardown_class(self):print("------该测试类的环境清除-----")if __name__ == '__main__':pytest.main(["test_func01.py","-s"])  

17：pytest结合allure报告操作　　
　　一：pytest自带的报告框架 pytest-html

二：allure环境搭建（allure是报告库不是python专属的，很全面的框架）-allure报告漂亮

1：下载allure.zip（压缩包）
　　　　2：解压allure.zip到一个文件目录
　　　　3：将allure-2.13.3\bin路径添加到环境变量path
　　　　4：pip install allure-pytest -------allure报告本身不是很漂亮，通过allure-pytest这个库可以定制化报告，让报告变得很漂亮
　　　　5：验证（cmd输入allure）

三：allure和pytest联合执行生成报告：运行两条语句

1：执行pytest单元测试，生成的allure报告需要的数据存在/tmp目录

pytest -sq --alluredir=…/report/tmp　　　#pytest把allure报告的生成的中间文件放到一个临时文件里面（pytets生成报告，需要数据，所以先把数据存起来）

#所有的报告需要数据支持的，数据来源pytest框架本身，结果数据存到一个文件，存在…/report/tmp文件夹

#tmp临时文件，一般json格式

2：执行命令，生成测试报告

allure generate …/report/tmp -o …/report/report -clean 　　　　　　#allure指令生成对应报告

18：allure模拟代码

  import pytestimport osclass Test_login():  def setup_class(self):print("执行测试类之前，我需要执行操作")@pytest.mark.parametrize("a",[1,2,3])def test_login01(self,a):  print("---test_login01----")assert 1 + 1 == a@pytest.mark.parametrize("a,b", [(1,2),(3,4),(5,6)])def test_login02(self,a,b):print("---test_login02----")assert a + 1 == bdef teardown_class(self):print("------该测试类的环境清除-----")if __name__ == '__main__':#需要打印对应的信息，需要在列表里面加-s#1:--alluredir ---生成临时文件，测试用例的结果数据放到目录   --alluredir   存放目录pytest.main(["test_func01.py","-s","--alluredir","../report/tmp"])  #框架自己调用函数#通过--alluredir把allure需要的数据存到../report/tmp这个路径下面#../--所在路径的父级别目录是test_case的目录隔壁邻居report文件下tmp，专门放alluer报告生成的需要的数据源# 2:临时数据没有报告的，allure generate allure才会生成报告   -----allure生成器生成allure报告--generate allure生成器,cmd指令#需要os模块os.system()调用指令可以在local的cmd里面敲os.system("allure generate ../report/tmp -o ../report/report --clean")#os.system("allure generate 报告需要的数据 -o 报告存放目录 --clean")#-o生成#allure generate生成报告指令，把../report/tmp 的文件-o生成报告out out一下，生成的报告放在../report/report#--clean把上次报告清除一下用--clean#allure报告生成的是一个服务，（本地服务）和jinkins结合，放在整个里面去集成，放到公共服务器里面          

19：allure报告的优化

  import pytestimport osimport allure       @allure.feature("登录模块")                                                      #一级标题，大模块标题（类标签）class Test_login():                                                              def setup_class(self):                                                                  print("执行测试类之前，我需要执行操作")@allure.story("登录login01")                                                  # 二级标签（每个接口的标签）@allure.title("login01")                                                     # 标题，每个用例带个标题（报告体现在每个测试用例）(一个接口有几个用例，title用例的标签)@pytest.mark.parametrize("a",[1,2,3])                                      def test_login01(self,a):                                                      print("---test_login01----")assert 1 + 1 == a@allure.story("登录login02")                                                  # 二级标签，定制allure报告层级@allure.title("login02")                                                     #标题，每个用例带个标题（报告体现在每个测试用例）@pytest.mark.parametrize("a,b", [(1,2),(3,4),(5,6)])                      def test_login02(self,a,b):print("---test_login02----")assert a + 1 == bdef teardown_class(self):                                               print("------该测试类的环境清除-----")@allure.feature("购物模块")class Test_Shopping():@allure.story("shopping")@allure.title("shopping01")@pytest.mark.parametrize("a,b", [(1, 2), (3, 4), (5, 6)])def test_shopping(self, a, b):print("---test_login02----")assert a + 1 == bif __name__ == '__main__':pytest.main(["test_func01.py","-s","--alluredir","../report/tmp"])    os.system("allure generate ../report/tmp -o ../report/report --clean")#allure报告生成的是一个服务，（本地服务）和jinkins结合，放在整个里面去集成，放到公共服务器里面     

20：其他知识点
　　　　测试用例一般写在excel表格文件里面，数据分离（维护好excel就行）

pytest–从头到尾到报告执行发邮件

字典是一种存储类型，json是一种格式（完全不同）

21：pytest参数解析

　pytest.main(['test_boss.py','-s','-k test_modify_psw','--alluredir=tmp/my_allure_results'])test_boss.py 　　　　　　　　指定测试用例文件，-s 　　　　　　　　　　　　 显示print语句-k test_modify_psw 　　　　 指定某个测试用例-n 　　　　　　　　　　　　表示用两个进程启动测试脚本生成报告缓存文件　　--alluredir=tmp/my_allure_resultsos.system('allure serve tmp/my_allure_results')　　　　打开测试报告，命令行需要python 的os模块调用

22：pytest的初始化和清除：

import pytest#假设启动被测app的时候需要去填写配置项信息，每个的端口号不同，多终端需要两个appim server#这时候setup_module和teardown_module不能传参，搞不定，需要换一种方法做测试用例的初始化和清除，#setup_module以模块为作用域，不写module以测试用例（测试函数）为作用域# def setup_module(): 　　 #测试用例之前执行，原始的setup和teardown有个缺陷，里面不能传参数，#             　　　　　　   #默认test级别，每个测试用例执行的时候都会执行一次，希望当前某个模块执行的时候只执行一次（不管里面用例执行多少次）#             　　　　　　   #setup初始化和tear_down升个级，升级成module模块级别的#     print("启动被测app")#     print('连接appium服务')## def teardown_module():#     print('关闭被测app')#     print('断开appium服务')#定义个函数，名字随便取　　使用@pytest.fixture装饰器把这个函数装饰成初始化清除函数@pytest.fixture(scope='module')    #作用域默认test，初始化，加装饰器，初始化清除函数,autouse=True（自动执行）这种方法不建议使用                               #def before_test():                   #初始化函数升级作用域到module模块级别print("启动被测app")print('连接appium服务')yield   #后面写清除动作，after_test()#清除函数，清除函数并不会直接被初始化函数使用，我们必须放在初始化函数yiled后面才能回被调用def after_test():print('关闭被测app')print('断开appium服务')#目前一共有两个port，需要测试两个手机，两个多终端,before_test需要装饰器标记#测试用例的参数化@pytest.mark.usefixtures('before_test')                        #这表示调用某个自定义的初始化函数，括号里面的字符串写被调用函数的名字@pytest.mark.parametrize('psw',['boss123','boss456'])def test_app(psw):                        #测试用例，可能涉及到其他参数,比如需要一些配置信息,测试用例涉及到参数，#多组参数需要使用装饰器pytest.mark.parametrize(数据驱动)，psw传参和形参名字对应的print('测试boss app')print(f'登录测试账号{psw}')if __name__ == '__main__':pytest.main(['pytest_ywt.py','-s'])

23：pytest之：不只是测试函数test_app能参数化，初始化函数before_test也能参数化
　　重点：测试用例的参数化+初始化清除函数的参数化　　初始化清除函数的参数化能够实现appium的多终端测试

初始化清除函数的参数化，方法很多种：

before_test初始化函数注入参数，因为print(f’连接appium服务{port}')里面port需要变化的，

@pytest.fixture(scope=‘module’,params=[(4723,),(4727,)])　　：初始化清除函数的参数化

始化函数装饰器里面加params参数传参，port=request.param[0] 来调用params里的参数

#初始化清除函数的参数化：只传单个参数
import pytest
@pytest.fixture(scope=‘module’,params=[(4723,),(4727,)]) #初始化清除函数的参数化params
def before_test(request):
port=request.param[0] 　　　　　　　　　　　　　　#param[0]，假如注入多个参数一个port和一个data–需要params传元组，
#params=[(4723,100),(4727,200)],一个参数的话不需要写成列表嵌套元素，
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　#params[0]代表获取元组第一个
print(“启动被测app”)
print(f’连接appium服务{port}')
yield #后面写清除动作，
after_test()
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　#request是pytest的对象，我们在用对象里面的方法的时候pycham不会自动帮我们取显示名字，
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　#它也不知道request里面到底什么内容

 def after_test():print('关闭被测app')print('断开appium服务')@pytest.mark.usefixtures('before_test')    @pytest.mark.parametrize('psw',['boss123','boss456'])def test_app(psw):                                   print('测试boss app')print(f'登录测试账号{psw}')if __name__ == '__main__':pytest.main(['pytest_ywt.py','-s'])    　　#初始化清除函数的参数化：传多个参数　　　　　　　　　　　　　　import pytest

　　　　　　　@pytest.fixture(scope='module',params=[(4723,'xiaomi'),(4727,'meizu')])  def before_testquest):           port=request.param[0]    　　　　　　#param[0]，假如注入多个参数一个port和一个data，需要params传元组，params=[(4723,100),(4727,200)],#一个参数的话不需要写成列表嵌套元素，request.params[0]代表获取元组第一个device=request.param[1]      　　　　#request.param[1]对应元素里面第二个参数，print(f"在{device}启动被测app")print(f'连接appium服务{port}')yield   #后面写清除动作，after_test()#request是pytest的对象，(固定写法：request.param)#我们在用对象里面的方法的时候pycham不会自动帮我们去显示名字，它也不知道request里面到底什么内容```cppdef after_test():print('关闭被测app')print('断开appium服务')@pytest.mark.usefixtures('before_test')                    @pytest.mark.parametrize('psw',['boss123','boss456'])def test_app(psw):           print('测试boss app')print(f'登录测试账号{psw}')if __name__ == '__main__':pytest.main(['pytest_ywt.py','-s'])

24：pytest框架执行代码也能在cmd里面直接输入命令执行
　　　　xxx\test_case> pytest -s 　　在test_case这个目录执行会运行test_case文件里面所有的测试文件（test开头的测试用例）

25：分布式
　　设置用例每个模块独立，有什么前置做到模块里面，比如测试10个模块，用相关联来做，不能做分布式(并发执行)

每个模块独立还能定制执行那个模块，关联性太强做不到

最好做到每个接口都独立化（前置条件做好）不要做太大关联性的接口

每一层都能做环境清除和定制化（包，模块。类，函数）分层，为后面mark（定点执行哪些用例）和分布式打基础

分布式：必须做到用例的隔离（低耦合，高内聚），用例走串行风险很大，很难维护

3000个请求，全部独立化，然后分布式来做（效率提高几倍–几十倍）

26：分布式的实现
　　分布式的核心点：封装设计：相互独立，登录和课程相互独立，至少模块为单元要相互独立，封装相互独立，接口用例之间最好也相互独立　　才能进行分布式

一：pytest分布式环境搭建和理论介绍：

第一步：安装一个库 pip install pytest-xdist 　　分布式运行插件,可以做分布式（这个库有两种运行方式）

运行方式：

1：串行，顺序运行，串行运行，从头到尾

2：并行:pytest-xdist做分布式有两种，一种多核，一种多台机器

一：多核：单机多核来做（同时跑） 使用-n参数

电脑多核有假有真：超线程技术（8内核搞成16核），真8核假8核—

cpu个数：硬件，几个cpu槽，i9900.i710–一般电脑就算一个cpu，单cpu，服务器可能有多个cpu

核数： 电脑的核数，

逻辑核数：逻辑核数可以虚拟化，8核可以变成16核（超线程技术）

多核的话xdist本身的多核的话一般用逻辑核数来做的

二：多机（可以使用虚拟机）—需要搭环境，多台机器 很麻烦，装环境，下库

二：测试用例比较多怎么办：分布式 两种情况

1：量大：多机 （需要文件报告收集还需要搭环境，做起来比较麻烦）

2：单机多核　　很简单，加-n 参数就行 （做ui和需要一些时间等待的时候时间优化特别明显）

串行运行：本身是线程去跑的，python就一个进程，里面很多线程，

走进程的话需要多台机器来做，分量， 用例设计不好会有大问题，数据不对(用例一定要独立化)

并行和多机：用例一定要设计好，不然数据容易出错，逻辑独立（不能有任何关联，不能有前后关系）　　数据和代码封装时候独立化

三：分布式运行代码

#验证单机多核分布式

 import pytestimport timedef test_01():time.sleep(3)print("-----test01-----")def test_02():time.sleep(3)print("-----test01-----")if __name__ == '__main__':# pytest.main(["test_xdist.py","-sq"])  　　　　　　　　#这是串行跑的   6spytest.main(["test_xdist.py", "-sq","-n","8"]) 　　　　#单机多核并行   加"-n","8" 参数  ，用8个核来跑,5.41s,时间少了#或者测试用例文件目录下 cmd，输入 pytest test_xdist.py -n 8  也可以    这样cmd里执行看到的结果更直观，#多核来跑在ui里面时间提升很大，ui里面很多地方需要sleep，等待元素（有等待的的提升比较大）多核跑更快#有等待的情况用多核跑效果越明显

串行运行本身按照线程去跑的，python本身就一个进程，里面很多线程
走进程的话，多台机器做比较合适—分量，
用例一定要设计好，不然数据容易出错，逻辑独立（不能有任何关联，不能有前后关系）----数据和代码封装时候独立化

pytest cmd执行多个模块用例：pytest test_xdist.py test_login.py -sq 　　：运行两个.py文件（写多个运行多个）
pytest cmd执行多个包的用例：pytest test_xdist test_login -sq 　　：运行test_xdist包和test_login 包
还可以运行不同模块的两个包,加包路径 case/test_xdist.py case2/test2_xdist.py

27：pytest的用例定制化执行　　mark标签，

所有的接口不需要全部都跑（冒烟，定制化执行某些指定的业务，）　　　　　“-m”,“test_lesson_add”

一：pytest框架mark标签　　标记非常丰富　　mark标签

mark标签：对于pytest，我们可以再每一个模块，每一个类，每一个方法和用例前面都加上mark，

那样我们在pytest运行的时候就可以只运行带有该mark标签的模块，类，用例

这样的话可以方便我们选择执行自动化时，是执行全部用例，某个模块用例，

某个流程用例，某个单独用例，总之就是可以某个单独的标签下所有用例

mark可以标记不同层次的东西（类，函数，方法都可以标记）文件不用标记（本身就可以定制化执行）

@pytest.mark.lessson_moudle 　　给测试类贴个标签，标签名字叫lessson_moudle标识课程模块，

各个函数，类都可以贴上标签（类似别称），选择某个标签就运行某一个（灵活方便）

什么都不选中照常运行，（全部运行，没有限制）

mark标签pytest运行可能报错，

PytestUnknownMarkWarning报错:是一个标签的mark警告，整个pytest这么写不识别你，但是不会报错，只是警告，

消除警告（增加标签栏，相当于标签的声明）

标签声明写法：teach_sq文件夹里创建一个pytest.ini的文件（pycham需要安装ini插件 file-setting-plugins(搜索ini)社区版似乎不行）

pycham找不到可以离线装

teach_sq
pytest.ini-----文件内容如下，相当于pytest的mark标签声明一下

#文件内容，markers后面把标签全部写上，　　　　lessson_moudle 一个类级别的mark标签名，
　　　　　　　　　　　　#test_lesson_add，test_lesson_list，test_lesson_delete 三个函数级别的mark标签名称
　　　　　　　　　　　　#　　mark标签名称: 描述 这样的格式来写，前面声明标签名称，后面是描述（随便写）

[pytest]　　　　　　　　　　　　　　　　　　　　
markers=
lessson_moudle: teach_lesson　　　　　　　　(标签名: 描述 这样的格式 　　前面lesson_modle和test_lesson_add等是mark的标签名称,
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　声明一个标签　　　　:冒号后面一定要加空格，规范)

后面的描述不建议写中文，会报错（需要转码，但是这个文件python自己调用的）
test_lesson_add: teach_lesson
test_lesson_list: teach_lesson
test_lesson_delete: teach_lesson
　　定制化执行test_lesson_add一个接口： “-m”,“test_lesson_add”

pytest.main([“test_lesson01.py”,“-s”,“-m”,“test_lesson_add”]) ---- -m就可以实现，mark定制化执行

定制化执行多个接口–逻辑或就行：“-m”,“test_lesson_add or test_lesson_delete”

pytest.main([“test_lesson01.py”,“-s”,“-m”,“test_lesson_add or test_lesson_delete”])

排除法排除一个-定制化除了某个接口不运行其他都运行—“-m”,“not test_lesson_add”

pytest.main([“test_lesson01.py”,“-s”,“-m”,“not test_lesson_add”])----除了test_lesson_add这个接口其他都运行

排除法排除多个-“-m”,“not (test_lesson_add or test_lesson_delete)”

pytest.main([“test_lesson01.py”,“-s”,“-m”,“not (test_lesson_add or test_lesson_delete)”])

筛选测试用例代码：

import pytest@pytest.mark.zzzzz
def test_001():print('test_001')def test_002():print('test_001')if __name__ == '__main__':pytest.main(["test1.py",'-s','-m','zzzzz'])

二：定制化执行：（组装流程）

1：mark标签：组装流程方便

-k：匹配筛选用例名称（可标准（全名）可模糊匹配）—指的是模块，-k和-m类似，有or和not，

但是-k只运行所有的用例，然后有排除模式，选定模式，还要其他模式（-k在cmd里面写的）

pytest -k test_lesson01.py ：执行test_lesson01.py模块的测试用例（sq可以不写，只是不加打印,sq错误执行的时候会有很多信息可以打印，）

全部选中,测试包里面的模块全部被选中：pytest -k test，（差不多功能的模块写同样单词命名，这样-k可以一起匹配上）

lesson_1.py 和lesson_2.py：想运行两个文件　　pytest -k lesson (默认模糊匹配lesson)

-m: 选择对应的标签(标签，mark需要打标签才能定制化执行，其他两个k和v不用打标签)

  　　　　 -v:节点，你要运行里面的某一个某一个里面的东西：(节点指定某一个)

示例：pytest_lesson.py::Test_lesson::test_01

pytest -v pytest_lesson.py::Test_lesson::test_01

-sq:（简化print打印信息） -s:输出print打印 -q简化输出

sq，错误时候显示错误信息，或者fail很多失败信息，很多打印的时候写sq打印（成功不用写）

三：跳过/条件跳过：通过上下条件判断这个东西要不要跑，（两种）　　　　skip

1：跳过（没有条件的跳过，指定跳过，不需要满足什么条件）　　　　skip

@pytest.mark.skip(“跳过test_lesson_add”)　　　　　　　　无条件跳过

接口函数前面写@pytest.mark.skip(“跳过test_lesson_add”)，

这个接口就会被无条件跳过，不执行（报告里面会描述出来）

2：有条件的跳过　　　　　　　　　　　　　　　　　　　　　　　　skipif

@pytest.mark.skipif(1==1,reason=“条件需要前面完成某一个步骤–前面条件为真的时候则跳过函数，不为真执行函数”)　　　　有条件的跳过

流程化需要跳过接口，1，2，3，

1为真运行的时候才执行2，1不执行2也不执行，直接跳过）

条件从哪里来，预期和实际的做个判断（找个前置条件做个判断是不是为真）

如果登录失败那么课程接口就不要取跑了（可以这么写）登录失败没有sessionid

使用场景：前面一个动作失败了后面的不要跑了，

前置条件,或者检测到服务器python环境不是要求的，不要跑，

对版本有要求（系统环境，解释器版本都可以作为代码要不要执行的前置条件）

标签只能到接口（方法层），不能指定到用例，用例是通过数据驱动来做的

四：定制执行还有一种写法：　　指名道姓----(下面的指令可以在cmd控制台命令里面直接执行)

只执行Test1的测试用例，执行命令：pytest -sq test_xt.py::Test1 py文件到类，类级别的（::级别关系）

只想执行Test2中test_3，执行命令：pytest -sq test_xt.py::Test2::test_3 py文件，类，接口方法

同时执行多个条件：执行命令：pytest -sq test_xt.py::Test1::test01 test_xt.py::Test2::test02

也可以根据用例名称进行筛选-k，执行命令：pytest -sq -k 2 test_xt.py

文章到这里就结束了，各位铁汁如果有什么觉得不对的可以发在评论区咱们来讨论哈，

最后： 为了回馈铁杆粉丝们，我给大家整理了完整的软件测试视频学习教程，朋友们如果需要可以自行免费领取 【保证100%免费】

📌 博客主页： 程序员念姐
📌 专注于软件测试领域相关技术实践和思考，持续分享自动化软件测试开发干货知识！
📌 如果你也想学习软件测试，文末卡片有我的交流群632880530，加入我们，一起交流和学习！