pip install pytest

pytest-html(生成htm报告的插件)

pytest-xdist (多线程运行的插件)

pytest-ordering (改变用例的执行顺序的插件)

pytest-rerunfailres (失败用例重跑的插件)

allure-pytest (生成美观自定义的allure报告)pytest test_*.py --alluredir=result + allure serve result
　　　　　　　　allure generate --alluredir=result -o report/ --clean
pytest-rerunfailures　(失败重跑插件)
pytest-repeat 　　（重复执行用例的插件）
pytest-assume　　（assume多重断言，断言失败后边的代码会继续执行）

//插件太多，可通过pip install -r pludin.txt一次性下载完成
例如：plugin.txt中内容如下
pytest-html
pytest-xdist
终端运行：pip install -r pugin.txt即可下载这两个插件

ERROR: usage: run.py [options] [file_or_dir] [file_or_dir] [...]

run.py: error: unrecognized arguments: --alluredir=./reports/temp/ --clean-alluredir

  inifile: C:\Users\EDY\PycharmProjects\ProductAuto\pytest.ini

  rootdir: C:\Users\EDY\PycharmProjects\ProductAuto

-vs    　　　 输出详细信息。输出调试信息。如: pytest -vs
-n  　　　　  多线程运行。( 前提安装插件: pytest-xdist)如: pytest -VS -n=2

--reruns     失败重跑(前提安装插件: pytest-rerunfailres )如: pytest --reruns=2

        　　　raise Exception()抛出异常,try except解决异常。

-x    　　　　出现一个用例失败则停止测试。如: pytest -x

--maxfail    出现几个失败才终止,如: pytest --maxfail=2

--html   　  生成html的测试报告(前提安装插件: pytest-html) , 如: pytest --html=report/report.html

-k    　　　　运行测试用例名称中包含某个字符串的测试用例。

-m    　　　　只测试被标记的用例
--strict-markers　未在pytest.ini配置文件注册的标记mark都会引发报错
--reruns n　　(安装pytest-rerunfailures插件)，失败重跑n次，最大运行次数n pytest --reruns 5
--reruns-delay n ）（pytest-rerunfailures插件），pytest --rerun 2 --reruns-delay 5 失败重跑之间间隔5s
--count　　　　重复执行测试，需安装pytest-repeat，使用：pytest --count=5或者pytest --count 5 
　　　　　　　　重复执行所有测试用例5次，主要结合-x使用，测试偶发bug，运行直到执行失败
　　　　　　　　还有@pytest.mark.repeat(n)可对测试类、方法使用

if __name__ == "__main__":

    pytest.main(["-vs”，“-x"])

pytest  test_*.py    //运行指定的test_*.py ，多个py文件分号隔开

pytest  testcase/    //运行指定的testcase目录下所有测试文件

pytest -k "cs”    //测试包含有“cs”的测试类和方法

pytest  testcase/test_*.py::Test_lei::test_* //可具体指定某个方法

[pytest]


//pytest参数配置

addopts = -VS


//需要执行用例模块目录

testpaths =./testcases


//可更改测试文件、类、方法的默认规则，一般不做更改

python_files = test_*.py

python_classes = Test*

python_functions = test_*

//标记用例，一般用于冒烟测试，以下的smoke是标签名，”冒烟测试“是描述，使用
markers=
　　smoke:"冒烟测试"
　　flow:"流水"

//与@pytest.mark.xfail()的strict一样，为False，意外pass的结果显示xpass，为True，则显示Failed
xfail_strict = False

//控制台日志输出控制器，为True输出，为False关闭
log_cli = True

//用来加速收集用例，去掉不要谝历的目录
norecursedirs = * （目录）

def test_001(self):  
　　 assert var==3　　//判断var等于3
　　 assert var in ‘ab’　　//判断字符串‘ab’包含var
　　 assert var is False　　//判断var 为假
　　 assert var not True　　//判断var不为真
　　 assert var　　//判断var为真

def test_002(self):

    with pytest.raises(ZeroDivisionError):

        1/0    

# test_tmp_path.py文件内容

import os

CONTENT = u"content"

def test_create_file(tmp_path):

    d = tmp_path / "sub"

    d.mkdir()

    p = d / "hello.txt"

    p.write_text(CONTENT)

    assert p.read_text() == CONTENT

    assert len(list(tmp_path.iterdir())) == 1

    assert 0


测试结果如下：除了assert0以外，其他都断言成功

_____________________________ test_create_file _____________________________

tmpdir = local('PYTEST_TMPDIR/test_create_file0')

    def test_create_file(tmpdir):

        p = tmpdir.mkdir("sub").join("hello.txt")

        p.write("content")

        assert p.read() == "content"

        assert len(tmpdir.listdir()) == 1

