Using fixtures in pytest.mark.parametrize

[pytestbot]

Originally reported by: Florian Rathgeber (BitBucket: frathgeber, GitHub: frathgeber)

---

I often have a use case like the following contrived example:

@pytest.fixture
def a():
 return 'a'

@pytest.fixture
def b():
 return 'b'

@pytest.mark.parametrize('arg', [a, b])
def test_foo(arg):
 assert len(arg) == 1

This doesn't currently do what's intended i.e. arg inside the test function is not the fixture value but the fixture function.

I can work around it by introducing a "meta fixture", but that's rather ugly:

@pytest.fixture(params=['a', 'b'])
def arg(request, a, b):
 return {'a': a, 'b': b}[request.param]

def test_foo(arg):
 assert len(arg) == 1

It would be convenient if a syntax like in the first case was supported.

---

• Bitbucket: https://bitbucket.org/pytest-dev/pytest/issue/349

[pytestbot]

Original comment by Matthias Geier (BitBucket: geier, GitHub: geier):

---

This would be a great feature!

I found another (I don't know if more or less ugly) work-around:

#!python

@pytest.mark.parametrize('arg', ['a', 'b'])
def test_foo(arg, request):
 val = request.getfuncargvalue(arg)
 assert len(val) == 1

This doesn't work, however, with parametrized fixtures.

BTW, it would also be great if fixtures were supported in the params argument of pytest.fixture.

[pytestbot]

Original comment by Floris Bruynooghe (BitBucket: flub, GitHub: flub):

---

Tentatively assigning this to me as I think I might be able to come up with a reasonable patch. It'll probably take me a long while though so don't let that discourage anyone else from working on this, assigning it more as a way of not forgetting about it.

[pytestbot]

Original comment by Praveen Shirali (BitBucket: praveenshirali, GitHub: praveenshirali):

---

The quoted examples work because functions a and b are part of the same module as test_foo, and within the scope of the example, the parametrization should work even if @pytest.fixture decorator isn't present around functions a and b. They are getting used as regular python functions and not as pytest fixtures. Note that fixtures can also be defined in external modules like conftest.py.

Another alternative to the above example is to directly call these functions in the list.

#!python

@pytest.mark.parametrize('arg', [a(), b()])
def test_foo(arg):
 assert len(arg) == 1

[pytestbot]

Original comment by BitBucket: dpwrussell, GitHub: dpwrussell:

---

This would be an awesome feature.

@praveenshirali I don't think your alternative is used as a fixture, it just calls the fixture function. So it would be run repeatedly. You would also have to specify the arguments to the fixture if there were any which could begin the cycle over again if they are also fixtures.

[mgeier]

Here's a related stackoverflow question: http://stackoverflow.com/questions/24340681/how-to-concatenate-several-parametrized-fixtures-into-a-new-fixture-in-py-test

[jlmenut]

Yes, I would like very much to have this feature also. Maybe a line in the doc explaining it's not possible for the moment would be useful also.

[kevincox]

It would also be killer if this supported parameterized fixtures generating the product of the fixtures. Although this might be a little much.

@pytest.fixture(params=["1", " ", 1, True, [None], {1:2}])
def truthy(request):
 return request.param

@pytest.fixture(params=[False, None, "", 0, [], {}])
def falsey(request):
 return request.param

@pytest.mark.parameterize("val,res", [
 (truthy, True),
 (falsey, False),
])
def test_bool(val, res)
 assert bool(val) is res

[SUNx2YCH]

+1 for this feature.
BTW, combining Florian Rathgeber and Matthias Geier solutions we can get a bit nicer "meta fixture":

@pytest.fixture
def a():
 return 'a'

@pytest.fixture
def b():
 return 'b'

@pytest.fixture(params=['a', 'b'])
def arg(request):
 return request.getfuncargvalue(request.param)

def test_foo(arg):
 assert len(arg) == 1

[rabbbit]

+1 on this.

I'm currently writing tests that look like:

@pytest.fixture
def my_fixture():
 return 'something'

@pytest.fixture
def another_fixture(my_fixture):
 return {'my_key': my_fixture}

def yet_another_fixture():
 return {'my_key': None}

@pytest.mark.parametrize('arg1, arg2', [
 (5, another_fixture(my_fixture())),
 (5, yet_another_fixture()),
)
def my_test(arg1, arg2):
 assert function_under_test(arg2) == arg1

and that's rather ugly.

[RonnyPfannschmidt]

@rabbbit your example is structurally wrong and runs fixture code at test importation time

[rabbbit]

@RonnyPfannschmidt I know - and that's why I'd like to be able to use fixtures in parametrize? And that would be awesome.

My example is wrong, but it follows the guideline of "always use fixtures". Otherwise we'd end up with fixtures in normal tests, and workarounds in parametrized tests.

Or is there a way of achieving this already, outside of dropping parametrize and doing 'if/elses' in the test function?