pytest模块的使用
pytest是第三方测试框架,是基于unittest的扩展框架,比unittest更简洁,更高效。安装pytest模块使用pip install pytest即可。安装好之后,到cmd中输入pytest --version检查是否安装成功。
pytest运行方法
想要用pytest运行,首先要import pytest 比如创建一个demo.py文件,内容为:
```python
import pytest # 导入包
def test_sucess(): # 定义第一个测试用例,assert 0表示断言失败
print("test sucess")
assert 0
def test_fail(): # 定义第二个测试用例,没有assert,默认成功
print("test fail")
if __name__ == "__main__":
#定义一个列表,列表内容为测试文件名,也可以定义为元组,表示需要运行的文件为demo.py
test_list = ['demo.py']
#用pytest模块的main()方法,参数为上面定义好的列表或者元组。
pytest.main(test_list)
#pytest.main(['-s','demo.py']) # 也可以这样写,这样写和上面那样写会运行结果会有所不同,可以自己试试看。
运行出来的结果是: demo.py F. **F:**表示测试失败 **.**表示测试成功
也可以在cmd下面运行,先进入需要测试的文件夹路径下,输入命令: pytest -s demo.py
这里要提醒一点,pytest必须遵循以下规则: 1、测试文件名以“test_”开头或者以”test”结尾 2、测试方法必须以“test”开头 3、测试类命名以Test开头
那么执行“pytest -s demo.py”这句话的时候,python就会自动去寻找test_开头或者结尾的函数来执行。
setup()方法teardown()方法
setup()方法和teardown()方法是两个特殊方法,setup()是在每一个编写的测试用例执行前必然会执行的方法,teardown()方法是在每个测试用例执行后执行的方法。 比如上面的两个测试用例,修改为:
class TestLogin:
def setup(self):
print("setup")
def teardown(self):
print("teardown")
def test_sucess(self):
print("test sucess")
def test_fail(self):
print("test fail")
上面这段代码,定义了一个测试类,有两个测试脚本test_sucess和test_fail,并且还增加了 setup()和teardown()方法,此时去终端执行pytest -s demo.py,运行结果为:
setup # setup方法打印出来的
test sucess #第一个测试用例打印出来的
.teardown #前面的点表示测试用例test_sucess执行成功,teardown是teardown
方法打印出来的
setup # 执行第二个测试用例的时候,会再次执行setup方法和teardown方法
test fail
.teardown
setup_class()、teardown_class()方法
如果理解了上面讲解的setup和teardown方法,那么setup_class和teardown_class方法也容易理解,这两个方法是针对测试类的,是每一个类执行前后必须执行的方法。
class TestLogin:
def setup_class(self):
print("setup_class")
def teardown_class(self):
print("teardown_class")
def setup(self):
print("setup")
def teardown(self):
print("teardown")
def test_sucess(self):
print("test sucess")
def test_fail(self):
print("test fail")
运行结果为:
setup_class # 类运行时先运行的方法
setup
test sucess
.teardown
setup
test fail
.teardown
teardown_class # 类中的方法都运行结束后,再运行的方法
一般情况下,比如setup_class()方法内,可以放连接手机的代码,对应的teardown_class方法就可以写退出driver的代码。也可以写的setup里面,根据自己的需求来定,写到setup中可能会更保险,写case的时候也会更简单,只是效率低了些。
pytest配置文件
pytest运行时可以有一个配置文件,名字为pytest.ini,并且这个配置文件名字必须这么写,一般放到测试项目目录中。
[pytest]
# 参数
addopts = -s
# 搜索哪个文件夹
testpaths = ./scripts
# 搜索的文件名以test_开头
python_files = test_*.py
# 搜索的类名以Test开头
python_classes = Test*
# 搜索的方法名以test_开头
python_functions = test_*
有了这个配置文件,就等同于告诉了python要运行哪个文件夹下的哪些文件。到cmd中运行的时候,进入到你自己的项目路径,不需要写参数,直接输入pytest就可以,就会按照你的配置文件来运行该运行的用例。
pytest常用插件
生成测试报告
pytest-html 安装方式: pip install pytest-html 安装成功后,运行的方式,有两种,第一种: 以前用pytest运行文件,改成pytest --html=report/report.html 意思是创建一个文件夹为report,在report文件夹中创建一个html文件,该文件里面存的就是运行的测试用例结果 如图:
第二种运行方式: 修改pytest.ini配置文件: addopts = -s --html=report/report.html 然后在终端依旧输入pytest运行,出来的结果是一样的,推荐第二种方式,更简单。 addopts还有很多其他参数,可以检索一下
**pycache**错误:如果是报这个错误,可能是在拷贝东西的时候出错误的,一般把文件夹中的__pycache__这个文件夹删掉就好,这个是一个自动生成的编译文件,在编译的时候发现已经有这个文件了,就会报错。
pytest控制函数执行顺序
安装插件:pip install pytest-ordering 这个插件的意义在于,如果你不想让你的case按照从上往下的顺序执行,就可以通过这个控件来控制一下。 具体用法如下:
import pytest # 注意导包
class TestLogin:
@pytest.mark.run(order=0)
def test_sucess(self): # 定义的第一个case,上面有一个装饰器
print("test sucess1")
@pytest.mark.run(order=2)
def test_sucess2(self):
print("test sucess2")
def test_fail(self):
print("test fail3")
@pytest.mark.run(order=1)
def test_sucess4(self):
print("test sucess4")
这里的装饰器:@pytest.mark.run(order=n) 用法是固定的用法,就是上面这样写,唯一变化的是order的值n,n可以为负数、正数、0,包括小数,执行顺序和order的值有关系,可以自己试验一下,order的值为0的时候是首先执行的用例,其次执行正数(由小到大的顺序),再其次执行没有此装饰器做标记的,最后执行order为负数的(由小到大的顺序)。
数字如果写的一样的话,就按照从上到下的顺序了。
失败重试
首先也安装插件:pip install pytest-rerunfailures 用法一:命令行输入命令:pytest --reruns n n是重试的次数 比如:pytest --reruns 2,即失败后再重试两次,总共执行三次。
用法二,修改配置文件: addopts = -s --html=report/report.html --reruns 3 修改完配置文件,直接命令行输入pytest运行即可。
失败重试的含义:assert 0或者assert False,都是return False的意思,失败重试的意思就是遇到return False,就重跑这个case,直到跑完n次或者直到这个case返回了Ture就停止尝试。 还可以加一个–reruns-delay 2 这种参数是失败重试的时候延迟两秒再重试
失败后还继续运行
pytest中断言失败后,往往就不再继续运行了,那如果我们希望失败后继续运行呢? 可以安装这个模块:pip install pytest-assume 然后在测试用例中断言的句子改为:pytest.assume(1==2)
pytest高级用法
跳过测试函数
有些测试用例本在某种条件下不希望执行测试,那么就可以使用跳过测试函数: skipif(condition,reason=None) condition:跳过的条件,条件返回True的时候就跳过这个case。参数必须写 reason:跳过的原因,内容可以不写,参数必须有。
使用方法: @pytest.mark.skipif(condition,reason=None)
比如:
@pytest.mark.skipif(True, reason='')
def test_sucess4(self):
print("test sucess4")
这样执行的结果就会跳过这个case,控制台输出的是一个s,s表示跳过用例没有执行。 结果:
scripts\test_login.py
test sucess2.
test sucess1.
s
test sucess4.
标记为预期失败的函数
标记为预期失败的意思就是这个case失败了才是对的,我们期望它是失败的。 xfail(condition,reason=None) condition:这里如果返回True,意思就是希望是预期失败的,False表示预期成功。 reason:原因,内容可以不写,参数必须有。 使用方法: @pytest.mark.xfail(condition,reason=None)
示例代码:
class TestLogin:
# 预期失败,结果成功
@pytest.mark.xfail(True, reason='') # 这里返回True表示预期失败
def test_sucess1(self):
print("test sucess1")
assert True # 结果返回True 这应该是一个失败的用例
# 预期失败,结果失败
@pytest.mark.xfail(True, reason='')
def test_sucess2(self):
print("test sucess2")
assert False
# 预期成功,结果失败
@pytest.mark.xfail(False, reason='') # False表示预期成果
def test_fail(self):
print('test fail')
assert False
# 预期成功,结果成功
@pytest.mark.xfail(False, reason='')
def test_sucess4(self):
print("test sucess4")
assert True
上面有四个用例,这四个用例,预期失败结果失败,或者预期成功结果成功,就算用例成功。其他都失败,运行出来的结果为: XPassed XFailed Failed Passed 上面的用例,从运行结果的颜色上面来看,红色表示失败,绿色成功,橙色就是预期失败结果失败的。预期和结果是不一样的,就会失败。 另外可以看到结果的前面有的有一个X,X表示这是一个预期失败的用例。
函数数据参数化
这点非常重要。 方便测试函数获取测试数据, 方法:parametrize(argnames,argvalues,indirect=Flase,ids=None,scope=None) 常用参数: argnames:参数名 argvalues:参数值,类型必须为list,参数只有一个时,格式为[value1,value2,value3…];参数有多个时,格式为[(参数1值,参数2值…),(参数1值,参数2值…)…] 使用方法:
@pytest.mark.parametrize(argnames,argvalues)
例如,一个参数的时候:
@pytest.mark.parametrize('search_values', ['wlan', '蓝牙', '1'])
多个参数的时候:
@pytest.mark.parametrize(('username','password'),[(‘zhangsan’,’mima1’),(‘lisi’,‘mima2’)]) # 注意这里第一个参数是元组
参数有几个,测试用例就运行几次。 下面这个代码示例,是进入到手机设置页面,点击放大镜,依次搜索’wlan’,’蓝牙’,’1’:
import time
import pytest
from appium import webdriver
class TestSearch:
# 连接手机,进入到设置页面
def setup(self):
server = r'http://localhost:4723/wd/hub' # Appium Server, 端口默认为4723
desired_capabilities = {
'platformName': 'Android',
'deviceName': '127.0.0.1:62001', # 需替换成你的deviceName
'platformVersion': '5.1.1',
'appPackage': 'com.android.settings',
'appActivity': '.Settings'
}
self.driver = webdriver.Remote(server, desired_capabilities)
#参数化方法,注意参数名和下面用到的参数名一致
@pytest.mark.parametrize('search_values', ['wlan', '蓝牙', '1'])
def test_search(self, search_values): # 参数名,和上面的参数化方法中的一致
# 点击放大镜按钮
self.driver.find_element_by_id('com.android.settings:id/search').click()
time.sleep(2)
# 输入搜索内容
self.driver.find_element_by_id('android:id/search_src_text').
send_keys(search_values)
print('search %s success' % search_values)
assert 1
还有多个参数的情况,比如说测试登录,需要输入用户名和密码两个参数,下面的代码示例是在通讯录添加姓名和电话号码:
# 连接手机,进入到通讯录页面
def setup(self):
server = r'http://localhost:4723/wd/hub' # Appium Server, 端口默认为4723
desired_capabilities = {
'platformName': 'Android',
'deviceName': '127.0.0.1:62001', # 需替换成你的deviceName
'platformVersion': '5.1.1',
'appPackage': 'com.android.contacts',
'appActivity': '.activities.PeopleActivity'
}
self.driver = webdriver.Remote(server, desired_capabilities)
@pytest.mark.parametrize(('username', 'tel'), [('zhangsan', '123'), ('lisi', '456')])
def test_add_tel(self, username, tel):
# 进入手机通讯录页面,点击新增联系人
self.driver.find_element_by_id('com.android.contacts:id/floating_action_button').click()
time.sleep(2)
# 我的手机添加通讯录的时候会有一个弹框提示,所以有下面这句
self.driver.find_element_by_xpath("//*[contains(@text, '本地')]").click()
time.sleep(2)
# 输入姓名
self.driver.find_element_by_xpath("//*[contains(@text, '姓名')]").send_keys(username)
# 输入电话
self.driver.find_element_by_xpath("//*[contains(@text, '电话')]").send_keys(tel)
# 点击返回
self.driver.keyevent(4)
pytest-fixture
fixture简介
fixture的目的是提供一个固定基线,在该基线上测试可以可靠地和重复地执行。fixture提供了区别于传统单元测试(setup/teardown)有显著改进: • 有独立的命名,并通过声明它们从测试函数、模块、类或整个项目中的使用来激活。 • 按模块化的方式实现,每个fixture都可以互相调用。 • fixture的范围从简单的单元扩展到复杂的功能测试,允许根据配置和组件选项对fixture和测试用例进行参数化,或者跨函数function、类class、模块module或整个测试会话sessio范围。
fixture用途
1.做测试前后的初始化设置,如测试数据准备,链接数据库,打开浏览器等这些操作都可以使用fixture来实现 2.测试用例的前置条件可以使用fixture实现 3.支持经典的xunit fixture ,像unittest使用的setup和teardown 4.fixture可以实现unittest不能实现的功能,比如unittest中的测试用例和测试用例之间是无法传递参数和数据的,但是fixture却可以解决这个问题
fixture()方法
定义一个fixture,和定义普通函数差不多,只是多了一个装饰器
@pytest.fixture(),并且fixture命名不要以test_开头,尽量和用例区别开。fixture是可以有返回值的,如果没return,默认返回None。用例调用fixture的返回值,直接就是把fixture的函数名称当成变量名称
fixture(scope=‘function’,params=None,autouse=False,ids=None,name=None): scope:有四个级别参数"function"(默认),“class”,“module”,“session”
params:一个可选的参数列表,它将导致多个参数调用fixture功能和所有测试使用它。
autouse:如果True,则为所有测试用例不需要传参也会调用这个fixture。如果为False则需要显示的调用fixture。
ids:每个字符串id的列表,每个字符串对应于params这样他们就是测试ID的一部分。如果没有提供ID它们将从params自动生成
name:fixture的名称。这默认为装饰函数的名称。如果fixture在定义它的统一模块中使用,夹具的功能名称将被请求夹具的功能arg遮蔽,解决这个问题的一种方法时将装饰函数命令"fixture_“然后使用”@pytest.fixture(name=‘’)"。
scope为默认值function: 它的作用范围是每个测试用例来之前运行一次,销毁代码在测试用例之后运行。
示例:
import pytest
@pytest.fixture()
def test1():
a = 'su'
print('\ntest1方法传出a')
return a
@pytest.fixture(scope='function')
def test2():
b = '男'
print('\ntest2方法传出b')
return b
class TestFixture:
def test_3(self, test1):
name = 'su'
print('找到name')
assert test1 == name
def test_4(self, test2):
sex = '男'
print('找到sex')
assert test2 == sex
执行的结果为: test1方法传出a 找到name . test2方法传出b 找到sex . scope=“class” fixture为class级别的时候,如果一个class里面有多个用例,都调用了此fixture,那么此fixture只在此class里所有用例开始前执行一次。
示例:
@pytest.fixture(scope='class')
def test1():
b = '男'
print('传出了%s, 且只在class里所有用例开始前执行一次!!!' % b)
return b
class TestCase:
def test_3(self, test1):
name = 'su'
print('找到name')
assert test1 == name
def test_4(self, test1):
sex = '男'
print('找到sex')
assert test1 == sex
执行结果为: 传出了男, 且只在class里所有用例开始前执行一次!!! 找到name F 找到sex . scope=“module” 在当前.py脚本里面所有用例开始前只执行一次 @pytest.fixture(scope=‘module’) scope=“session”
fixture为session级别是可以跨.py模块调用的,也就是当我们有多个.py文件的用例的时候,如果多个用例只需调用一次fixture,那就可以设置为scope=“session”,并且写到conftest.py文件里。
conftest.py文件名称是固定的,pytest会自动识别该文件。放到项目的根目录下就可以全局调用了,如果放到某个package下,那就在该package内有效。
fixture自动使用autouse=True
当用例很多的时候,每次都传fixture这个参数,会很麻烦。fixture里面有个参数autouse,默认是False没开启的,可以设置为True开启自动使用fixture功能,这样用例就不用每次都去传参了 autouse设置为True,自动调用fixture功能
@pytest.fixture(scope='module', autouse=True)
def test1():
print('\n开始执行module')
@pytest.fixture(scope='class', autouse=True)
def test2():
print('\n开始执行class')
@pytest.fixture(scope='function', autouse=True)
def test3():
print('\n开始执行function')
#上面定义fixture的时候设置了autouse=True,那么使用的时候就不需要传参了,该调用的时候自动会调用
def test_a():
print('---用例a执行---')
def test_d():
print('---用例d执行---')
class TestCase:
def test_b(self):
print('---用例b执行---')
def test_c(self):
print('---用例c执行---')
fixture嵌套使用
这里还有需要注意的是,fixture可以嵌套使用,如果你想在一个fixture执行前先执行另一个fixture:
order = []
@pytest.fixture
def f1(f3): # 这里f3这个fixture传到f1这个fixture中
order.append("f1")
@pytest.fixture()
def f3():
order.append("f3")
def test_1(f1): # 参数为f1,调用f1的时候会先执行f1的参数f3
print(order)
assert order == ["f3", "f1"]
执行结果: [‘f3’, ‘f1’] .
fixture参数化
需要使用params参数进行参数化,然后通过request.param取出 例如,如果只有一个参数:
@pytest.fixture(params=['男', '女']) #将一个list给params参数
def fix(request): # request参数必须这样写
return request.param # reques.param会依次将params里面的值返回去
def test_9(fix):
print(fix)
运行结果: 男 . 女 .
如果有多个参数:
li = [{'name':'zhangsan', 'pwd':'mima1'},{'name':'lisi', 'pwd':'mima2'}]
@pytest.fixture(params=li)
def fix(request):
return request.param
def test_9(fix):
print(fix['name'])
print(fix['pwd'])
fixture使用方式
第一种方式: 就是像上面用到的那样,当成参数传入到测试用例方法中。或者结合autouse=True的方式
第二种方式: 使用装饰器@pytest.mark.usefixtures()修饰需要运行的用例
示例:
@pytest.fixture()
def test1():
print('\n开始执行function')
@pytest.mark.usefixtures('test1')
def test_a():
print('---用例a执行---')
@pytest.mark.usefixtures('test1')
class TestCase:
def test_b(self):
print('---用例b执行---')
def test_c(self):
print('---用例c执行---')
执行结果为: 开始执行function —用例a执行— . 开始执行function —用例b执行— . 开始执行function —用例c执行— .
也可以叠加使用,在上面那段代码基础上加入tese2,然后使用的时候写两个装饰器:
@pytest.fixture()
def test2():
print('\n开始执行function2')
@pytest.mark.usefixtures('test1')
@pytest.mark.usefixtures('test2')
def test_a():
print('---用例a执行---')
usefixtures与传fixture区别
如果fixture有返回值,那么usefixture就无法获取到返回值,这个是装饰器usefixture与用例直接传fixture参数的区别。
当fixture需要用到return出来的参数时,只能使用参数名称直接当参数传入的方式,不需要用到return出来的参数时,两种方式都可以。
fixture做后置处理
在pytest中我们有teardown之类的后置处理,fixture也可以支持相关操作,通过yield关键字来实现。 比如示例:
@pytest.fixture(scope='module', autouse=True)
def test1():
print('\n开始执行module')
yield test1
# 因为scope='module',所以这个后置处理在该py模块执行完后再执行,所以执行结果是在最后打印了这句话
print('\ntest1的后置处理')
@pytest.fixture(scope='class', autouse=True)
def test2():
print('\n开始执行class')
yield test2
# scope='class',所以在每次类运行后执行
print('\ntest2的后置处理')
@pytest.fixture(scope='function', autouse=True)
def test3():
print('\n开始执行function')
yield test3
# scope='function',所以在每个方法执行完毕后执行
print('\ntest3的后置处理')
def test_a():
print('---用例a执行---')
class TestCase:
def test_b(self):
print('---用例b执行---')
def test_c(self):
print('---用例c执行---')
执行结果: 开始执行module 开始执行class 开始执行function —用例a执行— . test3的后置处理 test2的后置处理 开始执行class 开始执行function —用例b执行— . test3的后置处理 开始执行function —用例c执行— . test3的后置处理 test2的后置处理 test1的后置处理
示例二: 打开火狐浏览器,百度首页搜索pytest,检查是否搜索成功示例:
import pytest
from selenium import webdriver
import time
@pytest.fixture()
def fixtureFunc():
'''实现浏览器的打开和关闭'''
driver = webdriver.Firefox()
# 类似return driver,将driver返回给调用者,不同的是被掉函数执行时遇到yield会停止执行,接着执行调用处的函数,调用处的函数执行完后会继续执行yield关键后面的代码
yield driver
driver.quit()
def test_search(fixtureFunc):
'''访问百度首页,搜索pytest字符串是否在页面源码中'''
driver = fixtureFunc
driver.get('http://www.baidu.com')
driver.find_element_by_id('kw').send_keys('pytest')
driver.find_element_by_id('su').click()
time.sleep(3)
source = driver.page_source
assert 'pytest' in source
if __name__ == '__main__':
pytest.main(['-s', 'test_fixture_yield.py'])
相关文章
发表评论