@parametrize_with_cases now explicitly supports all id customization methods (ids, idgen and idstyle) supported by @parametrize (ids, idgen and idstyle). Updated documentation accordingly. Fixed #151

Author: Sylvain MARIE

docs/api_reference.md

@@ -43,6 +43,9 @@ def case_hi():
                         glob:str = None,
                         has_tag: Union[str, Iterable[str]]=None,
                         filter: Callable = None,
+                        ids: Union[Callable, Iterable[str]]=None,
+                        idstyle: Optional[str]='explicit',
+                        idgen: Union[str, Callable]=_IDGEN,
                         **kwargs
                         )
 ```
@@ -77,7 +80,12 @@ argvalues = get_parametrize_args(host_class_or_module_of_f, cases_funs)
  - `has_tag`: a single tag or a tuple, set, list of tags that should be matched by the ones set with the [`@case`](#case) decorator on the case function(s) to be selected.
 
  - `filter`: a callable receiving the case function and returning True or a truth value in case the function needs to be selected.
-
+ 
+ - `ids`: same as in pytest.mark.parametrize. Note that an alternative way to create ids exists with `idgen`. Only one non-None `ids` or `idgen` should be provided. See [`@parametrize`](#parametrize) for details.
+ 
+ - `idgen`: an id formatter. Either a string representing a template, or a callable receiving all argvalues at once (as opposed to the behaviour in pytest ids). This alternative way to generate ids can only be used when `ids` is not provided (None). You can use the special `pytest_cases.AUTO` formatter to generate an automatic id with template `<name>=<value>-<name2>=<value2>-...`. See [`@parametrize`](#parametrize) for details.
+ 
+ - `idstyle`: style of ids to be used in the "union" fixtures generated by [`@parametrize`](#parametrize) when some cases require fixtures. One of 'compact', 'explicit' or None/'nostyle'. See [`@parametrize`](#parametrize) for details.
 
 ### `get_all_cases`
 
@@ -272,16 +280,16 @@ Identical to `param_fixtures` but for a single parameter name, so that you can a
 ### `@parametrize`
 
 ```python
-@parametrize_plus(argnames: str=None,
-                  argvalues: Iterable[Any]=None,
-                  indirect: bool = False,
-                  ids: Union[Callable, Iterable[str]] = None,
-                  idstyle: str = 'explicit',
-                  idgen: Union[str, Callable] = _IDGEN,
-                  scope: str = None,
-                  hook: Callable = None,
-                  debug: bool = False,
-                  **args)
+@parametrize(argnames: str=None,
+             argvalues: Iterable[Any]=None,
+             indirect: bool = False,
+             ids: Union[Callable, Iterable[str]] = None,
+             idstyle: Optional[str] = 'explicit',
+             idgen: Union[str, Callable] = _IDGEN,
+             scope: str = None,
+             hook: Callable = None,
+             debug: bool = False,
+             **args)
 ```
 
 Equivalent to `@pytest.mark.parametrize` but also supports 
@@ -302,6 +310,29 @@ Finally, `pytest.param` is supported even when there are `fixture_ref` and `lazy
 
 Here as for all functions above, an optional `hook` can be passed, to apply on each fixture function that is created during this call. The hook function will be called everytime a fixture is about to be created. It will receive a single argument (the function implementing the fixture) and should return the function to use. For example you can use `saved_fixture` from `pytest-harvest` as a hook in order to save all such created fixtures in the fixture store.
 
+**Parameters**
+
+ - `argnames`: same than in `@pytest.mark.parametrize`
+
+ - `argvalues: same as in pytest.mark.parametrize except that `fixture_ref` and `lazy_value` are supported
+ 
+ - `indirect`: same as in pytest.mark.parametrize. Note that it is not recommended and is not guaranteed to work in complex parametrization scenarii.
+
+ - `ids`: same as in pytest.mark.parametrize. Note that an alternative way to create ids exists with `idgen`. Only one non-None `ids` or `idgen` should be provided.
+ 
+ - `idgen`: an id formatter. Either a string representing a template, or a callable receiving all argvalues at once (as opposed to the behaviour in pytest ids). This alternative way to generate ids can only be used when `ids` is not provided (None). You can use the special `pytest_cases.AUTO` formatter to generate an automatic id with template `<name>=<value>-<name2>=<value2>-...`.
+ 
+ - `idstyle`: style of ids to be used in the "union" fixtures generated by `@parametrize` when some cases require fixtures. One of 'compact', 'explicit' or None/'nostyle'.
+        
+ - `scope`: same as in pytest.mark.parametrize
+     
+ - `hook`: an optional hook to apply to each fixture function that is created during this call. The hook function will be called everytime a fixture is about to be created. It will receive a single argument (the function implementing the fixture) and should return the function to use. For example you can use `saved_fixture` from `pytest-harvest` as a hook in order to save all such created fixtures in the fixture store.
+        
+ - `debug`: print debug messages on stdout to analyze fixture creation (use pytest -s to see them)
+ 
+ - `args`: additional {argnames: argvalues} definition
+
+
 ### `lazy_value`
 
 ```python

