如何在@ pytest.mark.parametrize上使用类变量

Question

I have a testcase named test_case_params . It is required to pass some parameters (getting mock data from class Mock_data ) to a fixture and check the return value in the testcase. Do I have another option to use Mock_data.get_mock_data in @pytest.mark.parametrize and the testcase? The purpose is to make sure that all testcases are using the same mock data. What I did so far is creating a mock_data variable so that I can use it across all testcases since the entire Testsuit is inherited from TestFixure. But I am not sure how I can write the pytest.mark.parametrize part.

import pytest
class Mock_data:
    @staticmethod
    def get_mock_data():
        return [1,2,3,4,5]

class TestFixure(object):
    @pytest.fixture(scope='function')
    def func_fixture(self, request):
        print('#do something in fixure{}'.format(request.param))
        return request.param

        def fin():
            print('#do something on finalizer')
        request.addfinalizer(fin)

    @classmethod
    def setup_class(cls):
        super(TestFixure, cls).setup_class()
        cls.mock_data = Mock_data.get_mock_data()

    @classmethod
    def teardown_class(cls):
        super(TestMember, cls).teardown_class()


class TestSuite(TestFixure):
    @pytest.mark.parametrize('func_fixture', [Mock_data.get_mock_data()[1], Mock_data.get_mock_data()[2], Mock_data.get_mock_data()[3]], indirect=['func_fixture'])
    def test_case_params(self, func_fixture):
        print(func_fixture)
        assert func_fixture in self.mock_data

Answer 1

Your entire class TestFixure looks broken to me. Lines like super(TestFixure, cls).setup_class() suggest that you intend to derive it from something ... ?

I had a hard time figuring something like this out for the first time myself, so I rewrote your code example. I believe it does what you want and I hope it helps you to understand how the concepts of fixture and parametrization works:

import pytest

class __mock_data_class__:

    def __init__(self):
        self.vector = [2, 3, 4, 5, 6]

    def do_something(self, parameter):
        return self.vector[parameter] - 2

    def fin(self):
        self.vector.clear() # demo action at the end ...

@pytest.fixture(scope = 'function')
def mock_data(request):

    mock_data_object = __mock_data_class__()

    def __finalizer__():
        mock_data_object.fin()

    request.addfinalizer(__finalizer__)

    return mock_data_object

class TestSuite():

    @pytest.mark.parametrize('some_parameter', range(0, 5))
    def test_case_params(self, mock_data, some_parameter):
        print(some_parameter)
        assert some_parameter == mock_data.do_something(some_parameter)

Your mock data is generated (or fetched or ...) by a class named __mock_data_class__ . I will be initialized as mock_data once per test case (there is only one in your example, test_case_params ) thanks to scope = 'function' . The object will hold your data in a "field" named vector . The mock_data object lives until the test case has been called for every parameter passed into it ( range(0, 5) equals a generator for [0, 1, 2, 3, 4] ). At the end of its life, it will "destroy" the data (just as an example) with self.vector.clear() in the class method fin . Your test case can do something directly in the mock_data object by calling do_something .