Fixed ids precedence order when using pytest.mark.parametrize in a fixture_plus. Fixed #87

Author: Sylvain MARIE

pytest_cases/common.py

@@ -259,6 +259,18 @@ def get_parametrize_signature():
 
 
 # ---------- test ids utils ---------
+def combine_ids(paramid_tuples):
+    """
+    Receives a list of tuples containing ids for each parameterset.
+    Returns the final ids, that are obtained by joining the various param ids by '-' for each test node
+
+    :param paramid_tuples:
+    :return:
+    """
+    #
+    return ['-'.join(pid for pid in testid) for testid in paramid_tuples]
+
+
 def get_test_ids_from_param_values(param_names,
                                    param_values,
                                    ):
@@ -285,43 +297,81 @@ def get_test_ids_from_param_values(param_names,
 
 
 # ---- ParameterSet api ---
-def extract_parameterset_info(pnames, pmark):
+def analyze_parameter_set(pmark=None, argnames=None, argvalues=None, ids=None):
     """
+    analyzes a parameter set passed either as a pmark or as distinct
+    (argnames, argvalues, ids) to extract/construct the various ids, marks, and
+    values
 
-    :param pnames: the names in this parameterset
-    :param pmark: the parametrization mark (a _ParametrizationMark)
+    :return: ids, marks, values
+    """
+    if pmark is not None:
+        if any(a is not None for a in (argnames, argvalues, ids)):
+            raise ValueError("Either provide a pmark OR the details")
+        argnames = pmark.param_names
+        argvalues = pmark.param_values
+        ids = pmark.param_ids
+
+    # extract all parameters that have a specific configuration (pytest.param())
+    custom_pids, p_marks, p_values = extract_parameterset_info(argnames, argvalues)
+
+    # Create the proper id for each test
+    if ids is not None:
+        # overridden at global pytest.mark.parametrize level - this takes precedence.
+        try:  # an explicit list of ids ?
+            p_ids = list(ids)
+        except TypeError:  # a callable to apply on the values
+            p_ids = list(ids(v) for v in p_values)
+    else:
+        # default: values-based
+        p_ids = get_test_ids_from_param_values(argnames, p_values)
+
+    # Finally, local pytest.param takes precedence over everything else
+    for i, _id in enumerate(custom_pids):
+        if _id is not None:
+            p_ids[i] = _id
+
+    return p_ids, p_marks, p_values
+
+
+def extract_parameterset_info(argnames, argvalues):
+    """
+
+    :param argnames: the names in this parameterset
+    :param argvalues: the values in this parameterset
     :return:
     """
-    _pids = []
-    _pmarks = []
-    _pvalues = []
-    for v in pmark.param_values:
+    pids = []
+    pmarks = []
+    pvalues = []
+    for v in argvalues:
         if is_marked_parameter_value(v):
             # --id
             id = get_marked_parameter_id(v)
-            _pids.append(id)
+            pids.append(id)
             # --marks
             marks = get_marked_parameter_marks(v)
-            _pmarks.append(marks)  # note: there might be several
+            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):
+            if len(vals) != len(argnames):
                 raise ValueError("Internal error - unsupported pytest parametrization+mark combination. Please "
                                  "report this issue")
             if len(vals) == 1:
-                _pvalues.append(vals[0])
+                pvalues.append(vals[0])
             else:
-                _pvalues.append(vals)
+                pvalues.append(vals)
         else:
-            _pids.append(None)
-            _pmarks.append(None)
-            _pvalues.append(v)
+            pids.append(None)
+            pmarks.append(None)
+            pvalues.append(v)
 
-    return _pids, _pmarks, _pvalues
+    return pids, pmarks, pvalues
 
 
 try:  # pytest 3.x+
     from _pytest.mark import ParameterSet
+
     def is_marked_parameter_value(v):
         return isinstance(v, ParameterSet)
 

pytest_cases/main_fixtures.py

@@ -40,7 +40,7 @@
     pass
 
 from pytest_cases.common import yield_fixture, get_pytest_parametrize_marks, get_test_ids_from_param_values, \
-    make_marked_parameter_value, extract_parameterset_info, get_fixture_name, get_param_argnames_as_list, \
+    make_marked_parameter_value, get_fixture_name, get_param_argnames_as_list, analyze_parameter_set, combine_ids, \
     get_fixture_scope, remove_duplicates
 from pytest_cases.main_params import cases_data
 
@@ -579,34 +579,21 @@ def _decorate_fixture_plus(fixture_func,
     params_ids = []
     params_marks = []
     for pmark in parametrizer_marks:
+        # -- pmark is a single @pytest.parametrize mark. --
+
         # check number of parameter names in this parameterset
         if len(pmark.param_names) < 1:
             raise ValueError("Fixture function '%s' decorated with '@fixture_plus' has an empty parameter "
                              "name in a @pytest.mark.parametrize mark")
 
-        # remember
+        # remember the argnames
         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:
-            # 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
+        # analyse contents, extract marks and custom ids, apply custom ids
+        _paramids, _pmarks, _pvalues = analyze_parameter_set(pmark)
 
         # Finally store the ids, marks, and values for this parameterset
-        params_ids.append(paramids)
+        params_ids.append(_paramids)
         params_marks.append(tuple(_pmarks))
         params_values.append(tuple(_pvalues))
 
@@ -623,7 +610,7 @@ def _decorate_fixture_plus(fixture_func,
                 final_values[i] = make_marked_parameter_value(final_values[i], marks=marks)
     else:
         final_values = list(product(*params_values))
-        final_ids = get_test_ids_from_param_values(params_names_or_name_combinations, product(*params_ids))
+        final_ids = combine_ids(product(*params_ids))
         final_marks = tuple(product(*params_marks))
 
         # reapply the marks

pytest_cases/tests/fixtures/test_fixtures_parametrize.py

@@ -25,30 +25,31 @@ def test_one(myfix):
 
 
 @pytest_fixture_plus
+@pytest.mark.parametrize("arg3", [pytest_param(0, id='!0!')], ids=str)
 @pytest.mark.parametrize("arg1, arg2", [
     (1, 2),
     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 myfix2(arg1, arg2, arg3):
+    return arg1, arg2, arg3
 
 
 def test_two(myfix2):
-    assert myfix2 in {(1, 2), (3, 4), (5, 6)}
+    assert myfix2 in {(1, 2, 0), (3, 4, 0), (5, 6, 0)}
     print(myfix2)
 
 
 @pytest_fixture_plus
 @pytest.mark.parametrize("arg1, arg2", [
-    pytest_param(5, 6, id="ignored_id")
-], ids=['a'])
+    pytest_param(5, 6, id="a")
+], ids=['ignored_id'])
 def myfix3(arg1, arg2):
     return arg1, arg2
 
 
 def test_two(myfix2, myfix3):
-    assert myfix2 in {(1, 2), (3, 4), (5, 6)}
+    assert myfix2 in {(1, 2, 0), (3, 4, 0), (5, 6, 0)}
     print(myfix2)