New decorator @pytest_fixture_plus allows to use several @pytest.mark.parametrize on a fixture. Therefore one can use multiple @cases_data decorators, too. Fixes #19.

Note: this is a temporary feature, that will be removed if/when pytest supports it, see pytest-dev/pytest#3960.

Author: smarie

docs/index.md

@@ -97,18 +97,21 @@ Once you have done these three steps, executing `pytest` will run your test func
 
 ### d- Case fixtures
 
-You might be concerned that case data is gathered inside test execution. Indeed gathering case data is not part of the test *per se*. Besides if you use for example [pytest-harvest](https://smarie.github.io/python-pytest-harvest/) to benchmark your tests durations, you may want the test duration to be computed without acccounting for the data retrieval time (especially if you decide to add some caching mechanism as explained [here](https://smarie.github.io/python-pytest-cases/usage/advanced/#caching)).
+You might be concerned that case data is gathered or created *during* test execution. 
 
-The answer is simple: instead of parametrizing your test function, rather create a parametrized fixture:
+Indeed creating or collecting case data is not part of the test *per se*. Besides, if you benchmark your tests durations (for example with [pytest-harvest](https://smarie.github.io/python-pytest-harvest/)), you may want the test duration to be computed without acccounting for the data retrieval time - especially if you decide to add some caching mechanism as explained [here](https://smarie.github.io/python-pytest-cases/usage/advanced/#caching).
+
+It might therefore be more interesting for you to parametrize **case fixtures** instead of parametrizing your test function:
 
 ```python
-from pytest_cases import cases_fixture
+from pytest_cases import pytest_fixture_plus, cases_data
 from example import foo
 
 # import the module containing the test cases
 import test_foo_cases
 
-@cases_fixture(module=test_foo_cases)
+@pytest_fixture_plus
+@cases_data(module=test_foo_cases)
 def inputs(case_data):
     """ Example fixture that is automatically parametrized with @cases_data """
     # retrieve case data
@@ -119,8 +122,13 @@ def test_foo(inputs):
     foo(**inputs)
 ```
 
+In the above example, the `test_foo` test does not spend time collecting or generating data. When it is executed, it receives the required data directly as `inputs`. The test case creation instead happens when each `inputs` fixture instance is created by `pytest` - this is done in a separate pytest phase (named "setup"), and therefore is not counted in the test duration.
+
 Note: you can still use `request` in your fixture's signature if you wish to.
 
+!!! note "`@pytest_fixture_plus` deprecation if/when `@pytest.fixture` supports `@pytest.mark.parametrize`"
+    The ability for pytest fixtures to support the `@pytest.mark.parametrize` annotation is a feature that clearly belongs to `pytest` scope, and has been [requested already](https://github.com/pytest-dev/pytest/issues/3960). It is therefore expected that `@pytest_fixture_plus` will be deprecated in favor of `@pytest_fixture` if/when the `pytest` team decides to add the proposed feature. As always, deprecation will happen slowly across versions (at least two minor, or one major version update) so as for users to have the time to update their code bases.
+
 ## Usage - 'True' test cases
 
 #### a- Case functions update

pytest_cases/__init__.py

@@ -5,14 +5,15 @@
 except ImportError:
     pass
 
-from pytest_cases.main import cases_data, CaseDataGetter, cases_fixture, \
+from pytest_cases.main import cases_data, CaseDataGetter, cases_fixture, pytest_fixture_plus, \
     unfold_expected_err, get_all_cases, extract_cases_from_module, THIS_MODULE
 
 __all__ = [
-    # the 2 submodules
-    'main', 'case_funcs',
+    # the 3 submodules
+    'main', 'case_funcs', 'common',
     # all symbols imported above
-    'cases_data', 'CaseData', 'CaseDataGetter', 'cases_fixture', 'unfold_expected_err', 'get_all_cases',
+    'cases_data', 'CaseData', 'CaseDataGetter', 'cases_fixture', 'pytest_fixture_plus',
+    'unfold_expected_err', 'get_all_cases',
     'extract_cases_from_module',
     'case_name', 'Given', 'ExpectedNormal', 'ExpectedError',
     'test_target', 'case_tags', 'THIS_MODULE', 'cases_generator', 'MultipleStepsCaseData'

pytest_cases/common.py

@@ -0,0 +1,76 @@
+try:  # python 3.3+
+    from inspect import signature
+except ImportError:
+    from funcsigs import signature
+
+import pytest
+
+
+# Create a symbol that will work to create a fixture containing 'yield', whatever the pytest version
+# Note: if more prevision is needed, use    if LooseVersion(pytest.__version__) < LooseVersion('3.0.0')
+if int(pytest.__version__.split('.', 1)[0]) < 3:
+    yield_fixture = pytest.yield_fixture
+else:
+    yield_fixture = pytest.fixture
+
+
+class _LegacyMark:
+    __slots__ = "args", "kwargs"
+
+    def __init__(self, *args, **kwargs):
+        self.args = args
+        self.kwargs = kwargs
+
+
+class _ParametrizationMark:
+    """
+    Represents the information required by `decorate_pytest_fixture_plus` to work.
+    """
+    __slots__ = "param_names", "param_values", "param_ids"
+
+    def __init__(self, mark):
+        bound = get_parametrize_signature().bind(*mark.args, **mark.kwargs)
+        self.param_names = bound.arguments['argnames'].split(',')
+        self.param_values = bound.arguments['argvalues']
+        try:
+            bound.apply_defaults()
+            self.param_ids = bound.arguments['ids']
+        except AttributeError:
+            # can happen if signature is from funcsigs so we have to apply ourselves
+            self.param_ids = bound.arguments.get('ids', None)
+
+
+def get_pytest_parametrize_marks(f):
+    """
+    Returns the @pytest.mark.parametrize marks associated with a function
+
+    :param f:
+    :return: a tuple containing all 'parametrize' marks
+    """
+    # pytest > 3.2.0
+    marks = getattr(f, 'pytestmark', None)
+    if marks is not None:
+        return tuple(_ParametrizationMark(m) for m in marks if m.name == 'parametrize')
+    else:
+        # older versions
+        mark_info = getattr(f, 'parametrize', None)
+        if mark_info is not None:
+            # mark_info.args contains a list of (name, values)
+            return tuple(_ParametrizationMark(_LegacyMark(mark_info.args[2*i], mark_info.args[2*i + 1],
+                                                          **mark_info.kwargs))
+                         for i in range(len(mark_info.args) // 2))
+        else:
+            return ()
+
+
+def _pytest_mark_parametrize(argnames, argvalues, ids=None):
+    """ Fake method to have a reference signature of pytest.mark.parametrize"""
+    pass
+
+
+def get_parametrize_signature():
+    """
+
+    :return: a reference signature representing
+    """
+    return signature(_pytest_mark_parametrize)

pytest_cases/main.py

@@ -3,8 +3,10 @@
 
 import sys
 from abc import abstractmethod, ABCMeta
-from inspect import getmembers, isgeneratorfunction
+from distutils.version import LooseVersion
+from inspect import getmembers, isgeneratorfunction, getmodule
 
+from pytest_cases.common import yield_fixture, get_pytest_parametrize_marks
 from pytest_cases.decorator_hack import my_decorate
 
 try:  # type hints, python 3+
@@ -134,6 +136,14 @@ def cases_fixture(cases=None,                       # type: Union[Callable[[Any]
                   **kwargs
                   ):
     """
+    DEPRECATED - use double annotation `@pytest_fixture_plus` + `@cases_data` instead
+
+    ```python
+    @pytest_fixture_plus
+    @cases_data(module=xxx)
+    def my_fixture(case_data)
+    ```
+
     Decorates a function so that it becomes a parametrized fixture.
 
     The fixture will be automatically parametrized with all cases listed in module `module`, or with
@@ -190,39 +200,198 @@ def foo_fixture(request):
         `module`. It both `has_tag` and `filter` are set, both will be applied in sequence.
     :return:
     """
-    def fixture_decorator(fixture_func):
-        """
-        The generated fixture function decorator.
-
-        :param fixture_func:
-        :return:
-        """
-        # First list all cases according to user preferences
-        _cases = get_all_cases(cases, module, fixture_func, has_tag, filter)
+    def _double_decorator(f):
+        # apply @cases_data (that will translate to a @pytest.mark.parametrize)
+        parametrized_f = cases_data(cases=cases, module=module,
+                                    case_data_argname=case_data_argname, has_tag=has_tag, filter=filter)(f)
+        # apply @pytest_fixture_plus
+        return pytest_fixture_plus(**kwargs)(parametrized_f)
+
+    return _double_decorator
+
+
+def pytest_fixture_plus(scope="function",
+                        params=None,
+                        autouse=False,
+                        ids=None,
+                        name=None,
+                        **kwargs):
+    """ (return a) decorator to mark a fixture factory function.
+
+    Identical to `@pytest.fixture` decorator, except that it supports multi-parametrization with
+    `@pytest.mark.parametrize` as requested in https://github.com/pytest-dev/pytest/issues/3960.
+
+    :param scope: the scope for which this fixture is shared, one of
+                "function" (default), "class", "module" or "session".
+    :param params: an optional list of parameters which will cause multiple
+                invocations of the fixture function and all of the tests
+                using it.
+    :param autouse: if True, the fixture func is activated for all tests that
+                can see it.  If False (the default) then an explicit
+                reference is needed to activate the fixture.
+    :param ids: list of string ids each corresponding to the params
+                so that they are part of the test id. If no ids are provided
+                they will be generated automatically from the params.
+    :param name: the name of the fixture. This defaults to the name of the
+                decorated function. If a fixture is used in the same module in
+                which it is defined, the function name of the fixture will be
+                shadowed by the function arg that requests the fixture; one way
+                to resolve this is to name the decorated function
+                ``fixture_<fixturename>`` and then use
+                ``@pytest.fixture(name='<fixturename>')``.
+    :param kwargs: other keyword arguments for `@pytest.fixture`
+    """
 
-        # old: use id getter function : cases_ids = str
-        # new: hardcode the case ids, safer (?) in case this is mixed with another fixture
-        cases_ids = [str(c) for c in _cases]
+    if callable(scope) and params is None and autouse is False:
+        # direct decoration without arguments
+        return decorate_pytest_fixture_plus(scope)
+    else:
+        # arguments have been provided
+        def _decorator(f):
+            return decorate_pytest_fixture_plus(f,
+                                                scope=scope, params=params, autouse=autouse, ids=ids, name=name,
+                                                **kwargs)
+        return _decorator
+
+
+def decorate_pytest_fixture_plus(fixture_func,
+                                 scope="function",
+                                 params=None,
+                                 autouse=False,
+                                 ids=None,
+                                 name=None,
+                                 **kwargs):
+    """
+    Manual decorator equivalent to `@pytest_fixture_plus`
+
+    :param fixture_func: the function to decorate
+
+    :param scope: the scope for which this fixture is shared, one of
+                "function" (default), "class", "module" or "session".
+    :param params: an optional list of parameters which will cause multiple
+                invocations of the fixture function and all of the tests
+                using it.
+    :param autouse: if True, the fixture func is activated for all tests that
+                can see it.  If False (the default) then an explicit
+                reference is needed to activate the fixture.
+    :param ids: list of string ids each corresponding to the params
+                so that they are part of the test id. If no ids are provided
+                they will be generated automatically from the params.
+    :param name: the name of the fixture. This defaults to the name of the
+                decorated function. If a fixture is used in the same module in
+                which it is defined, the function name of the fixture will be
+                shadowed by the function arg that requests the fixture; one way
+                to resolve this is to name the decorated function
+                ``fixture_<fixturename>`` and then use
+                ``@pytest.fixture(name='<fixturename>')``.
+    :param kwargs:
+    :return:
+    """
+    # Compatibility for the 'name' argument
+    if LooseVersion(pytest.__version__) >= LooseVersion('3.0.0'):
+        # pytest version supports "name" keyword argument
+        kwargs['name'] = name
+    elif name is not None:
+        # 'name' argument is not supported in this old version, use the __name__ trick.
+        fixture_func.__name__ = name
+
+    # Collect all @pytest.mark.parametrize markers (including those created by usage of @cases_data)
+    parametrizer_marks = get_pytest_parametrize_marks(fixture_func)
+
+    # the module will be used to add fixtures dynamically
+    module = getmodule(fixture_func)
+
+    # for each dependency create an associated "param" fixture
+    # Note: we could instead have created a huge parameter containing all parameters...
+    # Pros = no additional fixture. Cons: less readable and ids would be difficult to create
+    params_map = dict()
+    for m in parametrizer_marks:
+        # check what the mark specifies in terms of parameters
+        if len(m.param_names) < 1:
+            raise ValueError("Fixture function '%s' decorated with '@pytest_fixture_plus' has an empty parameter "
+                             "name in a @pytest.mark.parametrize mark")
 
-        # create a fixture function wrapper
-        if not isgeneratorfunction(fixture_func):
-            def wrapper(f, request, args, kwargs):
-                kwargs[case_data_argname] = request.param
-                return f(*args, **kwargs)
         else:
-            def wrapper(f, request, args, kwargs):
-                kwargs[case_data_argname] = request.param
-                for res in f(*args, **kwargs):
-                    yield res
+            # create a fixture function for this parameter
+            def _param_fixture(request):
+                """a dummy fixture that simply returns the parameter"""
+                return request.param
+
+            # generate a fixture name (find an available name if already used)
+            gen_name = "gen_paramfixture__" + fixture_func.__name__ + "__" + 'X'.join(m.param_names)
+            i = 0
+            _param_fixture.__name__ = gen_name
+            while _param_fixture.__name__ in dir(module):
+                i += 1
+                _param_fixture.__name__ = gen_name + '_' + str(i)
+
+            # create the fixture with param name, values and ids, and with same scope than requesting func.
+            param_fixture = pytest.fixture(scope=scope, params=m.param_values, ids=m.param_ids)(_param_fixture)
+
+            # Add the fixture dynamically: we have to add it to the function holder module as explained in
+            # https://github.com/pytest-dev/pytest/issues/2424
+            if _param_fixture.__name__ not in dir(module):
+                setattr(module, _param_fixture.__name__, param_fixture)
+            else:
+                raise ValueError("The {} fixture automatically generated by `@pytest_fixture_plus` already exists in "
+                                 "module {}. This should not happen given the automatic name generation"
+                                 "".format(_param_fixture.__name__, module))
+
+            # remember
+            params_map[_param_fixture.__name__] = m.param_names
+
+    # wrap the fixture function so that each of its parameter becomes the associated fixture name
+    new_parameter_names = tuple(params_map.keys())
+    old_parameter_names = tuple(v for l in params_map.values() for v in l)
+
+    # common routine used below. Fills kwargs with the appropriate names and values from fixture_params
+    def _get_arguments(fixture_params, args_and_kwargs):
+        # unpack the underlying function's args/kwargs
+        args = args_and_kwargs.pop('args')
+        kwargs = args_and_kwargs.pop('kwargs')
+        if len(args_and_kwargs) > 0:
+            raise ValueError("Internal error - please file an issue in the github project page")
+
+        # fill the kwargs with additional arguments by using mapping
+        i = 0
+        for new_p_name in new_parameter_names:
+            if len(params_map[new_p_name]) == 1:
+                kwargs[params_map[new_p_name][0]] = fixture_params[i]
+                i += 1
+            else:
+                # unpack several
+                for old_p_name, old_p_value in zip(params_map[new_p_name], fixture_params[i]):
+                    kwargs[old_p_name] = old_p_value
+                    i += 1
 
-        fixture_func_wrapper = my_decorate(fixture_func, wrapper, additional_args=['request'],
-                                           removed_args=[case_data_argname])
+        return args, kwargs
 
-        # Finally create the pytest decorator and apply it
-        parametrizer = pytest.fixture(params=_cases, ids=cases_ids, **kwargs)
-        return parametrizer(fixture_func_wrapper)
+    if not isgeneratorfunction(fixture_func):
+        # normal function with return statement
+        def wrapper(f, *fixture_params, **args_and_kwargs):
+            args, kwargs = _get_arguments(fixture_params, args_and_kwargs)
+            return fixture_func(*args, **kwargs)
+
+        wrapped_fixture_func = my_decorate(fixture_func, wrapper,
+                                           additional_args=new_parameter_names, removed_args=old_parameter_names)
 
-    return fixture_decorator
+        # transform the created wrapper into a fixture
+        fixture_decorator = pytest.fixture(scope=scope, params=params, autouse=autouse, ids=ids, **kwargs)
+        return fixture_decorator(wrapped_fixture_func)
+
+    else:
+        # generator function (with a yield statement)
+        def wrapper(f, *fixture_params, **args_and_kwargs):
+            args, kwargs = _get_arguments(fixture_params, args_and_kwargs)
+            for res in fixture_func(*args, **kwargs):
+                yield res
+
+        wrapped_fixture_func = my_decorate(fixture_func, wrapper,
+                                           additional_args=new_parameter_names, removed_args=old_parameter_names)
+
+        # transform the created wrapper into a fixture
+        fixture_decorator = yield_fixture(scope=scope, params=params, autouse=autouse, ids=ids, **kwargs)
+        return fixture_decorator(wrapped_fixture_func)
 
 
 def cases_data(cases=None,                       # type: Union[Callable[[Any], Any], Iterable[Callable[[Any], Any]]]