- 1、assert的各种使用场景
- 2、基本模式和示例
- 2.1 更改命令行选项的默认值
- 2.2 构建一个依赖于命令行选项的测试
- 2.3 动态地添加命令行选项
- 2.4 控制跳过测试根据命令行选项
- 2.5 编写良好的断言程序
- 2.6 检测是否从 pytest 运行中运行
- 2.7 向测试报告题头添加信息
- 2.8 分析测试持续时间
- 2.11 处理过程后的测试报告/失败
- 2.12 在固定设备中提供测试结果信息
- 3、用例参数化
- 3.1 生成参数组合，取决于命令行
- 3.2 参数中设置不同的测试ID
- 3.3 “测试场景”的快速移植
- 3.4 延迟对参数化资源的设置
- 3.5 间接参数化
- 3.6 间接地应用于特定的参数
- 3.7 通过每个类的配置来参数化测试方法
- 3.8 使用多种固定装置的间接参数化
- 3.9 可选实现/导入的间接参数化
- 3.10 为个别参数化测试设置标记或测试ID
- 3.11 参数化条件提升
- 4、自定义标记
- 4.1 标记测试函数并运行
- 4.2 根据节点选择测试
- 4.3 根据正则表达式选择测试用例
- 4.4 注册标记
- 4.5 标记整个类或模块
- 4.6 参数化中标记各个测试
- 4.7 自定义标记和命令行选项
- 4.8 从多个地方读取标记
- 4.9 标记不同的测试平台环境
- 4.10 基于测试名称自动添加标记
- 5、session级别的固定装置
- 6、更改标准 (Python) 发现测试用例
- 6.1 在测试收集期间忽略路径: --ignore
- 6.2 在测试收集期间忽略测试用例：--deselect
- 6.3 更改目录递归
- 6.4 更改命名约定
- 6.5 查看测试用例树
- 6.6 忽略收集的某些文件
- 7、使用非python进行测试
- 7.1 在Yaml文件中指定测试的基本示例
包含了几十种断言失败的各种场景，涉及断言的，可以查看pytest文档的 5.1.1（以 PDF 格式下载最新版本），举例几个常用的断言：
@pytest.mark.parametrize("param1, param2", [(3, 6)])
def test_generative(param1, param2):
assert param1 * 2 < param2
assert (3 * 2) < 6
def test_simple(self):
def f():
return 42
def g():
return 43
assert f() == g()
assert 42 == 43
def test_eq_long_text(self):
a = "1" * 100 + "a" + "2" * 100
b = "1" * 100 + "b" + "2" * 100
assert a == b
# content of pytest.ini
[pytest]
addopts = -ra -q
根据命令行选项将不同的值传递给测试函数，运行用例：pytest -q test_sample.py --cmdopt=type3
# content of conftest.py
import pytest
def type_checker(value):
msg = "cmdopt must specify a numeric type as typeNNN"
if not value.startswith("type"):
raise pytest.UsageError(msg)
try:
int(value[4:])
except ValueError:
raise pytest.UsageError(msg)
return value
def pytest_addoption(parser):
parser.addoption(
"--cmdopt",
action="store",
default="type1",
help="my option: type1 or type2",
choices=("type1", "type2"),
type=type_checker,
)
@pytest.fixture
def cmdopt(request):
return request.config.getoption("--cmdopt")
# content of test_sample.py
def test_answer(cmdopt):
if cmdopt == "type1":
print("first")
elif cmdopt == "type2":
print("second")
assert 0
# setuptools plugin
import sys
def pytest_load_initial_conftests(args):
if "xdist" in sys.modules: # pytest-xdist plugin
import multiprocessing
num = max(multiprocessing.cpu_count() / 2, 1)
args[:] = ["-n", str(num)] + args
# content of conftest.py
import pytest
def pytest_addoption(parser):
parser.addoption("--runslow", action="store_true", default=False, help="run slow tests" )
def pytest_configure(config):
config.addinivalue_line("markers", "slow: mark test as slow to run")
def pytest_collection_modifyitems(config, items):
if config.getoption("--runslow"):
# --runslow given in cli: do not skip slow tests
return
skip_slow = pytest.mark.skip(reason="need --runslow option to run")
for item in items:
if "slow" in item.keywords:
item.add_marker(skip_slow)
# content of test_module.py
import pytest
def test_func_fast():
pass
@pytest.mark.slow
def test_func_slow():
pass
# content of test_checkconfig.py
import pytest
def checkconfig(x):
__tracebackhide__ = True
if not hasattr(x, "config"):
pytest.fail("not configured: {}".format(x))
def test_something():
checkconfig(42)
# content of your_module.py
_called_from_test = False
# content of conftest.py
def pytest_configure(config):
your_module._called_from_test = True
# content of conftest.py
def pytest_report_header(config):
return "project deps: mylib-1.1"
pytest --durations=3 test_some_are_slow.py
# content of test_some_are_slow.py
import time
def test_funcfast():
time.sleep(0.1)
def test_funcslow1():
time.sleep(0.2)
def test_funcslow2():
time.sleep(0.3)
# content of conftest.py
import pytest
import os.path
@pytest.hookimpl(tryfirst=True, hookwrapper=True)
def pytest_runtest_makereport(item, call):
# execute all other hooks to obtain the report object
outcome = yield
rep = outcome.get_result()
# we only look at actual failing test calls, not setup/teardown
if rep.when == "call" and rep.failed:
mode = "a" if os.path.exists("failures") else "w"
with open("failures", mode) as f:
# let's also access a fixture for the fun of it
if "tmp_path" in item.fixturenames:
extra = " ({})".format(item.funcargs["tmp_path"])
else:
extra = "" f.write(rep.nodeid + extra + "\n")
# content of test_module.py
def test_fail1(tmp_path):
assert 0
def test_fail2():
assert 0
# content of conftest.py
import pytest
@pytest.hookimpl(tryfirst=True, hookwrapper=True)
def pytest_runtest_makereport(item, call):
# execute all other hooks to obtain the report object
outcome = yield
rep = outcome.get_result()
# set a report attribute for each phase of a call, which can
# be "setup", "call", "teardown"
setattr(item, "rep_" + rep.when, rep)
@pytest.fixture
def something(request):
yield
# request.node is an "item" because we use the default
# "function" scope
if request.node.rep_setup.failed:
print("setting up a test failed!", request.node.nodeid)
elif request.node.rep_setup.passed:
if request.node.rep_call.failed:
print("executing test failed", request.node.nodeid)
# content of test_module.py
import pytest
@pytest.fixture
def other():
assert 0
def test_setup_fails(something, other):
pass
def test_call_fails(something):
assert 0
def test_fail2():
assert 0
2.9 测试步骤的增量测试
2.10 包装/目录级固定装置（设置）
2.13 PYTEST_CURRENT_TEST环境变量
2.14 Freezing pytest
pytest -vs test_sample.pypytest -vs test_sample.py --all
# content of conftest.py
def pytest_addoption(parser):
parser.addoption("--all", action="store_true", help="run all combinations")
def pytest_generate_tests(metafunc):
if "param1" in metafunc.fixturenames:
if metafunc.config.getoption("all"): # 如果在命令行中获取到了字符串all：pytest -vs test_sample.py --all
end = 5
else: # 如果在命令什么也没有：pytest -vs test_sample.py
end = 2
print("2")
metafunc.parametrize("param1", range(end))
# content of test_compute.py
def test_compute(param1):
assert param1 < 4
# content of test_time.py
from datetime import datetime, timedelta
import pytest
testdata = [
(datetime(2001, 12, 12), datetime(2001, 12, 11), timedelta(1)),
(datetime(2001, 12, 11), datetime(2001, 12, 12), timedelta(-1)),
]
@pytest.mark.parametrize("a,b,expected", testdata)
def test_timedistance_v0(a, b, expected):
diff = a - b
assert diff == expected
@pytest.mark.parametrize("a,b,expected", testdata, ids=["forward", "backward"])
def test_timedistance_v1(a, b, expected):
diff = a - b
assert diff == expected
def idfn(val):
if isinstance(val, (datetime,)):
# note this wouldn't show any hours/minutes/seconds
return val.strftime("%Y%m%d")
@pytest.mark.parametrize("a,b,expected", testdata, ids=idfn)
def test_timedistance_v2(a, b, expected):
diff = a - b
assert diff == expected
@pytest.mark.parametrize(
"a,b,expected",
[
pytest.param(datetime(2001, 12, 12), datetime(2001, 12, 11), timedelta(1), id="forward"),
pytest.param(datetime(2001, 12, 11), datetime(2001, 12, 12), timedelta(-1), id="backward"),
],
)
def test_timedistance_v3(a, b, expected):
diff = a - b
assert diff == expected
pytest test_time.py --collect-only，–collect-only 用来显示测试ID
collected 8 items
<Package test>
<Module test_time.py>
<Function test_timedistance_v0[a0-b0-expected0]>
<Function test_timedistance_v0[a1-b1-expected1]>
<Function test_timedistance_v1[forward]>
<Function test_timedistance_v1[backward]>
<Function test_timedistance_v2[20011212-20011211-expected0]>
<Function test_timedistance_v2[20011211-20011212-expected1]>
<Function test_timedistance_v3[forward]>
<Function test_timedistance_v3[backward]>
# content of test_scenarios.py
def pytest_generate_tests(metafunc):
idlist = []
argvalues = []
for scenario in metafunc.cls.scenarios:
idlist.append(scenario[0])
items = scenario[1].items()
argnames = [x[0] for x in items]
argvalues.append([x[1] for x in items])
metafunc.parametrize(argnames, argvalues, ids=idlist, scope="class")
scenario1 = ("basic", {"attribute": "value"})
scenario2 = ("advanced", {"attribute": "value2"})
class TestSampleWithScenarios:
scenarios = [scenario1, scenario2]
def test_demo1(self, attribute):
assert isinstance(attribute, str)
def test_demo2(self, attribute):
assert isinstance(attribute, str)
在参数化测试时，使用indirect=True参数允许参数化测试之前参数化测试：
例如，这可以用于在夹具中的测试运行时进行更昂贵的设置，而不是在收集时运行这些设置步骤。
import pytest
@pytest.fixture
def fixt(request):
return request.param * 3
@pytest.mark.parametrize("fixt", ["a", "b"], indirect=True)
def test_indirect(fixt):
assert len(fixt) == 3
对@pytest.mark.parametrize中的值再次做参数化，使用indirect=["x"]指定引用固定装置X再次对值进行参数化处理：
# content of test_indirect_list.py
import pytest
@pytest.fixture(scope="function")
def x(request):
return request.param * 3
@pytest.fixture(scope="function")
def y(request):
return request.param * 2
# indirect给了值X：引用了上面的固定装置X，没给Y，没引用固定装置Y，所以Y的取值是b
@pytest.mark.parametrize("x, y", [("a", "b")], indirect=["x"])
def test_indirect(x, y):
assert x == "aaa"
assert y == "b"
这里是一个示例pytest_generate_tests函数实现一个参数化方案
# content of ./test_parametrize.py
import pytest
def pytest_generate_tests(metafunc):
# called once per each test function
funcarglist = metafunc.cls.params[metafunc.function.__name__]
argnames = sorted(funcarglist[0])
metafunc.parametrize(argnames, [[funcargs[name] for name in argnames] for funcargs in funcarglist])
class TestClass:
# a map specifying multiple argument sets for a test method
params = { "test_equals": [dict(a=1, b=2), dict(a=3, b=3)], "test_zerodivision": [dict(a=1, b=0)],}
def test_equals(self, a, b):
assert a == b
def test_zerodivision(self, a, b):
with pytest.raises(ZeroDivisionError):
a / b
import shutil
import subprocess
import textwrap
import pytest
pythonlist = ["python3.5", "python3.6", "python3.7", "python3.9.6"]
@pytest.fixture(params=pythonlist)
def python1(request, tmp_path):
picklefile = tmp_path / "data.pickle"
return Python(request.param, picklefile)
@pytest.fixture(params=pythonlist)
def python2(request, python1):
return Python(request.param, python1.picklefile)
class Python:
def __init__(self, version, picklefile):
self.pythonpath = shutil.which(version)
if not self.pythonpath:
pytest.skip(f"{version!r} not found")
self.picklefile = picklefile
def dumps(self, obj):
dumpfile = self.picklefile.with_name("dump.py")
dumpfile.write_text(textwrap.dedent(
r"""
import pickle
f = open({!r}, 'wb')
s = pickle.dump({!r}, f, protocol=2)
f.close()
""".format(str(self.picklefile), obj)
))
subprocess.check_call((self.pythonpath, str(dumpfile)))
def load_and_is_true(self, expression):
loadfile = self.picklefile.with_name("load.py")
loadfile.write_text(
textwrap.dedent(
r"""
import pickle
f = open({!r}, 'rb')
obj = pickle.load(f)
f.close()
res = eval({!r})
if not res:
raise SystemExit(1)
""".format(
str(self.picklefile), expression
)))
print(loadfile)
subprocess.check_call((self.pythonpath, str(loadfile)))
@pytest.mark.parametrize("obj", [42, {}, {1: 3}])
def test_basic_objects(python1, python2, obj):
python1.dumps(obj)
python2.load_and_is_true(f"obj == {obj}")
# content of test_pytest_param_example.py
import pytest
@pytest.mark.parametrize(
"test_input,expected",
[
("3+5", 8),
pytest.param("1+7", 8, marks=pytest.mark.basic),
pytest.param("2+4", 6, marks=pytest.mark.basic, id="basic_2+4"),
pytest.param("6*9", 42, marks=[pytest.mark.basic, pytest.mark.xfail], id="basic_6*9"),
],
)
def test_eval(test_input, expected):
assert eval(test_input) == expected
from contextlib import contextmanager
import pytest
@contextmanager
def does_not_raise():
yield
@pytest.mark.parametrize(
"example_input,expectation",
[
(3, does_not_raise()),
(2, does_not_raise()),
(1, does_not_raise()),
(0, pytest.raises(ZeroDivisionError)),
],
)
def test_division(example_input, expectation):
"""Test how much I know division."""
with expectation:
assert (6 / example_input) is not None
pytest test_module.py -m webtest
pytest test_module.py -v -m "not webtest
# content of test_server.py
import pytest
@pytest.mark.webtest
def test_send_http():
pass # perform some webtest test for your app
def test_something_quick():
pass
def test_another():
pass
class TestClass:
def test_method(self):
pass
pytest -v test_server.py::TestClass
pytest -v test_server.py::TestClass::test_method
pytest -v test_server.py::TestClass test_server.py::test_send_http
pytest -v -k http test_server.py
pytest -v -k "not send_http" test_server.py
pytest -v -k "http or quick" test_server.py
# content of test_server.py
import pytest
@pytest.mark.webtest
def test_send_http():
pass # perform some webtest test for your app
def test_something_quick():
pass
def test_another():
pass
class TestClass:
def test_method(self):
pass
为测试套件注册标记很简单，查看注册的标记：pytest --markers
# content of pytest.ini
[pytest]
markers =
webtest: mark a test as a webtest.
slow: mark test as slow.
# content of test_mark_classlevel.py
import pytest
@pytest.mark.webtest
class TestClass:
def test_startup(self):
pass
def test_startup_and_more(self):
pass
要在模块级别应用标记，也可以使用全局变量定义：
import pytest
# 单个标记
pytestmark = pytest.mark.webtest
# 多个标记：
pytestmark = [pytest.mark.webtest, pytest.mark.slowtest]
class TestClass:
def test_startup(self):
pass
def test_startup_and_more(self):
pass
import pytest
class TestClass:
pytestmark = pytest.mark.webtest
def test_startup(self):
pass
import pytest
@pytest.mark.foo
@pytest.mark.parametrize(("n", "expected"), [(1, 2), pytest.param(1, 3, marks=pytest.mark.bar), (2, 3)])
def test_increment(n, expected):
assert n + 1 == expected
pytest -E stage2 test_moule.py
# content of conftest.py
import pytest
def pytest_addoption(parser):
parser.addoption(
"-E",
action="store",
metavar="NAME",
help="only run tests matching the environment NAME.", )
def pytest_configure(config):
# register an additional marker
config.addinivalue_line(
"markers", "env(name): mark test to run only on named environment" )
def pytest_runtest_setup(item):
envnames = [mark.args[0] for mark in item.iter_markers(name="env")]
if envnames:
if item.config.getoption("-E") not in envnames:
pytest.skip(f"test requires env in {envnames!r}")
# content of test_someenv.py
import pytest
@pytest.mark.env("stage1")
def test_basic_db_operation():
pass
# content of test_mark_three_times.py
import pytest
pytestmark = pytest.mark.glob("module", x=1)
@pytest.mark.glob("class", x=2)
class TestClass:
@pytest.mark.glob("function", x=3)
def test_something(self):
pass
# content of conftest.py`在这里插入代码片`
import sys
def pytest_runtest_setup(item):
for mark in item.iter_markers(name="glob"):
print(f"glob args={mark.args} kwargs={mark.kargs}")
sys.stdout.flush()
pytest -m linux test_plat.py
# content of conftest.py
#
import sys
import pytest
ALL = set("darwin linux win32".split())
def pytest_runtest_setup(item):
supported_platforms = ALL.intersection(mark.name for mark in item.iter_markers())
plat = sys.platform
if supported_platforms and plat not in supported_platforms:
pytest.skip(f"cannot run on platform {plat}")
# content of test_plat.py
import pytest
@pytest.mark.darwin
def test_if_apple_is_evil():
pass
@pytest.mark.linux
def test_if_linux_works():
pass
@pytest.mark.win32
def test_if_win32_crashes():
pass
def test_runs_everywhere():
pass
pytest -m interface --tb=short test_moudle.py
pytest -m "interface or event" --tb=short test_moudle.py
# content of test_module.py
def test_interface_simple():
assert 0
def test_interface_complex():
assert 0
def test_event_simple():
assert 0
def test_something_else():
assert 0
# content of conftest.py
import pytest
def pytest_collection_modifyitems(items):
for item in items:
if "interface" in item.nodeid:
item.add_marker(pytest.mark.interface)
elif "event" in item.nodeid:
item.add_marker(pytest.mark.event)
会话范围的夹具有效地访问所有收集的测试项目。 这是一个fixture函数的例子
遍历所有收集的测试并查看他们的测试类是否定义了 callme 方法并调用它：
# content of conftest.py
import pytest
@pytest.fixture(scope="session", autouse=True)
def callattr_ahead_of_alltests(request):
print("callattr_ahead_of_alltests called")
seen = {None}
session = request.node
for item in session.items:
cls = item.getparent(pytest.Class)
if cls not in seen:
if hasattr(cls.obj, "callme"):
cls.obj.callme()
seen.add(cls)
# content of test_module.py
class TestHello:
@classmethod
def callme(cls):
print("callme called!")
def test_method1(self):
print("test_method1 called")
def test_method2(self):
print("test_method2 called")
class TestOther:
@classmethod
def callme(cls):
print("callme other called")
def test_other(self):
print("test other")
# works with unittest as well ...
import unittest
class SomeTest(unittest.TestCase):
@classmethod
def callme(self):
print("SomeTest callme called")
def test_unit1(self):
print("test_unit1 method called")
C:\Users\mc\Desktop\python>pytest -q -s test_module.py
callattr_ahead_of_alltests called
callme called!
callme other called
SomeTest callme called
test_method1 called
.test_method2 called
.test other
.test_unit1 method called
- 通过传递
--ignore=path选项，
您可以在收集过程中轻松忽略某些测试目录和模块
cli。 pytest 允许多个 --ignore 选项。 例如test目录上执行：
pytest --ignore=tests/foobar/test_foobar_03.py --ignore=tests/hello/ - –ignore-glob 选项允许忽略基于 Unix shell 样式通配符的测试文件路径。 如果要排除
以 _01.py 结尾的测试模块：
pytest --ignore-glob='*_01.py'
tests/
|-- example
| |-- test_example_01.py
| |-- test_example_02.py
| |-- test_example_03.py
|-- foobar
| |-- test_foobar_01.py
| |-- test_foobar_02.py
| |-- test_foobar_03.py
|-- hello
|-- world
|-- test_world_01.py
|-- test_world_02.py
|-- test_world_03.py
pytest --deselect tests/foobar/test_foobar_01.py::test_a
告诉 pytest 不要递归到典型的 subversion 或 sphinx-build 目录或任何以 tmp 为前缀的目录。
# content of pytest.ini
[pytest]
norecursedirs = .svn _build tmp*
在你的配置文件中，您可以通过设置 python_files、python_classes 和
python_functions ：pytest --collect-only
# content of pytest.ini
# Example 1: have pytest look for "check" instead of "test"
[pytest]
python_files = check_*.py test_*.py example_*.py
python_classes = Check
python_functions = *_check
# content of check_myapp.py
class CheckMyApp:
def simple_check(self):
pass
def complex_check(self):
pass
注意：对unittest发现用例的方法不管用，因为pytest将测试用例方法的发现委托给unittest
6.5 查看测试用例树pytest --collect-only test_module.py
# content of test_module.py
class TestHello:
@classmethod
def callme(cls):
print("callme called!")
def test_method1(self):
print("test_method1 called")
def test_method2(self):
print("test_method2 called")
class TestOther:
@classmethod
def callme(cls):
print("callme other called")
def test_other(self):
print("test other")
# works with unittest as well ...
import unittest
class SomeTest(unittest.TestCase):
@classmethod
def callme(self):
print("SomeTest callme called")
def test_unit1(self):
print("test_unit1 method called")
C:\Users\mc\Desktop\python基础>pytest --collect-only test_module.py
======================================================================= test session starts ========================================================================
platform win32 -- Python 3.9.6, pytest-7.1.1, pluggy-0.13.1
rootdir: C:\Users\mc\Desktop\python基础
collected 4 items
<Module test_module.py>
<Class TestHello>
<Function test_method1>
<Function test_method2>
<Class TestOther>
<Function test_other>
<UnitTestCase SomeTest>
<TestCaseFunction test_unit1>
==================================================================== 4 tests collected in 0.03s ====================================================================
然而，许多项目会有一个他们不想被导入的 setup.py。 此外，可能只有文件可由特定的 python 版本导入。 对于这种情况，您可以通过将它们列出来动态定义要忽略的文件一个 conftest.py 文件
# content of pytest.ini
[pytest]
python_files = *.py
# content of conftest.py
import sys
collect_ignore = ["setup.py"]
if sys.version_info[0] > 2:
collect_ignore.append("pkg/module_py2.py")
# content of pkg/module_py2.py
def test_only_on_python2():
try:
assert 0
except Exception, e:
pass
这是一个示例 conftest.py（ pytest-yamlwsgi 插件），conftest.py 将收集 test*.yaml 文件并将 yaml 格式的内容作为自定义测试执行：pytest -vs test_simple.yaml
collected 2 items
test_simple.yaml::hello FAILED
test_simple.yaml::ok PASSED
# content of conftest.py
import pytest
def pytest_collect_file(parent, file_path):
if file_path.suffix == ".yaml" and file_path.name.startswith("test"):
return YamlFile.from_parent(parent, path=file_path)
class YamlFile(pytest.File):
def collect(self):
# We need a yaml parser, e.g. PyYAML.
import yaml
raw = yaml.safe_load(self.path.open())
for name, spec in sorted(raw.items()):
yield YamlItem.from_parent(self, name=name, spec=spec)
class YamlItem(pytest.Item):
def __init__(self, *, spec, **kwargs):
super().__init__(**kwargs)
self.spec = spec
def runtest(self):
for name, value in sorted(self.spec.items()):
# Some custom test execution (dumb example follows).
if name != value:
raise YamlException(self, name, value)
def repr_failure(self, excinfo):
"""Called when self.runtest() raises an exception."""
if isinstance(excinfo.value, YamlException):
return "\n".join(
[ "usecase execution failed", " spec failed: {1!r}: {2!r}".format(*excinfo.value.args),
" no further details known at this point.", ] )
def reportinfo(self):
return self.path, 0, f"usecase: {self.name}"
class YamlException(Exception):
"""Custom exception for error reporting."""
# test_simple.yaml
ok:
sub1: sub1
hello:
world: world
some: other
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）