>       assert 0

E       assert 0

def setup_module():

    print("=====整个.py模块开始前只执行一次:打开浏览器=====")

def teardown_module():

    print("=====整个.py模块结束后只执行一次:关闭浏览器=====")

def setup_function():

    print("===每个函数级别用例开始前都执行setup_function===")

def teardown_function():

    print("===每个函数级别用例结束后都执行teardown_function====")

def test_one():

    print("one")

class TestCase():

    def setup_class(self):

        print("====整个测试类开始前只执行一次setup_class====")

    def teardown_class(self):

        print("====整个测试类结束后只执行一次teardown_class====")

    def setup_method(self):

        print("==类里面每个用例执行前都会执行setup_method==")

    def teardown_method(self):

        print("==类里面每个用例结束后都会执行teardown_method==")

    def setup(self):

        print("=类里面每个用例执行前都会执行setup=")

    def teardown(self):

        print("=类里面每个用例结束后都会执行teardown=")

    def test_three(self):

        print("two")

//不调用则不显示

@pytest.fixture()

def ttt():

    print("fuction-setup4")

@pytest.fixture()

def aaa():

    print("fuction-setup1")

@pytest.fixture()

def bbb():

    print("fuction-setup2")

@pytest.fixture(scope="class")

def ccc():

    print("setup")     //调用程序前执行

    yield  //后面的的方法体相当于后置

    print("teardown")    //调用程序后执行

//类调用fuction范围级别固件bbb，相当于类里面的每个方法都调用bbb

@pytest.mark.usefixtures("bbb")

//类调用class级别固件ccc，只在调用的类前执行一次

@pytest.mark.usefixtures("ccc")

class Test_study:

    def test_ddd(self,aaa):    //先bbb输出，再aaa输出

        print("AAAAAA")

    @pytest.mark.smoke

    def test_eee(self):

        print("BBBBBB")

-------------------结果如下--------------------------------

kuadi/test_kuadi_login.py::Test_study::test_ddd setup

fuction-setup2

fuction-setup1

AAAAAA

PASSED

kuadi/test_kuadi_login.py::Test_study::test_eee fuction-setup2

BBBBBB

PASSEDteardown

@pytest.fixture(scope="class")

def aaa():

    print("aaa_start")

    yield

    print("aaa_end")

@pytest.fixture()

def bbb():

    print("bbb_start")

    yield

    print("bbb_end")

@pytest.mark.usefixtures("bbb")

def test_fff():

    print("fff")

class Test_QQQ:

    @pytest.mark.usefixtures("bbb")

    def test_ccc(self):

        print("ccc")

    def test_ddd(self, aaa):

        print("ddd")

    def test_eee(self):

        print("eee")

结果------------

fds.py::test_fff bbb_start

fff

PASSEDbbb_end

fds.py::Test_QQQ::test_ccc bbb_start

ccc

PASSEDbbb_end

fds.py::Test_QQQ::test_ddd aaa_start

ddd

PASSED

fds.py::Test_QQQ::test_eee eee

PASSEDaaa_end

//yield配合fixtrue实现前后置方法

@pytest.fixture(scope="class")

def ccc():

    print("setup")

    yield

    print("teardown")

//with配合yield，等待测试完成后，自动关闭连接

@pytest.fixture(scope="module")

def smtp_connection():

    with smtplib.SMTP("smtp.gmail.com", 587, timeout=5) as smtp_connection:

        yield smtp_connection

//通过后置操作在测试完成后关闭浏览器连接

@pytest.fixture(scope="module")

def test_addfinalizer(request):

    # 前置操作setup

    print("==再次打开浏览器==")

    test = "test_addfinalizer"

    def fin():

        # 后置操作teardown

        print("==再次关闭浏览器==")

    request.addfinalizer(fin)

    # 返回前置操作的变量

    return test

//测试方法和函数使用
@pytest.mark.parametrize("test_input,expected", [("3+5", 8), ("2+4", 6), ("6*9", 42)])

def test_eval(test_input, expected):

    assert eval(test_input) == expected

//测试类使用

@pytest.mark.parametrize("n,expected", [(1, 2), (3, 4)])

class TestClass:

    def test_simple_case(self, n, expected):

        assert n + 1 == expected

    def test_weird_simple_case(self, n, expected):

        assert (n * 1) + 1 == expected

//模块全局使用

pytestmark = pytest.mark.parametrize("n,expected", [(1, 2), (3, 4)])

class TestClass:

    def test_simple_case(self, n, expected):

        assert n + 1 == expected

//mark标记使用

