@pytest.mark.usefixtures can be now be used on case functions. Fixes #152

Author: Sylvain MARIE

pytest_cases/case_parametrizer_new.py

@@ -5,24 +5,22 @@
 # Use true division operator always even in old python 2.x (used in `_extract_cases_from_module`)
 from __future__ import division
 
-from functools import partial
+import functools
 from importlib import import_module
 from inspect import getmembers, isfunction, ismethod
 import re
 from warnings import warn
 
-import makefun
-
 try:
     from typing import Union, Callable, Iterable, Any, Type, List, Tuple  # noqa
 except ImportError:
     pass
 
 from .common_mini_six import string_types
-from .common_others import get_code_first_line, AUTO, AUTO2, qname
-from .common_pytest_marks import copy_pytest_marks, make_marked_parameter_value
+from .common_others import get_code_first_line, AUTO, AUTO2, qname, funcopy
+from .common_pytest_marks import copy_pytest_marks, make_marked_parameter_value, remove_pytest_mark
 from .common_pytest_lazy_values import lazy_value
-from .common_pytest import safe_isclass, MiniMetafunc, is_fixture, get_fixture_name, inject_host
+from .common_pytest import safe_isclass, MiniMetafunc, is_fixture, get_fixture_name, inject_host, add_fixture_params
 
 from . import fixture
 from .case_funcs_new import matches_tag_query, is_case_function, is_case_class, CaseInfo, CASE_PREFIX_FUN
