# Authors: Sylvain MARIE <*****@*****.**>
# + All contributors to <https://github.com/smarie/python-pytest-cases>
#
# License: 3-clause BSD, <https://github.com/smarie/python-pytest-cases/blob/master/LICENSE>
from pytest_cases import param_fixture, fixture_union
a = param_fixture("a", [1, 2])
b = param_fixture("b", [3, 4])
my_explicit = fixture_union('my_explicit', ['a', b], idstyle='explicit')
my_compact = fixture_union('my_compact',
['a', b]) # , idstyle='compact' is the default now
my_none = fixture_union('my_none', ['a', b], idstyle=None)
my_custom_list = fixture_union('my_custom_list', ['a', b], ids=['c=A', 'c=B'])
def my_gen(o):
return str(o)
my_custom_gen = fixture_union('my_custom_gen', ['a', b], ids=my_gen)
class TestA:
def test_ids_explicit(self, my_explicit):
pass
def test_ids_compact(my_compact):
pass
# discarded: 'base', 'entry_points', 'entry_points_annotations', 'entry_points_inline', 'utils_string', 'utils_typing'
submodules = ['composition', 'validation_lib']
exceptions_list = ['pop_kwargs']
def get_all_symbols(submodule):
import valid8 as v
m = getattr(v, submodule)
return [
s for s, v in vars(m).items()
if not s.startswith('_') and s not in exceptions_list
and getattr(v, '__module__', None) == 'valid8.%s' % submodule
]
symbols = [(m, s) for m in submodules for s in get_all_symbols(m)]
symbol = param_fixture("symbol", [s[1] for s in symbols],
ids=["%s_%s" % s for s in symbols])
def test_named_import(symbol):
import valid8 as v
o = getattr(v, symbol)
def test_import_from(symbol):
exec("from valid8 import %s" % symbol)
from pytest_cases import param_fixture, fixture_union, pytest_fixture_plus
a = param_fixture('a', ['x', 'y'])
@pytest_fixture_plus(params=[1, 2])
def b(request):
# make sure that if this is called, then it is for a good reason
assert request.param in [1, 2]
return request.param
c = fixture_union('c', [a, b])
def test_fixture_union(c, a):
print(c, a)
def test_synthesis(module_results_dct):
assert list(module_results_dct) == ["test_fixture_union[c_is_a-x]",
"test_fixture_union[c_is_a-y]",
"test_fixture_union[c_is_b-1-x]",
"test_fixture_union[c_is_b-1-y]",
"test_fixture_union[c_is_b-2-x]",
"test_fixture_union[c_is_b-2-y]"]
def my_hook(fixture_fun):
print(fixture_fun)
f_list.append(fixture_fun.__name__)
return fixture_fun
@fixture(hook=my_hook)
def foo():
return 2, 1
o, p = unpack_fixture('o,p', foo, hook=my_hook)
p1 = param_fixture("p1", [1, 2], hook=my_hook)
p2, p3 = param_fixtures("p2,p3", [(3, 4)], hook=my_hook)
u = fixture_union("u", (o, p), hook=my_hook)
@parametrize("arg", [fixture_ref(u),
fixture_ref(p1)])
def test_a(arg, p2, p3):
pass
def test_synthesis(module_results_dct):
assert list(module_results_dct) == [
'test_a[u-/o-3-4]',
import pytest
from pytest_cases import param_fixture, fixture_union
has_pytest_param = hasattr(pytest, 'param')
# pytest.param is not available in all versions
if has_pytest_param:
a = param_fixture("a", [1,
pytest.param(2, id='22'),
pytest.param(3, marks=pytest.mark.skip)
])
b = param_fixture("b", [3, 4])
c = fixture_union('c', [pytest.param('a', id='A'),
pytest.param(b, marks=pytest.mark.skip)
],
ids=['ignored', 'B'],
)
def test_foo(c):
pass
def test_synthesis(module_results_dct):
# TODO most probably the skip mark on b seeems to mess with the union behaviour.
assert list(module_results_dct) == [
'test_foo[A-1]',
import pytest
from pytest_cases import param_fixture, param_fixtures, pytest_fixture_plus
# pytest.param - not available in all versions
if LooseVersion(pytest.__version__) >= LooseVersion('3.0.0'):
pytest_param = pytest.param
else:
def pytest_param(*args, **kwargs):
return args
# ---------- (1)
# create a single parameter fixture with and without explicit symbol creation
param_fixture("my_parameter", [1, 2])
my_parameter2 = param_fixture("my_parameter2", [3, 4]) # Returning value
@pytest.fixture
def fixture_uses_param(my_parameter, my_parameter2):
return my_parameter, my_parameter2
def test_uses_param(my_parameter, my_parameter2, fixture_uses_param):
# check that the parameter injected in both is the same
assert my_parameter, my_parameter2 == fixture_uses_param
# ---------- (2)
# create a 2-tuple parameter fixture without symbol creation
from pytest_cases import param_fixture, fixture_union
# basic parametrized fixtures
a = param_fixture('a', ['x', 'y'])
b = param_fixture('b', [1, 2])
# union fixtures
c = fixture_union('c', [a, b])
d = fixture_union('d', [b, a])
def test_fixture_union_harder(c, a, d):
print(c, a, d)
def test_synthesis(module_results_dct):
assert list(module_results_dct) == [
"test_fixture_union_harder[c_is_a-x-d_is_b-1]",
"test_fixture_union_harder[c_is_a-x-d_is_b-2]",
"test_fixture_union_harder[c_is_a-x-d_is_a]",
"test_fixture_union_harder[c_is_a-y-d_is_b-1]",
"test_fixture_union_harder[c_is_a-y-d_is_b-2]",
"test_fixture_union_harder[c_is_a-y-d_is_a]",
"test_fixture_union_harder[c_is_b-1-x-d_is_b]",
"test_fixture_union_harder[c_is_b-1-x-d_is_a]",
"test_fixture_union_harder[c_is_b-1-y-d_is_b]",
"test_fixture_union_harder[c_is_b-1-y-d_is_a]",
"test_fixture_union_harder[c_is_b-2-x-d_is_b]",
"test_fixture_union_harder[c_is_b-2-x-d_is_a]",
"test_fixture_union_harder[c_is_b-2-y-d_is_b]",
"test_fixture_union_harder[c_is_b-2-y-d_is_a]"
class MyTester():
def __init__(self, arg=["var0", "var1"]):
self.arg = arg
# self.use_arg_to_init_logging_part()
def dothis(self):
print("this")
def dothat(self):
print("that")
# create a single parameter fixture
var = param_fixture("var", [['var1', 'var2']], ids=str)
@pytest.fixture
def tester(var):
"""Create tester object"""
return MyTester(var)
class TestIt:
""" Tests the answer at
https://stackoverflow.com/questions/18011902/py-test-pass-a-parameter-to-a-fixture-function/55394178#55394178"""
def test_tc1(self, tester):
tester.dothis()
assert 1
from distutils.version import LooseVersion
import pytest
from pytest_cases import param_fixture, param_fixtures, pytest_fixture_plus
# pytest.param - not available in all versions
if LooseVersion(pytest.__version__) >= LooseVersion('3.0.0'):
pytest_param = pytest.param
else:
def pytest_param(*args, **kwargs):
return args
# create a single parameter fixture
my_parameter = param_fixture("my_parameter", [1, 2, 3, 4])
@pytest.fixture
def fixture_uses_param(my_parameter):
return my_parameter
def test_uses_param(my_parameter, fixture_uses_param):
# check that the parameter injected in both is the same
assert my_parameter == fixture_uses_param
# -----
# create a 2-tuple parameter fixture
arg1, arg2 = param_fixtures("arg1, arg2", [(1, 2), (3, 4)])