@pytest_fixture_plus now correctly honors parameter id and marks overriden at single parameter level using pytest.param. Fixed #30

Updated tests accordingly
New utility function `extract_parameterset_info` in `common.py`.

Author: Sylvain MARIE

pytest_cases/common.py

@@ -26,7 +26,7 @@ class _ParametrizationMark:
 
     def __init__(self, mark):
         bound = get_parametrize_signature().bind(*mark.args, **mark.kwargs)
-        self.param_names = bound.arguments['argnames'].split(',')
+        self.param_names = bound.arguments['argnames'].replace(' ', '').split(',')
         self.param_values = bound.arguments['argvalues']
         try:
             bound.apply_defaults()
@@ -116,13 +116,13 @@ def get_test_ids_from_param_values(param_names,
 
     :param param_names:
     :param param_values:
-    :return:
+    :return: a list of param ids
     """
     nb_params = len(param_names)
     if nb_params == 0:
         raise ValueError("empty list provided")
     elif nb_params == 1:
-        paramids = tuple(str(v) for v in param_values)
+        paramids = list(str(v) for v in param_values)
     else:
         paramids = []
         for vv in param_values:
@@ -134,6 +134,41 @@ def get_test_ids_from_param_values(param_names,
 
 
 # ---- ParameterSet api ---
+def extract_parameterset_info(pnames, pmark):
+    """
+
+    :param pnames: the names in this parameterset
+    :param pmark: the parametrization mark (a _ParametrizationMark)
+    :return:
+    """
+    _pids = []
+    _pmarks = []
+    _pvalues = []
+    for v in pmark.param_values:
+        if is_marked_parameter_value(v):
+            # --id
+            id = get_marked_parameter_id(v)
+            _pids.append(id)
+            # --marks
+            marks = get_marked_parameter_marks(v)
+            _pmarks.append(marks)  # note: there might be several
+            # --value(a tuple if this is a tuple parameter)
+            vals = get_marked_parameter_values(v)
+            if len(vals) != len(pnames):
+                raise ValueError("Internal error - unsupported pytest parametrization+mark combination. Please "
+                                 "report this issue")
+            if len(vals) == 1:
+                _pvalues.append(vals[0])
+            else:
+                _pvalues.append(vals)
+        else:
+            _pids.append(None)
+            _pmarks.append(None)
+            _pvalues.append(v)
+
+    return _pids, _pmarks, _pvalues
+
+
 try:  # pytest 3.x+
     from _pytest.mark import ParameterSet
     def is_marked_parameter_value(v):
@@ -145,6 +180,9 @@ def get_marked_parameter_marks(v):
     def get_marked_parameter_values(v):
         return v.values
 
+    def get_marked_parameter_id(v):
+        return v.id
+
 except ImportError:  # pytest 2.x
     from _pytest.mark import MarkDecorator
 
@@ -157,6 +195,9 @@ def get_marked_parameter_marks(v):
     def get_marked_parameter_values(v):
         return v.args[1:]
 
+    def get_marked_parameter_id(v):
+        return v.kwargs.get('id', None)
+
 
 # ---- tools to reapply marks on test parameter values, whatever the pytest version ----
 

pytest_cases/main.py

@@ -42,8 +42,7 @@
 
 from pytest_cases.case_funcs import _GENERATOR_FIELD, CASE_TAGS_FIELD
 from pytest_cases.common import yield_fixture, get_pytest_parametrize_marks, get_test_ids_from_param_values, \
-    is_marked_parameter_value, get_marked_parameter_marks, get_marked_parameter_values, make_marked_parameter_value, \
-    get_pytest_marks_on_function
+    make_marked_parameter_value, get_pytest_marks_on_function, extract_parameterset_info
 
 
 class CaseDataGetter(six.with_metaclass(ABCMeta)):
@@ -271,58 +270,49 @@ def pytest_fixture_plus(scope="function",
         return fix_creator(scope=scope, autouse=autouse, **kwargs)(fixture_func)
 
     # (2) create the huge "param" containing all params combined
-    # --loop
+    # --loop (use the same order to get it right)
     params_names_or_name_combinations = []
     params_values = []
     params_ids = []
     params_marks = []
-    # -- use same order to get it right
-    for m in parametrizer_marks:
-        # check what the mark specifies in terms of parameters
-        if len(m.param_names) < 1:
+    for pmark in parametrizer_marks:
+        # check number of parameter names in this parameterset
+        if len(pmark.param_names) < 1:
             raise ValueError("Fixture function '%s' decorated with '@pytest_fixture_plus' has an empty parameter "
                              "name in a @pytest.mark.parametrize mark")
 
+        # remember
+        params_names_or_name_combinations.append(pmark.param_names)
+
+        # extract all parameters that have a specific configuration (pytest.param())
+        _pids, _pmarks, _pvalues = extract_parameterset_info(pmark.param_names, pmark)
+
+        # Create the proper id for each test
+        if pmark.param_ids is not None:
+            # overridden at global pytest.mark.parametrize level - this takes precedence.
+            try:  # an explicit list of ids ?
+                paramids = list(pmark.param_ids)
+            except TypeError:  # a callable to apply on the values
+                paramids = list(pmark.param_ids(v) for v in _pvalues)
         else:
-            # fix bug: pytest does not strip the param names when they come from a coma-separated "arg1, arg2"
-            _pnames = tuple(name.strip() for name in m.param_names)
-
-            # remember
-            params_names_or_name_combinations.append(_pnames)
-            _pvalues = []
-            _pmarks = []
-            for v in m.param_values:
-                if is_marked_parameter_value(v):
-                    marks = get_marked_parameter_marks(v)
-                    vals = get_marked_parameter_values(v)
-                    if len(vals) != len(_pnames):
-                        raise ValueError("Internal error - unsupported pytest parametrization+mark combination. Please "
-                                         "report this issue")
-                    _pmarks.append(marks)  # there might be several
-                    if len(vals) == 1:
-                        _pvalues.append(vals[0])
-                    else:
-                        _pvalues.append(vals)
-                else:
-                    _pmarks.append(None)
-                    _pvalues.append(v)
-            params_values.append(tuple(_pvalues))
-            params_marks.append(tuple(_pmarks))
-            if m.param_ids is not None:
-                try:
-                    paramids = tuple(m.param_ids)
-                except TypeError:
-                    paramids = tuple(m.param_ids(v) for v in _pvalues)
-            else:
-                paramids = get_test_ids_from_param_values(_pnames, _pvalues)
-            params_ids.append(paramids)
+            # default: values-based...
+            paramids = get_test_ids_from_param_values(pmark.param_names, _pvalues)
+            # ...but local pytest.param takes precedence
+            for i, _id in enumerate(_pids):
+                if _id is not None:
+                    paramids[i] = _id
+
+        # Finally store the ids, marks, and values for this parameterset
+        params_ids.append(paramids)
+        params_marks.append(tuple(_pmarks))
+        params_values.append(tuple(_pvalues))
 
     # (3) generate the ids and values, possibly reapplying marks
     if len(params_names_or_name_combinations) == 1:
         # we can simplify - that will be more readable
-        final_values = list(params_values[0])
         final_ids = params_ids[0]
         final_marks = params_marks[0]
+        final_values = list(params_values[0])
 
         # reapply the marks
         for i, marks in enumerate(final_marks):

pytest_cases/tests/simple/test_fixtures_params.py

@@ -7,7 +7,7 @@
 if LooseVersion(pytest.__version__) >= LooseVersion('3.0.0'):
     pytest_param = pytest.param
 else:
-    def pytest_param(*args):
+    def pytest_param(*args, **kwargs):
         return args
 
 
@@ -27,22 +27,45 @@ def test_one(myfix):
 @pytest_fixture_plus
 @pytest.mark.parametrize("arg1, arg2", [
     (1, 2),
-    pytest_param(3, 4),
+    pytest_param(3, 4, id="p_a"),
+    pytest_param(5, 6, id="skipped", marks=pytest.mark.skip)
 ])
 def myfix2(arg1, arg2):
     return arg1, arg2
 
 
 def test_two(myfix2):
-    assert myfix2 in {(1, 2), (3, 4)}
+    assert myfix2 in {(1, 2), (3, 4), (5, 6)}
+    print(myfix2)
+
+
+@pytest_fixture_plus
+@pytest.mark.parametrize("arg1, arg2", [
+    pytest_param(5, 6, id="ignored_id")
+], ids=['a'])
+def myfix3(arg1, arg2):
+    return arg1, arg2
+
+
+def test_two(myfix2, myfix3):
+    assert myfix2 in {(1, 2), (3, 4), (5, 6)}
     print(myfix2)
 
 
 def test_synthesis(module_results_dct):
     """Use pytest-harvest to check that the list of executed tests is correct """
+
+    if LooseVersion(pytest.__version__) >= LooseVersion('3.0.0'):
+        id_of_last_tests = ['p_a', 'skipped']
+        extra_test = []
+    else:
+        id_of_last_tests = ['3-4', '5-6']
+        extra_test = ['test_two[%s-a]' % id_of_last_tests[1]]
+
     assert list(module_results_dct) == ['test_one[one-one]',
                                         'test_one[one-two]',
                                         'test_one[two-one]',
                                         'test_one[two-two]',
-                                        'test_two[1-2]',
-                                        'test_two[3-4]']
+                                        'test_two[1-2-a]',
+                                        'test_two[%s-a]' % id_of_last_tests[0],
+                                        ] + extra_test