@@ -305,19 +303,26 @@ def case_to_argvalues(host_class_or_module,    # type: Union[Type, ModuleType]
         if not meta.is_parametrized:
             # single unparametrized case function
             if debug:
-                case_fun_str = qname(case_fun.func if isinstance(case_fun, partial) else case_fun)
+                case_fun_str = qname(case_fun.func if isinstance(case_fun, functools.partial) else case_fun)
                 print("Case function %s > 1 lazy_value() with id %s and marks %s" % (case_fun_str, case_id, case_marks))
             return (lazy_value(case_fun, id=case_id, marks=case_marks),)
         else:
             # parametrized. create one version of the callable for each parametrized call
             if debug:
-                case_fun_str = qname(case_fun.func if isinstance(case_fun, partial) else case_fun)
+                case_fun_str = qname(case_fun.func if isinstance(case_fun, functools.partial) else case_fun)
                 print("Case function %s > tuple of lazy_value() with ids %s and marks %s"
                       % (case_fun_str, ["%s-%s" % (case_id, c.id) for c in meta._calls], [c.marks for c in meta._calls]))
-            return tuple(lazy_value(partial(case_fun, **c.funcargs), id="%s-%s" % (case_id, c.id), marks=c.marks)
+            return tuple(lazy_value(functools.partial(case_fun, **c.funcargs),
+                                    id="%s-%s" % (case_id, c.id), marks=c.marks)
                          for c in meta._calls)
     else:
-        # at least a required fixture:
+        # at least a required fixture (direct req or through @pytest.mark.usefixtures ):
+        # handle @pytest.mark.usefixtures by creating a wrapper where the fixture is added to the signature
+        if meta.fixturenames_not_in_sig:
+            # create a wrapper with an explicit requirement for the fixtures
+            case_fun = add_fixture_params(case_fun, meta.fixturenames_not_in_sig)
+            # remove the `usefixtures` mark
+            remove_pytest_mark(case_fun, "usefixtures")
         # create or reuse a fixture in the host (pytest collector: module or class) of the parametrization target
         fix_name = get_or_create_case_fixture(case_id, case_fun, host_class_or_module, debug)
 
@@ -327,7 +332,7 @@ def case_to_argvalues(host_class_or_module,    # type: Union[Type, ModuleType]
         # reference that case fixture
         argvalues_tuple = (fixture_ref(fix_name),)
         if debug:
-            case_fun_str = qname(case_fun.func if isinstance(case_fun, partial) else case_fun)
+            case_fun_str = qname(case_fun.func if isinstance(case_fun, functools.partial) else case_fun)
             print("Case function %s > fixture_ref(%r) with marks %s" % (case_fun_str, fix_name, case_marks))
         return make_marked_parameter_value(argvalues_tuple, marks=case_marks) if case_marks else argvalues_tuple
 
@@ -358,8 +363,8 @@ def get_or_create_case_fixture(case_id,       # type: str
                          " %s. If you did not decorate it but still see this error, please report this issue"
                          % case_fun)
 
-    # source
-    case_in_class = isinstance(case_fun, partial) and hasattr(case_fun, 'host_class')
+    # source: detect a functools.partial wrapper created by us because of a host class
+    case_in_class = isinstance(case_fun, functools.partial) and hasattr(case_fun, 'host_class')
     true_case_func = case_fun.func if case_in_class else case_fun
     # case_host = case_fun.host_class if case_in_class else import_module(case_fun.__module__)
 
@@ -397,11 +402,6 @@ def name_changer(name, i):
     if debug:
         print("Case function %s > Creating fixture %r in %s" % (qname(true_case_func), fix_name, target_host))
 
-    def funcopy(f):
-        # apparently it is not possible to create an actual copy with copy() !
-        # Use makefun.partial which preserves the parametrization marks (we need them)
-        return makefun.partial(f)
-
     if case_in_class:
         if target_in_class:
             # both in class: direct copy of the non-partialized version
@@ -614,7 +614,7 @@ def _of_interest(x):  # noqa
                     # skip it
                     continue
                 # partialize the function to get one without the 'self' argument
-                new_m = partial(m, cls())
+                new_m = functools.partial(m, cls())
                 # remember the class
                 new_m.host_class = cls
                 # we have to recopy all metadata concerning the case function

pytest_cases/common_others.py

@@ -4,6 +4,7 @@
 # License: 3-clause BSD, <https://github.com/smarie/python-pytest-cases/blob/master/LICENSE>
 import functools
 import inspect
+import makefun
 from importlib import import_module
 from inspect import findsource
 import re
@@ -264,3 +265,25 @@ def qname(func):
         else:
             # host class: recurse (note that in python 2 nested classes do not have a way to know their parent class)
             return "%s.%s" % (qname(hostclass), func.__name__)
+
+
+# if sys.version_info > (3, ):
+def funcopy(f):
+    # see https://stackoverflow.com/a/6527746/7262247
+    # and https://stackoverflow.com/a/13503277/7262247
+    # apparently it is not possible to create an actual copy with copy() !
+    # Use makefun.partial which preserves the parametrization marks (we need them)
+    return makefun.partial(f)
+    # fun = FunctionType(f.__code__, f.__globals__, f.__name__, f.__defaults__, f.__closure__)
+    # fun.__dict__.update(f.__dict__)
+    # fun = functools.update_wrapper(fun, f)
+    # fun.__kwdefaults__ = f.__kwdefaults__
+    # return fun
+# else:
+#     def funcopy(f):
+#         fun = FunctionType(f.func_code, f.func_globals, name=f.func_name, argdefs=f.func_defaults,
+#                            closure=f.func_closure)
+#         fun.__dict__.update(f.__dict__)
+#         fun = functools.update_wrapper(fun, f)
+#         fun.__kwdefaults__ = f.__kwdefaults__
+#         return fun

pytest_cases/common_pytest.py

@@ -4,6 +4,8 @@
 # License: 3-clause BSD, <https://github.com/smarie/python-pytest-cases/blob/master/LICENSE>
 from __future__ import division
 
+from makefun import add_signature_parameters, wraps
+
 try:  # python 3.3+
     from inspect import signature, Parameter
 except ImportError:
@@ -23,7 +25,7 @@
 from .common_mini_six import string_types
 from .common_others import get_function_host
 from .common_pytest_marks import make_marked_parameter_value, get_param_argnames_as_list, has_pytest_param, \
-    get_pytest_parametrize_marks
+    get_pytest_parametrize_marks, get_pytest_usefixture_marks
 from .common_pytest_lazy_values import is_lazy_value
 
 
@@ -550,6 +552,10 @@ def __init__(self, func):
         self._calls = []
         # non-default parameters
         self.fixturenames = getfuncargnames(func)
+        # add declared used fixtures with @pytest.mark.usefixtures
+        self.fixturenames_not_in_sig = [f for f in get_pytest_usefixture_marks(func) if f not in self.fixturenames]
+        if self.fixturenames_not_in_sig:
+            self.fixturenames = tuple(self.fixturenames_not_in_sig + list(self.fixturenames))
         # get parametrization marks
         self.pmarks = get_pytest_parametrize_marks(self.function)
         if self.is_parametrized:
@@ -588,6 +594,41 @@ def update_callspecs(self):
                 c.marks = list(c.keywords.values())
 
 
+def add_fixture_params(func, new_names):
+    """Creates a wrapper of the given function with additional arguments"""
+
+    old_sig = signature(func)
+
+    # prepend all new parameters if needed
+    for n in new_names:
+        if n in old_sig.parameters:
+            raise ValueError("argument named %s already present in signature" % n)
+    new_sig = add_signature_parameters(old_sig,
+                                       first=[Parameter(n, kind=Parameter.POSITIONAL_OR_KEYWORD) for n in new_names])
+
+    assert not isgeneratorfunction(func)
+
+    # normal function with return statement
+    @wraps(func, new_sig=new_sig)
+    def wrapped_func(**kwargs):
+        for n in new_names:
+            kwargs.pop(n)
+        return func(**kwargs)
+
+    # else:
+    #     # generator function (with a yield statement)
+    #     @wraps(fixture_func, new_sig=new_sig)
+    #     def wrapped_fixture_func(*args, **kwargs):
+    #         request = kwargs['request'] if func_needs_request else kwargs.pop('request')
+    #         if is_used_request(request):
+    #             for res in fixture_func(*args, **kwargs):
+    #                 yield res
+    #         else:
+    #             yield NOT_USED
+
+    return wrapped_func
+
+
 def get_callspecs(func):
     """
     Returns a list of pytest CallSpec objects corresponding to calls that should be made for this parametrized function.

pytest_cases/common_pytest_marks.py

@@ -2,6 +2,8 @@
 #          + All contributors to <https://github.com/smarie/python-pytest-cases>
 #
 # License: 3-clause BSD, <https://github.com/smarie/python-pytest-cases/blob/master/LICENSE>
+import itertools
+
 import warnings
 from distutils.version import LooseVersion
 
@@ -114,6 +116,37 @@ def get_pytest_marks_on_function(f, as_decorators=False):
         return mks
 
 
+def get_pytest_usefixture_marks(f):
+    # pytest > 3.2.0
+    marks = getattr(f, 'pytestmark', None)
+    if marks is not None:
+        return tuple(itertools.chain.from_iterable(
+            mark.args for mark in marks if mark.name == 'usefixtures'
+        ))
+    else:
+        # older versions
+        mark_info = getattr(f, 'usefixtures', None)
+        if mark_info is not None:
+            return mark_info.args
+        else:
+            return ()
+
+
+def remove_pytest_mark(f, mark_name):
+    marks = getattr(f, 'pytestmark', None)
+    if marks is not None:
+        # pytest > 3.2.0
+        new_marks = [m for m in marks if m.name != mark_name]
+        setattr(f, 'pytestmark', new_marks)
+    else:
+        # older versions
+        try:
+            delattr(f, mark_name)
+        except AttributeError:
+            pass
+    return f
+
+
 def get_pytest_parametrize_marks(f):
     """
     Returns the @pytest.mark.parametrize marks associated with a function (and only those)

pytest_cases/tests/cases/issues/test_issue_152.py

@@ -0,0 +1,28 @@
+import pytest
+
+from pytest_cases import fixture, parametrize_with_cases
+
+used = False
+
+
+@fixture
+def validationOff():
+    global used
+    used = True
+    yield
+    used = False
+
+
+def case_first(validationOff):
+    pass
+
+
+@pytest.mark.usefixtures("validationOff")
+def case_second():
+    pass
+
+
+@parametrize_with_cases("a", cases='.')
+def test_uses_fixture(a):
+    global used
+    assert used