@parametrize: custom ids are now correctly taken into account when a single lazy_valueis used for a tuple of parameters. This issue could be seen also with @parametrize_with_cases: idgen does not seem to be taken into account when cases are unpacked into a tuple. Fixes #144

docstring of `lazy_value` was clarified accordingly.

Author: Sylvain MARIE

docs/api_reference.md

@@ -315,6 +315,8 @@ A reference to a value getter (an argvalue-providing callable), to be used in [`
 
 A `lazy_value` is the same thing than a function-scoped fixture, except that the value getter function is not a fixture and therefore can neither be parametrized nor depend on fixtures. It should have no mandatory argument.
 
+By default the associated id is the name of the `valuegetter` callable, but a specific `id` can be provided otherwise. Note that this `id` does not take precedence over custom `ids` or `idgen` passed to `@parametrize`.
+
 Note that a `lazy_value` can be included in a `pytest.param` without problem. In that case the id defined by `pytest.param` will take precedence over the one defined in `lazy_value` if any. The marks, however, will all be kept wherever they are defined.
 
 **Parameters**
@@ -323,6 +325,13 @@ Note that a `lazy_value` can be included in a `pytest.param` without problem. In
  - `id`: an optional id. Otherwise `valuegetter.__name__` will be used by default
  - `marks`: optional marks. `valuegetter` marks will also be preserved.
 
+### `is_lazy`
+
+```python
+def is_lazy(argval) -> bool
+```
+
+Return `True` if `argval` is the outcome of processing a `lazy_value` through `@parametrize`. This encompasses parameters that are items of lazy tuples that are created when parametrizing several argnames with the same `lazy_value()`.
 
 ### `fixture_ref`
 

pytest_cases/common_pytest_lazy_values.py

@@ -384,6 +384,9 @@ def lazy_value(valuegetter,  # type: Callable[[], Any]
     A `lazy_value` is the same thing than a function-scoped fixture, except that the value getter function is not a
     fixture and therefore can neither be parametrized nor depend on fixtures. It should have no mandatory argument.
 
+    By default the associated id is the name of the `valuegetter` callable, but a specific `id` can be provided
+    otherwise. Note that this `id` does not take precedence over custom `ids` or `idgen` passed to @parametrize.
+
     Note that a `lazy_value` can be included in a `pytest.param` without problem. In that case the id defined by
     `pytest.param` will take precedence over the one defined in `lazy_value` if any. The marks, however,
     will all be kept wherever they are defined.

pytest_cases/fixture_parametrize_plus.py

@@ -416,7 +416,8 @@ def _make_ids(**args):
     # extract all marks and custom ids.
     # Do not check consistency of sizes argname/argvalue as a fixture_ref can stand for several argvalues.
     marked_argvalues = argvalues
-    p_ids, p_marks, argvalues, fixture_indices = _process_argvalues(argnames, marked_argvalues, nb_params)
+    has_cust_ids = (idgen is not None) or (ids is not None)
+    p_ids, p_marks, argvalues, fixture_indices = _process_argvalues(argnames, marked_argvalues, nb_params, has_cust_ids)
 
     # generate id
     if idgen is not None:
@@ -867,7 +868,7 @@ def gen_id_using_str_formatter(**params):
     return ids
 
 
-def _process_argvalues(argnames, marked_argvalues, nb_params):
+def _process_argvalues(argnames, marked_argvalues, nb_params, has_custom_ids):
     """Internal method to use in _pytest_parametrize_plus
 
     Processes the provided marked_argvalues (possibly marked with pytest.param) and returns
@@ -878,6 +879,8 @@ def _process_argvalues(argnames, marked_argvalues, nb_params):
     :param argnames:
     :param marked_argvalues:
     :param nb_params:
+    :param has_custom_ids: a boolean indicating if custom ids are provided separately in `ids` or `idgen` (see
+        @parametrize)
     :return:
     """
     p_ids, p_marks, argvalues = extract_parameterset_info(argnames, marked_argvalues, check_nb=False)
@@ -887,80 +890,110 @@ def _process_argvalues(argnames, marked_argvalues, nb_params):
     if nb_params == 1:
         for i, v in enumerate(argvalues):
             if is_lazy_value(v):
-                # Note: no need to modify the id, it will be ok thanks to the lazy_value class design
-                # handle marks
+                # --- A lazy value is used for several parameters at the same time ---
+                # Users can declare custom marks in the lazy value API, we have to take these into account
+                # (1) if there was a pytest.param around it, we have to merge the marks from the lazy value into it
+                # (2) if there was no pytest.param around it and there are marks, we have to create the pytest.param
+                # Note: a custom id in lazy value does not require such processing as it does not need to take
+                # precedence over `ids` or `idgen`
+
+                # are there any marks in lazy_value ?
                 _mks = v.get_marks(as_decorators=True)
                 if len(_mks) > 0:
-                    # merge with the mark decorators possibly already present with pytest.param
-                    if p_marks[i] is None:
-                        p_marks[i] = []
-                    p_marks[i] = list(p_marks[i]) + _mks
+                    # update/create the pytest.param marks on this value
+                    p_marks[i] = (list(p_marks[i]) + _mks) if p_marks[i] is not None else list(_mks)
 
-                    # update the marked_argvalues
+                    # update the original marked_argvalues
                     marked_argvalues[i] = ParameterSet(values=(argvalues[i],), id=p_ids[i], marks=p_marks[i])
-                del _mks
 
-            if isinstance(v, fixture_ref):
+            elif isinstance(v, fixture_ref):
                 fixture_indices.append((i, None))
+
     elif nb_params > 1:
         for i, v in enumerate(argvalues):
+
+            # A/ First analyze what is the case at hand
+            _lazyvalue_used_as_tuple = False
+            _fixtureref_used_as_tuple = False
             if is_lazy_value(v):
-                # a lazy value is used for several parameters at the same time, and is NOT between pytest.param()
+                _lazyvalue_used_as_tuple = True
+            elif isinstance(v, fixture_ref):
+                _fixtureref_used_as_tuple = True
+            elif len(v) == 1 and is_lazy_value(v[0]):
+                # same than above but it was in a pytest.param
+                argvalues[i] = v = v[0]
+                _lazyvalue_used_as_tuple = True
+            elif len(v) == 1 and isinstance(v[0], fixture_ref):
+                # same than above but it was in a pytest.param
+                _fixtureref_used_as_tuple = True
+                argvalues[i] = v = v[0]
+
+            # B/ Now process it
+            if _lazyvalue_used_as_tuple:
+                # --- A lazy value is used for several parameters at the same time ---
+
+                # Since users have the possibility in the lazy value API to declare a custom id or custom marks,
+                # we have to take these into account.
+                # MARKS:
+                # (1) if there was a pytest.param around it, we have to merge the marks from the lazy value into it
+                # (2) if there was no pytest.param around it and there are marks, we have to create the pytest.param
+                # IDS:
+                # As opposed to the case of nb_params=1, we can not let pytest generate the id as it would create a
+                # tuple of LazyTupleItem ids (e.g. <id>[0]-<id>[1]-...). So
+                # (1) if there is a custom id list or generator, do not care about this.
+                # (2) if there is a pytest.param with a custom id, do not care about this
+                # (3) if there is nothing OR if there is a pytest.param with no id, we should create a pytest.param with
+                # the id.
+
+                # in this particular case we have to modify the initial list
                 argvalues[i] = v.as_lazy_tuple(nb_params)
 
-                # TUPLE usage: we HAVE to set an id to prevent too early access to the value by _idmaker
-                # note that on pytest 2 we cannot set an id here, the lazy value wont be too lazy
-                assert p_ids[i] is None
-                _id = v.get_id()
-                if not has_pytest_param:
-                    warn("The custom id %r in `lazy_value` will be ignored as this version of pytest is too old to"
-                         " support `pytest.param`." % _id)
-                    _id = None
+                # TUPLE usage: if the id is not provided elsewhere we HAVE to set an id to avoid <id>[0]-<id>[1]...
+                if p_ids[i] is None and not has_custom_ids:
+                    if not has_pytest_param:
+                        if v._id is not None:
+                            # (on pytest 2 we cannot do it since pytest.param does not exist)
+                            warn("The custom id %r in `lazy_value` will be ignored as this version of pytest is too old"
+                                 " to support `pytest.param`." % v._id)
+                        else:
+                            pass  # no warning, but no p_id update
+                    else:
+                        # update/create the pytest.param id on this value
+                        p_ids[i] = v.get_id()
 
                 # handle marks
                 _mks = v.get_marks(as_decorators=True)
                 if len(_mks) > 0:
-                    # merge with the mark decorators possibly already present with pytest.param
-                    assert p_marks[i] is None
-                    p_marks[i] = _mks
-
-                # note that here argvalues[i] IS a tuple-like so we do not create a tuple around it
-                marked_argvalues[i] = ParameterSet(values=argvalues[i], id=_id, marks=_mks)
-                p_ids[i] = _id
-                del _id, _mks
+                    # update/create the pytest.param marks on this value
+                    p_marks[i] = (list(p_marks[i]) + _mks) if p_marks[i] is not None else list(_mks)
+
+                # update the marked_argvalues
+                # - at least with the unpacked lazytuple if no pytest.param is there or needs to be created
+                # - with a pytest.param if one is needed
+                if p_ids[i] is None and p_marks[i] is None:
+                    marked_argvalues[i] = argvalues[i]
+                else:
+                    # note that here argvalues[i] IS a tuple-like so we do not create a tuple around it
+                    marked_argvalues[i] = ParameterSet(values=argvalues[i], id=p_ids[i], marks=p_marks[i] or ())
 
-            elif isinstance(v, fixture_ref):
+            elif _fixtureref_used_as_tuple:
                 # a fixture ref is used for several parameters at the same time
                 fixture_indices.append((i, None))
-
-            elif len(v) == 1 and is_lazy_value(v[0]):
-                # same than above but it was in a pytest.mark
-                # valueref_indices.append((i, None))
-                argvalues[i] = v[0].as_lazy_tuple(nb_params)  # unpack it
-                if p_ids[i] is None:
-                    # force-use the id from the lazy value (do not have pytest request for it, that would unpack it)
-                    p_ids[i] = v[0].get_id()
-                # handle marks
-                _mks = v[0].get_marks(as_decorators=True)
-                if len(_mks) > 0:
-                    # merge with the mark decorators possibly already present with pytest.param
-                    if p_marks[i] is None:
-                        p_marks[i] = []
-                    p_marks[i] = list(p_marks[i]) + _mks
-                del _mks
-                marked_argvalues[i] = ParameterSet(values=argvalues[i], id=p_ids[i], marks=p_marks[i])
-
-            elif len(v) == 1 and isinstance(v[0], fixture_ref):
-                # same than above but it was in a pytest.mark
-                fixture_indices.append((i, None))
-                argvalues[i] = v[0]  # unpack it
             else:
-                # check for consistency
+                # Tuple: check nb params for consistency
                 if len(v) != len(argnames):
                     raise ValueError("Inconsistent number of values in pytest parametrize: %s items found while the "
                                      "number of parameters is %s: %s." % (len(v), len(argnames), v))
 
-                # let's dig into the tuple
+                # let's dig into the tuple to check if there are fixture_refs or lazy_values
+                lv_pos_list = [j for j, _pval in enumerate(v) if is_lazy_value(_pval)]
+                if len(lv_pos_list) > 0:
+                    _mks = [mk for _lv in lv_pos_list for mk in v[_lv].get_marks(as_decorators=True)]
+                    if len(_mks) > 0:
+                        # update/create the pytest.param marks on this value
+                        p_marks[i] = (list(p_marks[i]) + _mks) if p_marks[i] is not None else list(_mks)
+                        marked_argvalues[i] = ParameterSet(values=argvalues[i], id=p_ids[i], marks=p_marks[i] or ())
+
                 fix_pos_list = [j for j, _pval in enumerate(v) if isinstance(_pval, fixture_ref)]
                 if len(fix_pos_list) > 0:
                     # there is at least one fixture ref inside the tuple

pytest_cases/tests/cases/issues/test_issue_142_2.py

@@ -0,0 +1,55 @@
+from pytest_cases import parametrize_with_cases, lazy_value, parametrize
+from pytest_cases.common_pytest_marks import has_pytest_param
+
+
+def case_dumb():
+    return 1, 2
+
+
+@parametrize("a,b", [(1, object()), lazy_value(case_dumb)])
+def test_foo(a, b):
+    pass
+
+
+@parametrize_with_cases('a,b', cases='.')
+def test_tuples_no_id(a, b):
+    assert True
+
+
+# --------- now we do the same with an id generator
+
+
+@parametrize("a,b", [(1, object()), lazy_value(case_dumb)], ids=["hello", "world"])
+def test_foo2(a, b):
+    pass
+
+
+def generate_id(**args):
+    return "hello"
+
+
+@parametrize_with_cases('a,b', cases='.', idgen=generate_id)
+def test_tuples(a, b):
+    assert True
+
+
+def test_synthesis(module_results_dct):
+    if has_pytest_param:
+        assert list(module_results_dct) == [
+            "test_foo[1-b0]",
+            "test_foo[case_dumb]",
+            'test_tuples_no_id[dumb]',
+            "test_foo2[hello]",
+            "test_foo2[world]",
+            'test_tuples[hello]',
+        ]
+    else:
+        # no pytest.param exists in this old pytest so the ids can not all be fixed
+        assert list(module_results_dct) == [
+            "test_foo[1-b0]",
+            "test_foo[case_dumb[0]-case_dumb[1]]",
+            'test_tuples_no_id[dumb[0]-dumb[1]]',
+            "test_foo2[hello]",
+            "test_foo2[world]",
+            'test_tuples[hello]',
+        ]

pytest_cases/tests/pytest_extension/parametrize_plus/test_lazy_value.py

@@ -4,7 +4,7 @@
 # License: 3-clause BSD, <https://github.com/smarie/python-pytest-cases/blob/master/LICENSE>
 import pytest
 
-from pytest_cases import parametrize_plus, lazy_value
+from pytest_cases import parametrize, lazy_value
 
 
 has_pytest_param = hasattr(pytest, 'param')
@@ -24,16 +24,16 @@ def val():
 
 
 if not has_pytest_param:
-    @parametrize_plus("a", [lazy_value(val),
-                            lazy_value(val_skipped_on_old_pytest),
-                            lazy_value(val, id='A')])
+    @parametrize("a", [lazy_value(val),
+                       lazy_value(val_skipped_on_old_pytest),
+                       lazy_value(val, id='A')])
     def test_foo_single(a):
         """here the fixture is used for both parameters at the same time"""
         assert a == 1
 
 
-    @parametrize_plus("a,b", [lazy_value(valtuple),
-                              (1, lazy_value(val))])
+    @parametrize("a,b", [lazy_value(valtuple),
+                         (1, lazy_value(val))])
     def test_foo_multi(a, b):
         """here the fixture is used for both parameters at the same time"""
         assert (a, b) == (1, 2) or (a, b) == (1, 1)
@@ -48,11 +48,11 @@ def test_synthesis(module_results_dct):
                                             'test_foo_multi[1-val]']
 
 else:
-    @parametrize_plus("a", [lazy_value(val),
-                            pytest.param(lazy_value(val_skipped_on_old_pytest), marks=pytest.mark.skip),
-                            pytest.param(lazy_value(val), id='B'),
-                            pytest.param(lazy_value(val, id='ignored'), id='C'),
-                            lazy_value(val, id='A')])
+    @parametrize("a", [lazy_value(val),
+                       pytest.param(lazy_value(val_skipped_on_old_pytest), marks=pytest.mark.skip),
+                       pytest.param(lazy_value(val), id='B'),
+                       pytest.param(lazy_value(val, id='ignored'), id='C'),
+                       lazy_value(val, id='A')])
     def test_foo_single(a):
         """here the fixture is used for both parameters at the same time"""
         assert a == 1
@@ -70,11 +70,14 @@ def valtuple_toskip():
         return 15, 2
 
 
-    @parametrize_plus("a,b", [lazy_value(valtuple),
-                              pytest.param(lazy_value(valtuple_only_right_when_lazy), id='A'),
-                              pytest.param(lazy_value(valtuple_toskip, marks=(pytest.mark.xfail,)), id='Wrong', marks=pytest.mark.skip),
-                              (1, lazy_value(val)),
-                              pytest.param(1, lazy_value(val), id='B')])
+    @parametrize("a,b", [lazy_value(valtuple),
+                         lazy_value(valtuple, id="hello"),
+                         lazy_value(valtuple_toskip, marks=pytest.mark.skip),
+                         (1, lazy_value(valtuple_toskip, marks=pytest.mark.skip)),
+                         pytest.param(lazy_value(valtuple_only_right_when_lazy), id='A'),
+                         pytest.param(lazy_value(valtuple_toskip, marks=(pytest.mark.xfail,)), id='Wrong', marks=pytest.mark.skip),
+                         (1, lazy_value(val)),
+                         pytest.param(1, lazy_value(val), id='B')])
     def test_foo_multi(a, b):
         """here the fixture is used for both parameters at the same time"""
         global flag
@@ -88,6 +91,7 @@ def test_synthesis2(module_results_dct):
                                             'test_foo_single[C]',
                                             'test_foo_single[A]',
                                             'test_foo_multi[valtuple]',
+                                            'test_foo_multi[hello]',
                                             'test_foo_multi[A]',
                                             'test_foo_multi[1-val]',
                                             'test_foo_multi[B]']