精华内容
下载资源
问答
  • pytest测试框架

    2021-01-08 20:58:56
    pytest是一个非常成熟的全功能的python测试框架,与python自带的unittest测试框架类似,但pytest使用起来更简洁和高效,并且兼容unittest框架 pytest能够支持简单的单元测试和复杂的功能测试,结合requests实现接口...

    pytest介绍:

    pytest是一个非常成熟的全功能的python测试框架,与python自带的unittest测试框架类似,但pytest使用起来更简洁和高效,并且兼容unittest框架

    pytest能够支持简单的单元测试和复杂的功能测试,结合requests实现接口测试,结合selenium、appnium实现自动化功能测试

    pytest结合allure可实现测试报告自动生成

    pytest支持多种第三方插件,可以跟Jenkins集成

    pytest访问网址:https://docs.pytest.org/en/stable/

    pytest安装(简单介绍一下):

    通过python的包管理工具pip进行安装:pip install pytest;升级pytest:pip install -U pytest

    pytest测试用例识别和运行:

    用例名称规范:

    1、python文件以test_开头,或者以_test结尾:test_*.py、*_test.py

    2、测试类以Test开头,并且不能带有init方法

    3、测试函数或者测试类中的用例方法以test_开头

    运行pytest测试用例:

    1、可以直接在terminal直接执行pytest或py.test,此时会自动去查找当前路径下符合规范的所有py文件并执行符合规范的测试用例

    2、pytest -v   打印详细运行的日志信息,比如每条用例的文件路径和属于哪个类

    3、pytest -s  带控制台输出结果,当代码中有print输出语句,如果想在运行结果中打印print的信息,可以加-s参数

    4、pytest -k  运行含有某个关键字的一类用例,使用方法如下:

        pytest -k 'classname'  运行类里所有方法,这里的匹配不是精准匹配,而是模糊匹配

        pytest -k 'methodname'  运行某个方法,同理,模糊匹配

        pytest -k 'name1 or name2'  运行匹配的所有用例,or为并列关系,模糊匹配

        pytest -k 'classname and not methonname'  运行类里所有方法,不包含某个方法

    5、pytest -x  遇到失败用例立即停止运行

    6、pytest --maxfail=[num]  用例失败个数达到设定值时停止运行

    7、pytest -m [标记名] 将运行有@pytest.mark.[标记名]这个标记的测试用例,在自动化过程中可以将测试用例添加标签进行分类

    8、--lf,--last-failed  运行上一次执行失败的用例,上一次没有失败的用例则全部执行

    9、--ff,--failed-first  先执行上一次失败的用例,后执行上一次成功的用例

    10、pytest --collect-only 只收集用例,不执行用例

    运行模式:

    1、使用pycharm里面自带的调试方式,用例方法名前面有个绿色按钮,直接点击就即可运行

    使用这种方式需要在pycharm中设置运行方式为pytest,File-Settings-Tools-Python Integrated Tools

    2、使用pytest运行

        pytest 文件名.py  单独执行某个py文件

        pytest 文件名.py::类名  单独执行某个py文件中的类

        pytest 文件名.py::类名::方法名  单独执行某个py文件下某个类的某个方法

    3、使用python解释器运行

    pytest参数化用例

    应用场景:测试数据是传入的,测试的预期结果也是传入的,两个不同的参数一一对应

    1、通过@pytest.mark.parametrize(argnames, argvalues)来进行参数化

    argnames:要参数化的变量,string(用逗号分隔),list,tuple

    argvalues:argnames每个对应的要参数化的值,list,list[tuple],需要和argnames一一对应

    @pytest.mark.parametrize(['a', 'b'], [(1, 2), (2, 3)])
    def test_param(a, b):
        c = a + b
        print(f"{a} + {b} eq {c}")

    上图中的参数化的代码也可以修改为以下几种方式:

    @pytest.mark.parametrize(('a', 'b'), [(1, 2), (2, 3)])
    @pytest.mark.parametrize("a, b", [(1, 2), (2, 3)])

    上面test_param代码运行结果如下:可以看到这一个用例的代码,运行结果有2条测试用例[(1-2),(2-3)],因为输入进行的参数化,并且测试用例的名称是自动生成的,格式:方法名[参数值-参数值]

    可以在parametrize参数中传入ids参数,将pytest自动命名的名称替换为ids中定义的名称

    @pytest.mark.parametrize("a, b", [(1, 2), (2, 3)], ids=["case1", "case2"])
    def test_param(a, b):
        c = a + b
        print(f"{a} + {b} eq {c}")

    2、参数的堆叠使用

    # 参数的堆叠使用
    @pytest.mark.parametrize("a", [0, 1])
    @pytest.mark.parametrize("b", [2, 3])
    def test_param2(a, b):
        c = a + b
        print(f"{a} + {b} eq {c}")

    运行的输出结果:根据参数堆叠,可以生成不同组合的测试数据

    3、通过yml数据文件来进行用例参数化(数据驱动,也可以使用json、excel等数据文件)

    可以将1章节的参数化的数据写入一个yml文件中,通过读取yml中已经预置好的数据进行参数化

    yml的基础教程参考:https://www.runoob.com/w3cnote/yaml-intro.html

    步骤1:首先新建一个data.yml文件,并在文件中写入如下数据:

    步骤2:在参数化中采用读取yml文件内容的方式将数据传入:

    # 通过yml文件读取测试数据,需要在文件开始导入yaml模块
    @pytest.mark.parametrize("a, b", yaml.safe_load(open("./data.yml"))['datas'],
                             ids=yaml.safe_load(open("./data.yml"))['ids'])
    def test_param3(a, b):
        c = a + b
        print(f"{a} + {b} eq {c}")

    步骤3:运行结果:

    以上内容可以进一步的优化或者封装:

    1、将yaml.safe_load(open("./data.yml"))['datas']使用函数封装后直接调用

    # 定义获取yml文件数据函数
    def get_datas():
        with open("./data.yml") as f:
            yml_data = yaml.safe_load(f)
            print(yml_data)
            datas = yml_data['datas']
            ids = yml_data['ids']
            return [datas, ids]
    
    @pytest.mark.parametrize("a, b", get_datas()[0], ids=get_datas()[1])
    def test_param4(a, b):
        c = a + b
        print(f"{a} + {b} eq {c}")

     

    pytest -m参数详解

    pytest -m [标记名] 将运行有@pytest.mark.[标记名]这个标记的测试用例,在自动化过程中可以将测试用例添加标签进行分类,比如将测试用例的等级进行分类,基本功能用例,冒烟用例等

    比如,如下代码段,两个测试用例分别标记了label1和label2

    class TestDemo:
        @pytest.mark.label1
        def test_haha(self):
            assert 1 == 1
    
        @pytest.mark.label2
        def test_hehe(self):
            assert 2 == 3

    1、可以使用pytest -m "label1" test_mark.py只运行标记了label1的测试用例,运行结果为1条用例:test_haha

    2、可以使用pytest -m "label1 or lable2" test_mark.py运行标记了label1或者label2的测试用例,运行结果为2条用例

    3、将test_hehe的用例改为如下标记,一个用例可以标记多个标签:

    @pytest.mark.label1
    @pytest.mark.label2
        def test_hehe(self):
            assert 2 == 3

    那么可以使用pytest -m "label1 and lable2" test_mark.py运行同时标记了label1和label2的测试用例,运行结果为1条用例:test_hehe

    4、使用自己定义的标记名执行用例时,运行结果会出现warning,可以使用pytest.ini文件配置自定义标签后消除warning信息

    在同级目录下创建一个pytest.ini文件,并进行如下设置:

    [pytest]
    markers = label1
              label2

    pytest的框架结构

    pytest提供了setup和teardown的方法来实现用例的前置和后置条件,比如某一类用例需要在执行步骤之前进行登录,执行完成后退出登录,登录和退出登录的操作可以同一使用一个方法来进行覆盖

    根据用例的运行级别可以分为以下几类:

    模块级:setup_module,teardown_module,在模块的开始调用setup_module方法,结束调用teardown_module方法,在python中,一个py文件就是一个模块

    函数级:setup_function,tearndown_function,在函数的开始和结束分别调用那两个方法(不在类中的函数,setup开始,teardown结束)

    类级:setup_class,tearndown_class,在类的开始和结束分别调用两个方法

    方法级:setup_method,teardown_method,在方法的开始和结束分别调用(专门用于类里面的方法)

    方法级:setup,teardown,如果在类里面定义,使用范围和setup_method、teardown_method一样;如果在类外面定义,使用范围和setup_function、teardown_function一样

    调用的顺序:

    setup_module>setup_class>setup_method>setup>teardown>teardown_method>tearndown_class>teardown_module

    自定义pytest的运行规则:

    1、自定义标记名,跟上面的pytest -m运行参数配合使用的,自定义了之后可以消除warning

    2、自定义运行时增加的默认参数

          addopts = -vs

    3、自定义可以被pytest识别的运行文件、运行类、运行用例等

    [pytest]
    markers = label1
              label2
    addopts = -vs
    python_files = check* test*
    python_classes = Test*
    python_funtions = check_* test_*

     

     

     

     

     

     

     

     

     

     

    展开全文
  • Pytest测试框架

    2020-11-25 18:21:52
    python的第三方库,与标准库unittest测试框架类似,但是比unittest框架使用起来更改简介,灵活,效率更高 当前比较流行的测试框架 Robot Framework Pytest UnitTest/PyUnit pytest 和unittest unittest: python的...

    什么是Pytest?

    python的第三方库,与标准库unittest测试框架类似,但是比unittest框架使用起来更加简洁,灵活,效率更高

    当前比较流行的测试框架

    • Robot Framework
    • Pytest
    • UnitTest/PyUnit

    pytest 和unittest

    unittest pytest
    用例编写规则 1)测试文件必须先import unittest
    2)测试类必须继承unittest.TestCase
    3)测试方法必须以“test_”开头
    4)测试类必须要有unittest.main()方法
    1)测试文件名必须以“test_”开头或者"test"结尾(如:test_ab.py)
    2)测试方法必须以“test
    ”开头
    3)测试类命名以"Test"开头
    用例分类执行 默认执行全部用例,也可以通过加载testsuit,执行部分用例 可以通过@pytest.mark来标记类和方法,pytest.main加入参数("-m")可以只运行标记的类和方法
    用例前置和后置 提供了setUp/tearDown,只能针对所有用例 pytest中的fixture显然更加灵活。可以任意自定义方法函数,只要加上@pytest.fixture()这个装饰器,那么被装饰的方法就可以被使用
    参数化 需依赖ddt库 使用@pytest.mark.parametrize装饰器
    断言 很多断言格式(assertEqual、assertIn、assertTrue、assertFalse) 只有assert一个表达式,用起来比较方便
    报告 使用HTMLTestRunnerNew库 有pytest-HTML、allure插件
    失败重跑 无此功能 pytest支持用例执行失败重跑,pytest-rerunfailures插件

    Pytest 特点

    • 简单灵活,容易上手
    • 支持参数化
    • 能够支持简单的单元测试和复杂的功能测试,还可以用来做selenium/appnium等自动化测试、接口自动化测试(pytest+requests)
    • pytest具有很多第三方插件,并且可以自定义扩展,比较好用的如pytest-selenium(集成selenium)、pytest-html(完美html测试报告生成)、pytest-rerunfailures(失败case重复执行)、pytest-xdist(多CPU分发)等
    • 测试用例的skip和xfail处理
    • 可以很好的和jenkins集成
    • report框架----allure 也支持了pytest

    安装

    pip install pytest
    

    如何编写pytest测试样例?

    • 1、文件名为test_*.py或者*_test.py
    • 2、以Test开头的类
    • 3、以test_开头的函数
    • 4、包package里面要有__init__.py

    在这里插入图片描述

    运行模式

    命令行运行所有case

    1、运行所有测试用例

    pytest
    

    在这里插入图片描述

    2、运行后生成测试报告
    安装pytest-html

    pip install pytest-html
    

    运行

    pytest --html=report.html
    

    在这里插入图片描述

    运行指定的case

    1、直接运行test_case.py文件中的所有case

    pytest test_case01.py
    

    在这里插入图片描述

    2、运行test_case.py文件中的TestCase class下的全部case

    pytest case_test.py::TestCase
    

    在这里插入图片描述

    3、运行test_case.py文件中的TestCase class下的指定的case

    pytest case_test.py::TestCase::test_case_002
    

    在这里插入图片描述

    多线程运行case

    安装pytest-xdist

    pip install pytest-xdist
    

    运行(NUM并发的进程数)

    pytest -n NUM
    

    在这里插入图片描述

    重运行机制-命令行运行

    安装pytest-rerunfailures

    pip install pytest-rerunfailures
    

    运行

    pytest --reruns 重试次数 --reruns-delay 次数之间的延时设置(单位:秒)
    
    pytest.main(['--reruns', '3', '--reruns-delay', '5'])
    
    pytest test_case01.py --reruns NUM
    

    在这里插入图片描述

    命令行参数

    1) -v:pytest -v 可以输出用例更加详细的执行信息(用例所在文件及用例名称)
    2)-s:pytest -s 输出用例中的调试信息(print()打印)
    3)-m:pytest -m “标记” 执行特定的测试用例(标示)

    注册标记-pytest.ini(不注册也可以但是有警报,编码要用GBK)

    [pytest]
    markers =
        run_case: 注册run_case标记
        run_case2
        run_case3
    

    例子:

    @pytest.mark.run_case
    def test_case_004():
        assert 2 == 3
    
    
    @pytest.mark.run_case2
    def test_case_005():
        assert 2 == 3
    
    
    @pytest.mark.run_case3
    def test_case_006():
        assert 2 == 3
    
    
    @pytest.mark.run_case
    def test_case_007():
        assert 2 == 3
    
    pytest test_case03.py -m "run_case"
    

    在这里插入图片描述
    运行多个标记(标记之间用or)

    pytest test_case03.py -m "run_case or run_case2"
    

    在这里插入图片描述

    4)-k:pytest -k “关键字” 执行用例包含"关键字"的用例
    pytest test_case03.py -k "007"
    

    在这里插入图片描述
    运行多个指定key(使用or)

    pytest test_case03.py -k "007 or 006"
    

    在这里插入图片描述

    5)-q:pytest -q 简化控制台的输出

    扩展

    1、夹具

    因为pytest中没有了setup teardown ,所以引入了一个新的名词,夹具

    优势

    • 命名方式灵活,不局限于setup和teardown这几个命名
    • conftest.py 配置里可以实现数据共享,不需要import就能自动找到配置
    • scope=“module” 可以实现多个.py跨文件共享前置, 每一个.py文件调用一次
    • scope=“session” 以实现多个.py跨文件使用一个session来完成多个用例
    • 多个测试用例可以调用同一个fixture功能
    @pytest.fixture()
    

    在同一文件下的夹具

    @pytest.fixture()
    def setUp():
        print("在用例执行之前执行")
        yield
        print("在用例执行之后执行")
    
    第一种:直接把夹具当做参数传进去

    在这里插入图片描述

    第二种:使用@pytest.mark.usefixtures("setUp")
    @pytest.mark.usefixtures("setUp")
    def test_case_009():
        print("测试用例函数:test_case_009")
        assert 2 == 2
    
    缺点

    如果别的文件也需要跟此功能的夹具一样,那么就需要重复的创建夹具

    为解决上面的确定,我们可以使用共享夹具conftest.py(共享夹具文件必须为这个名字)

    在这里插入图片描述

    @pytest.fixture函数的scope的作用域:

    • function,表示fixture函数在测试方法执行前和执行后执行一次。
    • class,表示fixture函数在测试类执行前和执行后执行一次。
    • module,表示fixture函数在测试脚本执行前和执行后执行一次。
    • package,表示fixture函数在测试包(文件夹)中第一个测试用例执行前和最后一个测试用例执行后执行一次。
    • session,表示所有测试的最开始和测试结束后执行一次。

    2、数据驱动

    @pytest.mark.parametrize("case", cases)
    
    • 1、第一个参数是字符串,多个参数中间用逗号隔开
    • 2、第二个参数是list,多组数据用元祖类型;传三个或更多参数也是这样传。list的每个元素都是一个元组,元组里的每个元素和按参数顺序一一对应
    • 3、传一个参数 @pytest.mark.parametrize(‘参数名’,list) 进行参数化
    • 4、传两个参数@pytest.mark.parametrize(‘参数名1,参数名2’,[(参数1_data[0], 参数2_data[0]),(参数1_data[1], 参数2_data[1])]) 进行参数化

    注意: 如果第二个参数list为空的时候,会自动跳过skipped

    在这里插入图片描述

    3、跳过用例

    @pytest.mark.skip()
    @pytest.mark.skipif()
    

    运行的时候加上-rs才会把跳过原因显示出来

    例子:

    @pytest.mark.skip("跳过此用例")
    def test_case01():
        a = 1
        b = 2
        assert a == b
    
    
    @pytest.mark.skipif(1 == 1, reason="如果满足条件的时候才会跳过")
    def test_case02():
        assert 1 == 1
    
    
    @pytest.mark.skipif(1 == 2, reason="如果满足条件的时候才会跳过")
    def test_case03():
        assert 1 == 2
    

    在这里插入图片描述

    4、失败重运行-使用装饰器

    @pytest.mark.flaky(reruns=重试次数, reruns_delay=次数之间的延时设置(单位:秒))
    @pytest.mark.flaky(reruns=3, reruns_delay=2)
    def test_case_014():
        assert 2 == 3
    

    在这里插入图片描述

    5、运行进度条显示

    pip install pytest-sugar
    
    展开全文
  • Pytest 测试框架

    2019-04-30 10:14:00
    Pytest是python的一种单元测试框架。 1. pytest 特点 入门简单,文档丰富 支持单元测试,功能测试 支持参数化,重复执行,部分执行,测试跳过 兼容其他测试框架(nose,unittest 等) 支持生成html报告 可...

    一 . Pytest 简介

    Pytest是python的一种单元测试框架。

    1. pytest 特点
    • 入门简单,文档丰富
    • 支持单元测试,功能测试
    • 支持参数化,重复执行,部分执行,测试跳过
    • 兼容其他测试框架(nose,unittest 等)
    • 支持生成html报告
    • 可集成CI环境(Jenkins 等)
    • 第三方插件丰富,良好的自定义扩展性
    2. pytest 与 unittest

    (1)unittest

    • 测试文件必须先 import unittest
    • 测试类必须继承unittest.TestCase
    • 测试方法必须以“test_”开头
    • 测试类必须要有unittest.main()方法
    • unittest只有setup/teardown装载测试用例
    • ...

    (2)pytest

    • 测试文件名必须以“test_”开头
    • 测试类以Test开头,并且不能带有 init 方法
    • 测试方法必须以“test_”开头
    • 除了有setup/teardown,还能更自由的定义fixture装载测试用例
    • ...

    (3)Comparison Table

     
    Pytest vs Unittest

     


    二 . Pytest 安装

    # 安装
    pip install -U pytest
    
    # 查看安装版本
    pip show pytest
    
    # 或者
    pytest --version
    

    三 . Pytest 运行

    一个简单的例子 test_class.py:

    # test_class.py
    class TestClass:
        def test_one(self):
            x = "this"
            assert 'h' in x
    
        def test_two(self):
            x = "hello"
            assert hasattr(x, 'check')
    
    1. cmd 中运行测试用例
    # cmd中 cd到 test_class.py所在文件夹
    # 运行 该文件夹中所有测试用例
    pytest
    # 或者
    py.test
    
    # 运行指定测试用例,加上-q参数用来指定执行的文件
    pytest -q test_class.py
    

    pytest运行规则:
    查找当前目录及其子目录下以test_.py或_test.py文件,
    找到文件后,在文件中找到以test开头函数并执行。

    2. pycharm 中运行测试用例

    一个简单的例子 test_sample.py:

    # content of test_sample.py
    import pytest
    
    def func(x):
        return x + 1
    
    
    def test_answer():
        assert func(3) == 5
    
    if __name__ == "__main__":
        pytest.main('-q test_sample.py')
    

    pycharm中运行pytest:

    • file->Setting->Tools->Python Integrated Tools->项目名称->Default test runner->选择py.test
    • 右键选择pytest运行或者直接运行.py文件

    四 . Pytest 装饰器

    1. setup 与 teardown

    装载运行级别:

    • 模块级(setup_module/teardown_module)开始于模块始末
    • 类级(setup_class/teardown_class)只在类中前后运行一次(在类中)
    • 方法级(setup_method/teardown_method)开始于方法始末(在类中)
    • 类里面的(setup/teardown)运行在调用方法的前后
    • 函数级(setup_function/teardown_function)只对函数用例生效(不在类中)

    一个简单的例子 test_module.py:

    # -*- coding: utf-8 -*-
    # Version : V1.0
    # Author  : Seven
    # Date    : 2018/8/2 19:41
    
    import pytest
    
    
    # 模块中的方法
    def setup_module():
        print("setup_module:整个.py模块只执行一次")
    
    
    def teardown_module():
        print("teardown_module:整个test_module.py模块只执行一次")
    
    
    def setup_function():
        print("setup_function:每个用例开始前都会执行")
    
    
    def teardown_function():
        print("teardown_function:每个用例结束后都会执行")
    
    
    # 测试模块中的用例1
    def test_one():
        print("正在执行测试模块----test_one")
        x = "this"
        assert 'h' in x
    
    
    # 测试模块中的用例2
    def test_two():
        print("正在执行测试模块----test_two")
        x = "hello"
        assert hasattr(x, 'check')
    
    
    # 测试类
    class TestCase():
    
        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_three(self):
            print("正在执行测试类----test_three")
            x = "this"
            assert 'h' in x
    
        def test_four(self):
            print("正在执行测试类----test_four")
            x = "hello"
            assert hasattr(x, 'check')
    
    
    if __name__ == "__main__":
        pytest.main(["-s", "test_module.py"])
    
    

    运行的效果:

    collected 4 items                                                              
    
    test_module.py setup_module:整个.py模块只执行一次
    setup_function:每个用例开始前都会执行
    正在执行测试模块----test_one
    .teardown_function:每个用例结束后都会执行
    setup_function:每个用例开始前都会执行
    正在执行测试模块----test_two
    Fteardown_function:每个用例结束后都会执行
    setup_class:所有用例执行之前
    setup:每个用例开始前都会执行
    正在执行测试类----test_three
    .teardown:每个用例结束后都会执行
    setup:每个用例开始前都会执行
    正在执行测试类----test_four
    Fteardown:每个用例结束后都会执行
    teardown_class:所有用例执行之后
    teardown_module:整个test_module.py模块只执行一次
    
    

    从结果看出:

    • setup_module/teardown_module的优先级是最大的
    • 然后函数里面的setup_function/teardown_function与类里面的setup_class/teardown_class互不干涉
    2. fixture

    一个简单的例子 test_fixture.py:

    # conftest.py
    # -*- coding: utf-8 -*-
    import pytest
    
    
    @pytest.fixture(scope="function")
    def login():
        print("请先输入账号和密码,然后登陆")
    
        yield
        print("退出登陆")
    
    # test_1.py
    # -*- coding: utf-8 -*-
    import pytest
    
    
    def test_fix1(login):
        print("test_fix1 in test_1.py:需要登陆再执行操作")
    
    
    def test_fix2():
        print("test_fix2 in test_1.py:不需要登陆再执行操作")
    
    
    def test_fix3(login):
        print("test_fix3 in test_1.py:需要登陆再执行操作")
    
    
    if __name__ == "__main__":
        pytest.main(['-s', 'test_1.py'])
    
    # test_2.py
    # -*- coding: utf-8 -*-
    import pytest
    
    
    def test_fix3():
        print("test_fix3 in test_2.py:不需要登陆再执行操作")
    
    
    def test_fix4(login):
        print("test_fix4 in test_2.py:需要登陆再执行操作")
    
    
    if __name__ == "__main__":
        pytest.main(['-s', 'test_2.py'])
    

    文件结构:

     
    conftest configuration

    运行效果:

     

    pytest -s test_1.py
    
    collected 3 items                                                              
    
    test_1.py 请先输入账号和密码,然后登陆
    test_fix1 in test_1.py:需要登陆再执行操作
    .退出登陆
    test_fix2 in test_1.py:不需要登陆再执行操作
    .请先输入账号和密码,然后登陆
    test_fix3 in test_1.py:需要登陆再执行操作
    .退出登陆
    
    pytest -s test_2.py
    
    collected 2 items                                                              
    
    test_2.py test_fix3 in test_2.py:不需要登陆再执行操作
    .请先输入账号和密码,然后登陆
    test_fix4 in test_2.py:需要登陆再执行操作
    .退出登陆
    

    从结果看出:
    (1) scope 参数 实现控制 setup 级别
    (2) conftest.py 配置 实现跨文件调用装饰器
    (3) yield 实现 teardown


    五 . Pytest 断言

    • pytest允许使用python的标准assert语句进行断言处理

    六 . Pytest 自动生成报告

    # 生成xml格式的报告
    pytest -v test_1.py --junitxml=Path
    
    # 生成txt格式的报告
    pytest -v test_1.py --resultlog=Path
    
    # 生成html格式的报告
    # 需预先装上pytest-html
    pip install pytest_html
    pytest -v test_1.py --html=Path
    

    生成报告效果图:

     
    pytest_report




    转自:https://www.jianshu.com/p/75c27fe23b4e

    转载于:https://www.cnblogs.com/beile/p/10794474.html

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,560
精华内容 1,024
关键字:

pytest测试框架