@pytest.mark.parametrize(

    "test_input,expected",

    [("3+5", 8), ("2+4", 6), pytest.param("6*9", 42, marks=pytest.mark.xfail)],

)

def test_eval(test_input, expected):

    assert eval(test_input) == expected

//叠加使用

@pytest.mark.parametrize("x", [0, 1])

@pytest.mark.parametrize("y", [2, 3])

def test_foo(x, y):

    print({x},{y})

结果按顺序：0，2/1,2/0.3/1,3

第一个例子
# content of conftest.py

import pytest

import smtplib

@pytest.fixture(scope="module", params=["smtp.gmail.com", "mail.python.org"])

def smtp_connection(request):

    smtp_connection = smtplib.SMTP(request.param, 587, timeout=5)

    yield smtp_connection

    print("finalizing {}".format(smtp_connection))

    smtp_connection.close()

//第二个例子
@pytest.fixture(params=[0, 1], ids=["spam", "ham"])

def a(request):

    return request.param

def test_a(a):

    pass

def idfn(fixture_value):

    if fixture_value == 0:

        return "eggs"

    else:

        return None

@pytest.fixture(params=[0, 1], ids=idfn)

def b(request):

    return request.param

def test_b(b):

    pass

结果-------------------------------------------------

  <Function test_a[spam]>

  <Function test_a[ham]>

  <Function test_b[eggs]>

  <Function test_b[1]>

@pytest.fixture(params=[0, 1, pytest.param(2, marks=pytest.mark.skip)])

def data_set(request):

    return request.param

def test_data(data_set):

    pass

class App:

    def __init__(self, smtp_connection):

        self.smtp_connection = smtp_connection

@pytest.fixture(scope="module")

def app(smtp_connection):

    return App(smtp_connection)

def test_smtp_connection_exists(app):

    assert app.smtp_connection

@pytest.fixture(scope="module", params=["mod1", "mod2"])

def modarg(request):

    param = request.param

    print("  SETUP modarg", param)

    yield param

    print("  TEARDOWN modarg", param)

@pytest.fixture(scope="function", params=[1, 2])

def otherarg(request):

    param = request.param

    print("  SETUP otherarg", param)

    yield param

    print("  TEARDOWN otherarg", param)

def test_0(otherarg):

    print("  RUN test0 with otherarg", otherarg)

def test_1(modarg):

    print("  RUN test1 with modarg", modarg)

def test_2(otherarg, modarg):

    print("  RUN test2 with otherarg {} and modarg {}".format(otherarg, modarg))

--------------------------------结果-------------------------------

collecting ... collected 8 items

test_module.py::test_0[1]   SETUP otherarg 1

  RUN test0 with otherarg 1

PASSED  TEARDOWN otherarg 1

test_module.py::test_0[2]   SETUP otherarg 2

  RUN test0 with otherarg 2

PASSED  TEARDOWN otherarg 2

test_module.py::test_1[mod1]   SETUP modarg mod1

  RUN test1 with modarg mod1

PASSED

test_module.py::test_2[mod1-1]   SETUP otherarg 1

  RUN test2 with otherarg 1 and modarg mod1

PASSED  TEARDOWN otherarg 1

test_module.py::test_2[mod1-2]   SETUP otherarg 2

  RUN test2 with otherarg 2 and modarg mod1

PASSED  TEARDOWN otherarg 2

test_module.py::test_1[mod2]   TEARDOWN modarg mod1

  SETUP modarg mod2

  RUN test1 with modarg mod2

PASSED

test_module.py::test_2[mod2-1]   SETUP otherarg 1

  RUN test2 with otherarg 1 and modarg mod2

PASSED  TEARDOWN otherarg 1

test_module.py::test_2[mod2-2]   SETUP otherarg 2

  RUN test2 with otherarg 2 and modarg mod2

PASSED  TEARDOWN otherarg 2

  TEARDOWN modarg mod2

# content of conftest.py 

import os

import tempfile

import pytest

@pytest.fixture

def cleandir():

    with tempfile.TemporaryDirectory() as newpath:

        old_cwd = os.getcwd()

        os.chdir(newpath)

        yield

        os.chdir(old_cwd)

------------------------------------

# content of test_setenv.py

import os

import pytest

@pytest.mark.usefixtures("cleandir")

class TestDirectoryInit:

    def test_cwd_starts_empty(self):

        assert os.listdir(os.getcwd()) == []

        with open("myfile", "w") as f:

            f.write("hello")

    def test_cwd_again_starts_empty(self):

        assert os.listdir(os.getcwd()) == []

//其他用法

@pytest.mark.usefixtures("cleandir", "anotherfixture")  指定多个fix true

def test():

    pass

//使用pytestmark在测试模块级别指定夹具的用途

