Class scope fixture doesn't tear down in between parametrized test runs

[Swordy777]

Hello!
I really like working with pytest, but I have encountered a certain problem I would like to ask for an advice on.
I have a test module with the following structure:

@pytest.fixture(autouse=True, scope="class")
def arrange_basic(important_fixture):
    # do some preparations

class TestClass1():
    def test_1(arrange_basic):
        #test something
    def test_2(arrange_basic):
        #test something

@pytest.mark.parametrize("test_param", [0, 1],  scope="class")
class TestClass2():
    @pytest.fixture(autouse=True, scope="class")
    def arrange_more(arrange_basic, test_param):
        # do some more preparations

    def test_1(arrange_basic, test_param):
        #test something
    def test_2(arrange_basic, test_param):
        #test something

So I have a problem with how fixtures are set up/torn down for TestClass2:

• set up arrange_basic()
• set up arrange_more()
• test_1()[test_param-0]
• test_2()[test_param-0]
• tear down arrange_more()
• set up arrange_more()
• test_1()[test_param-1]
• test_2()[test_param-1]
• tear down_arrange_more()
• tear down arrange_basic()

I would like for arrange_basic() to be torn down between sets of parametrized tests along with arrange_more(), but I don't know what way is the most efficient design-wise.
The only solution I have now is to have a copy of arrange_basic inside of TestClass2 where it has test parameter as an argument:

@pytest.mark.parametrize("test_param", [0, 1],  scope="class")
class TestClass2():
    @pytest.fixture(autouse=True, scope="class")
    def arrange_basic(important_fixture, test_param):
        # do some preparations

    @pytest.fixture(autouse=True, scope="class")
    def arrange_more(arrange_basic, test_param):
        # do some more preparations

This way it gets torn down between running sets of tests, but I don't like that I have to duplicate code. I found a similar topic #9458 but it seems that the conclusion was the same as what I came up with.

[RonnyPfannschmidt]

It's possible to use indirect parametrization to make pytest aware, however its expected behavior not to tear down there

[mikicz]

I came up against a very similar problem, see my discussion topic here: #11038

[Swordy777]

Thanks for suggesting a solution, I find it interesting, but at the same time it does have a lot of metaprogramming as you mentioned and I'm not sure if I can keep up with such a level of complexity.
In the meantime, I decided to at least decrease the amount of code duplication by making all the fixture steps a separate function and then wrapping it with a fixture for each class

def preparations(important_fixture):
    #preparations steps

class TestClass1():
    @pytest.fixture(autouse=True, scope="class")
    def arrange_basic(self, important_fixture):
        yield preparations(important_fixture)

    def test_1(self, arrange_basic):
        #test something
    def test_2(self, arrange_basic):
        #test something

@pytest.mark.parametrize("test_param", [0, 1],  scope="class")
class TestClass2():
    @pytest.fixture(autouse=True, scope="class")
    def arrange_basic(self, important_fixture, test_param):
        yield preparations(important_fixture)

    @pytest.fixture(autouse=True, scope="class")
    def arrange_more(self, arrange_basic, test_param):
        # do some more preparations

    def test_1(self, arrange_basic, test_param):
        #test something
    def test_2(self, arrange_basic, test_param):
        #test something

Again, it sure is not an optimal solution

[Swordy777]

@mikicz Thanks again for the solution! After a while I realized that I need to set up a lot more fixtures before my tests. Most of what I have in conftest.py should ideally be called for each set of parametrized class tests. And that's where your solution works perfectly.
I made some changes, such as:

• transferred it to helpers.py
• arguments are received in style of @pytest.mark.parametrize (a string and list of tuples)
• class name is based on parameter values (easier to read in terminal; also in style of @pytest.mark.parametrize)
• return a dictionary of classes each time you call it (there were problems when calling a function from a separate module that uses globals())

Now, if simplified, it looks like this:

# content of conftest.py

@pytest.fixture(scope="class")
def important_fixture():
    print("setup important_fixture")
    # common preparations
    yield data
    print("teardown important_fixture")

# content of test_mytests.py

import pytest

from helpers import generate_tests_cls_parametrize

list_of_param_tuples = [('a', 'b'), ('c', 'd')]

# Actually useful if you need to adjust the scope for each class;
# otherwise you can just make it a fixture with autouse=True as usual
def preparations(important_fixture):
    #preparations steps

# doesn't need parametrization
class TestClass1():      
    @pytest.fixture(autouse=True, scope="class")
    def arrange_basic(self, important_fixture):
        print("setup arrange_basic")
        yield preparations(important_fixture)
        print("teardown arrange_basic")

    def test_1(self, arrange_basic):
        #test something
    def test_2(self, arrange_basic):
        #test something

# needs parametrization
class Class2():
    @pytest.fixture(autouse=True, scope="function")
    def arrange_basic(self, important_fixture, param1, param2):
        print("setup arrange_basic")
        yield preparations(important_fixture)
        print("teardown arrange_basic")

    @pytest.fixture(autouse=True, scope="function")
    def arrange_more(self, arrange_basic, param1, param2):
        print("setup arrange_more")
        # do some more preparations
        print("teardown arrange_more")

    def test_1(self, arrange_basic):
        #test something
    def test_2(self, arrange_more):
        #test something

generated_classes = generate_tests_cls_parametrize(Class2, "param1, param2", list_of_param_tuples)
for class_name in generated_classes:
    globals()[class_name] = generated_classes[class_name]

Output:

test_mytests.py::TestClass1::test_1
setup important_fixture
setup arrange_basic
PASSED
test_mytests.py::TestClass1::test_2 PASSED
teardown arrange_basic
teardown important_fixture

test_mytests.py::TestClass2[a-b]::test_1
setup important_fixture
setup arrange_basic
setup arrange_more
PASSED
teardown arrange_more
teardown arrange_basic

test_mytests.py::TestClass2[a-b]::test_2
setup arrange_basic
setup arrange_more
FAILED
teardown arrange_more
teardown arrange_basic
teardown important_fixture

test_mytests.py::TestClass2[c-d]::test_1
setup important_fixture
setup arrange_basic
setup arrange_more
PASSED
teardown arrange_more
teardown arrange_basic

test_mytests.py::TestClass2[c-d]::test_2
setup arrange_basic
setup arrange_more
FAILED
teardown arrange_more
teardown arrange_basic
teardown important_fixture

There are still some downsides, for example having to switch between naming classes "TestSomething" or "Something" depending on them requiring parametrization, but overall seems better than other possible options

[mikicz]

I'm happy you found my solution helpful! I did indeed also ran into trouble with the globals() solution, so also returning a dictionary in my productionized version. Then locals() can be used instead of globals() btw :)