1739 lines
55 KiB
Python
1739 lines
55 KiB
Python
# -*- coding: utf-8 -*-
|
|
import re
|
|
import sys
|
|
import attr
|
|
import _pytest._code
|
|
import py
|
|
import pytest
|
|
from _pytest import python, fixtures
|
|
|
|
import hypothesis
|
|
from hypothesis import strategies
|
|
|
|
PY3 = sys.version_info >= (3, 0)
|
|
|
|
|
|
class TestMetafunc(object):
|
|
def Metafunc(self, func, config=None):
|
|
# the unit tests of this class check if things work correctly
|
|
# on the funcarg level, so we don't need a full blown
|
|
# initiliazation
|
|
class FixtureInfo(object):
|
|
name2fixturedefs = None
|
|
|
|
def __init__(self, names):
|
|
self.names_closure = names
|
|
|
|
@attr.s
|
|
class DefinitionMock(object):
|
|
obj = attr.ib()
|
|
|
|
names = fixtures.getfuncargnames(func)
|
|
fixtureinfo = FixtureInfo(names)
|
|
definition = DefinitionMock(func)
|
|
return python.Metafunc(definition, fixtureinfo, config)
|
|
|
|
def test_no_funcargs(self, testdir):
|
|
def function():
|
|
pass
|
|
|
|
metafunc = self.Metafunc(function)
|
|
assert not metafunc.fixturenames
|
|
repr(metafunc._calls)
|
|
|
|
def test_function_basic(self):
|
|
def func(arg1, arg2="qwe"):
|
|
pass
|
|
|
|
metafunc = self.Metafunc(func)
|
|
assert len(metafunc.fixturenames) == 1
|
|
assert "arg1" in metafunc.fixturenames
|
|
assert metafunc.function is func
|
|
assert metafunc.cls is None
|
|
|
|
def test_addcall_no_args(self):
|
|
def func(arg1):
|
|
pass
|
|
|
|
metafunc = self.Metafunc(func)
|
|
metafunc.addcall()
|
|
assert len(metafunc._calls) == 1
|
|
call = metafunc._calls[0]
|
|
assert call.id == "0"
|
|
assert not hasattr(call, "param")
|
|
|
|
def test_addcall_id(self):
|
|
def func(arg1):
|
|
pass
|
|
|
|
metafunc = self.Metafunc(func)
|
|
pytest.raises(ValueError, "metafunc.addcall(id=None)")
|
|
|
|
metafunc.addcall(id=1)
|
|
pytest.raises(ValueError, "metafunc.addcall(id=1)")
|
|
pytest.raises(ValueError, "metafunc.addcall(id='1')")
|
|
metafunc.addcall(id=2)
|
|
assert len(metafunc._calls) == 2
|
|
assert metafunc._calls[0].id == "1"
|
|
assert metafunc._calls[1].id == "2"
|
|
|
|
def test_addcall_param(self):
|
|
def func(arg1):
|
|
pass
|
|
|
|
metafunc = self.Metafunc(func)
|
|
|
|
class obj(object):
|
|
pass
|
|
|
|
metafunc.addcall(param=obj)
|
|
metafunc.addcall(param=obj)
|
|
metafunc.addcall(param=1)
|
|
assert len(metafunc._calls) == 3
|
|
assert metafunc._calls[0].getparam("arg1") == obj
|
|
assert metafunc._calls[1].getparam("arg1") == obj
|
|
assert metafunc._calls[2].getparam("arg1") == 1
|
|
|
|
def test_addcall_funcargs(self):
|
|
def func(x):
|
|
pass
|
|
|
|
metafunc = self.Metafunc(func)
|
|
|
|
class obj(object):
|
|
pass
|
|
|
|
metafunc.addcall(funcargs={"x": 2})
|
|
metafunc.addcall(funcargs={"x": 3})
|
|
pytest.raises(pytest.fail.Exception, "metafunc.addcall({'xyz': 0})")
|
|
assert len(metafunc._calls) == 2
|
|
assert metafunc._calls[0].funcargs == {"x": 2}
|
|
assert metafunc._calls[1].funcargs == {"x": 3}
|
|
assert not hasattr(metafunc._calls[1], "param")
|
|
|
|
def test_parametrize_error(self):
|
|
def func(x, y):
|
|
pass
|
|
|
|
metafunc = self.Metafunc(func)
|
|
metafunc.parametrize("x", [1, 2])
|
|
pytest.raises(ValueError, lambda: metafunc.parametrize("x", [5, 6]))
|
|
pytest.raises(ValueError, lambda: metafunc.parametrize("x", [5, 6]))
|
|
metafunc.parametrize("y", [1, 2])
|
|
pytest.raises(ValueError, lambda: metafunc.parametrize("y", [5, 6]))
|
|
pytest.raises(ValueError, lambda: metafunc.parametrize("y", [5, 6]))
|
|
|
|
def test_parametrize_bad_scope(self, testdir):
|
|
def func(x):
|
|
pass
|
|
|
|
metafunc = self.Metafunc(func)
|
|
try:
|
|
metafunc.parametrize("x", [1], scope="doggy")
|
|
except ValueError as ve:
|
|
assert "has an unsupported scope value 'doggy'" in str(ve)
|
|
|
|
def test_parametrize_and_id(self):
|
|
def func(x, y):
|
|
pass
|
|
|
|
metafunc = self.Metafunc(func)
|
|
|
|
metafunc.parametrize("x", [1, 2], ids=["basic", "advanced"])
|
|
metafunc.parametrize("y", ["abc", "def"])
|
|
ids = [x.id for x in metafunc._calls]
|
|
assert ids == ["basic-abc", "basic-def", "advanced-abc", "advanced-def"]
|
|
|
|
def test_parametrize_and_id_unicode(self):
|
|
"""Allow unicode strings for "ids" parameter in Python 2 (##1905)"""
|
|
|
|
def func(x):
|
|
pass
|
|
|
|
metafunc = self.Metafunc(func)
|
|
metafunc.parametrize("x", [1, 2], ids=[u"basic", u"advanced"])
|
|
ids = [x.id for x in metafunc._calls]
|
|
assert ids == [u"basic", u"advanced"]
|
|
|
|
def test_parametrize_with_wrong_number_of_ids(self, testdir):
|
|
def func(x, y):
|
|
pass
|
|
|
|
metafunc = self.Metafunc(func)
|
|
|
|
pytest.raises(
|
|
ValueError, lambda: metafunc.parametrize("x", [1, 2], ids=["basic"])
|
|
)
|
|
|
|
pytest.raises(
|
|
ValueError,
|
|
lambda: metafunc.parametrize(
|
|
("x", "y"), [("abc", "def"), ("ghi", "jkl")], ids=["one"]
|
|
),
|
|
)
|
|
|
|
@pytest.mark.issue510
|
|
def test_parametrize_empty_list(self):
|
|
def func(y):
|
|
pass
|
|
|
|
class MockConfig(object):
|
|
def getini(self, name):
|
|
return ""
|
|
|
|
@property
|
|
def hook(self):
|
|
return self
|
|
|
|
def pytest_make_parametrize_id(self, **kw):
|
|
pass
|
|
|
|
metafunc = self.Metafunc(func, MockConfig())
|
|
metafunc.parametrize("y", [])
|
|
assert "skip" == metafunc._calls[0].marks[0].name
|
|
|
|
def test_parametrize_with_userobjects(self):
|
|
def func(x, y):
|
|
pass
|
|
|
|
metafunc = self.Metafunc(func)
|
|
|
|
class A(object):
|
|
pass
|
|
|
|
metafunc.parametrize("x", [A(), A()])
|
|
metafunc.parametrize("y", list("ab"))
|
|
assert metafunc._calls[0].id == "x0-a"
|
|
assert metafunc._calls[1].id == "x0-b"
|
|
assert metafunc._calls[2].id == "x1-a"
|
|
assert metafunc._calls[3].id == "x1-b"
|
|
|
|
@hypothesis.given(strategies.text() | strategies.binary())
|
|
@hypothesis.settings(
|
|
deadline=400.0
|
|
) # very close to std deadline and CI boxes are not reliable in CPU power
|
|
def test_idval_hypothesis(self, value):
|
|
from _pytest.python import _idval
|
|
|
|
escaped = _idval(value, "a", 6, None)
|
|
assert isinstance(escaped, str)
|
|
if PY3:
|
|
escaped.encode("ascii")
|
|
else:
|
|
escaped.decode("ascii")
|
|
|
|
def test_unicode_idval(self):
|
|
"""This tests that Unicode strings outside the ASCII character set get
|
|
escaped, using byte escapes if they're in that range or unicode
|
|
escapes if they're not.
|
|
|
|
"""
|
|
from _pytest.python import _idval
|
|
|
|
values = [
|
|
(u"", ""),
|
|
(u"ascii", "ascii"),
|
|
(u"ação", "a\\xe7\\xe3o"),
|
|
(u"josé@blah.com", "jos\\xe9@blah.com"),
|
|
(
|
|
u"δοκ.ιμή@παράδειγμα.δοκιμή",
|
|
"\\u03b4\\u03bf\\u03ba.\\u03b9\\u03bc\\u03ae@\\u03c0\\u03b1\\u03c1\\u03ac\\u03b4\\u03b5\\u03b9\\u03b3"
|
|
"\\u03bc\\u03b1.\\u03b4\\u03bf\\u03ba\\u03b9\\u03bc\\u03ae",
|
|
),
|
|
]
|
|
for val, expected in values:
|
|
assert _idval(val, "a", 6, None) == expected
|
|
|
|
def test_bytes_idval(self):
|
|
"""unittest for the expected behavior to obtain ids for parametrized
|
|
bytes values:
|
|
- python2: non-ascii strings are considered bytes and formatted using
|
|
"binary escape", where any byte < 127 is escaped into its hex form.
|
|
- python3: bytes objects are always escaped using "binary escape".
|
|
"""
|
|
from _pytest.python import _idval
|
|
|
|
values = [
|
|
(b"", ""),
|
|
(b"\xc3\xb4\xff\xe4", "\\xc3\\xb4\\xff\\xe4"),
|
|
(b"ascii", "ascii"),
|
|
(u"αρά".encode("utf-8"), "\\xce\\xb1\\xcf\\x81\\xce\\xac"),
|
|
]
|
|
for val, expected in values:
|
|
assert _idval(val, "a", 6, None) == expected
|
|
|
|
def test_class_or_function_idval(self):
|
|
"""unittest for the expected behavior to obtain ids for parametrized
|
|
values that are classes or functions: their __name__.
|
|
"""
|
|
from _pytest.python import _idval
|
|
|
|
class TestClass(object):
|
|
pass
|
|
|
|
def test_function():
|
|
pass
|
|
|
|
values = [(TestClass, "TestClass"), (test_function, "test_function")]
|
|
for val, expected in values:
|
|
assert _idval(val, "a", 6, None) == expected
|
|
|
|
@pytest.mark.issue250
|
|
def test_idmaker_autoname(self):
|
|
from _pytest.python import idmaker
|
|
|
|
result = idmaker(
|
|
("a", "b"), [pytest.param("string", 1.0), pytest.param("st-ring", 2.0)]
|
|
)
|
|
assert result == ["string-1.0", "st-ring-2.0"]
|
|
|
|
result = idmaker(
|
|
("a", "b"), [pytest.param(object(), 1.0), pytest.param(object(), object())]
|
|
)
|
|
assert result == ["a0-1.0", "a1-b1"]
|
|
# unicode mixing, issue250
|
|
result = idmaker(
|
|
(py.builtin._totext("a"), "b"), [pytest.param({}, b"\xc3\xb4")]
|
|
)
|
|
assert result == ["a0-\\xc3\\xb4"]
|
|
|
|
def test_idmaker_with_bytes_regex(self):
|
|
from _pytest.python import idmaker
|
|
|
|
result = idmaker(("a"), [pytest.param(re.compile(b"foo"), 1.0)])
|
|
assert result == ["foo"]
|
|
|
|
def test_idmaker_native_strings(self):
|
|
from _pytest.python import idmaker
|
|
|
|
totext = py.builtin._totext
|
|
result = idmaker(
|
|
("a", "b"),
|
|
[
|
|
pytest.param(1.0, -1.1),
|
|
pytest.param(2, -202),
|
|
pytest.param("three", "three hundred"),
|
|
pytest.param(True, False),
|
|
pytest.param(None, None),
|
|
pytest.param(re.compile("foo"), re.compile("bar")),
|
|
pytest.param(str, int),
|
|
pytest.param(list("six"), [66, 66]),
|
|
pytest.param({7}, set("seven")),
|
|
pytest.param(tuple("eight"), (8, -8, 8)),
|
|
pytest.param(b"\xc3\xb4", b"name"),
|
|
pytest.param(b"\xc3\xb4", totext("other")),
|
|
],
|
|
)
|
|
assert result == [
|
|
"1.0--1.1",
|
|
"2--202",
|
|
"three-three hundred",
|
|
"True-False",
|
|
"None-None",
|
|
"foo-bar",
|
|
"str-int",
|
|
"a7-b7",
|
|
"a8-b8",
|
|
"a9-b9",
|
|
"\\xc3\\xb4-name",
|
|
"\\xc3\\xb4-other",
|
|
]
|
|
|
|
def test_idmaker_enum(self):
|
|
from _pytest.python import idmaker
|
|
|
|
enum = pytest.importorskip("enum")
|
|
e = enum.Enum("Foo", "one, two")
|
|
result = idmaker(("a", "b"), [pytest.param(e.one, e.two)])
|
|
assert result == ["Foo.one-Foo.two"]
|
|
|
|
@pytest.mark.issue351
|
|
def test_idmaker_idfn(self):
|
|
from _pytest.python import idmaker
|
|
|
|
def ids(val):
|
|
if isinstance(val, Exception):
|
|
return repr(val)
|
|
|
|
result = idmaker(
|
|
("a", "b"),
|
|
[
|
|
pytest.param(10.0, IndexError()),
|
|
pytest.param(20, KeyError()),
|
|
pytest.param("three", [1, 2, 3]),
|
|
],
|
|
idfn=ids,
|
|
)
|
|
assert result == ["10.0-IndexError()", "20-KeyError()", "three-b2"]
|
|
|
|
@pytest.mark.issue351
|
|
def test_idmaker_idfn_unique_names(self):
|
|
from _pytest.python import idmaker
|
|
|
|
def ids(val):
|
|
return "a"
|
|
|
|
result = idmaker(
|
|
("a", "b"),
|
|
[
|
|
pytest.param(10.0, IndexError()),
|
|
pytest.param(20, KeyError()),
|
|
pytest.param("three", [1, 2, 3]),
|
|
],
|
|
idfn=ids,
|
|
)
|
|
assert result == ["a-a0", "a-a1", "a-a2"]
|
|
|
|
@pytest.mark.issue351
|
|
def test_idmaker_idfn_exception(self):
|
|
from _pytest.python import idmaker
|
|
from _pytest.recwarn import WarningsRecorder
|
|
|
|
class BadIdsException(Exception):
|
|
pass
|
|
|
|
def ids(val):
|
|
raise BadIdsException("ids raised")
|
|
|
|
rec = WarningsRecorder()
|
|
with rec:
|
|
idmaker(
|
|
("a", "b"),
|
|
[
|
|
pytest.param(10.0, IndexError()),
|
|
pytest.param(20, KeyError()),
|
|
pytest.param("three", [1, 2, 3]),
|
|
],
|
|
idfn=ids,
|
|
)
|
|
|
|
assert [str(i.message) for i in rec.list] == [
|
|
"Raised while trying to determine id of parameter a at position 0."
|
|
"\nUpdate your code as this will raise an error in pytest-4.0.",
|
|
"Raised while trying to determine id of parameter b at position 0."
|
|
"\nUpdate your code as this will raise an error in pytest-4.0.",
|
|
"Raised while trying to determine id of parameter a at position 1."
|
|
"\nUpdate your code as this will raise an error in pytest-4.0.",
|
|
"Raised while trying to determine id of parameter b at position 1."
|
|
"\nUpdate your code as this will raise an error in pytest-4.0.",
|
|
"Raised while trying to determine id of parameter a at position 2."
|
|
"\nUpdate your code as this will raise an error in pytest-4.0.",
|
|
"Raised while trying to determine id of parameter b at position 2."
|
|
"\nUpdate your code as this will raise an error in pytest-4.0.",
|
|
]
|
|
|
|
def test_parametrize_ids_exception(self, testdir):
|
|
"""
|
|
:param testdir: the instance of Testdir class, a temporary
|
|
test directory.
|
|
"""
|
|
testdir.makepyfile(
|
|
"""
|
|
import pytest
|
|
|
|
def ids(arg):
|
|
raise Exception("bad ids")
|
|
|
|
@pytest.mark.parametrize("arg", ["a", "b"], ids=ids)
|
|
def test_foo(arg):
|
|
pass
|
|
"""
|
|
)
|
|
with pytest.warns(DeprecationWarning):
|
|
result = testdir.runpytest("--collect-only")
|
|
result.stdout.fnmatch_lines(
|
|
[
|
|
"<Module 'test_parametrize_ids_exception.py'>",
|
|
" <Function 'test_foo[a]'>",
|
|
" <Function 'test_foo[b]'>",
|
|
]
|
|
)
|
|
|
|
def test_idmaker_with_ids(self):
|
|
from _pytest.python import idmaker
|
|
|
|
result = idmaker(
|
|
("a", "b"), [pytest.param(1, 2), pytest.param(3, 4)], ids=["a", None]
|
|
)
|
|
assert result == ["a", "3-4"]
|
|
|
|
def test_idmaker_with_paramset_id(self):
|
|
from _pytest.python import idmaker
|
|
|
|
result = idmaker(
|
|
("a", "b"),
|
|
[pytest.param(1, 2, id="me"), pytest.param(3, 4, id="you")],
|
|
ids=["a", None],
|
|
)
|
|
assert result == ["me", "you"]
|
|
|
|
def test_idmaker_with_ids_unique_names(self):
|
|
from _pytest.python import idmaker
|
|
|
|
result = idmaker(
|
|
("a"), map(pytest.param, [1, 2, 3, 4, 5]), ids=["a", "a", "b", "c", "b"]
|
|
)
|
|
assert result == ["a0", "a1", "b0", "c", "b1"]
|
|
|
|
def test_addcall_and_parametrize(self):
|
|
def func(x, y):
|
|
pass
|
|
|
|
metafunc = self.Metafunc(func)
|
|
metafunc.addcall({"x": 1})
|
|
metafunc.parametrize("y", [2, 3])
|
|
assert len(metafunc._calls) == 2
|
|
assert metafunc._calls[0].funcargs == {"x": 1, "y": 2}
|
|
assert metafunc._calls[1].funcargs == {"x": 1, "y": 3}
|
|
assert metafunc._calls[0].id == "0-2"
|
|
assert metafunc._calls[1].id == "0-3"
|
|
|
|
@pytest.mark.issue714
|
|
def test_parametrize_indirect(self):
|
|
def func(x, y):
|
|
pass
|
|
|
|
metafunc = self.Metafunc(func)
|
|
metafunc.parametrize("x", [1], indirect=True)
|
|
metafunc.parametrize("y", [2, 3], indirect=True)
|
|
assert len(metafunc._calls) == 2
|
|
assert metafunc._calls[0].funcargs == {}
|
|
assert metafunc._calls[1].funcargs == {}
|
|
assert metafunc._calls[0].params == dict(x=1, y=2)
|
|
assert metafunc._calls[1].params == dict(x=1, y=3)
|
|
|
|
@pytest.mark.issue714
|
|
def test_parametrize_indirect_list(self):
|
|
def func(x, y):
|
|
pass
|
|
|
|
metafunc = self.Metafunc(func)
|
|
metafunc.parametrize("x, y", [("a", "b")], indirect=["x"])
|
|
assert metafunc._calls[0].funcargs == dict(y="b")
|
|
assert metafunc._calls[0].params == dict(x="a")
|
|
|
|
@pytest.mark.issue714
|
|
def test_parametrize_indirect_list_all(self):
|
|
def func(x, y):
|
|
pass
|
|
|
|
metafunc = self.Metafunc(func)
|
|
metafunc.parametrize("x, y", [("a", "b")], indirect=["x", "y"])
|
|
assert metafunc._calls[0].funcargs == {}
|
|
assert metafunc._calls[0].params == dict(x="a", y="b")
|
|
|
|
@pytest.mark.issue714
|
|
def test_parametrize_indirect_list_empty(self):
|
|
def func(x, y):
|
|
pass
|
|
|
|
metafunc = self.Metafunc(func)
|
|
metafunc.parametrize("x, y", [("a", "b")], indirect=[])
|
|
assert metafunc._calls[0].funcargs == dict(x="a", y="b")
|
|
assert metafunc._calls[0].params == {}
|
|
|
|
@pytest.mark.issue714
|
|
def test_parametrize_indirect_list_functional(self, testdir):
|
|
"""
|
|
Test parametrization with 'indirect' parameter applied on
|
|
particular arguments. As y is is direct, its value should
|
|
be used directly rather than being passed to the fixture
|
|
y.
|
|
|
|
:param testdir: the instance of Testdir class, a temporary
|
|
test directory.
|
|
"""
|
|
testdir.makepyfile(
|
|
"""
|
|
import pytest
|
|
@pytest.fixture(scope='function')
|
|
def x(request):
|
|
return request.param * 3
|
|
@pytest.fixture(scope='function')
|
|
def y(request):
|
|
return request.param * 2
|
|
@pytest.mark.parametrize('x, y', [('a', 'b')], indirect=['x'])
|
|
def test_simple(x,y):
|
|
assert len(x) == 3
|
|
assert len(y) == 1
|
|
"""
|
|
)
|
|
result = testdir.runpytest("-v")
|
|
result.stdout.fnmatch_lines(["*test_simple*a-b*", "*1 passed*"])
|
|
|
|
@pytest.mark.issue714
|
|
def test_parametrize_indirect_list_error(self, testdir):
|
|
def func(x, y):
|
|
pass
|
|
|
|
metafunc = self.Metafunc(func)
|
|
with pytest.raises(ValueError):
|
|
metafunc.parametrize("x, y", [("a", "b")], indirect=["x", "z"])
|
|
|
|
@pytest.mark.issue714
|
|
def test_parametrize_uses_no_fixture_error_indirect_false(self, testdir):
|
|
"""The 'uses no fixture' error tells the user at collection time
|
|
that the parametrize data they've set up doesn't correspond to the
|
|
fixtures in their test function, rather than silently ignoring this
|
|
and letting the test potentially pass.
|
|
"""
|
|
testdir.makepyfile(
|
|
"""
|
|
import pytest
|
|
|
|
@pytest.mark.parametrize('x, y', [('a', 'b')], indirect=False)
|
|
def test_simple(x):
|
|
assert len(x) == 3
|
|
"""
|
|
)
|
|
result = testdir.runpytest("--collect-only")
|
|
result.stdout.fnmatch_lines(["*uses no argument 'y'*"])
|
|
|
|
@pytest.mark.issue714
|
|
def test_parametrize_uses_no_fixture_error_indirect_true(self, testdir):
|
|
testdir.makepyfile(
|
|
"""
|
|
import pytest
|
|
@pytest.fixture(scope='function')
|
|
def x(request):
|
|
return request.param * 3
|
|
@pytest.fixture(scope='function')
|
|
def y(request):
|
|
return request.param * 2
|
|
|
|
@pytest.mark.parametrize('x, y', [('a', 'b')], indirect=True)
|
|
def test_simple(x):
|
|
assert len(x) == 3
|
|
"""
|
|
)
|
|
result = testdir.runpytest("--collect-only")
|
|
result.stdout.fnmatch_lines(["*uses no fixture 'y'*"])
|
|
|
|
@pytest.mark.issue714
|
|
def test_parametrize_indirect_uses_no_fixture_error_indirect_string(self, testdir):
|
|
testdir.makepyfile(
|
|
"""
|
|
import pytest
|
|
@pytest.fixture(scope='function')
|
|
def x(request):
|
|
return request.param * 3
|
|
|
|
@pytest.mark.parametrize('x, y', [('a', 'b')], indirect='y')
|
|
def test_simple(x):
|
|
assert len(x) == 3
|
|
"""
|
|
)
|
|
result = testdir.runpytest("--collect-only")
|
|
result.stdout.fnmatch_lines(["*uses no fixture 'y'*"])
|
|
|
|
@pytest.mark.issue714
|
|
def test_parametrize_indirect_uses_no_fixture_error_indirect_list(self, testdir):
|
|
testdir.makepyfile(
|
|
"""
|
|
import pytest
|
|
@pytest.fixture(scope='function')
|
|
def x(request):
|
|
return request.param * 3
|
|
|
|
@pytest.mark.parametrize('x, y', [('a', 'b')], indirect=['y'])
|
|
def test_simple(x):
|
|
assert len(x) == 3
|
|
"""
|
|
)
|
|
result = testdir.runpytest("--collect-only")
|
|
result.stdout.fnmatch_lines(["*uses no fixture 'y'*"])
|
|
|
|
@pytest.mark.issue714
|
|
def test_parametrize_argument_not_in_indirect_list(self, testdir):
|
|
testdir.makepyfile(
|
|
"""
|
|
import pytest
|
|
@pytest.fixture(scope='function')
|
|
def x(request):
|
|
return request.param * 3
|
|
|
|
@pytest.mark.parametrize('x, y', [('a', 'b')], indirect=['x'])
|
|
def test_simple(x):
|
|
assert len(x) == 3
|
|
"""
|
|
)
|
|
result = testdir.runpytest("--collect-only")
|
|
result.stdout.fnmatch_lines(["*uses no argument 'y'*"])
|
|
|
|
def test_parametrize_gives_indicative_error_on_function_with_default_argument(
|
|
self, testdir
|
|
):
|
|
testdir.makepyfile(
|
|
"""
|
|
import pytest
|
|
|
|
@pytest.mark.parametrize('x, y', [('a', 'b')])
|
|
def test_simple(x, y=1):
|
|
assert len(x) == 1
|
|
"""
|
|
)
|
|
result = testdir.runpytest("--collect-only")
|
|
result.stdout.fnmatch_lines(
|
|
["*already takes an argument 'y' with a default value"]
|
|
)
|
|
|
|
def test_addcalls_and_parametrize_indirect(self):
|
|
def func(x, y):
|
|
pass
|
|
|
|
metafunc = self.Metafunc(func)
|
|
metafunc.addcall(param="123")
|
|
metafunc.parametrize("x", [1], indirect=True)
|
|
metafunc.parametrize("y", [2, 3], indirect=True)
|
|
assert len(metafunc._calls) == 2
|
|
assert metafunc._calls[0].funcargs == {}
|
|
assert metafunc._calls[1].funcargs == {}
|
|
assert metafunc._calls[0].params == dict(x=1, y=2)
|
|
assert metafunc._calls[1].params == dict(x=1, y=3)
|
|
|
|
def test_parametrize_functional(self, testdir):
|
|
testdir.makepyfile(
|
|
"""
|
|
import pytest
|
|
def pytest_generate_tests(metafunc):
|
|
metafunc.parametrize('x', [1,2], indirect=True)
|
|
metafunc.parametrize('y', [2])
|
|
@pytest.fixture
|
|
def x(request):
|
|
return request.param * 10
|
|
|
|
def test_simple(x,y):
|
|
assert x in (10,20)
|
|
assert y == 2
|
|
"""
|
|
)
|
|
result = testdir.runpytest("-v")
|
|
result.stdout.fnmatch_lines(
|
|
["*test_simple*1-2*", "*test_simple*2-2*", "*2 passed*"]
|
|
)
|
|
|
|
def test_parametrize_onearg(self):
|
|
metafunc = self.Metafunc(lambda x: None)
|
|
metafunc.parametrize("x", [1, 2])
|
|
assert len(metafunc._calls) == 2
|
|
assert metafunc._calls[0].funcargs == dict(x=1)
|
|
assert metafunc._calls[0].id == "1"
|
|
assert metafunc._calls[1].funcargs == dict(x=2)
|
|
assert metafunc._calls[1].id == "2"
|
|
|
|
def test_parametrize_onearg_indirect(self):
|
|
metafunc = self.Metafunc(lambda x: None)
|
|
metafunc.parametrize("x", [1, 2], indirect=True)
|
|
assert metafunc._calls[0].params == dict(x=1)
|
|
assert metafunc._calls[0].id == "1"
|
|
assert metafunc._calls[1].params == dict(x=2)
|
|
assert metafunc._calls[1].id == "2"
|
|
|
|
def test_parametrize_twoargs(self):
|
|
metafunc = self.Metafunc(lambda x, y: None)
|
|
metafunc.parametrize(("x", "y"), [(1, 2), (3, 4)])
|
|
assert len(metafunc._calls) == 2
|
|
assert metafunc._calls[0].funcargs == dict(x=1, y=2)
|
|
assert metafunc._calls[0].id == "1-2"
|
|
assert metafunc._calls[1].funcargs == dict(x=3, y=4)
|
|
assert metafunc._calls[1].id == "3-4"
|
|
|
|
def test_parametrize_multiple_times(self, testdir):
|
|
testdir.makepyfile(
|
|
"""
|
|
import pytest
|
|
pytestmark = pytest.mark.parametrize("x", [1,2])
|
|
def test_func(x):
|
|
assert 0, x
|
|
class TestClass(object):
|
|
pytestmark = pytest.mark.parametrize("y", [3,4])
|
|
def test_meth(self, x, y):
|
|
assert 0, x
|
|
"""
|
|
)
|
|
result = testdir.runpytest()
|
|
assert result.ret == 1
|
|
result.assert_outcomes(failed=6)
|
|
|
|
def test_parametrize_CSV(self, testdir):
|
|
testdir.makepyfile(
|
|
"""
|
|
import pytest
|
|
@pytest.mark.parametrize("x, y,", [(1,2), (2,3)])
|
|
def test_func(x, y):
|
|
assert x+1 == y
|
|
"""
|
|
)
|
|
reprec = testdir.inline_run()
|
|
reprec.assertoutcome(passed=2)
|
|
|
|
def test_parametrize_class_scenarios(self, testdir):
|
|
testdir.makepyfile(
|
|
"""
|
|
# same as doc/en/example/parametrize scenario example
|
|
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")
|
|
|
|
class Test(object):
|
|
scenarios = [['1', {'arg': {1: 2}, "arg2": "value2"}],
|
|
['2', {'arg':'value2', "arg2": "value2"}]]
|
|
|
|
def test_1(self, arg, arg2):
|
|
pass
|
|
|
|
def test_2(self, arg2, arg):
|
|
pass
|
|
|
|
def test_3(self, arg, arg2):
|
|
pass
|
|
"""
|
|
)
|
|
result = testdir.runpytest("-v")
|
|
assert result.ret == 0
|
|
result.stdout.fnmatch_lines(
|
|
"""
|
|
*test_1*1*
|
|
*test_2*1*
|
|
*test_3*1*
|
|
*test_1*2*
|
|
*test_2*2*
|
|
*test_3*2*
|
|
*6 passed*
|
|
"""
|
|
)
|
|
|
|
def test_format_args(self):
|
|
def function1():
|
|
pass
|
|
|
|
assert fixtures._format_args(function1) == "()"
|
|
|
|
def function2(arg1):
|
|
pass
|
|
|
|
assert fixtures._format_args(function2) == "(arg1)"
|
|
|
|
def function3(arg1, arg2="qwe"):
|
|
pass
|
|
|
|
assert fixtures._format_args(function3) == "(arg1, arg2='qwe')"
|
|
|
|
def function4(arg1, *args, **kwargs):
|
|
pass
|
|
|
|
assert fixtures._format_args(function4) == "(arg1, *args, **kwargs)"
|
|
|
|
|
|
class TestMetafuncFunctional(object):
|
|
def test_attributes(self, testdir):
|
|
p = testdir.makepyfile(
|
|
"""
|
|
# assumes that generate/provide runs in the same process
|
|
import sys, pytest
|
|
def pytest_generate_tests(metafunc):
|
|
metafunc.addcall(param=metafunc)
|
|
|
|
@pytest.fixture
|
|
def metafunc(request):
|
|
assert request._pyfuncitem._genid == "0"
|
|
return request.param
|
|
|
|
def test_function(metafunc, pytestconfig):
|
|
assert metafunc.config == pytestconfig
|
|
assert metafunc.module.__name__ == __name__
|
|
assert metafunc.function == test_function
|
|
assert metafunc.cls is None
|
|
|
|
class TestClass(object):
|
|
def test_method(self, metafunc, pytestconfig):
|
|
assert metafunc.config == pytestconfig
|
|
assert metafunc.module.__name__ == __name__
|
|
if sys.version_info > (3, 0):
|
|
unbound = TestClass.test_method
|
|
else:
|
|
unbound = TestClass.test_method.im_func
|
|
# XXX actually have an unbound test function here?
|
|
assert metafunc.function == unbound
|
|
assert metafunc.cls == TestClass
|
|
"""
|
|
)
|
|
result = testdir.runpytest(p, "-v")
|
|
result.assert_outcomes(passed=2)
|
|
|
|
def test_addcall_with_two_funcargs_generators(self, testdir):
|
|
testdir.makeconftest(
|
|
"""
|
|
def pytest_generate_tests(metafunc):
|
|
assert "arg1" in metafunc.fixturenames
|
|
metafunc.addcall(funcargs=dict(arg1=1, arg2=2))
|
|
"""
|
|
)
|
|
p = testdir.makepyfile(
|
|
"""
|
|
def pytest_generate_tests(metafunc):
|
|
metafunc.addcall(funcargs=dict(arg1=1, arg2=1))
|
|
|
|
class TestClass(object):
|
|
def test_myfunc(self, arg1, arg2):
|
|
assert arg1 == arg2
|
|
"""
|
|
)
|
|
result = testdir.runpytest("-v", p)
|
|
result.stdout.fnmatch_lines(
|
|
["*test_myfunc*0*PASS*", "*test_myfunc*1*FAIL*", "*1 failed, 1 passed*"]
|
|
)
|
|
|
|
def test_two_functions(self, testdir):
|
|
p = testdir.makepyfile(
|
|
"""
|
|
def pytest_generate_tests(metafunc):
|
|
metafunc.addcall(param=10)
|
|
metafunc.addcall(param=20)
|
|
|
|
import pytest
|
|
@pytest.fixture
|
|
def arg1(request):
|
|
return request.param
|
|
|
|
def test_func1(arg1):
|
|
assert arg1 == 10
|
|
def test_func2(arg1):
|
|
assert arg1 in (10, 20)
|
|
"""
|
|
)
|
|
result = testdir.runpytest("-v", p)
|
|
result.stdout.fnmatch_lines(
|
|
[
|
|
"*test_func1*0*PASS*",
|
|
"*test_func1*1*FAIL*",
|
|
"*test_func2*PASS*",
|
|
"*1 failed, 3 passed*",
|
|
]
|
|
)
|
|
|
|
def test_noself_in_method(self, testdir):
|
|
p = testdir.makepyfile(
|
|
"""
|
|
def pytest_generate_tests(metafunc):
|
|
assert 'xyz' not in metafunc.fixturenames
|
|
|
|
class TestHello(object):
|
|
def test_hello(xyz):
|
|
pass
|
|
"""
|
|
)
|
|
result = testdir.runpytest(p)
|
|
result.assert_outcomes(passed=1)
|
|
|
|
def test_generate_plugin_and_module(self, testdir):
|
|
testdir.makeconftest(
|
|
"""
|
|
def pytest_generate_tests(metafunc):
|
|
assert "arg1" in metafunc.fixturenames
|
|
metafunc.addcall(id="world", param=(2,100))
|
|
"""
|
|
)
|
|
p = testdir.makepyfile(
|
|
"""
|
|
def pytest_generate_tests(metafunc):
|
|
metafunc.addcall(param=(1,1), id="hello")
|
|
|
|
import pytest
|
|
@pytest.fixture
|
|
def arg1(request):
|
|
return request.param[0]
|
|
@pytest.fixture
|
|
def arg2(request):
|
|
return request.param[1]
|
|
|
|
class TestClass(object):
|
|
def test_myfunc(self, arg1, arg2):
|
|
assert arg1 == arg2
|
|
"""
|
|
)
|
|
result = testdir.runpytest("-v", p)
|
|
result.stdout.fnmatch_lines(
|
|
[
|
|
"*test_myfunc*hello*PASS*",
|
|
"*test_myfunc*world*FAIL*",
|
|
"*1 failed, 1 passed*",
|
|
]
|
|
)
|
|
|
|
def test_generate_tests_in_class(self, testdir):
|
|
p = testdir.makepyfile(
|
|
"""
|
|
class TestClass(object):
|
|
def pytest_generate_tests(self, metafunc):
|
|
metafunc.addcall(funcargs={'hello': 'world'}, id="hello")
|
|
|
|
def test_myfunc(self, hello):
|
|
assert hello == "world"
|
|
"""
|
|
)
|
|
result = testdir.runpytest("-v", p)
|
|
result.stdout.fnmatch_lines(["*test_myfunc*hello*PASS*", "*1 passed*"])
|
|
|
|
def test_two_functions_not_same_instance(self, testdir):
|
|
p = testdir.makepyfile(
|
|
"""
|
|
def pytest_generate_tests(metafunc):
|
|
metafunc.addcall({'arg1': 10})
|
|
metafunc.addcall({'arg1': 20})
|
|
|
|
class TestClass(object):
|
|
def test_func(self, arg1):
|
|
assert not hasattr(self, 'x')
|
|
self.x = 1
|
|
"""
|
|
)
|
|
result = testdir.runpytest("-v", p)
|
|
result.stdout.fnmatch_lines(
|
|
["*test_func*0*PASS*", "*test_func*1*PASS*", "*2 pass*"]
|
|
)
|
|
|
|
def test_issue28_setup_method_in_generate_tests(self, testdir):
|
|
p = testdir.makepyfile(
|
|
"""
|
|
def pytest_generate_tests(metafunc):
|
|
metafunc.addcall({'arg1': 1})
|
|
|
|
class TestClass(object):
|
|
def test_method(self, arg1):
|
|
assert arg1 == self.val
|
|
def setup_method(self, func):
|
|
self.val = 1
|
|
"""
|
|
)
|
|
result = testdir.runpytest(p)
|
|
result.assert_outcomes(passed=1)
|
|
|
|
def test_parametrize_functional2(self, testdir):
|
|
testdir.makepyfile(
|
|
"""
|
|
def pytest_generate_tests(metafunc):
|
|
metafunc.parametrize("arg1", [1,2])
|
|
metafunc.parametrize("arg2", [4,5])
|
|
def test_hello(arg1, arg2):
|
|
assert 0, (arg1, arg2)
|
|
"""
|
|
)
|
|
result = testdir.runpytest()
|
|
result.stdout.fnmatch_lines(
|
|
["*(1, 4)*", "*(1, 5)*", "*(2, 4)*", "*(2, 5)*", "*4 failed*"]
|
|
)
|
|
|
|
def test_parametrize_and_inner_getfixturevalue(self, testdir):
|
|
p = testdir.makepyfile(
|
|
"""
|
|
def pytest_generate_tests(metafunc):
|
|
metafunc.parametrize("arg1", [1], indirect=True)
|
|
metafunc.parametrize("arg2", [10], indirect=True)
|
|
|
|
import pytest
|
|
@pytest.fixture
|
|
def arg1(request):
|
|
x = request.getfixturevalue("arg2")
|
|
return x + request.param
|
|
|
|
@pytest.fixture
|
|
def arg2(request):
|
|
return request.param
|
|
|
|
def test_func1(arg1, arg2):
|
|
assert arg1 == 11
|
|
"""
|
|
)
|
|
result = testdir.runpytest("-v", p)
|
|
result.stdout.fnmatch_lines(["*test_func1*1*PASS*", "*1 passed*"])
|
|
|
|
def test_parametrize_on_setup_arg(self, testdir):
|
|
p = testdir.makepyfile(
|
|
"""
|
|
def pytest_generate_tests(metafunc):
|
|
assert "arg1" in metafunc.fixturenames
|
|
metafunc.parametrize("arg1", [1], indirect=True)
|
|
|
|
import pytest
|
|
@pytest.fixture
|
|
def arg1(request):
|
|
return request.param
|
|
|
|
@pytest.fixture
|
|
def arg2(request, arg1):
|
|
return 10 * arg1
|
|
|
|
def test_func(arg2):
|
|
assert arg2 == 10
|
|
"""
|
|
)
|
|
result = testdir.runpytest("-v", p)
|
|
result.stdout.fnmatch_lines(["*test_func*1*PASS*", "*1 passed*"])
|
|
|
|
def test_parametrize_with_ids(self, testdir):
|
|
testdir.makeini(
|
|
"""
|
|
[pytest]
|
|
console_output_style=classic
|
|
"""
|
|
)
|
|
testdir.makepyfile(
|
|
"""
|
|
import pytest
|
|
def pytest_generate_tests(metafunc):
|
|
metafunc.parametrize(("a", "b"), [(1,1), (1,2)],
|
|
ids=["basic", "advanced"])
|
|
|
|
def test_function(a, b):
|
|
assert a == b
|
|
"""
|
|
)
|
|
result = testdir.runpytest("-v")
|
|
assert result.ret == 1
|
|
result.stdout.fnmatch_lines_random(
|
|
["*test_function*basic*PASSED", "*test_function*advanced*FAILED"]
|
|
)
|
|
|
|
def test_parametrize_without_ids(self, testdir):
|
|
testdir.makepyfile(
|
|
"""
|
|
import pytest
|
|
def pytest_generate_tests(metafunc):
|
|
metafunc.parametrize(("a", "b"),
|
|
[(1,object()), (1.3,object())])
|
|
|
|
def test_function(a, b):
|
|
assert 1
|
|
"""
|
|
)
|
|
result = testdir.runpytest("-v")
|
|
result.stdout.fnmatch_lines(
|
|
"""
|
|
*test_function*1-b0*
|
|
*test_function*1.3-b1*
|
|
"""
|
|
)
|
|
|
|
def test_parametrize_with_None_in_ids(self, testdir):
|
|
testdir.makepyfile(
|
|
"""
|
|
import pytest
|
|
def pytest_generate_tests(metafunc):
|
|
metafunc.parametrize(("a", "b"), [(1,1), (1,1), (1,2)],
|
|
ids=["basic", None, "advanced"])
|
|
|
|
def test_function(a, b):
|
|
assert a == b
|
|
"""
|
|
)
|
|
result = testdir.runpytest("-v")
|
|
assert result.ret == 1
|
|
result.stdout.fnmatch_lines_random(
|
|
[
|
|
"*test_function*basic*PASSED*",
|
|
"*test_function*1-1*PASSED*",
|
|
"*test_function*advanced*FAILED*",
|
|
]
|
|
)
|
|
|
|
def test_fixture_parametrized_empty_ids(self, testdir):
|
|
"""Fixtures parametrized with empty ids cause an internal error (#1849)."""
|
|
testdir.makepyfile(
|
|
"""
|
|
import pytest
|
|
|
|
@pytest.fixture(scope="module", ids=[], params=[])
|
|
def temp(request):
|
|
return request.param
|
|
|
|
def test_temp(temp):
|
|
pass
|
|
"""
|
|
)
|
|
result = testdir.runpytest()
|
|
result.stdout.fnmatch_lines(["* 1 skipped *"])
|
|
|
|
def test_parametrized_empty_ids(self, testdir):
|
|
"""Tests parametrized with empty ids cause an internal error (#1849)."""
|
|
testdir.makepyfile(
|
|
"""
|
|
import pytest
|
|
|
|
@pytest.mark.parametrize('temp', [], ids=list())
|
|
def test_temp(temp):
|
|
pass
|
|
"""
|
|
)
|
|
result = testdir.runpytest()
|
|
result.stdout.fnmatch_lines(["* 1 skipped *"])
|
|
|
|
def test_parametrized_ids_invalid_type(self, testdir):
|
|
"""Tests parametrized with ids as non-strings (#1857)."""
|
|
testdir.makepyfile(
|
|
"""
|
|
import pytest
|
|
|
|
@pytest.mark.parametrize("x, expected", [(10, 20), (40, 80)], ids=(None, 2))
|
|
def test_ids_numbers(x,expected):
|
|
assert x * 2 == expected
|
|
"""
|
|
)
|
|
result = testdir.runpytest()
|
|
result.stdout.fnmatch_lines(
|
|
["*ids must be list of strings, found: 2 (type: int)*"]
|
|
)
|
|
|
|
def test_parametrize_with_identical_ids_get_unique_names(self, testdir):
|
|
testdir.makepyfile(
|
|
"""
|
|
import pytest
|
|
def pytest_generate_tests(metafunc):
|
|
metafunc.parametrize(("a", "b"), [(1,1), (1,2)],
|
|
ids=["a", "a"])
|
|
|
|
def test_function(a, b):
|
|
assert a == b
|
|
"""
|
|
)
|
|
result = testdir.runpytest("-v")
|
|
assert result.ret == 1
|
|
result.stdout.fnmatch_lines_random(
|
|
["*test_function*a0*PASSED*", "*test_function*a1*FAILED*"]
|
|
)
|
|
|
|
@pytest.mark.parametrize(("scope", "length"), [("module", 2), ("function", 4)])
|
|
def test_parametrize_scope_overrides(self, testdir, scope, length):
|
|
testdir.makepyfile(
|
|
"""
|
|
import pytest
|
|
values = []
|
|
def pytest_generate_tests(metafunc):
|
|
if "arg" in metafunc.funcargnames:
|
|
metafunc.parametrize("arg", [1,2], indirect=True,
|
|
scope=%r)
|
|
@pytest.fixture
|
|
def arg(request):
|
|
values.append(request.param)
|
|
return request.param
|
|
def test_hello(arg):
|
|
assert arg in (1,2)
|
|
def test_world(arg):
|
|
assert arg in (1,2)
|
|
def test_checklength():
|
|
assert len(values) == %d
|
|
"""
|
|
% (scope, length)
|
|
)
|
|
reprec = testdir.inline_run()
|
|
reprec.assertoutcome(passed=5)
|
|
|
|
def test_parametrize_issue323(self, testdir):
|
|
testdir.makepyfile(
|
|
"""
|
|
import pytest
|
|
|
|
@pytest.fixture(scope='module', params=range(966))
|
|
def foo(request):
|
|
return request.param
|
|
|
|
def test_it(foo):
|
|
pass
|
|
def test_it2(foo):
|
|
pass
|
|
"""
|
|
)
|
|
reprec = testdir.inline_run("--collect-only")
|
|
assert not reprec.getcalls("pytest_internalerror")
|
|
|
|
def test_usefixtures_seen_in_generate_tests(self, testdir):
|
|
testdir.makepyfile(
|
|
"""
|
|
import pytest
|
|
def pytest_generate_tests(metafunc):
|
|
assert "abc" in metafunc.fixturenames
|
|
metafunc.parametrize("abc", [1])
|
|
|
|
@pytest.mark.usefixtures("abc")
|
|
def test_function():
|
|
pass
|
|
"""
|
|
)
|
|
reprec = testdir.runpytest()
|
|
reprec.assert_outcomes(passed=1)
|
|
|
|
def test_generate_tests_only_done_in_subdir(self, testdir):
|
|
sub1 = testdir.mkpydir("sub1")
|
|
sub2 = testdir.mkpydir("sub2")
|
|
sub1.join("conftest.py").write(
|
|
_pytest._code.Source(
|
|
"""
|
|
def pytest_generate_tests(metafunc):
|
|
assert metafunc.function.__name__ == "test_1"
|
|
"""
|
|
)
|
|
)
|
|
sub2.join("conftest.py").write(
|
|
_pytest._code.Source(
|
|
"""
|
|
def pytest_generate_tests(metafunc):
|
|
assert metafunc.function.__name__ == "test_2"
|
|
"""
|
|
)
|
|
)
|
|
sub1.join("test_in_sub1.py").write("def test_1(): pass")
|
|
sub2.join("test_in_sub2.py").write("def test_2(): pass")
|
|
result = testdir.runpytest("--keep-duplicates", "-v", "-s", sub1, sub2, sub1)
|
|
result.assert_outcomes(passed=3)
|
|
|
|
def test_generate_same_function_names_issue403(self, testdir):
|
|
testdir.makepyfile(
|
|
"""
|
|
import pytest
|
|
|
|
def make_tests():
|
|
@pytest.mark.parametrize("x", range(2))
|
|
def test_foo(x):
|
|
pass
|
|
return test_foo
|
|
|
|
test_x = make_tests()
|
|
test_y = make_tests()
|
|
"""
|
|
)
|
|
reprec = testdir.runpytest()
|
|
reprec.assert_outcomes(passed=4)
|
|
|
|
@pytest.mark.issue463
|
|
@pytest.mark.parametrize("attr", ["parametrise", "parameterize", "parameterise"])
|
|
def test_parametrize_misspelling(self, testdir, attr):
|
|
testdir.makepyfile(
|
|
"""
|
|
import pytest
|
|
|
|
@pytest.mark.{}("x", range(2))
|
|
def test_foo(x):
|
|
pass
|
|
""".format(
|
|
attr
|
|
)
|
|
)
|
|
reprec = testdir.inline_run("--collectonly")
|
|
failures = reprec.getfailures()
|
|
assert len(failures) == 1
|
|
expectederror = "MarkerError: test_foo has '{}', spelling should be 'parametrize'".format(
|
|
attr
|
|
)
|
|
assert expectederror in failures[0].longrepr.reprcrash.message
|
|
|
|
|
|
class TestMetafuncFunctionalAuto(object):
|
|
"""
|
|
Tests related to automatically find out the correct scope for parametrized tests (#1832).
|
|
"""
|
|
|
|
def test_parametrize_auto_scope(self, testdir):
|
|
testdir.makepyfile(
|
|
"""
|
|
import pytest
|
|
|
|
@pytest.fixture(scope='session', autouse=True)
|
|
def fixture():
|
|
return 1
|
|
|
|
@pytest.mark.parametrize('animal', ["dog", "cat"])
|
|
def test_1(animal):
|
|
assert animal in ('dog', 'cat')
|
|
|
|
@pytest.mark.parametrize('animal', ['fish'])
|
|
def test_2(animal):
|
|
assert animal == 'fish'
|
|
|
|
"""
|
|
)
|
|
result = testdir.runpytest()
|
|
result.stdout.fnmatch_lines(["* 3 passed *"])
|
|
|
|
def test_parametrize_auto_scope_indirect(self, testdir):
|
|
testdir.makepyfile(
|
|
"""
|
|
import pytest
|
|
|
|
@pytest.fixture(scope='session')
|
|
def echo(request):
|
|
return request.param
|
|
|
|
@pytest.mark.parametrize('animal, echo', [("dog", 1), ("cat", 2)], indirect=['echo'])
|
|
def test_1(animal, echo):
|
|
assert animal in ('dog', 'cat')
|
|
assert echo in (1, 2, 3)
|
|
|
|
@pytest.mark.parametrize('animal, echo', [('fish', 3)], indirect=['echo'])
|
|
def test_2(animal, echo):
|
|
assert animal == 'fish'
|
|
assert echo in (1, 2, 3)
|
|
"""
|
|
)
|
|
result = testdir.runpytest()
|
|
result.stdout.fnmatch_lines(["* 3 passed *"])
|
|
|
|
def test_parametrize_auto_scope_override_fixture(self, testdir):
|
|
testdir.makepyfile(
|
|
"""
|
|
import pytest
|
|
|
|
@pytest.fixture(scope='session', autouse=True)
|
|
def animal():
|
|
return 'fox'
|
|
|
|
@pytest.mark.parametrize('animal', ["dog", "cat"])
|
|
def test_1(animal):
|
|
assert animal in ('dog', 'cat')
|
|
"""
|
|
)
|
|
result = testdir.runpytest()
|
|
result.stdout.fnmatch_lines(["* 2 passed *"])
|
|
|
|
def test_parametrize_all_indirects(self, testdir):
|
|
testdir.makepyfile(
|
|
"""
|
|
import pytest
|
|
|
|
@pytest.fixture()
|
|
def animal(request):
|
|
return request.param
|
|
|
|
@pytest.fixture(scope='session')
|
|
def echo(request):
|
|
return request.param
|
|
|
|
@pytest.mark.parametrize('animal, echo', [("dog", 1), ("cat", 2)], indirect=True)
|
|
def test_1(animal, echo):
|
|
assert animal in ('dog', 'cat')
|
|
assert echo in (1, 2, 3)
|
|
|
|
@pytest.mark.parametrize('animal, echo', [("fish", 3)], indirect=True)
|
|
def test_2(animal, echo):
|
|
assert animal == 'fish'
|
|
assert echo in (1, 2, 3)
|
|
"""
|
|
)
|
|
result = testdir.runpytest()
|
|
result.stdout.fnmatch_lines(["* 3 passed *"])
|
|
|
|
def test_parametrize_issue634(self, testdir):
|
|
testdir.makepyfile(
|
|
"""
|
|
import pytest
|
|
|
|
@pytest.fixture(scope='module')
|
|
def foo(request):
|
|
print('preparing foo-%d' % request.param)
|
|
return 'foo-%d' % request.param
|
|
|
|
def test_one(foo):
|
|
pass
|
|
|
|
def test_two(foo):
|
|
pass
|
|
|
|
test_two.test_with = (2, 3)
|
|
|
|
def pytest_generate_tests(metafunc):
|
|
params = (1, 2, 3, 4)
|
|
if not 'foo' in metafunc.fixturenames:
|
|
return
|
|
|
|
test_with = getattr(metafunc.function, 'test_with', None)
|
|
if test_with:
|
|
params = test_with
|
|
metafunc.parametrize('foo', params, indirect=True)
|
|
"""
|
|
)
|
|
result = testdir.runpytest("-s")
|
|
output = result.stdout.str()
|
|
assert output.count("preparing foo-2") == 1
|
|
assert output.count("preparing foo-3") == 1
|
|
|
|
|
|
@pytest.mark.filterwarnings("ignore:Applying marks directly to parameters")
|
|
@pytest.mark.issue308
|
|
class TestMarkersWithParametrization(object):
|
|
def test_simple_mark(self, testdir):
|
|
s = """
|
|
import pytest
|
|
|
|
@pytest.mark.foo
|
|
@pytest.mark.parametrize(("n", "expected"), [
|
|
(1, 2),
|
|
pytest.mark.bar((1, 3)),
|
|
(2, 3),
|
|
])
|
|
def test_increment(n, expected):
|
|
assert n + 1 == expected
|
|
"""
|
|
items = testdir.getitems(s)
|
|
assert len(items) == 3
|
|
for item in items:
|
|
assert "foo" in item.keywords
|
|
assert "bar" not in items[0].keywords
|
|
assert "bar" in items[1].keywords
|
|
assert "bar" not in items[2].keywords
|
|
|
|
def test_select_based_on_mark(self, testdir):
|
|
s = """
|
|
import pytest
|
|
|
|
@pytest.mark.parametrize(("n", "expected"), [
|
|
(1, 2),
|
|
pytest.mark.foo((2, 3)),
|
|
(3, 4),
|
|
])
|
|
def test_increment(n, expected):
|
|
assert n + 1 == expected
|
|
"""
|
|
testdir.makepyfile(s)
|
|
rec = testdir.inline_run("-m", "foo")
|
|
passed, skipped, fail = rec.listoutcomes()
|
|
assert len(passed) == 1
|
|
assert len(skipped) == 0
|
|
assert len(fail) == 0
|
|
|
|
@pytest.mark.xfail(reason="is this important to support??")
|
|
def test_nested_marks(self, testdir):
|
|
s = """
|
|
import pytest
|
|
mastermark = pytest.mark.foo(pytest.mark.bar)
|
|
|
|
@pytest.mark.parametrize(("n", "expected"), [
|
|
(1, 2),
|
|
mastermark((1, 3)),
|
|
(2, 3),
|
|
])
|
|
def test_increment(n, expected):
|
|
assert n + 1 == expected
|
|
"""
|
|
items = testdir.getitems(s)
|
|
assert len(items) == 3
|
|
for mark in ["foo", "bar"]:
|
|
assert mark not in items[0].keywords
|
|
assert mark in items[1].keywords
|
|
assert mark not in items[2].keywords
|
|
|
|
def test_simple_xfail(self, testdir):
|
|
s = """
|
|
import pytest
|
|
|
|
@pytest.mark.parametrize(("n", "expected"), [
|
|
(1, 2),
|
|
pytest.mark.xfail((1, 3)),
|
|
(2, 3),
|
|
])
|
|
def test_increment(n, expected):
|
|
assert n + 1 == expected
|
|
"""
|
|
testdir.makepyfile(s)
|
|
reprec = testdir.inline_run()
|
|
# xfail is skip??
|
|
reprec.assertoutcome(passed=2, skipped=1)
|
|
|
|
def test_simple_xfail_single_argname(self, testdir):
|
|
s = """
|
|
import pytest
|
|
|
|
@pytest.mark.parametrize("n", [
|
|
2,
|
|
pytest.mark.xfail(3),
|
|
4,
|
|
])
|
|
def test_isEven(n):
|
|
assert n % 2 == 0
|
|
"""
|
|
testdir.makepyfile(s)
|
|
reprec = testdir.inline_run()
|
|
reprec.assertoutcome(passed=2, skipped=1)
|
|
|
|
def test_xfail_with_arg(self, testdir):
|
|
s = """
|
|
import pytest
|
|
|
|
@pytest.mark.parametrize(("n", "expected"), [
|
|
(1, 2),
|
|
pytest.mark.xfail("True")((1, 3)),
|
|
(2, 3),
|
|
])
|
|
def test_increment(n, expected):
|
|
assert n + 1 == expected
|
|
"""
|
|
testdir.makepyfile(s)
|
|
reprec = testdir.inline_run()
|
|
reprec.assertoutcome(passed=2, skipped=1)
|
|
|
|
def test_xfail_with_kwarg(self, testdir):
|
|
s = """
|
|
import pytest
|
|
|
|
@pytest.mark.parametrize(("n", "expected"), [
|
|
(1, 2),
|
|
pytest.mark.xfail(reason="some bug")((1, 3)),
|
|
(2, 3),
|
|
])
|
|
def test_increment(n, expected):
|
|
assert n + 1 == expected
|
|
"""
|
|
testdir.makepyfile(s)
|
|
reprec = testdir.inline_run()
|
|
reprec.assertoutcome(passed=2, skipped=1)
|
|
|
|
def test_xfail_with_arg_and_kwarg(self, testdir):
|
|
s = """
|
|
import pytest
|
|
|
|
@pytest.mark.parametrize(("n", "expected"), [
|
|
(1, 2),
|
|
pytest.mark.xfail("True", reason="some bug")((1, 3)),
|
|
(2, 3),
|
|
])
|
|
def test_increment(n, expected):
|
|
assert n + 1 == expected
|
|
"""
|
|
testdir.makepyfile(s)
|
|
reprec = testdir.inline_run()
|
|
reprec.assertoutcome(passed=2, skipped=1)
|
|
|
|
@pytest.mark.parametrize("strict", [True, False])
|
|
def test_xfail_passing_is_xpass(self, testdir, strict):
|
|
s = """
|
|
import pytest
|
|
|
|
@pytest.mark.parametrize(("n", "expected"), [
|
|
(1, 2),
|
|
pytest.mark.xfail("sys.version_info > (0, 0, 0)", reason="some bug", strict={strict})((2, 3)),
|
|
(3, 4),
|
|
])
|
|
def test_increment(n, expected):
|
|
assert n + 1 == expected
|
|
""".format(
|
|
strict=strict
|
|
)
|
|
testdir.makepyfile(s)
|
|
reprec = testdir.inline_run()
|
|
passed, failed = (2, 1) if strict else (3, 0)
|
|
reprec.assertoutcome(passed=passed, failed=failed)
|
|
|
|
def test_parametrize_called_in_generate_tests(self, testdir):
|
|
s = """
|
|
import pytest
|
|
|
|
|
|
def pytest_generate_tests(metafunc):
|
|
passingTestData = [(1, 2),
|
|
(2, 3)]
|
|
failingTestData = [(1, 3),
|
|
(2, 2)]
|
|
|
|
testData = passingTestData + [pytest.mark.xfail(d)
|
|
for d in failingTestData]
|
|
metafunc.parametrize(("n", "expected"), testData)
|
|
|
|
|
|
def test_increment(n, expected):
|
|
assert n + 1 == expected
|
|
"""
|
|
testdir.makepyfile(s)
|
|
reprec = testdir.inline_run()
|
|
reprec.assertoutcome(passed=2, skipped=2)
|
|
|
|
@pytest.mark.issue290
|
|
def test_parametrize_ID_generation_string_int_works(self, testdir):
|
|
testdir.makepyfile(
|
|
"""
|
|
import pytest
|
|
|
|
@pytest.fixture
|
|
def myfixture():
|
|
return 'example'
|
|
@pytest.mark.parametrize(
|
|
'limit', (0, '0'))
|
|
def test_limit(limit, myfixture):
|
|
return
|
|
"""
|
|
)
|
|
reprec = testdir.inline_run()
|
|
reprec.assertoutcome(passed=2)
|
|
|
|
@pytest.mark.parametrize("strict", [True, False])
|
|
def test_parametrize_marked_value(self, testdir, strict):
|
|
s = """
|
|
import pytest
|
|
|
|
@pytest.mark.parametrize(("n", "expected"), [
|
|
pytest.param(
|
|
2,3,
|
|
marks=pytest.mark.xfail("sys.version_info > (0, 0, 0)", reason="some bug", strict={strict}),
|
|
),
|
|
pytest.param(
|
|
2,3,
|
|
marks=[pytest.mark.xfail("sys.version_info > (0, 0, 0)", reason="some bug", strict={strict})],
|
|
),
|
|
])
|
|
def test_increment(n, expected):
|
|
assert n + 1 == expected
|
|
""".format(
|
|
strict=strict
|
|
)
|
|
testdir.makepyfile(s)
|
|
reprec = testdir.inline_run()
|
|
passed, failed = (0, 2) if strict else (2, 0)
|
|
reprec.assertoutcome(passed=passed, failed=failed)
|
|
|
|
def test_pytest_make_parametrize_id(self, testdir):
|
|
testdir.makeconftest(
|
|
"""
|
|
def pytest_make_parametrize_id(config, val):
|
|
return str(val * 2)
|
|
"""
|
|
)
|
|
testdir.makepyfile(
|
|
"""
|
|
import pytest
|
|
|
|
@pytest.mark.parametrize("x", range(2))
|
|
def test_func(x):
|
|
pass
|
|
"""
|
|
)
|
|
result = testdir.runpytest("-v")
|
|
result.stdout.fnmatch_lines(["*test_func*0*PASS*", "*test_func*2*PASS*"])
|
|
|
|
def test_pytest_make_parametrize_id_with_argname(self, testdir):
|
|
testdir.makeconftest(
|
|
"""
|
|
def pytest_make_parametrize_id(config, val, argname):
|
|
return str(val * 2 if argname == 'x' else val * 10)
|
|
"""
|
|
)
|
|
testdir.makepyfile(
|
|
"""
|
|
import pytest
|
|
|
|
@pytest.mark.parametrize("x", range(2))
|
|
def test_func_a(x):
|
|
pass
|
|
|
|
@pytest.mark.parametrize("y", [1])
|
|
def test_func_b(y):
|
|
pass
|
|
"""
|
|
)
|
|
result = testdir.runpytest("-v")
|
|
result.stdout.fnmatch_lines(
|
|
["*test_func_a*0*PASS*", "*test_func_a*2*PASS*", "*test_func_b*10*PASS*"]
|
|
)
|