pytestmark = pytest.mark.usefixtures("cleandir")

//将项目中所有测试所需的夹具放入ini文件中

[pytest]

usefixtures = cleandir

@pytest.fixture(scope="function")

def input_user(request):

    user = request.param

    print("登录账户：%s" % user)

    return user

@pytest.fixture(scope="function")

def input_psw(request):

    psw = request.param

    print("登录密码：%s" % psw)

    return psw

name = ["name1", "name2"]

pwd = ["pwd1", "pwd2"]

@pytest.mark.parametrize("input_user", name, indirect=True)

@pytest.mark.parametrize("input_psw", pwd, indirect=True)

def test_more_fixture(input_user, input_psw):

    print("fixture返回的内容:", input_user, input_psw)

tests/

    __init__.py

    conftest.py

        # content of tests/conftest.py

        import pytest

        @pytest.fixture(params=['one', 'two', 'three']) //最初的参数化fixtrue

        def parametrized_username(request):

            return request.param

        @pytest.fixture　　//最初的非参数化fixtrue

        def non_parametrized_username(request):

            return 'username'

    test_something.py

        # content of tests/test_something.py

        import pytest

        @pytest.fixture　　//非参数化fixtrue覆盖参数化fixtrue

        def parametrized_username():

            return 'overridden-username'


　　　　　//参数化fixtrue覆盖非参数化fixtrue

        @pytest.fixture(params=['one', 'two', 'three'])

        def non_parametrized_username(request):

            return request.param

        def test_username(parametrized_username):

            assert parametrized_username == 'overridden-username'

        def test_parametrized_username(non_parametrized_username):

            assert non_parametrized_username in ['one', 'two', 'three']

    test_something_else.py

        # content of tests/test_something_else.py

        def test_username(parametrized_username):

            assert parametrized_username in ['one', 'two', 'three']

        def test_username(non_parametrized_username):

            assert non_parametrized_username == 'username'

//直接参数化也可以覆盖fixtrue
tests/

    __init__.py

    conftest.py

        # content of tests/conftest.py

        import pytest

        @pytest.fixture

        def username():

            return 'username'

    test_something.py

        # content of tests/test_something.py

        import pytest

        @pytest.mark.parametrize('username', ['directly-overridden-username'])

        def test_username(username):

            assert username == 'directly-overridden-username'

//raises参数为空或者与所报的错误匹配时结果是xfail,此结果是预期失败，说明用例通过

   @pytest.mark.xfail()

    def test_002(self):

        print("账户修改")

        raise Exception

//raises参数与所报的错误不匹配时结果是failed

    @pytest.mark.xfail(raises=ZeroDivisionError)

    def test_004(self):

        print("账户修改")

        raise Exception

--------------------结果------------------------

test_interface.py::Test_kuaidi::test_002 账户修改

XFAIL

test_interface.py::Test_kuaidi::test_004 账户修改

FAILED

@pytest.mark.xfail(raises=ZeroDivisionError)

class Test_kuaidi:

    def test_002(self):  //不匹配的用例显示failed

        print("账户修改")

        raise Exception

    def test_004(self):    //xpass，意外通过

        print("账户修改")

        # raise Exception

    def test_005(self):    //匹配的用例显示xfail

        1/0

------------------------结果展示---------------

test_interface.py::Test_kuaidi::test_002 账户修改

FAILED

test_interface.py::Test_kuaidi::test_004 账户修改

XPASS

test_interface.py::Test_kuaidi::test_005 XFAIL

def test_aaa():

    pytest.xfail(reason="功能未做")

---------结果-------------------------

test_interface.py::test_aaa XFAIL (功能未做)

@pytest.mark.skipif(sys.platform == 'win32', reason="does not run on windows")

class TestSkipIf(object):

    def test_function(self):

        print("不能在window上运行")

def test_aaa():

    pytest.skip("功能未做") //注意，pytest.skip(reason="功能未做")会报错

结果：test_interface.py::test_aaa SKIPPED (功能未做)

pytest.skip(r"功能未做",allow_module_level=True)

结果：跳过所有剩余用例

expy = pytest.importorskip("pytest", minversion="7.0",reason="pytest7.0版本没有出来")

@expy

def test_import():

    print("test")
结果：会跳过所有该模块的用例测试

    @pytest.mark.flaky(reruns=2,reruns_delay=5)

    def test_ddd(self):

        assert False

---------------------执行结果-------------------------

kuadi/test_kuadi_login.py::Test_study::test_ddd RERUN

kuadi/test_kuadi_login.py::Test_study::test_ddd RERUN

kuadi/test_kuadi_login.py::Test_study::test_ddd FAILED