pytest_cases/case_parametrizer_new.py

@@ -27,14 +27,13 @@
 from . import fixture
 from .case_funcs_new import matches_tag_query, is_case_function, is_case_class, CaseInfo, CASE_PREFIX_FUN
 from .fixture__creation import check_name_available, CHANGE
-from .fixture_parametrize_plus import fixture_ref, _parametrize_plus
-
+from .fixture_parametrize_plus import fixture_ref, _parametrize_plus, _IDGEN
 
 THIS_MODULE = object()
 """Singleton that can be used instead of a module name to indicate that the module is the current one"""
 
 try:
-    from typing import Literal  # noqa
+    from typing import Literal, Optional  # noqa
     from types import ModuleType  # noqa
 
     ModuleRef = Union[str, ModuleType, Literal[AUTO], Literal[AUTO2], Literal[THIS_MODULE]]  # noqa
@@ -49,6 +48,9 @@ def parametrize_with_cases(argnames,                # type: Union[str, List[str]
                            glob=None,               # type: str
                            has_tag=None,            # type: Any
                            filter=None,             # type: Callable[[Callable], bool]  # noqa
+                           ids=None,                # type: Union[Callable, Iterable[str]]
+                           idstyle='explicit',      # type: Optional[str]
+                           idgen=_IDGEN,            # type: Union[str, Callable]
                            debug=False,             # type: bool
                            **kwargs
                            ):
@@ -95,6 +97,14 @@ def parametrize_with_cases(argnames,                # type: Union[str, List[str]
         decorator on the case function(s) to be selected.
     :param filter: a callable receiving the case function and returning True or a truth value in case the function
         needs to be selected.
+    :param ids: same as in pytest.mark.parametrize. Note that an alternative way to create ids exists with `idgen`. Only
+        one non-None `ids` or `idgen` should be provided. See `@parametrize` for details.
+    :param idgen: an id formatter. Either a string representing a template, or a callable receiving all argvalues
+        at once (as opposed to the behaviour in pytest ids). This alternative way to generate ids can only be used when
+        `ids` is not provided (None). You can use the special `AUTO` formatter to generate an automatic id with
+        template <name>=<value>-<name2>=<value2>-etc. See `@parametrize` for details.
+    :param idstyle: style of ids to be used in the "union" fixtures generated by `@parametrize` when some cases require
+        fixtures. One of 'compact', 'explicit' or None/'nostyle'. See `@parametrize` for details.
     :param debug: a boolean flag to debug what happens behind the scenes
     :return:
     """
@@ -112,7 +122,8 @@ def _apply_parametrization(f, host_class_or_module):
 
         # Finally apply parametrization - note that we need to call the private method so that fixture are created in
         # the right module (not here)
-        _parametrize_with_cases, needs_inject = _parametrize_plus(argnames, argvalues, debug=debug, **kwargs)
+        _parametrize_with_cases, needs_inject = _parametrize_plus(argnames, argvalues, ids=ids, idstyle=idstyle,
+                                                                  idgen=idgen, debug=debug, **kwargs)
 
         if needs_inject:
             return _parametrize_with_cases(f, host_class_or_module)

pytest_cases/fixture_core1_unions.py

@@ -291,7 +291,7 @@ def _fixture_union(fixtures_dest,
                    fix_alternatives,      # type: Sequence[UnionFixtureAlternative]
                    unique_fix_alt_names,  # type: List[str]
                    scope="function",      # type: str
-                   idstyle="explicit",    # type: str
+                   idstyle="explicit",    # type: Optional[str]
                    ids=None,              # type: Union[Callable, Iterable[str]]
                    autouse=False,         # type: bool
                    hook=None,             # type: Callable[[Callable], Callable]